fix: use incident code instead of uuid in geojson properties, add missing tests

Bug fix:
- spp_api_v2_gis _get_geojson_properties used incident_id.uuid but
  spp.hazard.incident has no uuid field; use .code instead

New tests in spp_gis (11 added, 78 total):
- UUID copy=False generates new UUID on copy
- Rename to duplicate active name raises ValidationError
- Reactivate archived record with duplicate name raises ValidationError
- create_from_geojson accepts dict input (not just string)
- Different geometry sizes produce different area_sqkm values
- Empty recordset to_geojson_collection returns empty features
- GeoJSON property values are correct (not just keys present)
- Description defaults to empty string in properties
- geofence_type defaults to "custom" when omitted
- area_sqkm is strictly positive for known test polygon
- Archived geofences excluded from default search

New tests in spp_hazard (5 added, 38 total):
- hazard_zone geofence type via selection_add
- Geofence linked to actual hazard incident
- incident_id ondelete set null behavior
- hazard_zone type label in GeoJSON properties
- Geofence without incident works fine

New test in spp_api_v2_gis (1 added, 191 total):
- Linked incident code and name appear in GeoJSON properties

Author: jeremi

spp_api_v2_gis/models/geofence.py

@@ -21,6 +21,6 @@ class GisGeofence(models.Model):
     def _get_geojson_properties(self):
         """Extend properties with incident info from spp_hazard."""
         props = super()._get_geojson_properties()
-        props["incident_id"] = self.incident_id.uuid if self.incident_id and hasattr(self.incident_id, "uuid") else None
+        props["incident_id"] = self.incident_id.code if self.incident_id else None
         props["incident_name"] = self.incident_id.name if self.incident_id else None
         return props

spp_api_v2_gis/tests/test_geofence_model.py

@@ -61,9 +61,8 @@ def test_geofence_targeting_area_type(self):
 
         self.assertEqual(geofence.geofence_type, "targeting_area")
 
-    def test_geojson_properties_include_incident(self):
-        """Test that incident fields appear in properties when spp_hazard adds them."""
-        # incident_id should be available since spp_hazard is a dependency
+    def test_geojson_properties_incident_none(self):
+        """Test that incident fields are None when no incident is linked."""
         geofence = self.env["spp.gis.geofence"].create(
             {
                 "name": "Incident Props Test",
@@ -72,16 +71,45 @@ def test_geojson_properties_include_incident(self):
             }
         )
 
-        feature = geofence.to_geojson()
-        props = feature["properties"]
+        props = geofence.to_geojson()["properties"]
 
-        # spp_api_v2_gis extends _get_geojson_properties with incident fields
         self.assertIn("incident_id", props)
         self.assertIn("incident_name", props)
-        # No incident linked, so values should be None
         self.assertIsNone(props["incident_id"])
         self.assertIsNone(props["incident_name"])
 
