Handle calling values() on QuerySet.

Author: adamghill

django_unicorn/serializer.py

@@ -101,7 +101,12 @@ def _json_serializer(obj):
             queryset_json = []
 
             for model in obj:
-                model_json = _get_model_dict(model)
+                if obj.query.values_select and isinstance(model, dict):
+                    # If the queryset was created with values it's already a dictionary
+                    model_json = model
+                else:
+                    model_json = _get_model_dict(model)
+
                 queryset_json.append(model_json)
 
             return queryset_json

django_unicorn/views/utils.py

@@ -1,6 +1,6 @@
 import logging
 from dataclasses import is_dataclass
-from typing import Any, Dict, Set, Union
+from typing import Any, Dict, Union
 
 from django.db.models import Model, QuerySet
 
@@ -198,23 +198,23 @@ class TestComponent(UnicornView):
             queryset._result_cache = []
 
         for (idx, model) in enumerate(queryset._result_cache):
-            if model.pk == model_value.get("pk"):
-                constructed_model = _construct_model(
-                    model_type, model_value, constructed_models
-                )
+            if hasattr(model, "pk") and model.pk == model_value.get("pk"):
+                constructed_model = _construct_model(model_type, model_value)
                 queryset._result_cache[idx] = constructed_model
                 model_found = True
 
         if not model_found:
-            constructed_model = _construct_model(
-                model_type, model_value, constructed_models
-            )
+            constructed_model = _construct_model(model_type, model_value)
             queryset._result_cache.append(constructed_model)
 
     return queryset
 
 
 def _construct_model(model_type, model_data: Dict):
+    """
+    Construct a model based on the type and dictionary data.
+    """
+
     if not model_data:
         return None
 
@@ -223,14 +223,13 @@ def _construct_model(model_type, model_data: Dict):
     for field_name in model_data.keys():
         for field in model._meta.fields:
             if field.name == field_name or (field_name == "pk" and field.primary_key):
-                # if field.is_relation:
-                #     related_model = _construct_model(
-                #         field.model, model_data[field_name]
-                #     )
-                #     setattr(model, field.name, related_model)
-                # else:
-
-                setattr(model, field.name, model_data[field_name])
+                column_name = field.name
+
+                if field.is_relation:
+                    column_name = field.attname
+
+                setattr(model, column_name, model_data[field_name])
+
                 break
 
     return model

tests/test_model_lifecycle.py

@@ -0,0 +1,91 @@
+import uuid
+
+import pytest
+
+from django_unicorn.components import UnicornView, unicorn_view
+from django_unicorn.serializer import dumps, loads
+from django_unicorn.views.utils import _construct_model, set_property_from_data
+from example.coffee.models import Flavor
+
+
+class FakeComponent(UnicornView):
+    flavors = Flavor.objects.none()
+
+    def __init__(self, **kwargs):
+        self.flavors = Flavor.objects.none()
+        super().__init__(**kwargs)
+
+
+@pytest.mark.django_db
+def test_model():
+    flavor = Flavor(name="first-flavor")
+    flavor.save()
+
+    str_data = dumps({"flavor": flavor})
+    data = loads(str_data)
+    flavor_data = data["flavor"]
+
+    actual = _construct_model(Flavor, flavor_data)
+
+    assert actual.pk == flavor.id
+    assert actual.name == flavor.name
+    assert actual.parent is None
+
+
+@pytest.mark.django_db
+def test_model_foreign_key():
+    parent = Flavor(name="parent-flavor")
+    parent.save()
+    flavor = Flavor(name="first-flavor", parent=parent)
+    flavor.save()
+
+    str_data = dumps({"flavor": flavor})
+    data = loads(str_data)
+    flavor_data = data["flavor"]
+
+    actual = _construct_model(Flavor, flavor_data)
+
+    assert actual.pk == flavor.id
+    assert actual.name == flavor.name
+    assert actual.parent.pk == parent.id
+    assert actual.parent.name == parent.name
+
+
+@pytest.mark.django_db
+def test_queryset():
+    test_component = FakeComponent(component_name="test", component_id="asdf")
+    assert test_component.flavors.count() == 0
+
+    flavor = Flavor(name="qs-first-flavor")
+    flavor.save()
+
+    flavors = Flavor.objects.filter(name="qs-first-flavor")
+    str_data = dumps({"flavors": flavors})
+    data = loads(str_data)
+    flavors_data = data["flavors"]
+
+    set_property_from_data(test_component, "flavors", flavors_data)
+
+    assert test_component.flavors.count() == 1
+    assert test_component.flavors[0].uuid == str(flavor.uuid)
+    assert test_component.flavors[0].id == flavor.id
+
+
+@pytest.mark.django_db
+def test_queryset_values():
+    test_component = FakeComponent(component_name="test", component_id="asdf")
+    assert test_component.flavors.count() == 0
+
+    flavor = Flavor(name="values-first-flavor")
+    flavor.save()
+
+    flavors = Flavor.objects.filter(name="values-first-flavor").values("uuid")
+    str_data = dumps({"flavors": flavors})
+    data = loads(str_data)
+    flavors_data = data["flavors"]
+
+    set_property_from_data(test_component, "flavors", flavors_data)
+
+    assert test_component.flavors.count() == 1
+    assert test_component.flavors[0].uuid == str(flavor.uuid)
+    assert test_component.flavors[0].id is None

tests/views/utils/test_construct_model.py

@@ -0,0 +1,80 @@
+import pytest
+
+from django_unicorn.views.utils import _construct_model
+from example.books.models import Author, Book
+from example.coffee.models import Flavor
+
+
+def test_construct_model_simple_model():
+    model_data = {
+        "pk": 1,
+        "name": "test-name",
+    }
+
+    actual = _construct_model(Flavor, model_data)
+
+    assert actual.pk == 1
+    assert actual.name == "test-name"
+
+
+@pytest.mark.django_db
+def test_construct_model_foreign_key():
+    flavor = Flavor(name="first-flavor")
+    flavor.save()
+    parent = Flavor(name="parent-flavor")
+    parent.save()
+
+    model_data = {
+        "pk": flavor.id,
+        "name": flavor.name,
+        "parent": parent.id,
+    }
+
+    actual = _construct_model(Flavor, model_data)
+
+    assert actual.pk == flavor.pk
+    assert actual.name == flavor.name
+    assert actual.parent.pk == parent.pk
+    assert actual.parent.name == parent.name
+
+
+@pytest.mark.django_db
+@pytest.mark.skip(
+    "This test isn't all that helpful unless related models get serialized"
+)
+def test_construct_model_recursive_foreign_key():
+    flavor = Flavor(name="first-flavor")
+    flavor.save()
+    parent = Flavor(name="parent-flavor")
+    parent.save()
+
+    model_data = {
+        "pk": flavor.pk,
+        "name": flavor.name,
+        "parent": parent.pk,
+    }
+
+    actual = _construct_model(Flavor, model_data)
+
+    assert actual.pk == flavor.pk
+    assert actual.name == flavor.name
+    assert actual.parent.pk == parent.pk
+    assert actual.parent.name == parent.name
+
+
+@pytest.mark.django_db
+def test_construct_model_many_to_many():
+    author = Author(name="author 1")
+    author.save()
+    book = Book(title="book 1", date_published="2021-01-01")
+    book.save()
+    author.books.add(book)
+
+    author_data = {"pk": author.pk, "name": author.name, "books": [book.pk,]}
+
+    actual = _construct_model(Author, author_data)
+
+    assert actual.pk == author.pk
+    assert actual.name == author.name
+    assert actual.books.count() == 1
+    assert actual.books.all()[0].title == book.title