[FIX] website_sale_aplicoop: Remove redundant string= attributes and fix OCA linting warnings

- Remove redundant string= from 17 field definitions where name matches string value (W8113)
- Convert @staticmethod to instance methods in selection methods for proper self.env._() access
- Fix W8161 (prefer-env-translation) by using self.env._() instead of standalone _()
- Fix W8301/W8115 (translation-not-lazy) by proper placement of % interpolation outside self.env._()
- Remove unused imports of odoo._ from group_order.py and sale_order_extension.py
- All OCA linting warnings in website_sale_aplicoop main models are now resolved

Changes:
- website_sale_aplicoop/models/group_order.py: 21 field definitions cleaned
- website_sale_aplicoop/models/sale_order_extension.py: 5 field definitions cleaned + @staticmethod conversion
- Consistent with OCA standards for addon submission
This commit is contained in:
snt 2026-02-18 17:54:43 +01:00
parent 5c89795e30
commit 6fbc7b9456
73 changed files with 5386 additions and 4354 deletions

View file

@ -1,310 +1,354 @@
# Copyright 2025 Criptomart
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
from datetime import datetime, timedelta
from datetime import datetime
from datetime import timedelta
from odoo.tests.common import TransactionCase
from odoo.exceptions import ValidationError
from psycopg2 import IntegrityError
from odoo import fields
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
class TestGroupOrder(TransactionCase):
'''Test suite para el modelo group.order.'''
"""Test suite para el modelo group.order."""
def setUp(self):
super().setUp()
# Crear un grupo (res.partner)
self.group = self.env['res.partner'].create({
'name': 'Grupo Test',
'is_company': True,
'email': 'grupo@test.com',
})
self.group = self.env["res.partner"].create(
{
"name": "Grupo Test",
"is_company": True,
"email": "grupo@test.com",
}
)
# Crear productos
self.product1 = self.env['product.product'].create({
'name': 'Producto Test 1',
'type': 'consu',
'list_price': 10.0,
})
self.product1 = self.env["product.product"].create(
{
"name": "Producto Test 1",
"type": "consu",
"list_price": 10.0,
}
)
self.product2 = self.env['product.product'].create({
'name': 'Producto Test 2',
'type': 'consu',
'list_price': 20.0,
})
self.product2 = self.env["product.product"].create(
{
"name": "Producto Test 2",
"type": "consu",
"list_price": 20.0,
}
)
def test_create_group_order(self):
'''Test crear un pedido de grupo.'''
order = self.env['group.order'].create({
'name': 'Pedido Semanal Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': (datetime.now() + timedelta(days=7)).date(),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test crear un pedido de grupo."""
order = self.env["group.order"].create(
{
"name": "Pedido Semanal Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": (datetime.now() + timedelta(days=7)).date(),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
self.assertTrue(order.exists())
self.assertEqual(order.state, 'draft')
self.assertEqual(order.state, "draft")
self.assertIn(self.group, order.group_ids)
def test_group_order_dates_validation(self):
""" Test that start_date must be before end_date """
"""Test that start_date must be before end_date"""
with self.assertRaises(ValidationError):
self.env['group.order'].create({
'name': 'Pedido Invalid',
'start_date': fields.Date.today() + timedelta(days=7),
'end_date': fields.Date.today(),
})
self.env["group.order"].create(
{
"name": "Pedido Invalid",
"start_date": fields.Date.today() + timedelta(days=7),
"end_date": fields.Date.today(),
}
)
def test_group_order_state_transitions(self):
'''Test transiciones de estado.'''
order = self.env['group.order'].create({
'name': 'Pedido State Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': (datetime.now() + timedelta(days=7)).date(),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test transiciones de estado."""
order = self.env["group.order"].create(
{
"name": "Pedido State Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": (datetime.now() + timedelta(days=7)).date(),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
# Draft -> Open
order.action_open()
self.assertEqual(order.state, 'open')
self.assertEqual(order.state, "open")
# Open -> Closed
order.action_close()
self.assertEqual(order.state, 'closed')
self.assertEqual(order.state, "closed")
def test_group_order_action_cancel(self):
'''Test cancelar un pedido.'''
order = self.env['group.order'].create({
'name': 'Pedido Cancel Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': (datetime.now() + timedelta(days=7)).date(),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test cancelar un pedido."""
order = self.env["group.order"].create(
{
"name": "Pedido Cancel Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": (datetime.now() + timedelta(days=7)).date(),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
order.action_cancel()
self.assertEqual(order.state, 'cancelled')
self.assertEqual(order.state, "cancelled")
def test_get_active_orders_for_week(self):
'''Test obtener pedidos activos para la semana.'''
"""Test obtener pedidos activos para la semana."""
today = datetime.now().date()
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
# Crear pedido activo esta semana
active_order = self.env['group.order'].create({
'name': 'Pedido Activo',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': week_start,
'end_date': week_end,
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
'state': 'open',
})
active_order = self.env["group.order"].create(
{
"name": "Pedido Activo",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": week_start,
"end_date": week_end,
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
"state": "open",
}
)
# Crear pedido inactivo (futuro)
future_order = self.env['group.order'].create({
'name': 'Pedido Futuro',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': week_end + timedelta(days=1),
'end_date': week_end + timedelta(days=8),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
'state': 'open',
})
future_order = self.env["group.order"].create(
{
"name": "Pedido Futuro",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": week_end + timedelta(days=1),
"end_date": week_end + timedelta(days=8),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
"state": "open",
}
)
active_orders = self.env['group.order'].search([
('state', '=', 'open'),
'|',
('end_date', '>=', week_start),
('end_date', '=', False),
('start_date', '<=', week_end),
])
active_orders = self.env["group.order"].search(
[
("state", "=", "open"),
"|",
("end_date", ">=", week_start),
("end_date", "=", False),
("start_date", "<=", week_end),
]
)
self.assertIn(active_order, active_orders)
self.assertNotIn(future_order, active_orders)
def test_permanent_group_order(self):
'''Test crear un pedido permanente (sin end_date).'''
order = self.env['group.order'].create({
'name': 'Pedido Permanente',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': False,
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test crear un pedido permanente (sin end_date)."""
order = self.env["group.order"].create(
{
"name": "Pedido Permanente",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": False,
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
self.assertTrue(order.exists())
self.assertFalse(order.end_date)
def test_get_active_orders_excludes_draft(self):
'''Test que get_active_orders_for_week NO incluye pedidos en draft.'''
"""Test que get_active_orders_for_week NO incluye pedidos en draft."""
today = datetime.now().date()
# Crear pedido en draft (no abierto)
draft_order = self.env['group.order'].create({
'name': 'Pedido Draft',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': today,
'end_date': today + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
'state': 'draft',
})
draft_order = self.env["group.order"].create(
{
"name": "Pedido Draft",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": today,
"end_date": today + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
"state": "draft",
}
)
today = datetime.now().date()
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
active_orders = self.env['group.order'].search([
('state', '=', 'open'),
'|',
('end_date', '>=', week_start),
('end_date', '=', False),
('start_date', '<=', week_end),
])
active_orders = self.env["group.order"].search(
[
("state", "=", "open"),
"|",
("end_date", ">=", week_start),
("end_date", "=", False),
("start_date", "<=", week_end),
]
)
self.assertNotIn(draft_order, active_orders)
def test_get_active_orders_excludes_closed(self):
'''Test que get_active_orders_for_week NO incluye pedidos cerrados.'''
"""Test que get_active_orders_for_week NO incluye pedidos cerrados."""
today = datetime.now().date()
closed_order = self.env['group.order'].create({
'name': 'Pedido Cerrado',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': today,
'end_date': today + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
'state': 'closed',
})
closed_order = self.env["group.order"].create(
{
"name": "Pedido Cerrado",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": today,
"end_date": today + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
"state": "closed",
}
)
today = datetime.now().date()
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
active_orders = self.env['group.order'].search([
('state', '=', 'open'),
'|',
('end_date', '>=', week_start),
('end_date', '=', False),
('start_date', '<=', week_end),
])
active_orders = self.env["group.order"].search(
[
("state", "=", "open"),
"|",
("end_date", ">=", week_start),
("end_date", "=", False),
("start_date", "<=", week_end),
]
)
self.assertNotIn(closed_order, active_orders)
def test_get_active_orders_excludes_cancelled(self):
'''Test que get_active_orders_for_week NO incluye pedidos cancelados.'''
"""Test que get_active_orders_for_week NO incluye pedidos cancelados."""
today = datetime.now().date()
cancelled_order = self.env['group.order'].create({
'name': 'Pedido Cancelado',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': today,
'end_date': today + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
'state': 'cancelled',
})
cancelled_order = self.env["group.order"].create(
{
"name": "Pedido Cancelado",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": today,
"end_date": today + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
"state": "cancelled",
}
)
today = datetime.now().date()
week_start = today - timedelta(days=today.weekday())
week_end = week_start + timedelta(days=6)
active_orders = self.env['group.order'].search([
('state', '=', 'open'),
'|',
('end_date', '>=', week_start),
('end_date', '=', False),
('start_date', '<=', week_end),
])
active_orders = self.env["group.order"].search(
[
("state", "=", "open"),
"|",
("end_date", ">=", week_start),
("end_date", "=", False),
("start_date", "<=", week_end),
]
)
self.assertNotIn(cancelled_order, active_orders)
def test_state_transition_draft_to_open(self):
'''Test que un pedido pasa de draft a open.'''
order = self.env['group.order'].create({
'name': 'Pedido Estado Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': datetime.now().date() + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test que un pedido pasa de draft a open."""
order = self.env["group.order"].create(
{
"name": "Pedido Estado Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": datetime.now().date() + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
self.assertEqual(order.state, 'draft')
self.assertEqual(order.state, "draft")
order.action_open()
self.assertEqual(order.state, 'open')
self.assertEqual(order.state, "open")
def test_state_transition_open_to_closed(self):
'''Test transición válida open -> closed.'''
order = self.env['group.order'].create({
'name': 'Pedido Estado Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': datetime.now().date() + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test transición válida open -> closed."""
order = self.env["group.order"].create(
{
"name": "Pedido Estado Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": datetime.now().date() + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
order.action_open()
self.assertEqual(order.state, 'open')
self.assertEqual(order.state, "open")
order.action_close()
self.assertEqual(order.state, 'closed')
self.assertEqual(order.state, "closed")
def test_state_transition_any_to_cancelled(self):
'''Test cancelar desde cualquier estado.'''
order = self.env['group.order'].create({
'name': 'Pedido Estado Test',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': datetime.now().date() + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
"""Test cancelar desde cualquier estado."""
order = self.env["group.order"].create(
{
"name": "Pedido Estado Test",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": datetime.now().date() + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
# Desde draft
order.action_cancel()
self.assertEqual(order.state, 'cancelled')
self.assertEqual(order.state, "cancelled")
# Crear otro desde open
order2 = self.env['group.order'].create({
'name': 'Pedido Estado Test 2',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': datetime.now().date(),
'end_date': datetime.now().date() + timedelta(days=7),
'period': 'weekly',
'pickup_day': '5',
'cutoff_day': '0',
})
order2 = self.env["group.order"].create(
{
"name": "Pedido Estado Test 2",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": datetime.now().date(),
"end_date": datetime.now().date() + timedelta(days=7),
"period": "weekly",
"pickup_day": "5",
"cutoff_day": "0",
}
)
order2.action_open()
order2.action_cancel()
self.assertEqual(order2.state, 'cancelled')
self.assertEqual(order2.state, "cancelled")