+    def test_geojson_properties_with_linked_incident(self):
+        """Test that incident code and name appear in properties when linked."""
+        # Create a hazard incident
+        category = self.env["spp.hazard.category"].create(
+            {
+                "name": "Test Cat GIS",
+                "code": "TEST_CAT_GIS_API",
+            }
+        )
+        incident = self.env["spp.hazard.incident"].create(
+            {
+                "name": "API Test Incident",
+                "code": "API-INC-001",
+                "category_id": category.id,
+                "start_date": "2024-01-01",
+            }
+        )
+
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Linked Incident Test",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "hazard_zone",
+                "incident_id": incident.id,
+            }
+        )
+
+        props = geofence.to_geojson()["properties"]
+
+        self.assertEqual(props["incident_id"], "API-INC-001")
+        self.assertEqual(props["incident_name"], "API Test Incident")
+
     def test_geofence_type_label_service_area(self):
         """Test that service_area type label is correct."""
         geofence = self.env["spp.gis.geofence"].create(

spp_gis/tests/test_geofence.py

@@ -502,3 +502,204 @@ def test_geofence_uuid_in_properties(self):
         self.assertIn("uuid", props)
         self.assertNotIn("id", props)
         self.assertEqual(props["uuid"], geofence.uuid)
+
+    def test_geofence_uuid_copy_generates_new(self):
+        """Test that copying a geofence generates a new UUID."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "UUID Copy Original",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        copied = geofence.copy({"name": "UUID Copy Clone"})
+
+        self.assertTrue(copied.uuid)
+        self.assertNotEqual(geofence.uuid, copied.uuid)
+        self.assertEqual(len(copied.uuid), 36)
+
+    def test_geofence_rename_to_duplicate_raises(self):
+        """Test that renaming a geofence to an existing active name raises error."""
+        self.env["spp.gis.geofence"].create(
+            {
+                "name": "Existing Name",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        geofence2 = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Different Name",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        with self.assertRaises(ValidationError):
+            geofence2.write({"name": "Existing Name"})
+
+    def test_geofence_reactivate_duplicate_name_raises(self):
+        """Test that reactivating an archived geofence with a duplicate name raises error."""
+        self.env["spp.gis.geofence"].create(
+            {
+                "name": "Active Name",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        archived = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Temp Name",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+        archived.write({"active": False, "name": "Active Name"})
+
+        with self.assertRaises(ValidationError):
+            archived.write({"active": True})
+
+    def test_create_from_geojson_dict_input(self):
+        """Test creating geofence from dict input (not string)."""
+        geofence = self.env["spp.gis.geofence"].create_from_geojson(
+            geojson_str=self.sample_polygon,
+            name="Dict Input",
+            geofence_type="custom",
+        )
+
+        self.assertTrue(geofence)
+        self.assertEqual(geofence.name, "Dict Input")
+
+    def test_geofence_area_varies_by_geometry_size(self):
+        """Test that different sized geometries produce different areas."""
+        small_geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Small Area",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        # 2x2 degree polygon (roughly 4x the area of 1x1)
+        larger_polygon = {
+            "type": "Polygon",
+            "coordinates": [
+                [
+                    [100.0, 0.0],
+                    [102.0, 0.0],
+                    [102.0, 2.0],
+                    [100.0, 2.0],
+                    [100.0, 0.0],
+                ]
+            ],
+        }
+        large_geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Large Area",
+                "geometry": json.dumps(larger_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        self.assertGreater(small_geofence.area_sqkm, 0)
+        self.assertGreater(large_geofence.area_sqkm, small_geofence.area_sqkm)
+
+    def test_to_geojson_collection_empty_recordset(self):
+        """Test to_geojson_collection with empty recordset."""
+        empty = self.env["spp.gis.geofence"].browse([])
+        collection = empty.to_geojson_collection()
+
+        self.assertEqual(collection["type"], "FeatureCollection")
+        self.assertEqual(collection["features"], [])
+
+    def test_geojson_properties_values_correct(self):
+        """Test that GeoJSON property values are correct, not just present."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Values Check",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "area_of_interest",
+                "created_from": "api",
+                "tag_ids": [(6, 0, [self.tag1.id])],
+            }
+        )
+
+        props = geofence.to_geojson()["properties"]
+
+        self.assertEqual(props["uuid"], geofence.uuid)
+        self.assertEqual(props["name"], "Values Check")
+        self.assertEqual(props["description"], "")
+        self.assertEqual(props["geofence_type"], "area_of_interest")
+        self.assertEqual(props["geofence_type_label"], "Area of Interest")
+        self.assertIsInstance(props["area_sqkm"], float)
+        self.assertEqual(props["tags"], ["Test Tag 1"])
+        self.assertEqual(props["created_from"], "api")
+        self.assertEqual(props["created_by"], self.env.user.name)
+        self.assertIsNotNone(props["create_date"])
+
+    def test_geofence_description_none_becomes_empty_string(self):
+        """Test that missing description becomes empty string in properties."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "No Description",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        props = geofence.to_geojson()["properties"]
+        self.assertEqual(props["description"], "")
+
+    def test_geofence_type_defaults_to_custom(self):
+        """Test that geofence_type defaults to custom when not specified."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Default Type Test",
+                "geometry": json.dumps(self.sample_polygon),
+            }
+        )
+
+        self.assertEqual(geofence.geofence_type, "custom")
+
+    def test_geofence_area_positive_for_known_polygon(self):
+        """Test that area is strictly positive for the known ~12,300 sqkm test polygon."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Positive Area Test",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        # 1 degree x 1 degree near equator is roughly 12,300 sq km
+        self.assertGreater(geofence.area_sqkm, 0)
+
+    def test_geofence_archive_excludes_from_search(self):
+        """Test that archived geofences are excluded from default search."""
+        geofence = self.env["spp.gis.geofence"].create(
+            {
+                "name": "Archive Search Test",
+                "geometry": json.dumps(self.sample_polygon),
+                "geofence_type": "custom",
+            }
+        )
+
+        # Should be found by default search
+        found = self.env["spp.gis.geofence"].search([("name", "=", "Archive Search Test")])
+        self.assertEqual(len(found), 1)
+
+        # Archive it
+        geofence.write({"active": False})
+
+        # Should no longer appear in default search
+        found = self.env["spp.gis.geofence"].search([("name", "=", "Archive Search Test")])
+        self.assertEqual(len(found), 0)
+
+        # Should appear when explicitly searching inactive
+        found = (
+            self.env["spp.gis.geofence"].with_context(active_test=False).search([("name", "=", "Archive Search Test")])
+        )
+        self.assertEqual(len(found), 1)

spp_hazard/tests/__init__.py

@@ -4,3 +4,4 @@
 from . import test_hazard_incident
 from . import test_hazard_impact
 from . import test_hazard_impact_type
+from . import test_geofence