Merge pull request #291 from American-Institutes-for-Research/HEA-1094/fix_FoodPurchase_and_OtherPurchase_validations

Update validate_quantity_purchased and validate_quantity_produced met…

Author: rhunwicks

apps/baseline/models.py

@@ -2474,20 +2474,27 @@ class FoodPurchase(LivelihoodActivity):
         help_text=_("Number of times in a year that the purchase is made"),
     )
 
+    def calculate_fields(self):
+        if self.times_per_year is None and self.times_per_month is not None and self.months_per_year is not None:
+            self.times_per_year = self.times_per_month * self.months_per_year
+        if self.quantity_purchased is None and self.unit_multiple is not None and self.times_per_year is not None:
+            self.quantity_purchased = self.unit_multiple * self.times_per_year
+        super().calculate_fields()
+
     def validate_quantity_purchased(self):
-        if (
-            self.quantity_purchased is not None
-            and self.unit_multiple is not None
-            and self.times_per_month is not None
-            and self.months_per_year is not None
-        ):
-            if not math.isclose(
-                self.quantity_purchased, self.unit_multiple * self.times_per_month * self.months_per_year
-            ):
+        if self.times_per_month is not None and self.months_per_year is not None:
+            expected_times_per_year = self.times_per_month * self.months_per_year
+            if self.times_per_year is not None and not math.isclose(self.times_per_year, expected_times_per_year):
                 raise ValidationError(
                     _(
-                        "Quantity purchased for a Food Purchase must be purchase amount * purchases per month * months per year"  # NOQA: E501
+                        "Times per year must be times per month * months per year. Expected: %(expected)s, Found: %(found)s"  # NOQA: E501
                     )
+                    % {"expected": expected_times_per_year, "found": self.times_per_year}
+                )
+        if self.quantity_purchased is not None and self.unit_multiple is not None and self.times_per_year is not None:
+            if not math.isclose(self.quantity_purchased, self.unit_multiple * self.times_per_year):
+                raise ValidationError(
+                    _("Quantity purchased for a Food Purchase must be purchase amount * purchases per year")
                 )
 
     def validate_expenditure(self):
@@ -2569,21 +2576,41 @@ def clean(self):
             )
         super().clean()
 
+    def calculate_fields(self):
+        if self.times_per_year is None and self.times_per_month is not None and self.months_per_year is not None:
+            self.times_per_year = self.times_per_month * self.months_per_year
+        if (
+            self.quantity_produced is None
+            and self.payment_per_time is not None
+            and self.people_per_household is not None
+            and self.times_per_year is not None
+        ):
+            self.quantity_produced = self.payment_per_time * self.people_per_household * self.times_per_year
+        super().calculate_fields()
+
     def validate_quantity_produced(self):
+        if self.times_per_month is not None and self.months_per_year is not None:
+            expected_times_per_year = self.times_per_month * self.months_per_year
+            if self.times_per_year is not None and not math.isclose(self.times_per_year, expected_times_per_year):
+                raise ValidationError(
+                    _(
+                        "Times per year must be times per month * months per year. Expected: %(expected)s, Found: %(found)s"  # NOQA: E501
+                    )
+                    % {"expected": expected_times_per_year, "found": self.times_per_year}
+                )
         if (
             self.quantity_produced is not None
             and self.payment_per_time is not None
             and self.people_per_household is not None
-            and self.times_per_month is not None
-            and self.months_per_year is not None
+            and self.times_per_year is not None
         ):
             if not math.isclose(
                 self.quantity_produced,
-                self.payment_per_time * self.people_per_household * self.times_per_month * self.months_per_year,
+                self.payment_per_time * self.people_per_household * self.times_per_year,
             ):
                 raise ValidationError(
                     _(
-                        "Quantity produced for Payment In Kind must be payment per time * number of people * labor per month * months per year"  # NOQA: E501
+                        "Quantity produced for Payment In Kind must be payment per time * number of people * times per year"  # NOQA: E501
                     )
                 )
 
