chg ! fetch countries and offices by updated_at (#94)

Author: vitali-yanushchyk-valor

src/country_workspace/contrib/hope/sync/context_geo.py

@@ -32,7 +32,10 @@ def sync_countries(self) -> None:
         self.sync_entity(
             SyncConfig(
                 model=Country,
-                endpoint=EndpointConfig(path="lookups/country"),
+                endpoint=EndpointConfig(
+                    path="lookups/country",
+                    params={"updated_at_after": self.get_updated_at_after(Country)},
+                ),
                 prepare_defaults=lambda r: {f: r.get(f) for f in ("name", "iso_code2", "iso_code3")},
             ),
         )

src/country_workspace/contrib/hope/sync/context_programs.py

@@ -44,10 +44,12 @@ def sync_offices(self) -> None:
         self.sync_entity(
             SyncConfig(
                 model=Office,
-                endpoint=EndpointConfig(path="business_areas"),
+                endpoint=EndpointConfig(
+                    path="business_areas",
+                    params={"updated_at_after": self.get_updated_at_after(Office)},
+                ),
                 prepare_defaults=lambda r: {f: r.get(f) for f in ("name", "slug", "code", "long_name", "active")},
                 should_process=lambda r: r.get("active"),
-                should_deactivate=lambda r: not r.get("active"),
             ),
         )
 

tests/contrib/hope/conftest.py

@@ -1,4 +1,5 @@
-from typing import Callable, Any
+from collections.abc import Callable
+from typing import Any
 from unittest.mock import Mock
 import pytest
 from django.db.models import Q
@@ -25,6 +26,7 @@ def base_sync(mocker: MockerFixture) -> BaseSync:
 @pytest.fixture
 def mock_model(mocker: MockerFixture) -> Mock:
     model = mocker.Mock()
+    model.DoesNotExist = type("DoesNotExist", (Exception,), {})
     model._meta = mocker.Mock()
     model._meta.model_name = "test_model"
     return model

tests/contrib/hope/test_context_geo.py

@@ -1,108 +1,214 @@
+from collections.abc import Callable
 from unittest.mock import Mock
+from datetime import datetime, timezone, timedelta
 import pytest
 from pytest_mock import MockerFixture
 from mptt.exceptions import InvalidMove
 from uuid import uuid4
+from io import StringIO
 
-from country_workspace.contrib.hope.sync.base import LogLevel
+from country_workspace.contrib.hope.sync.base import BaseSync, SkipRecordError
 from country_workspace.contrib.hope.sync.context_geo import SyncContextGeo, SyncStep, sync_context_geo
+from country_workspace.models import Country, AreaType, Area
+
+_today = datetime.now(timezone.utc).date()
 
 COUNTRY = {
+    "path": "lookups/country",
+    "updated_at_after": "2025-05-05",
     "results": [
         {
             "id": str(uuid4()),
-            "name": "Ukraine",
-            "iso_code2": "UA",
-            "iso_code3": "UKR",
+            "name": "Testland Example",
+            "iso_code2": "TL",
+            "iso_code3": "TLD",
+            "short_name": "Testland",
         },
     ],
 }
 
-AREATYPE = {
+AREA_TYPES = {
+    "path": "areatypes",
+    "updated_at_after": "2025-05-05",
     "results": [
         {
             "id": str(uuid4()),
-            "name": "UA52",
-            "country": "UA",
-            "area_level": 1,
+            "name": "RegionExample",
+            "country": "country-hope-id",
+            "parent": "parent-hope-id",
+            "area_level": 2,
+            "valid_from": (_today - timedelta(days=30)).isoformat(),
+            "valid_until": (_today + timedelta(days=30)).isoformat(),
+            "extras": {"foo": "bar"},
         },
     ],
 }
 
-AREA = {
+
+AREAS = {
+    "path": "areas",
+    "updated_at_after": "2025-05-05",
     "results": [
         {
             "id": str(uuid4()),
-            "name": "Kyivska",
-            "p_code": "UA32",
-            "area_type": str(uuid4()),
-        }
+            "name": "AreaExample",
+            "area_type": "areatype-hope-id",
+            "parent": "parent-area-id",
+            "p_code": "P001",
+            "valid_from": (_today - timedelta(days=30)).isoformat(),
+            "valid_until": (_today + timedelta(days=30)).isoformat(),
+            "extras": {"x": "y"},
+        },
     ],
 }
 
 
-def test_assign_parents_success(mock_model: Mock, mocker: MockerFixture) -> None:
-    child_instance = Mock()
-    parent_instance = Mock()
-    mock_model.objects.get.side_effect = [child_instance, parent_instance]
-    mock_model.objects.bulk_update = Mock()
+@pytest.fixture
+def sync_geo(base_sync: BaseSync) -> Callable:
+    return SyncContextGeo(client=base_sync.client, stdout=base_sync.stdout)
+
+
+def test_sync_countries(mocker: MockerFixture, sync_geo: SyncContextGeo) -> None:
+    mock_sync_entity = mocker.patch.object(sync_geo, "sync_entity")
+    mocker.patch.object(sync_geo, "get_updated_at_after", return_value=COUNTRY["updated_at_after"])
+
+    sync_geo.sync_countries()
+
+    mock_sync_entity.assert_called_once()
+    config = mock_sync_entity.call_args.args[0]
+    assert config["model"] is Country
+    ep = config["endpoint"]
+    assert (ep["path"], ep.get("params")) == (COUNTRY["path"], {"updated_at_after": COUNTRY["updated_at_after"]})
+
+    expected_defaults = {k: COUNTRY["results"][0][k] for k in ("name", "iso_code2", "iso_code3")}
+    defaults = config["prepare_defaults"](COUNTRY["results"][0])
+    assert defaults == expected_defaults
 
-    sync_context = SyncContextGeo(client=mocker.Mock(), stdout=mocker.Mock())
 
-    parent_mapping = {"1": "2"}
-    sync_context._assign_parents(mock_model, parent_mapping)
+@pytest.mark.parametrize("expect_error", [False, True], ids=["Country-Exist", "Country-DoesNotExist"])
+def test_sync_area_types(mocker: MockerFixture, sync_geo: SyncContextGeo, expect_error: bool) -> None:
+    mocker.patch.object(sync_geo, "sync_countries")
+    m_entity = mocker.patch.object(sync_geo, "sync_entity")
+    mocker.patch.object(sync_geo, "get_updated_at_after", return_value=AREA_TYPES["updated_at_after"])
+    m_assign = mocker.patch.object(sync_geo, "_assign_parents")
+    m_rebuild = mocker.patch.object(AreaType.objects, "rebuild")
 
-    assert child_instance.parent == parent_instance
-    mock_model.objects.bulk_update.assert_called_once_with([child_instance], fields=["parent"])
+    if expect_error:
+        mock_country = mocker.patch.object(Country.objects, "get", side_effect=Country.DoesNotExist)
+    else:
+        mock_country = mocker.patch.object(Country.objects, "get", return_value=object())
+
+    sync_geo.sync_area_types()
+
+    m_entity.assert_called_once()
+    cfg = m_entity.call_args[0][0]
+    rec = AREA_TYPES["results"][0]
+
+    if expect_error:
+        with pytest.raises(SkipRecordError, match="Country not found."):
+            cfg["prepare_defaults"](rec)
+    else:
+        expected = {
+            "country": mock_country.return_value,
+            **{k: rec[k] for k in ("name", "area_level", "valid_from", "valid_until", "extras")},
+        }
+        assert cfg["prepare_defaults"](rec) == expected
+
+        m_assign.assert_called_once_with(AreaType, {rec["id"]: rec["parent"]})
+        m_rebuild.assert_called_once()
+
+
+@pytest.mark.parametrize("expect_error", [False, True], ids=["AreaType-Exist", "AreaType-DoesNotExist"])
+def test_sync_areas(mocker: MockerFixture, sync_geo: SyncContextGeo, expect_error: bool) -> None:
+    mocker.patch.object(sync_geo, "sync_area_types")
+    m_entity = mocker.patch.object(sync_geo, "sync_entity")
+    mocker.patch.object(sync_geo, "get_updated_at_after", return_value=AREAS["updated_at_after"])
+    m_assign = mocker.patch.object(sync_geo, "_assign_parents")
+    m_rebuild = mocker.patch.object(Area.objects, "rebuild")
+
+    if expect_error:
+        mocker.patch.object(AreaType.objects, "get", side_effect=AreaType.DoesNotExist)
+    else:
+        mock_area_type = mocker.patch.object(AreaType.objects, "get", return_value=object())
+
+    sync_geo.sync_areas()
+
+    m_entity.assert_called_once()
+    cfg = m_entity.call_args[0][0]
+    rec = AREAS["results"][0]
+
+    if expect_error:
+        with pytest.raises(SkipRecordError, match="AreaType not found."):
+            cfg["prepare_defaults"](rec)
+    else:
+        expected = {
+            "area_type": mock_area_type.return_value,
+            **{k: rec[k] for k in ("name", "p_code", "valid_from", "valid_until", "extras")},
+        }
+        assert cfg["prepare_defaults"](rec) == expected
+        m_assign.assert_called_once_with(Area, {rec["id"]: rec["parent"]})
+        m_rebuild.assert_called_once()
 
 
 @pytest.mark.parametrize(
-    ("get_side_effect", "error_message"),
+    ("child_ok", "parent_ok", "bulk_exc", "expected_bulk_calls", "expected_logs"),
     [
-        ([Exception("DoesNotExist"), Mock()], "test_model: child '1' not found for parent assignment"),
-        ([Mock(), Exception("DoesNotExist")], "test_model parent '2' not found for assignment"),
+        (True, True, False, 1, []),
+        (False, True, False, 0, ["RECORD_SKIPPED"]),
+        (True, False, False, 0, ["RECORD_SKIPPED"]),
+        (True, True, True, 1, ["RECORD_SYNC_FAILURE"]),
     ],
-    ids=["missing_child", "missing_parent"],
+    ids=["success", "missing_child", "missing_parent", "invalid_move"],
 )
-def test_assign_parents_missing(mock_model: Mock, mocker: MockerFixture, get_side_effect, error_message) -> None:
-    mock_model.DoesNotExist = Exception
-    mock_model.objects.get.side_effect = get_side_effect
-    mocker.patch.object(SyncContextGeo, "emit_log")
-
-    sync_context = SyncContextGeo(client=mocker.Mock(), stdout=mocker.Mock())
-    sync_context._assign_parents(mock_model, {"1": "2"})
-
-    sync_context.emit_log.assert_called_once_with(
-        "RECORD_SKIPPED",
-        hope_id="1",
-        error=error_message,
-    )
-    assert not hasattr(mock_model.objects, "bulk_update") or not mock_model.objects.bulk_update.called
+def test_assign_parents(
+    mocker: MockerFixture,
+    sync_geo: SyncContextGeo,
+    mock_model: Mock,
+    child_ok: bool,
+    parent_ok: bool,
+    bulk_exc: bool,
+    expected_bulk_calls: int,
+    expected_logs: list[str],
+) -> None:
+    child_id, parent_id = "c1", "p1"
+    mapping = {child_id: parent_id}
+    child_inst = mocker.Mock(hope_id=child_id)
+    parent_inst = mocker.Mock(hope_id=parent_id)
+
+    def fake_get(*, hope_id):
+        instances = {
+            **({child_id: child_inst} if child_ok else {}),
+            **({parent_id: parent_inst} if parent_ok else {}),
+        }
+        obj = instances.get(hope_id)
+        if obj is None:
+            raise mock_model.DoesNotExist
+        return obj
+
+    mocker.patch.object(mock_model.objects, "get", side_effect=fake_get)
+
+    m_bulk = mocker.patch.object(mock_model.objects, "bulk_update")
+    if bulk_exc:
+        m_bulk.side_effect = InvalidMove("boom")
 
+    m_log = mocker.patch.object(sync_geo, "emit_log")
 
-def test_assign_parents_invalid_move(mock_model: Mock, mocker: MockerFixture) -> None:
-    child_instance = Mock()
-    parent_instance = Mock()
-    mock_model.objects.get.side_effect = [child_instance, parent_instance]
-    mock_model.objects.bulk_update.side_effect = InvalidMove("Invalid tree move")
-    mocker.patch.object(SyncContextGeo, "emit_log")
+    sync_geo._assign_parents(mock_model, mapping)
 
-    sync_context = SyncContextGeo(client=mocker.Mock(), stdout=mocker.Mock())
+    assert m_bulk.call_count == expected_bulk_calls
+    keys = [call.args[0] for call in m_log.call_args_list]
+    assert keys == expected_logs
 
-    parent_mapping = {"1": "2"}
-    sync_context._assign_parents(mock_model, parent_mapping)
 
-    mock_model._meta.model_name = "test_model"
-    sync_context.emit_log.assert_called_once_with(
-        "RECORD_SYNC_FAILURE",
-        LogLevel.ERROR,
-        hope_id="multiple",
-        error="Invalid MPTT move during bulk update for 'test_model': Invalid tree move",
+def test_sync_context_geo_invokes_sync_context(mocker):
+    fake_result = {"ok": True}
+    patch = mocker.patch(
+        "country_workspace.contrib.hope.sync.context_geo.sync_context",
+        return_value=fake_result,
     )
+    stdout = StringIO()
 
+    result = sync_context_geo(step=SyncStep.AREAS, stdout=stdout)
 
-def test_sync_context_geo_step(mock_model: Mock, mocker: MockerFixture) -> None:
-    mocker.patch.object(SyncContextGeo, "sync_countries")
-    result = sync_context_geo(step=SyncStep.COUNTRIES, stdout=mocker.Mock())
-    SyncContextGeo.sync_countries.assert_called_once()
-    assert isinstance(result, dict)
+    patch.assert_called_once_with(SyncContextGeo, step=SyncStep.AREAS, stdout=stdout)
+    assert result is fake_result