[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

@ -13,7 +13,8 @@ Coverage:
- Draft timeline (very old draft, recent draft)
"""
from datetime import datetime, timedelta
from datetime import datetime
from datetime import timedelta
from odoo.tests.common import TransactionCase
@ -23,91 +24,117 @@ class TestSaveDraftOrder(TransactionCase):
def setUp(self):
super().setUp()
self.group = self.env['res.partner'].create({
'name': 'Test Group',
'is_company': True,
})
self.group = self.env["res.partner"].create(
{
"name": "Test Group",
"is_company": True,
}
)
self.member_partner = self.env['res.partner'].create({
'name': 'Group Member',
'email': 'member@test.com',
})
self.member_partner = self.env["res.partner"].create(
{
"name": "Group Member",
"email": "member@test.com",
}
)
self.group.member_ids = [(4, self.member_partner.id)]
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser@test.com',
'email': 'testuser@test.com',
'partner_id': self.member_partner.id,
})
self.user = self.env["res.users"].create(
{
"name": "Test User",
"login": "testuser@test.com",
"email": "testuser@test.com",
"partner_id": self.member_partner.id,
}
)
self.category = self.env['product.category'].create({
'name': 'Test Category',
})
self.category = self.env["product.category"].create(
{
"name": "Test Category",
}
)
self.product1 = self.env['product.product'].create({
'name': 'Product 1',
'type': 'consu',
'list_price': 10.0,
'categ_id': self.category.id,
})
self.product1 = self.env["product.product"].create(
{
"name": "Product 1",
"type": "consu",
"list_price": 10.0,
"categ_id": self.category.id,
}
)
self.product2 = self.env['product.product'].create({
'name': 'Product 2',
'type': 'consu',
'list_price': 20.0,
'categ_id': self.category.id,
})
self.product2 = self.env["product.product"].create(
{
"name": "Product 2",
"type": "consu",
"list_price": 20.0,
"categ_id": self.category.id,
}
)
start_date = datetime.now().date()
self.group_order = self.env['group.order'].create({
'name': 'Test Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start_date,
'end_date': start_date + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'pickup_date': start_date + timedelta(days=3),
'cutoff_day': '0',
})
self.group_order = self.env["group.order"].create(
{
"name": "Test Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start_date,
"end_date": start_date + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"pickup_date": start_date + timedelta(days=3),
"cutoff_day": "0",
}
)
self.group_order.action_open()
self.group_order.product_ids = [(4, self.product1.id), (4, self.product2.id)]
def test_save_draft_with_items(self):
"""Test saving draft order with products."""
draft_order = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [
(0, 0, {
'product_id': self.product1.id,
'product_qty': 2,
'price_unit': self.product1.list_price,
}),
(0, 0, {
'product_id': self.product2.id,
'product_qty': 1,
'price_unit': self.product2.list_price,
}),
],
})
draft_order = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product1.id,
"product_qty": 2,
"price_unit": self.product1.list_price,
},
),
(
0,
0,
{
"product_id": self.product2.id,
"product_qty": 1,
"price_unit": self.product2.list_price,
},
),
],
}
)
self.assertTrue(draft_order.exists())
self.assertEqual(draft_order.state, 'draft')
self.assertEqual(draft_order.state, "draft")
self.assertEqual(len(draft_order.order_line), 2)
def test_save_draft_empty_order(self):
"""Test saving draft order without items."""
# Edge case: empty draft
empty_draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [],
})
empty_draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [],
}
)
# Should be valid (user hasn't added products yet)
self.assertTrue(empty_draft.exists())
@ -116,15 +143,23 @@ class TestSaveDraftOrder(TransactionCase):
def test_save_draft_updates_existing(self):
"""Test that saving draft updates existing draft, not creates new."""
# Create initial draft
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [(0, 0, {
'product_id': self.product1.id,
'product_qty': 1,
})],
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product1.id,
"product_qty": 1,
},
)
],
}
)
draft_id = draft.id
@ -132,29 +167,33 @@ class TestSaveDraftOrder(TransactionCase):
draft.order_line[0].product_qty = 5
# Should be same draft, not new one
updated_draft = self.env['sale.order'].browse(draft_id)
updated_draft = self.env["sale.order"].browse(draft_id)
self.assertTrue(updated_draft.exists())
self.assertEqual(updated_draft.order_line[0].product_qty, 5)
def test_save_draft_preserves_group_order_reference(self):
"""Test that group_order_id is preserved when saving."""
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
}
)
# Link must be preserved
self.assertEqual(draft.group_order_id, self.group_order)
def test_save_draft_preserves_pickup_date(self):
"""Test that pickup_date is preserved in draft."""
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'pickup_date': self.group_order.pickup_date,
'state': 'draft',
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"pickup_date": self.group_order.pickup_date,
"state": "draft",
}
)
self.assertEqual(draft.pickup_date, self.group_order.pickup_date)
@ -164,63 +203,83 @@ class TestLoadDraftOrder(TransactionCase):
def setUp(self):
super().setUp()
self.group = self.env['res.partner'].create({
'name': 'Test Group',
'is_company': True,
})
self.group = self.env["res.partner"].create(
{
"name": "Test Group",
"is_company": True,
}
)
self.member_partner = self.env['res.partner'].create({
'name': 'Group Member',
'email': 'member@test.com',
})
self.member_partner = self.env["res.partner"].create(
{
"name": "Group Member",
"email": "member@test.com",
}
)
self.group.member_ids = [(4, self.member_partner.id)]
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser@test.com',
'email': 'testuser@test.com',
'partner_id': self.member_partner.id,
})
self.user = self.env["res.users"].create(
{
"name": "Test User",
"login": "testuser@test.com",
"email": "testuser@test.com",
"partner_id": self.member_partner.id,
}
)
self.product = self.env['product.product'].create({
'name': 'Test Product',
'type': 'consu',
'list_price': 10.0,
})
self.product = self.env["product.product"].create(
{
"name": "Test Product",
"type": "consu",
"list_price": 10.0,
}
)
start_date = datetime.now().date()
self.group_order = self.env['group.order'].create({
'name': 'Test Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start_date,
'end_date': start_date + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
self.group_order = self.env["group.order"].create(
{
"name": "Test Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start_date,
"end_date": start_date + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
self.group_order.action_open()
def test_load_existing_draft(self):
"""Test loading an existing draft order."""
# Create draft
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [(0, 0, {
'product_id': self.product.id,
'product_qty': 3,
})],
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product.id,
"product_qty": 3,
},
)
],
}
)
# Load it
loaded = self.env['sale.order'].search([
('id', '=', draft.id),
('partner_id', '=', self.member_partner.id),
('state', '=', 'draft'),
])
loaded = self.env["sale.order"].search(
[
("id", "=", draft.id),
("partner_id", "=", self.member_partner.id),
("state", "=", "draft"),
]
)
self.assertEqual(len(loaded), 1)
self.assertEqual(loaded[0].order_line[0].product_qty, 3)
@ -228,29 +287,37 @@ class TestLoadDraftOrder(TransactionCase):
def test_load_draft_not_visible_to_other_user(self):
"""Test that draft from one user not accessible to another."""
# Create draft for member_partner
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
}
)
# Create another user/partner
other_partner = self.env['res.partner'].create({
'name': 'Other Member',
'email': 'other@test.com',
})
other_partner = self.env["res.partner"].create(
{
"name": "Other Member",
"email": "other@test.com",
}
)
other_user = self.env['res.users'].create({
'name': 'Other User',
'login': 'other@test.com',
'partner_id': other_partner.id,
})
other_user = self.env["res.users"].create(
{
"name": "Other User",
"login": "other@test.com",
"partner_id": other_partner.id,
}
)
# Other user should not see original draft
other_drafts = self.env['sale.order'].search([
('id', '=', draft.id),
('partner_id', '=', other_partner.id),
])
other_drafts = self.env["sale.order"].search(
[
("id", "=", draft.id),
("partner_id", "=", other_partner.id),
]
)
self.assertEqual(len(other_drafts), 0)
@ -260,14 +327,16 @@ class TestLoadDraftOrder(TransactionCase):
self.group_order.action_close()
# Create draft before closure (simulated)
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
}
)
# Draft should still be loadable (but should warn)
loaded = self.env['sale.order'].browse(draft.id)
loaded = self.env["sale.order"].browse(draft.id)
self.assertTrue(loaded.exists())
# Controller should check: group_order.state and warn if closed
@ -277,41 +346,51 @@ class TestDraftConsistency(TransactionCase):
def setUp(self):
super().setUp()
self.group = self.env['res.partner'].create({
'name': 'Test Group',
'is_company': True,
})
self.group = self.env["res.partner"].create(
{
"name": "Test Group",
"is_company": True,
}
)
self.member_partner = self.env['res.partner'].create({
'name': 'Group Member',
'email': 'member@test.com',
})
self.member_partner = self.env["res.partner"].create(
{
"name": "Group Member",
"email": "member@test.com",
}
)
self.group.member_ids = [(4, self.member_partner.id)]
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser@test.com',
'partner_id': self.member_partner.id,
})
self.user = self.env["res.users"].create(
{
"name": "Test User",
"login": "testuser@test.com",
"partner_id": self.member_partner.id,
}
)
self.product = self.env['product.product'].create({
'name': 'Test Product',
'type': 'consu',
'list_price': 100.0,
})
self.product = self.env["product.product"].create(
{
"name": "Test Product",
"type": "consu",
"list_price": 100.0,
}
)
start_date = datetime.now().date()
self.group_order = self.env['group.order'].create({
'name': 'Test Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start_date,
'end_date': start_date + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
self.group_order = self.env["group.order"].create(
{
"name": "Test Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start_date,
"end_date": start_date + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
self.group_order.action_open()
def test_draft_price_snapshot(self):
@ -319,16 +398,24 @@ class TestDraftConsistency(TransactionCase):
original_price = self.product.list_price
# Save draft with current price
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [(0, 0, {
'product_id': self.product.id,
'product_qty': 1,
'price_unit': original_price,
})],
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product.id,
"product_qty": 1,
"price_unit": original_price,
},
)
],
}
)
saved_price = draft.order_line[0].price_unit
@ -342,18 +429,26 @@ class TestDraftConsistency(TransactionCase):
def test_draft_quantity_consistency(self):
"""Test that quantities are preserved across saves."""
# Save draft
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [(0, 0, {
'product_id': self.product.id,
'product_qty': 5,
})],
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product.id,
"product_qty": 5,
},
)
],
}
)
# Re-load draft
reloaded = self.env['sale.order'].browse(draft.id)
reloaded = self.env["sale.order"].browse(draft.id)
self.assertEqual(reloaded.order_line[0].product_qty, 5)
@ -362,62 +457,80 @@ class TestProductArchivedInDraft(TransactionCase):
def setUp(self):
super().setUp()
self.group = self.env['res.partner'].create({
'name': 'Test Group',
'is_company': True,
})
self.group = self.env["res.partner"].create(
{
"name": "Test Group",
"is_company": True,
}
)
self.member_partner = self.env['res.partner'].create({
'name': 'Group Member',
'email': 'member@test.com',
})
self.member_partner = self.env["res.partner"].create(
{
"name": "Group Member",
"email": "member@test.com",
}
)
self.group.member_ids = [(4, self.member_partner.id)]
self.user = self.env['res.users'].create({
'name': 'Test User',
'login': 'testuser@test.com',
'partner_id': self.member_partner.id,
})
self.user = self.env["res.users"].create(
{
"name": "Test User",
"login": "testuser@test.com",
"partner_id": self.member_partner.id,
}
)
self.product = self.env['product.product'].create({
'name': 'Test Product',
'type': 'consu',
'list_price': 10.0,
'active': True,
})
self.product = self.env["product.product"].create(
{
"name": "Test Product",
"type": "consu",
"list_price": 10.0,
"active": True,
}
)
start_date = datetime.now().date()
self.group_order = self.env['group.order'].create({
'name': 'Test Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start_date,
'end_date': start_date + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
self.group_order = self.env["group.order"].create(
{
"name": "Test Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start_date,
"end_date": start_date + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
self.group_order.action_open()
def test_load_draft_with_archived_product(self):
"""Test loading draft when product has been archived."""
# Create draft with active product
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': self.group_order.id,
'state': 'draft',
'order_line': [(0, 0, {
'product_id': self.product.id,
'product_qty': 2,
})],
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": self.group_order.id,
"state": "draft",
"order_line": [
(
0,
0,
{
"product_id": self.product.id,
"product_qty": 2,
},
)
],
}
)
# Archive the product
self.product.active = False
# Load draft - should still work (historical data)
loaded = self.env['sale.order'].browse(draft.id)
loaded = self.env["sale.order"].browse(draft.id)
self.assertTrue(loaded.exists())
# But product may not be editable/accessible
@ -427,108 +540,128 @@ class TestDraftTimeline(TransactionCase):
def setUp(self):
super().setUp()
self.group = self.env['res.partner'].create({
'name': 'Test Group',
'is_company': True,
})
self.group = self.env["res.partner"].create(
{
"name": "Test Group",
"is_company": True,
}
)
self.member_partner = self.env['res.partner'].create({
'name': 'Group Member',
'email': 'member@test.com',
})
self.member_partner = self.env["res.partner"].create(
{
"name": "Group Member",
"email": "member@test.com",
}
)
self.group.member_ids = [(4, self.member_partner.id)]
self.product = self.env['product.product'].create({
'name': 'Test Product',
'type': 'consu',
'list_price': 10.0,
})
self.product = self.env["product.product"].create(
{
"name": "Test Product",
"type": "consu",
"list_price": 10.0,
}
)
def test_draft_from_current_week(self):
"""Test draft from current/open group order."""
start_date = datetime.now().date()
current_order = self.env['group.order'].create({
'name': 'Current Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start_date,
'end_date': start_date + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
current_order = self.env["group.order"].create(
{
"name": "Current Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start_date,
"end_date": start_date + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
current_order.action_open()
draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': current_order.id,
'state': 'draft',
})
draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": current_order.id,
"state": "draft",
}
)
# Should be accessible and valid
self.assertTrue(draft.exists())
self.assertEqual(draft.group_order_id.state, 'open')
self.assertEqual(draft.group_order_id.state, "open")
def test_draft_from_old_order_6_months_ago(self):
"""Test draft from order that was 6 months ago."""
old_start = datetime.now().date() - timedelta(days=180)
old_end = old_start + timedelta(days=7)
old_order = self.env['group.order'].create({
'name': 'Old Order',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': old_start,
'end_date': old_end,
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
old_order = self.env["group.order"].create(
{
"name": "Old Order",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": old_start,
"end_date": old_end,
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
old_order.action_open()
old_order.action_close()
old_draft = self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': old_order.id,
'state': 'draft',
})
old_draft = self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": old_order.id,
"state": "draft",
}
)
# Should still exist but be inaccessible (order closed)
self.assertTrue(old_draft.exists())
self.assertEqual(old_order.state, 'closed')
self.assertEqual(old_order.state, "closed")
def test_draft_order_count_for_user(self):
"""Test counting total drafts for a user."""
# Create multiple orders and drafts
orders = []
for i in range(3):
start = datetime.now().date() + timedelta(days=i*7)
order = self.env['group.order'].create({
'name': f'Order {i}',
'group_ids': [(6, 0, [self.group.id])],
'type': 'regular',
'start_date': start,
'end_date': start + timedelta(days=7),
'period': 'weekly',
'pickup_day': '3',
'cutoff_day': '0',
})
start = datetime.now().date() + timedelta(days=i * 7)
order = self.env["group.order"].create(
{
"name": f"Order {i}",
"group_ids": [(6, 0, [self.group.id])],
"type": "regular",
"start_date": start,
"end_date": start + timedelta(days=7),
"period": "weekly",
"pickup_day": "3",
"cutoff_day": "0",
}
)
order.action_open()
orders.append(order)
# Create draft for each
for order in orders:
self.env['sale.order'].create({
'partner_id': self.member_partner.id,
'group_order_id': order.id,
'state': 'draft',
})
self.env["sale.order"].create(
{
"partner_id": self.member_partner.id,
"group_order_id": order.id,
"state": "draft",
}
)
# Count drafts for user
user_drafts = self.env['sale.order'].search([
('partner_id', '=', self.member_partner.id),
('state', '=', 'draft'),
])
user_drafts = self.env["sale.order"].search(
[
("partner_id", "=", self.member_partner.id),
("state", "=", "draft"),
]
)
self.assertEqual(len(user_drafts), 3)