cf9ea887c1
- Add mypy.ini configuration to exclude migration scripts - Rename migration files to proper snake_case (post-migration.py → post_migration.py) - Add __init__.py to migration directories for proper Python package structure - Add new portal access tests for website_sale_aplicoop - Code formatting improvements (black, isort) - Update copilot instructions and project configuration Related to previous code quality refactoring work.
367 lines
12 KiB
Python
367 lines
12 KiB
Python
# Copyright 2025 Criptomart
|
|
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl)
|
|
|
|
"""
|
|
Test suite for validations and constraints in website_sale_aplicoop.
|
|
|
|
Coverage:
|
|
- group.order constraint: same company for all groups
|
|
- group.order constraint: start_date < end_date
|
|
- group.order computed field: image_1920 fallback logic
|
|
- group.order computed field: product count
|
|
- res.partner validation: user without partner_id
|
|
- group.order state transitions: illegal transitions
|
|
"""
|
|
|
|
from datetime import datetime
|
|
from datetime import timedelta
|
|
|
|
from odoo.exceptions import UserError
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.tests.common import TransactionCase
|
|
|
|
|
|
class TestGroupOrderValidations(TransactionCase):
|
|
"""Test constraints and validations for group.order model."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.company1 = self.env.company
|
|
self.company2 = self.env["res.company"].create(
|
|
{
|
|
"name": "Company 2",
|
|
}
|
|
)
|
|
|
|
self.group_c1 = self.env["res.partner"].create(
|
|
{
|
|
"name": "Group Company 1",
|
|
"is_company": True,
|
|
"company_id": self.company1.id,
|
|
}
|
|
)
|
|
|
|
self.group_c2 = self.env["res.partner"].create(
|
|
{
|
|
"name": "Group Company 2",
|
|
"is_company": True,
|
|
"company_id": self.company2.id,
|
|
}
|
|
)
|
|
|
|
def test_group_order_same_company_constraint(self):
|
|
"""Test that all groups in an order must be from same company."""
|
|
start_date = datetime.now().date()
|
|
|
|
# Creating order with groups from different companies should fail
|
|
with self.assertRaises(ValidationError):
|
|
self.env["group.order"].create(
|
|
{
|
|
"name": "Multi-Company Order",
|
|
"group_ids": [(6, 0, [self.group_c1.id, self.group_c2.id])],
|
|
"type": "regular",
|
|
"start_date": start_date,
|
|
"end_date": start_date + timedelta(days=7),
|
|
"period": "weekly",
|
|
"pickup_day": "3",
|
|
"cutoff_day": "0",
|
|
}
|
|
)
|
|
|
|
def test_group_order_same_company_mixed_single(self):
|
|
"""Test that single company group is valid."""
|
|
start_date = datetime.now().date()
|
|
|
|
# Single company should pass
|
|
order = self.env["group.order"].create(
|
|
{
|
|
"name": "Single Company Order",
|
|
"group_ids": [(6, 0, [self.group_c1.id])],
|
|
"type": "regular",
|
|
"start_date": start_date,
|
|
"end_date": start_date + timedelta(days=7),
|
|
"period": "weekly",
|
|
"pickup_day": "3",
|
|
"cutoff_day": "0",
|
|
}
|
|
)
|
|
self.assertTrue(order.exists())
|
|
|
|
def test_group_order_date_validation_start_after_end(self):
|
|
"""Test that start_date must be before end_date."""
|
|
start_date = datetime.now().date()
|
|
end_date = start_date - timedelta(days=1) # End before start
|
|
|
|
with self.assertRaises(ValidationError):
|
|
self.env["group.order"].create(
|
|
{
|
|
"name": "Bad Dates Order",
|
|
"group_ids": [(6, 0, [self.group_c1.id])],
|
|
"type": "regular",
|
|
"start_date": start_date,
|
|
"end_date": end_date,
|
|
"period": "weekly",
|
|
"pickup_day": "3",
|
|
"cutoff_day": "0",
|
|
}
|
|
)
|
|
|
|
def test_group_order_date_validation_same_date(self):
|
|
"""Test that start_date == end_date is allowed (single-day order)."""
|
|
same_date = datetime.now().date()
|
|
|
|
order = self.env["group.order"].create(
|
|
{
|
|
"name": "Same Day Order",
|
|
"group_ids": [(6, 0, [self.group_c1.id])],
|
|
"type": "regular",
|
|
"start_date": same_date,
|
|
"end_date": same_date,
|
|
"period": "once",
|
|
"pickup_day": "0",
|
|
"cutoff_day": "0",
|
|
}
|
|
)
|
|
self.assertTrue(order.exists())
|
|
|
|
|
|
class TestGroupOrderImageFallback(TransactionCase):
|
|
"""Test image_1920 computed field fallback logic."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.group = self.env["res.partner"].create(
|
|
{
|
|
"name": "Test Group",
|
|
"is_company": 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",
|
|
}
|
|
)
|
|
|
|
def test_image_fallback_order_image_first(self):
|
|
"""Test that order image takes priority over group image."""
|
|
# Set both order and group image
|
|
test_image = b"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
|
|
|
|
self.group_order.image_1920 = test_image
|
|
self.group.image_1920 = test_image
|
|
|
|
# Order image should be returned
|
|
computed_image = self.group_order.image_1920
|
|
self.assertEqual(computed_image, test_image)
|
|
|
|
def test_image_fallback_group_image_when_no_order_image(self):
|
|
"""Test fallback to group image when order has no image."""
|
|
test_image = b"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
|
|
|
|
# Only set group image
|
|
self.group_order.image_1920 = False
|
|
self.group.image_1920 = test_image
|
|
|
|
# Group image should be returned as fallback
|
|
# Note: This requires the computed field logic to be tested
|
|
# after field recalculation
|
|
|
|
def test_image_fallback_none_when_no_images(self):
|
|
"""Test that None is returned when no image available."""
|
|
# No images set
|
|
self.group_order.image_1920 = False
|
|
self.group.image_1920 = False
|
|
|
|
# Should be empty/False
|
|
computed_image = self.group_order.image_1920
|
|
self.assertFalse(computed_image)
|
|
|
|
|
|
class TestGroupOrderProductCount(TransactionCase):
|
|
"""Test product_count computed field."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.group = self.env["res.partner"].create(
|
|
{
|
|
"name": "Test Group",
|
|
"is_company": 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.product1 = self.env["product.product"].create(
|
|
{
|
|
"name": "Product 1",
|
|
"type": "consu",
|
|
"list_price": 10.0,
|
|
}
|
|
)
|
|
|
|
self.product2 = self.env["product.product"].create(
|
|
{
|
|
"name": "Product 2",
|
|
"type": "consu",
|
|
"list_price": 20.0,
|
|
}
|
|
)
|
|
|
|
def test_product_count_initial_zero(self):
|
|
"""Test that new order has zero products."""
|
|
self.assertEqual(self.group_order.product_count, 0)
|
|
|
|
def test_product_count_increments_on_add(self):
|
|
"""Test that product_count increases when adding products."""
|
|
self.group_order.product_ids = [(4, self.product1.id)]
|
|
self.assertEqual(self.group_order.product_count, 1)
|
|
|
|
self.group_order.product_ids = [(4, self.product2.id)]
|
|
self.assertEqual(self.group_order.product_count, 2)
|
|
|
|
def test_product_count_decrements_on_remove(self):
|
|
"""Test that product_count decreases when removing products."""
|
|
self.group_order.product_ids = [(6, 0, [self.product1.id, self.product2.id])]
|
|
self.assertEqual(self.group_order.product_count, 2)
|
|
|
|
self.group_order.product_ids = [(3, self.product1.id)]
|
|
self.assertEqual(self.group_order.product_count, 1)
|
|
|
|
def test_product_count_all_removed(self):
|
|
"""Test that product_count is zero when all removed."""
|
|
self.group_order.product_ids = [(6, 0, [self.product1.id, self.product2.id])]
|
|
self.group_order.product_ids = [(6, 0, [])]
|
|
self.assertEqual(self.group_order.product_count, 0)
|
|
|
|
|
|
class TestStateTransitions(TransactionCase):
|
|
"""Test group.order state transition validation."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.group = self.env["res.partner"].create(
|
|
{
|
|
"name": "Test Group",
|
|
"is_company": True,
|
|
}
|
|
)
|
|
|
|
start_date = datetime.now().date()
|
|
self.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",
|
|
}
|
|
)
|
|
|
|
def test_illegal_transition_draft_to_closed(self):
|
|
"""Test that Draft -> Closed transition is not allowed."""
|
|
# Should not allow skipping Open state
|
|
self.assertEqual(self.order.state, "draft")
|
|
|
|
# Calling action_close() without action_open() should fail
|
|
with self.assertRaises((ValidationError, UserError)):
|
|
self.order.action_close()
|
|
|
|
def test_illegal_transition_cancelled_to_open(self):
|
|
"""Test that Cancelled -> Open transition is not allowed."""
|
|
self.order.action_cancel()
|
|
self.assertEqual(self.order.state, "cancelled")
|
|
|
|
# Should not allow re-opening cancelled order
|
|
with self.assertRaises((ValidationError, UserError)):
|
|
self.order.action_open()
|
|
|
|
def test_legal_transition_draft_open_closed(self):
|
|
"""Test that Draft -> Open -> Closed is allowed."""
|
|
self.assertEqual(self.order.state, "draft")
|
|
|
|
self.order.action_open()
|
|
self.assertEqual(self.order.state, "open")
|
|
|
|
self.order.action_close()
|
|
self.assertEqual(self.order.state, "closed")
|
|
|
|
def test_transition_draft_to_cancelled(self):
|
|
"""Test that Draft -> Cancelled is allowed."""
|
|
self.assertEqual(self.order.state, "draft")
|
|
|
|
self.order.action_cancel()
|
|
self.assertEqual(self.order.state, "cancelled")
|
|
|
|
def test_transition_open_to_cancelled(self):
|
|
"""Test that Open -> Cancelled is allowed (emergency stop)."""
|
|
self.order.action_open()
|
|
self.assertEqual(self.order.state, "open")
|
|
|
|
self.order.action_cancel()
|
|
self.assertEqual(self.order.state, "cancelled")
|
|
|
|
|
|
class TestUserPartnerValidation(TransactionCase):
|
|
"""Test validation when user has no partner_id."""
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.group = self.env["res.partner"].create(
|
|
{
|
|
"name": "Test Group",
|
|
"is_company": True,
|
|
}
|
|
)
|
|
|
|
# Create user without partner (edge case)
|
|
self.user_no_partner = self.env["res.users"].create(
|
|
{
|
|
"name": "User No Partner",
|
|
"login": "noparnter@test.com",
|
|
"partner_id": False, # Explicitly no partner
|
|
}
|
|
)
|
|
|
|
def test_user_without_partner_cannot_access_order(self):
|
|
"""Test that user without partner_id has no access to orders."""
|
|
start_date = datetime.now().date()
|
|
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",
|
|
}
|
|
)
|
|
|
|
# User without partner should not have access
|
|
# This should be validated in controller
|
|
self.assertFalse(self.user_no_partner.partner_id)
|