wbcore 2.2.1__py2.py3-none-any.whl → 2.2.4__py2.py3-none-any.whl

wbcore/contrib/example_app/tests/test_serializers/test_team_result_serializer.py

@@ -0,0 +1,30 @@
+import pytest
+from django.forms.models import model_to_dict
+from rest_framework.exceptions import ValidationError
+from rest_framework.test import APITestCase
+from wbcore.contrib.example_app.factories import (
+    LeagueFactory,
+    TeamFactory,
+    TeamResultsFactory,
+)
+from wbcore.contrib.example_app.serializers import TeamResultsModelSerializer
+
+
+@pytest.mark.django_db
+class TestTeamResultSerializer(APITestCase):
+    def test_result_serializer(self):
+        team = TeamFactory()
+        league = LeagueFactory()
+        result: dict = model_to_dict(TeamResultsFactory.build(team=team, league=league))
+        result["games_played"] = 3
+        result_serializer = TeamResultsModelSerializer(data=result)
+
+        self.assertTrue(result_serializer.is_valid())
+
+    def test_same_result(self):
+        result = TeamResultsFactory()
+        new_result: dict = model_to_dict(TeamResultsFactory.build(team=result.team, league=result.league))
+        new_result["games_played"] = 3
+
+        with pytest.raises(ValidationError):
+            TeamResultsModelSerializer(data=new_result).is_valid(raise_exception=True)

wbcore/contrib/example_app/tests/test_serializers/test_team_serializer.py