@@ -2626,7 +2653,23 @@ class ReliefGiftOther(LivelihoodActivity):
         help_text=_("Number of times in a year that the item is received"),
     )
 
+    def calculate_fields(self):
+        if self.times_per_year is None and self.times_per_month is not None and self.months_per_year is not None:
+            self.times_per_year = self.times_per_month * self.months_per_year
+        if self.quantity_produced is None and self.unit_multiple is not None and self.times_per_year is not None:
+            self.quantity_produced = self.unit_multiple * self.times_per_year
+        super().calculate_fields()
+
     def validate_quantity_produced(self):
+        if self.times_per_month is not None and self.months_per_year is not None:
+            expected_times_per_year = self.times_per_month * self.months_per_year
+            if self.times_per_year is not None and not math.isclose(self.times_per_year, expected_times_per_year):
+                raise ValidationError(
+                    _(
+                        "Times per year must be times per month * months per year. Expected: %(expected)s, Found: %(found)s"  # NOQA: E501
+                    )
+                    % {"expected": expected_times_per_year, "found": self.times_per_year}
+                )
         if self.quantity_produced is not None and self.unit_multiple is not None and self.times_per_year is not None:
             if not math.isclose(self.quantity_produced, self.unit_multiple * self.times_per_year):
                 raise ValidationError(
@@ -2733,26 +2776,31 @@ def clean(self):
     def validate_income(self):
         if (
             self.people_per_household is not None
-            and self.income is not None
-            and self.payment_per_time is not None
             and self.times_per_month is not None
             and self.months_per_year is not None
         ):
-            if not math.isclose(
-                self.income,
-                self.payment_per_time * self.people_per_household * self.times_per_month * self.months_per_year,
-            ):
+            expected_times_per_year = self.people_per_household * self.times_per_month * self.months_per_year
+            if self.times_per_year is not None and not math.isclose(self.times_per_year, expected_times_per_year):
                 raise ValidationError(
                     _(
-                        "Quantity produced for Other Cash Income must be payment per time * number of people * labor per month * months per year"  # NOQA: E501
+                        "Times per year must be people per household * times per month * months per year. Expected: %(expected)s, Found: %(found)s"  # NOQA: E501
                     )
+                    % {"expected": expected_times_per_year, "found": self.times_per_year}
                 )
-        elif self.income is not None and self.payment_per_time is not None and self.times_per_year is not None:
+        if self.income is not None and self.payment_per_time is not None and self.times_per_year is not None:
             if not math.isclose(self.income, self.payment_per_time * self.times_per_year):
                 raise ValidationError(_("Income for 'Other Cash Income' must be payment per time * times per year"))
 
     def calculate_fields(self):
-        self.times_per_year = self.people_per_household * self.times_per_month * self.months_per_year
+        if (
+            self.times_per_year is None
+            and self.people_per_household is not None
+            and self.times_per_month is not None
+            and self.months_per_year is not None
+        ):
+            self.times_per_year = self.people_per_household * self.times_per_month * self.months_per_year
+        if self.income is None and self.payment_per_time is not None and self.times_per_year is not None:
+            self.income = self.payment_per_time * self.times_per_year
         super().calculate_fields()
 
     class Meta:
@@ -2796,6 +2844,18 @@ class OtherPurchase(LivelihoodActivity):
         help_text=_("Number of times in a year that the product is purchased"),
     )
 
+    def calculate_fields(self):
+        if self.times_per_year is None and self.times_per_month is not None and self.months_per_year is not None:
+            self.times_per_year = self.times_per_month * self.months_per_year
+        if (
+            self.expenditure is None
+            and self.price is not None
+            and self.unit_multiple is not None
+            and self.times_per_year is not None
+        ):
+            self.expenditure = self.price * self.unit_multiple * self.times_per_year
+        super().calculate_fields()
+
     def validate_expenditure(self):
         errors = []
         if self.times_per_month is not None and self.months_per_year is not None:

apps/baseline/tests/factories.py

@@ -664,7 +664,7 @@ class Meta:
     people_per_household = fuzzy.FuzzyInteger(1, 30)
     times_per_month = fuzzy.FuzzyInteger(1, 40)
     months_per_year = fuzzy.FuzzyInteger(1, 12)
-    times_per_year = factory.LazyAttribute(lambda o: o.times_per_month * o.months_per_year)
+    times_per_year = factory.LazyAttribute(lambda o: o.people_per_household * o.times_per_month * o.months_per_year)
 
 
 class OtherPurchaseFactory(LivelihoodActivityFactory):

apps/baseline/tests/test_models.py

@@ -288,19 +288,37 @@ def setUpTestData(cls):
             unit_multiple=None,
             times_per_month=None,
             months_per_year=None,
+            times_per_year=None,
             quantity_purchased=None,
         )
+        # Correct via times_per_month/months_per_year path (times_per_year matches)
         cls.foodpurchase2 = FoodPurchase(
             unit_multiple=2,
             times_per_month=5,
             months_per_year=12,
-            quantity_purchased=120,
+            times_per_year=60,  # 5 * 12 = 60
+            quantity_purchased=120,  # 2 * 60 = 120
         )
-        # Incorrect: 2 * 5 * 12 = 120
+        # Incorrect quantity_purchased: 2 * 60 = 120, not 100
         cls.foodpurchase3 = FoodPurchase(
             unit_multiple=2,
             times_per_month=5,
             months_per_year=12,
+            times_per_year=60,
+            quantity_purchased=100,
+        )
+        # Correct via times_per_year only (no times_per_month/months_per_year)
+        cls.foodpurchase4 = FoodPurchase(
+            unit_multiple=3,
+            times_per_year=10,
+            quantity_purchased=30,  # 3 * 10 = 30
+        )
+        # Inconsistent times_per_year vs times_per_month * months_per_year
+        cls.foodpurchase5 = FoodPurchase(
+            unit_multiple=2,
+            times_per_month=5,
+            months_per_year=12,
+            times_per_year=50,  # Incorrect: should be 60
             quantity_purchased=100,
         )
 
