add unit tests

Signed-off-by: tdruez <tdruez@aboutcode.org>

Author: tdruez

component_catalog/tests/test_models.py

@@ -36,6 +36,7 @@
 from component_catalog.models import ComponentType
 from component_catalog.models import LicenseExpressionMixin
 from component_catalog.models import Package
+from component_catalog.models import PackageAffectedByVulnerability
 from component_catalog.models import PackageAlreadyExistsWarning
 from component_catalog.models import Subcomponent
 from component_catalog.tests import make_package
@@ -1372,9 +1373,15 @@ def test_component_catalog_models_get_exclude_candidates_fields(self):
         )
 
         for model_class, expected in input_data:
-            results = [f.name for f in model_class().get_exclude_candidates_fields()]
+            results = [field.name for field in model_class().get_exclude_candidates_fields()]
             self.assertEqual(sorted(expected), sorted(results))
 
+    def test_package_affected_by_vulnerability_excludes_auto_now_add_fields(self):
+        field_names = [
+            field.name for field in PackageAffectedByVulnerability().get_exclude_candidates_fields()
+        ]
+        self.assertNotIn("detected_date", field_names)
+
     def test_component_create_with_or_and_and_in_license_name_and_key(self):
         or_license = License.objects.create(
             key="orrible",

policy/tests/test_rules.py

@@ -202,6 +202,22 @@ def test_does_not_count_links_with_terminal_analysis(self):
         count = UnresolvedVulnerabilityRule().count_violations(self.product, 0, {})
         self.assertEqual(0, count)
 
+    def test_does_not_count_links_with_resolved_with_pedigree_analysis(self):
+        package = make_package(self.dataspace)
+        vulnerability = make_vulnerability(self.dataspace, affecting=package)
+        product_package = make_product_package(self.product, package=package)
+        make_vulnerability_analysis(product_package, vulnerability, state="resolved_with_pedigree")
+        count = UnresolvedVulnerabilityRule().count_violations(self.product, 0, {})
+        self.assertEqual(0, count)
+
+    def test_does_not_count_links_with_not_affected_analysis(self):
+        package = make_package(self.dataspace)
+        vulnerability = make_vulnerability(self.dataspace, affecting=package)
+        product_package = make_product_package(self.product, package=package)
+        make_vulnerability_analysis(product_package, vulnerability, state="not_affected")
+        count = UnresolvedVulnerabilityRule().count_violations(self.product, 0, {})
+        self.assertEqual(0, count)
+
 
 class StaleVulnerabilityRuleTestCase(TestCase):
     def setUp(self):
@@ -237,6 +253,17 @@ def test_does_not_count_links_below_min_risk_score(self):
         count = StaleVulnerabilityRule().count_violations(self.product, 0, {})
         self.assertEqual(0, count)
 
+    def test_custom_max_days_triggers_for_links_within_window(self):
+        package = make_package(self.dataspace)
+        vulnerability = make_vulnerability(self.dataspace, affecting=package, risk_score=9.0)
+        make_product_package(self.product, package=package)
+        recent_date = timezone.now() - timedelta(days=10)
+        PackageAffectedByVulnerability.objects.filter(
+            package=package, vulnerability=vulnerability
+        ).update(detected_date=recent_date)
+        count = StaleVulnerabilityRule().count_violations(self.product, 0, {"max_days": 5})
+        self.assertEqual(1, count)
+
     def test_does_not_count_stale_links_with_terminal_analysis(self):
         package = make_package(self.dataspace)
         vulnerability = make_vulnerability(self.dataspace, affecting=package, risk_score=9.0)

product_portfolio/tests/test_filters.py

@@ -10,18 +10,22 @@
 from django.test import TestCase
 
 from component_catalog.models import Package
+from component_catalog.tests import make_component
 from component_catalog.tests import make_package
 from dje.models import Dataspace
 from license_library.models import License
 from organization.models import Owner
 from policy.models import UsagePolicy
+from product_portfolio.filters import ProductComponentFilterSet
 from product_portfolio.filters import ProductFilterSet
 from product_portfolio.filters import ProductPackageFilterSet
 from product_portfolio.models import Product
 from product_portfolio.models import ProductPackage
 from product_portfolio.models import ProductPolicyViolation
 from product_portfolio.tests import make_product
+from product_portfolio.tests import make_product_component
 from product_portfolio.tests import make_product_package
+from vulnerabilities.tests import make_vulnerability
 
 
 class ProductPackageFilterSetTestCase(TestCase):
@@ -164,3 +168,35 @@ def test_filter_by_unknown_rule_returns_all(self):
         )
         self.assertIn(self.pp_with_policy, filterset.qs)
         self.assertIn(self.pp_without_policy, filterset.qs)
+
+
+class ProductPackageFilterByRuleDistinctTestCase(TestCase):
+    def setUp(self):
+        self.dataspace = Dataspace.objects.create(name="nexB")
+        self.product = make_product(self.dataspace)
+
+    def test_filter_by_vulnerability_rule_returns_distinct_results(self):
+        package = make_package(self.dataspace)
+        make_vulnerability(self.dataspace, affecting=package)
+        make_vulnerability(self.dataspace, affecting=package)
+        make_product_package(self.product, package=package)
+        filterset = ProductPackageFilterSet(
+            dataspace=self.dataspace,
+            data={"policy_rule": "vulnerability_detected"},
+        )
+        self.assertEqual(1, filterset.qs.count())
+
+
+class ProductComponentFilterByRuleTestCase(TestCase):
+    def setUp(self):
+        self.dataspace = Dataspace.objects.create(name="nexB")
+        self.product = make_product(self.dataspace)
+
+    def test_filter_by_policy_rule_returns_empty_for_components(self):
+        component = make_component(self.dataspace)
+        make_product_component(self.product, component=component)
+        filterset = ProductComponentFilterSet(
+            dataspace=self.dataspace,
+            data={"policy_rule": "usage_policy_error"},
+        )
+        self.assertEqual(0, filterset.qs.count())

product_portfolio/tests/test_models.py

@@ -1375,6 +1375,11 @@ def test_with_policy_violation_count_counts_unresolved_violations(self):
         qs = Product.unsecured_objects.filter(pk=self.product.pk).with_policy_violation_count()
         self.assertEqual(2, qs.get().policy_violation_count)
 
+    def test_with_policy_violation_count_excludes_obsolete_rule_types(self):
+        self._make_violation("obsolete_rule")
+        qs = Product.unsecured_objects.filter(pk=self.product.pk).with_policy_violation_count()
+        self.assertEqual(0, qs.get().policy_violation_count)
+
     def test_with_compliance_issues_includes_product_with_policy_violation(self):
         self._make_violation("usage_policy_error")
         qs = (