Add generic adapter capability model

tests/test_adapter_models.py

@@ -0,0 +1,103 @@
+import unittest
+
+from dns_sync.adapters import (
+    CERTIFICATES,
+    DNS_RECORDS,
+    PROXY_HOSTS,
+    Capability,
+    CapabilityOperation,
+    Endpoint,
+    EndpointPlan,
+    NormalizedObject,
+    Observation,
+    PlanAction,
+    PlanOperation,
+)
+
+
+class EndpointTests(unittest.TestCase):
+    def test_identity_uses_plugin_and_address_not_label(self):
+        eve = Endpoint("NPM", "192.168.1.3:81/", label="EVE")
+        renamed = Endpoint("npm", "192.168.1.3:81", label="anything")
+
+        self.assertEqual(eve.identity, "npm://192.168.1.3:81")
+        self.assertEqual(eve.identity, renamed.identity)
+
+    def test_empty_endpoint_fields_are_rejected(self):
+        with self.assertRaises(ValueError):
+            Endpoint("", "192.168.1.3:81")
+
+        with self.assertRaises(ValueError):
+            Endpoint("npm", "")
+
+
+class CapabilityTests(unittest.TestCase):
+    def test_capabilities_are_object_type_specific(self):
+        capabilities = frozenset(
+            {
+                Capability(PROXY_HOSTS, CapabilityOperation.DISCOVER),
+                Capability(PROXY_HOSTS, CapabilityOperation.APPLY),
+                Capability(CERTIFICATES, CapabilityOperation.DISCOVER),
+                Capability(CERTIFICATES, CapabilityOperation.APPLY),
+                Capability(DNS_RECORDS, CapabilityOperation.DISCOVER),
+            }
+        )
+
+        self.assertIn(
+            Capability(CERTIFICATES, CapabilityOperation.APPLY),
+            capabilities,
+        )
+        self.assertNotIn(
+            Capability(DNS_RECORDS, CapabilityOperation.APPLY),
+            capabilities,
+        )
+
+
+class ObservationAndPlanTests(unittest.TestCase):
+    def test_local_objects_can_share_one_logical_identity(self):
+        first = NormalizedObject(
+            object_type=CERTIFICATES,
+            logical_key="chaptarr.loxthelion.com",
+            local_key="63",
+            payload={"expires_on": "2026-10-01T00:00:00+00:00"},
+        )
+        second = NormalizedObject(
+            object_type=CERTIFICATES,
+            logical_key="chaptarr.loxthelion.com",
+            local_key="67",
+            payload={"expires_on": "2026-11-01T00:00:00+00:00"},
+        )
+
+        observations = [
+            Observation("npm://192.168.1.3:81", first),
+            Observation("npm://192.168.1.3:81", second),
+        ]
+
+        self.assertEqual(
+            observations[0].object.logical_key,
+            observations[1].object.logical_key,
+        )
+        self.assertNotEqual(
+            observations[0].object.local_key,
+            observations[1].object.local_key,
+        )
+
+    def test_plan_is_scoped_to_one_endpoint(self):
+        desired = NormalizedObject(
+            object_type=DNS_RECORDS,
+            logical_key="example.loxthelion.com",
+            payload={
+                "hostname": "example.loxthelion.com",
+                "ip": "192.168.1.101",
+                "record_type": "A",
+            },
+        )
+        action = PlanAction(
+            endpoint_id="verizon://192.168.1.1",
+            operation=PlanOperation.CREATE,
+            desired=desired,
+        )
+        plan = EndpointPlan(action.endpoint_id, (action,))
+
+        self.assertEqual(plan.endpoint_id, "verizon://192.168.1.1")
+        self.assertEqual(plan.actions, (action,))

tests/test_legacy_dns_engine.py

@@ -0,0 +1,54 @@
+import unittest
+
+from dns_sync.engine import build_sync_plan
+from dns_sync.models import (
+    DesiredRecord,
+    ProviderCapabilities,
+    ProviderRecord,
+)
+
+
+class LegacyDnsEngineTests(unittest.TestCase):
+    def test_existing_dns_plan_still_adds_updates_and_preserves_matches(self):
+        desired = {
+            "add.example.com": DesiredRecord(
+                hostname="add.example.com",
+                ip="192.168.1.101",
+            ),
+            "keep.example.com": DesiredRecord(
+                hostname="keep.example.com",
+                ip="192.168.1.101",
+            ),
+            "update.example.com": DesiredRecord(
+                hostname="update.example.com",
+                ip="192.168.1.101",
+            ),
+        }
+        current = {
+            "keep.example.com": ProviderRecord(
+                hostname="keep.example.com",
+                ip="192.168.1.101",
+            ),
+            "update.example.com": ProviderRecord(
+                hostname="update.example.com",
+                ip="192.168.1.50",
+            ),
+        }
+
+        plan = build_sync_plan(
+            desired,
+            current,
+            ProviderCapabilities(),
+        )
+
+        actions = {
+            item.desired.hostname: item.action
+            for item in plan
+        }
+        self.assertEqual(actions["add.example.com"], "ADD")
+        self.assertEqual(actions["keep.example.com"], "UNCHANGED")
+        self.assertEqual(actions["update.example.com"], "UPDATE")
+
+
+if __name__ == "__main__":
+    unittest.main()