@@ -0,0 +1,70 @@
+from datetime import date, datetime, timedelta
+
+import pytest
+from django.forms.models import model_to_dict
+from rest_framework.exceptions import ValidationError
+from rest_framework.test import APITestCase
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.example_app.factories import (
+    PlayerFactory,
+    SportPersonFactory,
+    StadiumFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.serializers import (
+    PlayerModelSerializer,
+    SportPersonModelSerializer,
+    TeamErrorMessages,
+    TeamModelSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestSportPersonModelSerializer(APITestCase):
+    def test_person_serializer(self):
+        person_data: dict = model_to_dict(SportPersonFactory.build(profile=PersonFactory()))
+        sport_person_serializer = SportPersonModelSerializer(data=person_data)
+        self.assertTrue(sport_person_serializer.is_valid())
+
+    def test_player_serializer(self):
+        player_data: dict = model_to_dict(PlayerFactory.build(current_team=TeamFactory()))
+        player_serializer = PlayerModelSerializer(data=player_data)
+        self.assertTrue(player_serializer.is_valid())
+
+
+@pytest.mark.django_db
+class TestTeamModelSerializer(APITestCase):
+    def test_team_serializer(self):
+        coach = SportPersonFactory()
+        stadium = StadiumFactory()
+
+        team_data: dict = model_to_dict(TeamFactory.build(coach=coach, home_stadium=stadium))
+        team_serializer = TeamModelSerializer(data=team_data)
+        self.assertTrue(team_serializer.is_valid())
+
+    def test_team_exists(self):
+        coach = SportPersonFactory()
+        stadium = StadiumFactory()
+        team = TeamFactory(coach=coach, home_stadium=stadium)
+        new_team_data: dict = model_to_dict(TeamFactory.build(home_stadium=stadium, name=team.name))
+        with self.assertRaisesMessage(ValidationError, TeamErrorMessages.team_exists.value):
+            team_serializer = TeamModelSerializer(data=new_team_data)
+            self.assertFalse(team_serializer.is_valid(raise_exception=True))
+
+    def test_team_wrong_date(self):
+        stadium = StadiumFactory()
+        future_date: date = (datetime.now() + timedelta(days=1)).date()
+        team_data: dict = model_to_dict(TeamFactory.build(founded_date=future_date, home_stadium=stadium))
+
+        with self.assertRaisesMessage(ValidationError, TeamErrorMessages.wrong_founding_date.value):
+            team_serializer = TeamModelSerializer(data=team_data)
+            self.assertFalse(team_serializer.is_valid(raise_exception=True))
+
+    def test_team_name_placeholder(self):
+        coach = SportPersonFactory()
+        stadium = StadiumFactory()
+        team_data: dict = model_to_dict(TeamFactory.build(home_stadium=stadium, coach=coach))
+        team_serializer = TeamModelSerializer(data=team_data)
+        self.assertTrue(team_serializer.is_valid())
+        self.assertTrue("name" in team_serializer.fields)
+        self.assertTrue(team_serializer.fields["name"].placeholder == "Enter team name here")

wbcore/contrib/example_app/tests/test_viewsets/test_event_viewset.py

@@ -0,0 +1,162 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.example_app.factories import EventFactory, EventTypeFactory
+from wbcore.contrib.example_app.models import Event, EventType
+from wbcore.contrib.example_app.serializers import (
+    EventModelSerializer,
+    EventTypeModelSerializer,
+)
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    find_instances_in_response,
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import EventModelViewSet, EventTypeModelViewSet
+
+
+@pytest.mark.django_db
+class TestEventModelViewSet(TestCase):
+    def setUp(self) -> None:
+        self.user = UserFactory(is_active=True, is_superuser=True)
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:event-list")
+        self.detail_url_str = "example_app:event-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        event = EventFactory()
+        response = get_create_view(self.client, event, self.user, self.list_url, EventModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(
+            Event.objects.filter(event_type=event.event_type, match=event.match, minute=event.minute).exists()
+        )
+
+    def test_detail_view(self):
+        instance = EventFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["id"], instance.id)
+
+    def test_update_view(self):
+        instance = EventFactory()
+        max_match_duration = instance.match.sport.match_duration
+        instance.minute = max_match_duration - instance.minute
+        response = get_update_view(self.client, instance, EventModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["minute"], instance.minute)
+
+    def test_partial_update_view(self):
+        instance = EventFactory()
+        max_match_duration = instance.match.sport.match_duration
+        response = get_partial_view(
+            self.client, instance.id, {"minute": max_match_duration - instance.minute}, self.detail_url_str
+        )
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["minute"], instance.minute)
+
+    def test_delete_view(self):
+        instance = EventFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        # It is not possible to delete an event, since the get_endpoint_url returns None. I suppose that is expected behavior.
+        self.assertEqual(response.status_code, 405)
+        self.assertTrue(Event.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        event1 = EventFactory(minute=30)
+        EventFactory(person=event1.person, minute=20, event_type=event1.event_type, match=event1.match)
+        EventFactory(person=event1.person, minute=40, event_type=event1.event_type, match=event1.match)
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], Event.objects.count())
+        self.assertEqual(response.data["results"][0]["minute"], 20)
+        self.assertEqual(response.data["results"][1]["minute"], 30)
+        self.assertEqual(response.data["results"][2]["minute"], 40)
+
+
+@pytest.mark.django_db
+class TestEventTypeModelViewSet(TestCase):
+    def setUp(self) -> None:
+        self.user = UserFactory(is_active=True, is_superuser=True)
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:eventtype-list")
+        self.detail_url_str = "example_app:eventtype-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        event_type = EventTypeFactory()
+        response = get_create_view(self.client, event_type, self.user, self.list_url, EventTypeModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(EventType.objects.filter(name=event_type.name).exists())
+
+    def test_detail_view(self):
+        instance = EventTypeFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["id"], instance.id)
+
+    def test_update_view(self):
+        instance = EventTypeFactory()
+        instance.name = "Updated Instance"
+        response = get_update_view(self.client, instance, EventTypeModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_partial_update_view(self):
+        instance = EventTypeFactory()
+        response = get_partial_view(self.client, instance.id, {"name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_delete_view(self):
+        instance = EventTypeFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Event.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        event_a = EventTypeFactory(name="BBB")
+        event_b = EventTypeFactory(name="AAA", sport=event_a.sport)
+        event_c = EventTypeFactory(name="CCC", sport=event_a.sport)
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], EventType.objects.count())
+        self.assertEqual(response.data["results"][0]["id"], event_b.id)
+        self.assertEqual(response.data["results"][1]["id"], event_a.id)
+        self.assertEqual(response.data["results"][2]["id"], event_c.id)
+
+    def test_event_type_sport(self):
+        type_a = EventTypeFactory()
+        type_b = EventTypeFactory(sport=type_a.sport)
+        type_c = EventTypeFactory()
+        expected_number_of_types = EventType.objects.filter(sport=type_a.sport).count()
+        event_type_url = reverse("example_app:eventtype-sport-list", args=[type_a.sport.id])
+        response = self.client.get(event_type_url)
+        type_a_found, type_b_found, type_c_found = find_instances_in_response([type_a, type_b, type_c], response)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response.data["count"],
+            expected_number_of_types,
+            f"The answer should contain {expected_number_of_types} types",
+        )
+        self.assertTrue(type_a_found, "Type A was not found in Response")
+        self.assertTrue(type_b_found, "Type B was not found in Response")
+        self.assertFalse(type_c_found, "type C was found in Response, but should not be found")

wbcore/contrib/example_app/tests/test_viewsets/test_league_viewset.py