@@ -310,11 +328,16 @@ def test_validate_quantity_purchased(self):
         """
         # Missing data should not raise ValidationError
         self.foodpurchase1.validate_quantity_purchased()
-        # Expected consistant values, should not raise
+        # Correct via times_per_month/months_per_year (times_per_year set consistently)
         self.foodpurchase2.validate_quantity_purchased()
-        # Incorrect: 2 * 5 * 12 = 120
+        # Incorrect quantity_purchased
         with conditional_logging():
             self.assertRaises(ValidationError, self.foodpurchase3.validate_quantity_purchased)
+        # Correct via times_per_year only
+        self.foodpurchase4.validate_quantity_purchased()
+        # Inconsistent times_per_year
+        with self.assertRaises(ValidationError):
+            self.foodpurchase5.validate_quantity_purchased()
 
 
 class PaymentInKindTestCase(TestCase):
@@ -326,21 +349,26 @@ def setUpTestData(cls):
             people_per_household=None,
             times_per_month=None,
             months_per_year=None,
+            times_per_year=None,
             quantity_produced=None,
         )
+        # Correct: times_per_year = 5 * 12 = 60; quantity_produced = 10 * 2 * 60 = 1200
         cls.paymentinkind2 = PaymentInKind(
             payment_per_time=10,
             people_per_household=2,
             times_per_month=5,
             months_per_year=12,
-            quantity_produced=1200,  # 10 * 2 * 5 * 12 = 1200
+            times_per_year=60,
+            quantity_produced=1200,
         )
+        # Incorrect quantity_produced: 10 * 2 * 60 = 1200, not 1000
         cls.paymentinkind3 = PaymentInKind(
             payment_per_time=10,
             people_per_household=2,
             times_per_month=5,
             months_per_year=12,
-            quantity_produced=1000,  # Incorrect: should be 1200
+            times_per_year=60,
+            quantity_produced=1000,
         )
 
     def test_validate_quantity_produced(self):
@@ -350,10 +378,10 @@ def test_validate_quantity_produced(self):
         # Missing data should not raise ValidationError
         self.paymentinkind1.validate_quantity_produced()
 
-        # Expected consistent values, should not raise ValidationError
+        # Correct (times_per_year consistent with times_per_month * months_per_year)
         self.paymentinkind2.validate_quantity_produced()
 
-        # Incorrect: 10 * 2 * 5 * 12 = 1200
+        # Incorrect quantity_produced
         with self.assertRaises(ValidationError):
             self.paymentinkind3.validate_quantity_produced()
 
@@ -377,18 +405,22 @@ def setUpTestData(cls):
         # Create different instances without saving
         cls.reliefgift1 = ReliefGiftOther(
             unit_multiple=None,
+            times_per_month=None,
+            months_per_year=None,
             times_per_year=None,
             quantity_produced=None,
         )
+        # Correct via times_per_year only
         cls.reliefgift2 = ReliefGiftOther(
             unit_multiple=10,
             times_per_year=12,
             quantity_produced=120,  # 10 * 12 = 120
         )
+        # Incorrect quantity_produced
         cls.reliefgift3 = ReliefGiftOther(
             unit_multiple=10,
             times_per_year=12,
-            quantity_produced=100,  # Incorrect: should be 10 * 12 = 120
+            quantity_produced=100,  # Incorrect: should be 120
         )
 
     def test_validate_quantity_produced(self):
@@ -398,10 +430,10 @@ def test_validate_quantity_produced(self):
         # Missing data should not raise ValidationError
         self.reliefgift1.validate_quantity_produced()
 
-        # Expected consistent values, should not raise ValidationError
+        # Correct via times_per_year only
         self.reliefgift2.validate_quantity_produced()
 
-        # Incorrect: 10 * 12 = 120
+        # Incorrect quantity_produced
         with self.assertRaises(ValidationError):
             self.reliefgift3.validate_quantity_produced()
 
@@ -415,27 +447,34 @@ def setUpTestData(cls):
             people_per_household=None,
             times_per_month=None,
             months_per_year=None,
+            times_per_year=None,
             income=None,
         )
+        # Correct: times_per_year = 2 * 5 * 12 = 120; income = 100 * 120 = 12000
         cls.othercashincome2 = OtherCashIncome(
             payment_per_time=100,
             people_per_household=2,
             times_per_month=5,
             months_per_year=12,
-            income=12000,  # 100 * 2 * 5 * 12 = 12000
+            times_per_year=120,
+            income=12000,
         )
+        # Incorrect income: 100 * 120 = 12000, not 10000
         cls.othercashincome3 = OtherCashIncome(
             payment_per_time=100,
             people_per_household=2,
             times_per_month=5,
             months_per_year=12,
-            income=10000,  # Incorrect: should be 12000
+            times_per_year=120,
+            income=10000,
         )
+        # Correct via times_per_year only (no people_per_household/times_per_month)
         cls.othercashincome4 = OtherCashIncome(
             payment_per_time=100,
             times_per_year=24,
             income=2400,  # 100 * 24 = 2400
         )
+        # Incorrect income via times_per_year only
         cls.othercashincome5 = OtherCashIncome(
             payment_per_time=100,
             times_per_year=24,
@@ -448,7 +487,7 @@ def test_validate_income(self):
         # Correct data should not raise ValidationError
         self.othercashincome2.validate_income()
         self.othercashincome4.validate_income()
-        # Incorrect data should raise ValidationError.
+        # Incorrect income should raise ValidationError
         with self.assertRaises(ValidationError):
             self.othercashincome3.validate_income()
         with self.assertRaises(ValidationError):