CountryChoice Field should work with isocode2 and isocode3 (#88)

* add ! country_iso_code3 to sync

* chg ! use isocode2 and isocode3 as choices for CountryChoice

Author: vitali-yanushchyk-valor

src/country_workspace/admin/locations.py

@@ -30,10 +30,12 @@ class CountryAdmin(SyncAdminMixin, BaseModelAdmin):
     list_display = (
         "name",
         "iso_code2",
+        "iso_code3",
     )
     search_fields = (
         "name",
         "iso_code2",
+        "iso_code3",
     )
     sync_config = SyncConfig(model=Country, step=SyncStep.COUNTRIES, sync_handler=ContextGeoSyncHandler())
 

src/country_workspace/contrib/hope/geo.py

@@ -47,22 +47,32 @@ def get_choices_for_parent_value(self, parent_value: Any, only_codes: bool | Non
 
 
 class CountryChoice(forms.ChoiceField):
-    def get_choices(self) -> list[tuple[str, str]]:
-        ret = []
+    def __init__(self, choices: tuple[tuple[str, str]] = (), **kwargs: Any) -> None:
+        super().__init__(choices=choices, **kwargs)
+        self.iso3_to_iso2 = {}
+        self.choices = self.get_choices()
+
+    def get_choices(self) -> tuple[tuple[str, str]]:
         key = "lookups/country"
-        if not (data := cache_manager.retrieve(key)):
+        if data := cache_manager.retrieve(key):
+            return self._set_choices(data)
+        try:
             client = HopeClient()
-            try:
-                data = list(client.get("lookups/country"))
-                cache_manager.store(key, data, timeout=300)
-            except RemoteError as e:
-                logger.exception(e)
-                return ret
-        return [(record["iso_code2"], record["name"]) for record in data]
+            data = list(client.get("lookups/country"))
+            cache_manager.store(key, data, timeout=300)
+            return self._set_choices(data)
+        except RemoteError as e:
+            logger.exception(e)
+            return ()
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-        self.choices = self.get_choices()
+    def prepare_value(self, value: Any) -> str | None:
+        return super().prepare_value(self.iso3_to_iso2.get(value, value))
+
+    def to_python(self, value: Any) -> str | None:
+        return super().to_python(self.iso3_to_iso2.get(value, value))
+
+    def _set_choices(self, data: list[dict[str, str]]) -> tuple[tuple[str, str]]:
+        return tuple([(self.iso3_to_iso2.setdefault(rec["iso_code3"], rec["iso_code2"]), rec["name"]) for rec in data])
 
 
 class Admin1Choice(DynamicChoiceField):

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

@@ -30,7 +30,7 @@ def sync_countries(self) -> None:
             SyncConfig(
                 model=Country,
                 path="lookups/country",
-                prepare_defaults=lambda r: {f: r.get(f) for f in ("name", "iso_code2")},
+                prepare_defaults=lambda r: {f: r.get(f) for f in ("name", "iso_code2", "iso_code3")},
             ),
         )
 

src/country_workspace/migrations/0013_country_iso_code3.py

@@ -0,0 +1,30 @@
+from django.db import migrations, models
+from django.db.migrations.state import StateApps
+from django.db.backends.base.schema import BaseDatabaseSchemaEditor
+
+
+def fill_iso_code3(apps: StateApps, schema_editor: BaseDatabaseSchemaEditor) -> None:
+    Country = apps.get_model("country_workspace", "Country")
+    for index, country in enumerate(Country.objects.all(), start=1):
+        country.iso_code3 = f"{index:03d}"
+        country.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("country_workspace", "0012_country_hope_id"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="country",
+            name="iso_code3",
+            field=models.CharField(max_length=3, unique=True, null=True),
+        ),
+        migrations.RunPython(fill_iso_code3, reverse_code=migrations.RunPython.noop),
+        migrations.AlterField(
+            model_name="country",
+            name="iso_code3",
+            field=models.CharField(max_length=3, unique=True),
+        ),
+    ]

src/country_workspace/models/locations.py

@@ -8,9 +8,10 @@
 
 
 class Country(BaseModel):
+    hope_id = models.CharField(max_length=200, unique=True, editable=False)
     name = models.CharField(max_length=255, db_index=True)
     iso_code2 = models.CharField(max_length=2, unique=True)
-    hope_id = models.CharField(max_length=200, unique=True, editable=False)
+    iso_code3 = models.CharField(max_length=3, unique=True)
 
     class Meta:
         verbose_name_plural = "Countries"

tests/contrib/hope/test_geo.py

@@ -1,9 +1,12 @@
 from typing import TYPE_CHECKING
-
+import pytest
 from constance.test import override_config
 from testutils.factories import FieldDefinitionFactory, FieldsetFactory, FlexFieldFactory
+from unittest import mock
 
-from country_workspace.contrib.hope.geo import Admin1Choice, CountryChoice
+from country_workspace.contrib.hope.geo import Admin1Choice, CountryChoice, HopeClient
+from country_workspace.exceptions import RemoteError
+from country_workspace.cache.manager import cache_manager
 
 if TYPE_CHECKING:
     from hope_flex_fields.models import Fieldset
@@ -102,3 +105,48 @@ def test_validate_child(db, mocked_responses):
 
     errors = fs.validate([{"country": "AF", "region": "---"}])
     assert errors == {1: {"region": "['Not valid child for selected parent']"}}
+
+
+@override_config(HOPE_API_URL="https://dev-hope.unitst.org/api/rest/")
+@pytest.mark.parametrize(
+    ("value", "expected_validate", "expected_prepare"),
+    [
+        ("AF", {}, "AF"),
+        ("AFG", {}, "AF"),
+        ("XX", {1: {"country": ["Select a valid choice. XX is not one of the available choices."]}}, "XX"),
+        (None, {}, None),
+    ],
+    ids=["iso_code2", "iso_code3", "invalid", "empty"],
+)
+def test_country_choice(db, mocked_responses, value, expected_validate, expected_prepare):
+    mocked_responses.add(mocked_responses.GET, "https://dev-hope.unitst.org/api/rest/lookups/country/", json=COUNTRIES)
+    fd = FieldDefinitionFactory(field_type=CountryChoice)
+    fs: Fieldset = FieldsetFactory()
+    FlexFieldFactory(name="country", definition=fd, fieldset=fs)
+
+    errors = fs.validate([{"country": value}])
+    assert errors == expected_validate
+
+    form_class = fs.get_form_class()
+    form = form_class(data={"country": value})
+    assert form.fields["country"].prepare_value(value) == expected_prepare
+
+
+@pytest.mark.parametrize(
+    ("field_cls", "call", "call_args", "expected"),
+    [
+        (Admin1Choice, "get_choices_for_parent_value", ("AF", False), []),
+        (Admin1Choice, "get_choices_for_parent_value", ("AF", True), []),
+        (CountryChoice, None, None, []),
+    ],
+    ids=["admin1", "admin1_only_codes", "country"],
+)
+@override_config(HOPE_API_URL="https://dev-hope.unitst.org/api/rest/")
+def test_remote_error_fields(field_cls, call, call_args, expected):
+    with (
+        mock.patch.object(cache_manager, "retrieve", return_value=None),
+        mock.patch.object(HopeClient, "get", side_effect=RemoteError("API failure")),
+    ):
+        field = field_cls()
+        result = field.choices if call is None else getattr(field, call)(*call_args)
+        assert result == expected