From 1ff204e9f1fafd0fe413658a83d444c92cce4de7 Mon Sep 17 00:00:00 2001 From: Oliver Sauder Date: Wed, 27 Dec 2023 22:14:01 +0400 Subject: [PATCH] Migrated included tests to pytest style --- example/tests/integration/test_includes.py | 65 ---------- tests/conftest.py | 35 +++++ tests/models.py | 6 +- tests/serializers.py | 36 ++++-- tests/test_utils.py | 2 +- tests/test_views.py | 143 ++++++++++++++++++++- tests/views.py | 33 ++++- 7 files changed, 237 insertions(+), 83 deletions(-) diff --git a/example/tests/integration/test_includes.py b/example/tests/integration/test_includes.py index f8fe8604..d32ff7e3 100644 --- a/example/tests/integration/test_includes.py +++ b/example/tests/integration/test_includes.py @@ -4,71 +4,6 @@ pytestmark = pytest.mark.django_db -def test_included_data_on_list(multiple_entries, client): - response = client.get( - reverse("entry-list"), data={"include": "comments", "page[size]": 5} - ) - included = response.json().get("included") - - assert len(response.json()["data"]) == len( - multiple_entries - ), "Incorrect entry count" - assert [x.get("type") for x in included] == [ - "comments", - "comments", - ], "List included types are incorrect" - - comment_count = len( - [resource for resource in included if resource["type"] == "comments"] - ) - expected_comment_count = sum(entry.comments.count() for entry in multiple_entries) - assert comment_count == expected_comment_count, "List comment count is incorrect" - - -def test_included_data_on_list_with_one_to_one_relations(multiple_entries, client): - response = client.get( - reverse("entry-list"), data={"include": "authors.bio.metadata", "page[size]": 5} - ) - included = response.json().get("included") - - assert len(response.json()["data"]) == len( - multiple_entries - ), "Incorrect entry count" - expected_include_types = [ - "authorBioMetadata", - "authorBioMetadata", - "authorBios", - "authorBios", - "authors", - "authors", - ] - include_types = [x.get("type") for x in included] - assert include_types == expected_include_types, "List included types are incorrect" - - -def test_default_included_data_on_detail(single_entry, client): - return test_included_data_on_detail( - single_entry=single_entry, client=client, query="" - ) - - -def test_included_data_on_detail(single_entry, client, query="?include=comments"): - response = client.get( - reverse("entry-detail", kwargs={"pk": single_entry.pk}) + query - ) - included = response.json().get("included") - - assert [x.get("type") for x in included] == [ - "comments" - ], "Detail included types are incorrect" - - comment_count = len( - [resource for resource in included if resource["type"] == "comments"] - ) - expected_comment_count = single_entry.comments.count() - assert comment_count == expected_comment_count, "Detail comment count is incorrect" - - def test_dynamic_related_data_is_included(single_entry, entry_factory, client): entry_factory() response = client.get( diff --git a/tests/conftest.py b/tests/conftest.py index ebdf5348..682d8342 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,9 +3,11 @@ from tests.models import ( BasicModel, + ForeignKeySource, ForeignKeyTarget, ManyToManySource, ManyToManyTarget, + NestedRelatedSource, ) @@ -39,6 +41,11 @@ def foreign_key_target(db): return ForeignKeyTarget.objects.create(name="Target") +@pytest.fixture +def foreign_key_source(db, foreign_key_target): + return ForeignKeySource.objects.create(name="Source", target=foreign_key_target) + + @pytest.fixture def many_to_many_source(db, many_to_many_targets): source = ManyToManySource.objects.create(name="Source") @@ -54,6 +61,34 @@ def many_to_many_targets(db): ] +@pytest.fixture +def many_to_many_sources(db, many_to_many_targets): + source1 = ManyToManySource.objects.create(name="Source1") + source2 = ManyToManySource.objects.create(name="Source2") + + source1.targets.add(*many_to_many_targets) + source2.targets.add(*many_to_many_targets) + + return [source1, source2] + + +@pytest.fixture +def nested_related_source( + db, + foreign_key_source, + foreign_key_target, + many_to_many_targets, + many_to_many_sources, +): + source = NestedRelatedSource.objects.create( + fk_source=foreign_key_source, fk_target=foreign_key_target + ) + source.m2m_targets.add(*many_to_many_targets) + source.m2m_sources.add(*many_to_many_sources) + + return source + + @pytest.fixture def client(): return APIClient() diff --git a/tests/models.py b/tests/models.py index a483f2d0..812ee5bf 100644 --- a/tests/models.py +++ b/tests/models.py @@ -42,11 +42,11 @@ class ForeignKeySource(DJAModel): class NestedRelatedSource(DJAModel): - m2m_source = models.ManyToManyField(ManyToManySource, related_name="nested_source") + m2m_sources = models.ManyToManyField(ManyToManySource, related_name="nested_source") fk_source = models.ForeignKey( ForeignKeySource, related_name="nested_source", on_delete=models.CASCADE ) - m2m_target = models.ManyToManyField(ManyToManySource, related_name="nested_target") + m2m_targets = models.ManyToManyField(ManyToManyTarget, related_name="nested_target") fk_target = models.ForeignKey( - ForeignKeySource, related_name="nested_target", on_delete=models.CASCADE + ForeignKeyTarget, related_name="nested_target", on_delete=models.CASCADE ) diff --git a/tests/serializers.py b/tests/serializers.py index e0f7c03b..4159039d 100644 --- a/tests/serializers.py +++ b/tests/serializers.py @@ -1,11 +1,11 @@ from rest_framework_json_api import serializers -from rest_framework_json_api.relations import ResourceRelatedField from tests.models import ( BasicModel, ForeignKeySource, ForeignKeyTarget, ManyToManySource, ManyToManyTarget, + NestedRelatedSource, ) @@ -15,33 +15,51 @@ class Meta: model = BasicModel +class ForeignKeyTargetSerializer(serializers.ModelSerializer): + class Meta: + fields = ("name",) + model = ForeignKeyTarget + + class ForeignKeySourceSerializer(serializers.ModelSerializer): - target = ResourceRelatedField(queryset=ForeignKeyTarget.objects) + included_serializers = {"target": ForeignKeyTargetSerializer} class Meta: model = ForeignKeySource fields = ("target",) +class ManyToManyTargetSerializer(serializers.ModelSerializer): + class Meta: + fields = ("name",) + model = ManyToManyTarget + + class ManyToManySourceSerializer(serializers.ModelSerializer): - targets = ResourceRelatedField(many=True, queryset=ManyToManyTarget.objects) + included_serializers = {"targets": "tests.serializers.ManyToManyTargetSerializer"} class Meta: model = ManyToManySource fields = ("targets",) -class ManyToManyTargetSerializer(serializers.ModelSerializer): +class ManyToManySourceReadOnlySerializer(serializers.ModelSerializer): class Meta: - model = ManyToManyTarget + model = ManyToManySource + fields = ("targets",) -class ManyToManySourceReadOnlySerializer(serializers.ModelSerializer): - targets = ResourceRelatedField(many=True, read_only=True) +class NestedRelatedSourceSerializer(serializers.ModelSerializer): + included_serializers = { + "m2m_sources": ManyToManySourceSerializer, + "fk_source": ForeignKeySourceSerializer, + "m2m_targets": ManyToManyTargetSerializer, + "fk_target": ForeignKeyTargetSerializer, + } class Meta: - model = ManyToManySource - fields = ("targets",) + model = NestedRelatedSource + fields = ("m2m_sources", "fk_source", "m2m_targets", "fk_target") class CallableDefaultSerializer(serializers.Serializer): diff --git a/tests/test_utils.py b/tests/test_utils.py index f2a3d176..4e103ae2 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -325,7 +325,7 @@ class Meta: {"many": True, "queryset": ManyToManyTarget.objects.all()}, ), ( - "m2m_target.sources.", + "m2m_target.sources", "ManyToManySource", {"many": True, "queryset": ManyToManySource.objects.all()}, ), diff --git a/tests/test_views.py b/tests/test_views.py index 47fec02a..de5d1b7a 100644 --- a/tests/test_views.py +++ b/tests/test_views.py @@ -12,9 +12,14 @@ from rest_framework_json_api.renderers import JSONRenderer from rest_framework_json_api.utils import format_link_segment from rest_framework_json_api.views import ModelViewSet, ReadOnlyModelViewSet -from tests.models import BasicModel -from tests.serializers import BasicModelSerializer -from tests.views import BasicModelViewSet +from tests.models import BasicModel, ForeignKeySource +from tests.serializers import BasicModelSerializer, ForeignKeyTargetSerializer +from tests.views import ( + BasicModelViewSet, + ForeignKeySourceViewSet, + ManyToManySourceViewSet, + NestedRelatedSourceViewSet, +) class TestModelViewSet: @@ -80,6 +85,90 @@ def test_list(self, client, model): "meta": {"pagination": {"count": 1, "page": 1, "pages": 1}}, } + @pytest.mark.urls(__name__) + def test_list_with_include_foreign_key(self, client, foreign_key_source): + url = reverse("foreign-key-source-list") + response = client.get(url, data={"include": "target"}) + assert response.status_code == status.HTTP_200_OK + result = response.json() + assert "included" in result + assert [ + { + "type": "ForeignKeyTarget", + "id": str(foreign_key_source.target.pk), + "attributes": {"name": foreign_key_source.target.name}, + } + ] == result["included"] + + @pytest.mark.urls(__name__) + def test_list_with_include_many_to_many_field( + self, client, many_to_many_source, many_to_many_targets + ): + url = reverse("many-to-many-source-list") + response = client.get(url, data={"include": "targets"}) + assert response.status_code == status.HTTP_200_OK + result = response.json() + assert "included" in result + assert [ + { + "type": "ManyToManyTarget", + "id": str(target.pk), + "attributes": {"name": target.name}, + } + for target in many_to_many_targets + ] == result["included"] + + @pytest.mark.urls(__name__) + def test_list_with_include_nested_related_field( + self, client, nested_related_source, many_to_many_sources, many_to_many_targets + ): + url = reverse("nested-related-source-list") + response = client.get(url, data={"include": "m2m_sources,m2m_sources.targets"}) + assert response.status_code == status.HTTP_200_OK + result = response.json() + assert "included" in result + + assert [ + { + "type": "ManyToManySource", + "id": str(source.pk), + "relationships": { + "targets": { + "data": [ + {"id": str(target.pk), "type": "ManyToManyTarget"} + for target in source.targets.all() + ], + "meta": {"count": source.targets.count()}, + } + }, + } + for source in many_to_many_sources + ] + [ + { + "type": "ManyToManyTarget", + "id": str(target.pk), + "attributes": {"name": target.name}, + } + for target in many_to_many_targets + ] == result[ + "included" + ] + + @pytest.mark.urls(__name__) + def test_list_with_default_included_resources(self, client, foreign_key_source): + url = reverse("default-included-resources-list") + response = client.get(url) + assert response.status_code == status.HTTP_200_OK + result = response.json() + assert "included" in result + assert [ + { + "type": "ForeignKeyTarget", + "id": str(foreign_key_source.target.pk), + "attributes": {"name": foreign_key_source.target.name}, + } + ] == result["included"] + @pytest.mark.urls(__name__) def test_retrieve(self, client, model): url = reverse("basic-model-detail", kwargs={"pk": model.pk}) @@ -93,6 +182,21 @@ def test_retrieve(self, client, model): } } + @pytest.mark.urls(__name__) + def test_retrieve_with_include_foreign_key(self, client, foreign_key_source): + url = reverse("foreign-key-source-detail", kwargs={"pk": foreign_key_source.pk}) + response = client.get(url, data={"include": "target"}) + assert response.status_code == status.HTTP_200_OK + result = response.json() + assert "included" in result + assert [ + { + "type": "ForeignKeyTarget", + "id": str(foreign_key_source.target.pk), + "attributes": {"name": foreign_key_source.target.name}, + } + ] == result["included"] + @pytest.mark.urls(__name__) def test_patch(self, client, model): data = { @@ -231,6 +335,23 @@ def test_patch_with_custom_id(self, client): # Routing setup +class DefaultIncludedResourcesSerializer(serializers.ModelSerializer): + included_serializers = {"target": ForeignKeyTargetSerializer} + + class Meta: + model = ForeignKeySource + fields = ("target",) + + class JSONAPIMeta: + included_resources = ["target"] + + +class DefaultIncludedResourcesViewSet(ModelViewSet): + serializer_class = DefaultIncludedResourcesSerializer + queryset = ForeignKeySource.objects.all() + ordering = ["id"] + + class CustomModel: def __init__(self, response_dict): for k, v in response_dict.items(): @@ -280,6 +401,22 @@ def patch(self, request, *args, **kwargs): router = SimpleRouter() router.register(r"basic_models", BasicModelViewSet, basename="basic-model") +router.register( + r"foreign_key_sources", ForeignKeySourceViewSet, basename="foreign-key-source" +) +router.register( + r"many_to_many_sources", ManyToManySourceViewSet, basename="many-to-many-source" +) +router.register( + r"nested_related_sources", + NestedRelatedSourceViewSet, + basename="nested-related-source", +) +router.register( + r"default_included_resources", + DefaultIncludedResourcesViewSet, + basename="default-included-resources", +) urlpatterns = [ path("custom", CustomAPIView.as_view(), name="custom"), diff --git a/tests/views.py b/tests/views.py index 42d8a0b0..72a7ea59 100644 --- a/tests/views.py +++ b/tests/views.py @@ -1,8 +1,37 @@ from rest_framework_json_api.views import ModelViewSet -from tests.models import BasicModel -from tests.serializers import BasicModelSerializer +from tests.models import ( + BasicModel, + ForeignKeySource, + ManyToManySource, + NestedRelatedSource, +) +from tests.serializers import ( + BasicModelSerializer, + ForeignKeySourceSerializer, + ManyToManySourceSerializer, + NestedRelatedSourceSerializer, +) class BasicModelViewSet(ModelViewSet): serializer_class = BasicModelSerializer queryset = BasicModel.objects.all() + ordering = ["text"] + + +class ForeignKeySourceViewSet(ModelViewSet): + serializer_class = ForeignKeySourceSerializer + queryset = ForeignKeySource.objects.all() + ordering = ["name"] + + +class ManyToManySourceViewSet(ModelViewSet): + serializer_class = ManyToManySourceSerializer + queryset = ManyToManySource.objects.all() + ordering = ["name"] + + +class NestedRelatedSourceViewSet(ModelViewSet): + serializer_class = NestedRelatedSourceSerializer + queryset = NestedRelatedSource.objects.all() + ordering = ["id"]