@@ -0,0 +1,84 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import LeagueFactory
+from wbcore.contrib.example_app.models import League
+from wbcore.contrib.example_app.serializers import LeagueModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    find_instances_in_response,
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import LeagueModelViewSet
+
+
+@pytest.mark.django_db
+class TestLeagueModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:league-list")
+        self.detail_url_str = "example_app:league-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        league = LeagueFactory()
+        response = get_create_view(self.client, league, self.user, self.list_url, LeagueModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(League.objects.filter(name=league.name).exists())
+
+    def test_detail_view(self):
+        instance = LeagueFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_update_view(self):
+        instance = LeagueFactory()
+        instance.name = "Updated Instance"
+        response = get_update_view(self.client, instance, LeagueModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_partial_update_view(self):
+        instance = LeagueFactory()
+        response = get_partial_view(self.client, instance.id, {"name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["name"], instance.name)
+
+    def test_delete_view(self):
+        instance = LeagueFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(League.objects.filter(pk=instance.pk).exists())
+
+    def test_league_sport(self):
+        league_a = LeagueFactory()
+        league_b = LeagueFactory(sport=league_a.sport)
+        league_c = LeagueFactory()
+        expected_number_of_league = League.objects.filter(sport=league_a.sport).count()
+        league_sport_url = reverse("example_app:league-sport-list", args=[league_a.sport.id])
+        response = self.client.get(league_sport_url)
+        league_a_found, league_b_found, league_c_found = find_instances_in_response(
+            [league_a, league_b, league_c], response
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response.data["count"],
+            expected_number_of_league,
+            f"The answer should contain {expected_number_of_league} leagues",
+        )
+        self.assertTrue(league_a_found, "Player A was not found in Response.")
+        self.assertTrue(league_b_found, "Player B was not found in Response.")
+        self.assertFalse(league_c_found, "Player C was found in Response, but should not be found.")

wbcore/contrib/example_app/tests/test_viewsets/test_match_viewset.py

@@ -0,0 +1,65 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import MatchFactory, TeamFactory
+from wbcore.contrib.example_app.models import Match
+from wbcore.contrib.example_app.serializers import MatchModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import MatchModelViewSet
+
+
+@pytest.mark.django_db
+class TestMatchModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:match-list")
+        self.detail_url_str = "example_app:match-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        match = MatchFactory()
+        response = get_create_view(self.client, match, self.user, self.list_url, MatchModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(Match.objects.filter(home=match.home, away=match.away).exists())
+
+    def test_detail_view(self):
+        instance = MatchFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["id"], instance.id)
+
+    def test_update_view(self):
+        instance = MatchFactory(status=Match.MatchStatus.SCHEDULED)
+        new_home_team = TeamFactory()
+        instance.home = new_home_team
+        response = get_update_view(self.client, instance, MatchModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["home"], instance.home.id)
+
+    def test_partial_update_view(self):
+        instance = MatchFactory()
+        new_home_team = TeamFactory()
+        response = get_partial_view(self.client, instance.id, {"home": new_home_team.id}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["home"], instance.home.id)
+
+    def test_delete_view(self):
+        instance = MatchFactory()
+        self.assertTrue(Match.objects.filter(pk=instance.pk).exists())
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Match.objects.filter(pk=instance.pk).exists())

wbcore/contrib/example_app/tests/test_viewsets/test_person_viewset.py

@@ -0,0 +1,166 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import (
+    PlayerFactory,
+    SportPersonFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.models import Player, SportPerson
+from wbcore.contrib.example_app.serializers import (
+    PlayerModelSerializer,
+    SportPersonModelSerializer,
+)
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    find_instances_in_response,
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import (
+    PlayerModelViewSet,
+    SportPersonModelViewSet,
+)
+
+
+@pytest.mark.django_db
+class TestSportPersonModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:person-list")
+        self.detail_url_str = "example_app:person-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        person = SportPersonFactory()
+        response = get_create_view(self.client, person, self.user, self.list_url, SportPersonModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(SportPerson.objects.filter(last_name=person.last_name).exists())
+
+    def test_detail_view(self):
+        instance = SportPersonFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_update_view(self):
+        instance = SportPersonFactory()
+        instance.last_name = "Updated Instance"
+        instance.profile_image = None
+        response = get_update_view(self.client, instance, SportPersonModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_partial_update_view(self):
+        instance = SportPersonFactory()
+        response = get_partial_view(self.client, instance.id, {"last_name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_delete_view(self):
+        instance = SportPersonFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(SportPerson.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        person_a = SportPersonFactory(first_name="Hans", last_name="Brecht")
+        person_b = SportPersonFactory(first_name="Hans", last_name="Ahrens")
+        person_c = SportPersonFactory(first_name="Ralf", last_name="Christ")
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], SportPerson.objects.count())
+        self.assertEqual(response.data["results"][0]["id"], person_b.id)
+        self.assertEqual(response.data["results"][1]["id"], person_a.id)
+        self.assertEqual(response.data["results"][2]["id"], person_c.id)
+
+
+@pytest.mark.django_db
+class TestPlayerModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.detail_url_str = "example_app:player-detail"
+        self.list_url = reverse("example_app:player-list")
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        player = PlayerFactory()
+        response = get_create_view(self.client, player, self.user, self.list_url, PlayerModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(Player.objects.filter(last_name=player.last_name).exists())
+
+    def test_detail_view(self):
+        instance = PlayerFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_update_view(self):
+        instance = PlayerFactory()
+        instance.last_name = "Updated Instance"
+        response = get_update_view(self.client, instance, PlayerModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_partial_update_view(self):
+        instance = PlayerFactory()
+        response = get_partial_view(self.client, instance.id, {"last_name": "Updated Instance"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["last_name"], instance.last_name)
+
+    def test_delete_view(self):
+        instance = PlayerFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Player.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        team_a, team_b = TeamFactory(name="Team A"), TeamFactory(name="Team B")
+        person_a = PlayerFactory(first_name="Hans", last_name="Ahrens", current_team=team_b)
+        person_b = PlayerFactory(first_name="Hans", last_name="Ahrens", current_team=team_a)
+        person_c = PlayerFactory(first_name="Ralf", last_name="Brecht")
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], Player.objects.count())
+        self.assertEqual(response.data["results"][0]["id"], person_b.id)
+        self.assertEqual(response.data["results"][1]["id"], person_a.id)
+        self.assertEqual(response.data["results"][2]["id"], person_c.id)
+
+    def test_player_team(self):
+        player_a = PlayerFactory()
+        player_b = PlayerFactory(current_team=player_a.current_team)
+        player_c = PlayerFactory()
+        expected_number_of_player = Player.objects.filter(current_team=player_a.current_team).count()
+        player_team_url = reverse("example_app:player-team-list", args=[player_a.current_team.id])
+        response = self.client.get(player_team_url)
+        player_a_found, player_b_found, player_c_found = find_instances_in_response(
+            [player_a, player_b, player_c], response
+        )
+        self.assertEqual(
+            response.data["count"],
+            expected_number_of_player,
+            f"The answer should contain {expected_number_of_player} players",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(player_a_found, "Player A was not found in Response")
+        self.assertTrue(player_b_found, "Player B was not found in Response")
+        self.assertFalse(player_c_found, "Player C was found in Response, but should not be found")

wbcore/contrib/example_app/tests/test_viewsets/test_role_viewset.py

@@ -0,0 +1,75 @@
+import pytest
+from django.test import Client, TestCase
+from django.urls import reverse
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbcore.contrib.example_app.factories import RoleFactory
+from wbcore.contrib.example_app.models import Role
+from wbcore.contrib.example_app.serializers import RoleModelSerializer
+from wbcore.contrib.example_app.tests.test_viewsets.test_utils_viewsets import (
+    get_create_view,
+    get_delete_view,
+    get_detail_view,
+    get_partial_view,
+    get_update_view,
+)
+from wbcore.contrib.example_app.viewsets import RoleModelViewSet
+
+
+@pytest.mark.django_db
+class TestRoleModelViewSet(TestCase):
+    def setUp(self):
+        self.user = SuperUserFactory()
+        self.client = Client()
+        self.client.force_login(user=self.user)
+        self.list_url = reverse("example_app:role-list")
+        self.detail_url_str = "example_app:role-detail"
+
+    def test_list_view(self):
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+
+    def test_create_view(self):
+        role = RoleFactory()
+        response = get_create_view(self.client, role, self.user, self.list_url, RoleModelViewSet)
+        self.assertEqual(response.status_code, 201)
+        self.assertTrue(Role.objects.filter(title=role.title).exists())
+
+    def test_detail_view(self):
+        instance = RoleFactory()
+        response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["title"], instance.title)
+
+    def test_update_view(self):
+        instance = RoleFactory()
+        instance.title = "Updated Instance"
+        response = get_update_view(self.client, instance, RoleModelSerializer, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["title"], instance.title)
+
+    def test_partial_update_view(self):
+        instance = RoleFactory()
+        response = get_partial_view(self.client, instance.id, {"title": "Patched Title"}, self.detail_url_str)
+        instance.refresh_from_db()
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["instance"]["title"], instance.title)
+
+    def test_delete_view(self):
+        instance = RoleFactory()
+        response = get_delete_view(self.client, self.detail_url_str, instance.pk)
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Role.objects.filter(pk=instance.pk).exists())
+
+    def test_ordering_fields(self):
+        first_role, second_role, third_role = "Role A", "Role B", "Role C"
+        RoleFactory(title=second_role)
+        RoleFactory(title=first_role)
+        RoleFactory(title=third_role)
+
+        response = self.client.get(self.list_url)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["count"], Role.objects.count())
+        self.assertEqual(response.data["results"][0]["title"], first_role)
+        self.assertEqual(response.data["results"][1]["title"], second_role)
+        self.assertEqual(response.data["results"][2]["title"], third_role)