wbcore 1.59.9__py2.py3-none-any.whl

wbcore/contrib/example_app/tests/test_models/test_others.py

@@ -0,0 +1,161 @@
+import pytest
+from django.db import IntegrityError
+from wbcore.contrib.example_app.factories import (
+    LeagueFactory,
+    MatchFactory,
+    PlayerFactory,
+    RoleFactory,
+    SportFactory,
+    SportPersonFactory,
+    StadiumFactory,
+    TeamFactory,
+    TeamResultsFactory,
+)
+from wbcore.contrib.example_app.models import League, Match, Player, SportPerson
+
+
+@pytest.mark.django_db
+class TestPerson:
+    def test_str_full(self):
+        person = SportPersonFactory.create(first_name="Test", last_name="Name")
+        assert person.str_full() == "Test Name"
+
+    def test_str_full_coach(self):
+        person = SportPersonFactory.create(first_name="Test", last_name="Name")
+        TeamFactory.create(coach=person, name="Test Team")
+        assert person.str_full() == "Test Name (Coach of Test Team)"
+
+    def test_str_full_commissioner(self):
+        commissioner = SportPersonFactory.create(first_name="Test", last_name="Name")
+        LeagueFactory.create(commissioner=commissioner, name="Test League")
+        assert commissioner.str_full() == "Test Name (Commissioner of Test League)"
+
+    def test_get_player_fail(self):
+        person = SportPersonFactory.create()
+        assert person.get_player() is None
+
+    def test_get_player_sucess(self):
+        player = PlayerFactory.create()
+        person = SportPerson.objects.get(id=player.pk)
+        assert person.get_player() == player
+
+
+@pytest.mark.django_db
+class TestPlayer:
+    def test_str_full(self):
+        player = PlayerFactory.create(first_name="Test", last_name="Name", current_team=None)
+        assert player.str_full() == "Test Name"
+
+    def test_str_full_team(self):
+        player = PlayerFactory.create(
+            current_team__name="Test Team", position=None, first_name="Test", last_name="Name"
+        )
+        assert player.str_full() == "Test Name (Test Team)"
+
+    def test_str_full_team_position(self):
+        player = PlayerFactory.create(
+            current_team__name="Test Team", position="Test Position", first_name="Test", last_name="Name"
+        )
+        assert player.str_full() == "Test Name (Test Position at Test Team)"
+
+
+@pytest.mark.django_db
+class TestRole:
+    def test_str(self):
+        role = RoleFactory.create(title="Test Role")
+        assert role.__str__() == "Test Role"
+
+
+@pytest.mark.django_db
+class TestSport:
+    def test_str(self):
+        sport = SportFactory.create(name="Test Sport")
+        assert sport.__str__() == "Test Sport"
+
+    def test_post_save(self):
+        sport = SportFactory.create()
+        league1 = LeagueFactory.create(sport=sport)
+        old_name = sport.name
+        new_name = "New Sport Name"
+        sport.name = new_name
+        sport.save()
+        new_computed_str = League.objects.get(id=league1.pk).computed_str
+        assert old_name not in new_computed_str
+        assert new_name in new_computed_str
+
+
+@pytest.mark.django_db
+class TestLeague:
+    def test_str(self):
+        league = LeagueFactory(name="Test League", sport__name="Test Sport")
+        assert league.__str__() == "Test League (Test Sport)"
+
+    def test_unique_constraint(self):
+        league = LeagueFactory.create()
+        with pytest.raises(IntegrityError):
+            LeagueFactory(name=league.name, sport=league.sport)
+
+    def test_post_save(self):
+        commissioner = SportPersonFactory.create()
+        league = LeagueFactory(commissioner=commissioner)
+        old_name = league.name
+        new_name = "New League Name"
+        league.name = new_name
+        league.save()
+        new_computed_str = SportPerson.objects.get(id=commissioner.pk).computed_str
+        assert old_name not in new_computed_str
+        assert new_name in new_computed_str
+
+
+@pytest.mark.django_db
+class TestTeamResults:
+    def test_str(self):
+        team_results = TeamResultsFactory(team__name="Test Team", league__name="Test League")
+        assert team_results.__str__() == "Test Team in Test League"
+
+    @pytest.mark.parametrize("points_for, points_against, difference", [(33, 91, -58), (252, 171, 81), (86, 86, 0)])
+    def test_save(self, points_for, points_against, difference):
+        team_results = TeamResultsFactory(match_points_for=points_for, match_points_against=points_against)
+        assert team_results.match_point_difference == difference
+
+    def test_unique_constraint(self):
+        team_results = TeamResultsFactory.create()
+        with pytest.raises(IntegrityError):
+            TeamResultsFactory(team=team_results.team, league=team_results.league)
+
+
+@pytest.mark.django_db
+class TestStadium:
+    def test_str(self):
+        stadium = StadiumFactory(name="Test Stadium")
+        assert stadium.__str__() == "Test Stadium"
+
+
+@pytest.mark.django_db
+class TestTeam:
+    def test_str(self):
+        team = TeamFactory(name="Test Team")
+        assert team.__str__() == "Test Team"
+
+    def test_post_save(self):
+        team = TeamFactory.create()
+        old_name = team.name
+        player1 = PlayerFactory(current_team=team)
+        player2 = PlayerFactory(current_team=team)
+        player3 = PlayerFactory(current_team=team)
+        match1 = MatchFactory(home=team)
+        match2 = MatchFactory(away=team)
+        new_name = "New Team Name"
+        team.name = new_name
+        team.save()
+        for match in [match1, match2]:
+            match_new_computed_str = Match.objects.get(id=match.pk).computed_str
+            assert old_name not in match_new_computed_str
+            assert new_name in match_new_computed_str
+        for player in [player1, player2, player3]:
+            player_new_computed_str = Player.objects.get(id=player.pk).computed_str
+            assert old_name not in player_new_computed_str
+            assert new_name in player_new_computed_str
+        coach_new_computed_str = SportPerson.objects.get(id=team.coach.pk).computed_str
+        assert old_name not in coach_new_computed_str
+        assert new_name in coach_new_computed_str

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

@@ -0,0 +1,34 @@
+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.example_app.factories import LeagueFactory, SportFactory
+from wbcore.contrib.example_app.serializers import LeagueModelSerializer
+
+
+@pytest.mark.django_db
+class TestLeagueModelSerializer(APITestCase):
+    def test_league_serializer(self):
+        sport = SportFactory.create()
+        league_data: dict = model_to_dict(LeagueFactory.build(sport=sport))
+        league_serializer = LeagueModelSerializer(data=league_data)
+
+        self.assertTrue(league_serializer.is_valid())
+
+    def test_league_exists(self):
+        sport = SportFactory.create()
+        league = LeagueFactory.create(sport=sport)
+        new_league_data: dict = model_to_dict(LeagueFactory.build(sport=sport, name=league.name))
+
+        with pytest.raises(ValidationError):
+            LeagueModelSerializer(data=new_league_data).is_valid(raise_exception=True)
+
+    def test_league_wrong_date(self):
+        sport = SportFactory.create()
+        future_date: date = (datetime.now() + timedelta(days=1)).date()
+        league_data: dict = model_to_dict(LeagueFactory.build(sport=sport, established_date=future_date))
+
+        with pytest.raises(ValidationError):
+            LeagueModelSerializer(data=league_data).is_valid(raise_exception=True)

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

@@ -0,0 +1,139 @@
+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 (
+    EventFactory,
+    EventTypeFactory,
+    LeagueFactory,
+    MatchFactory,
+    SportFactory,
+    SportPersonFactory,
+    StadiumFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.serializers import (
+    EventErrorMessages,
+    EventModelSerializer,
+    EventTypeModelSerializer,
+    LeaguePlayerStatisticsModelSerializer,
+    LeagueTeamStatisticsModelSerializer,
+    MatchErrorMessages,
+    MatchModelSerializer,
+)
+
+
+@pytest.mark.django_db
+class TestMatchModelSerializer(APITestCase):
+    def test_match_serializer(self):
+        match_data: dict = model_to_dict(
+            MatchFactory.build(
+                away=TeamFactory.create(),
+                home=TeamFactory.create(),
+                sport=SportFactory.create(),
+                stadium=StadiumFactory.create(),
+            )
+        )
+        match_serializer = MatchModelSerializer(data=match_data)
+        self.assertTrue(match_serializer.is_valid())
+
+    def test_match_same_teams(self):
+        team = TeamFactory.create()
+        match_data: dict = model_to_dict(
+            MatchFactory.build(away=team, home=team, sport=SportFactory.create(), stadium=StadiumFactory.create())
+        )
+        with self.assertRaisesMessage(ValidationError, MatchErrorMessages.same_teams.value):
+            league_serializer = MatchModelSerializer(data=match_data)
+            self.assertFalse(league_serializer.is_valid(raise_exception=True))
+
+    def test_match_same_date(self):
+        match = MatchFactory()
+        match_data: dict = model_to_dict(match)
+        with pytest.raises(ValidationError):
+            MatchModelSerializer(data=match_data).is_valid(raise_exception=True)
+
+    def test_match_wrong_sport(self):
+        match_data: dict = model_to_dict(
+            MatchFactory.build(
+                away=TeamFactory(),
+                home=TeamFactory(),
+                stadium=StadiumFactory(),
+                sport=SportFactory(),
+                league=LeagueFactory(),
+            )
+        )
+        with self.assertRaisesMessage(ValidationError, MatchErrorMessages.wrong_sport.value):
+            league_serializer = MatchModelSerializer(data=match_data)
+            self.assertFalse(league_serializer.is_valid(raise_exception=True))
+
+
+@pytest.mark.django_db
+class TestEventTypeModelSerializer(APITestCase):
+    def test_event_type_serializer(self):
+        event_type_data: dict = model_to_dict(EventTypeFactory.build(sport=SportFactory()))
+        event_type_serializer = EventTypeModelSerializer(data=event_type_data)
+        self.assertTrue(event_type_serializer.is_valid())
+
+    def test_event_type_same_name(self):
+        event_type = EventTypeFactory()
+        event_type_data: dict = model_to_dict(EventTypeFactory.build(name=event_type.name, sport=event_type.sport))
+        with pytest.raises(ValidationError):
+            EventTypeModelSerializer(data=event_type_data).is_valid(raise_exception=True)
+
+
+@pytest.mark.django_db
+class TestEventModelSerializer(APITestCase):
+    def test_event_serializer(self):
+        match = MatchFactory()
+        event_type = EventTypeFactory(sport=match.sport)
+        event_data: dict = model_to_dict(
+            EventFactory.build(person=SportPersonFactory(), event_type=event_type, match=match)
+        )
+        event_serializer = EventModelSerializer(data=event_data)
+        self.assertTrue(event_serializer.is_valid())
+
+    def test_event_wrong_duration(self):
+        sport = SportFactory(match_duration=60)
+        event_type = EventTypeFactory(sport=sport)
+        match = MatchFactory(sport=sport)
+        event: dict = model_to_dict(
+            EventFactory.build(person=SportPersonFactory(), minute=61, event_type=event_type, match=match)
+        )
+        with self.assertRaisesMessage(ValidationError, EventErrorMessages.wrong_duration.value):
+            event_serializer = EventModelSerializer(data=event)
+            self.assertFalse(event_serializer.is_valid(raise_exception=True))
+
+    def test_event_duplication(self):
+        event = EventFactory.create()
+        event_data = model_to_dict(event)
+
+        with pytest.raises(ValidationError):
+            EventModelSerializer(data=event_data).is_valid(raise_exception=True)
+
+    def test_event_wrong_type(self):
+        event_type = EventTypeFactory()
+        match = MatchFactory()
+        event_data: dict = model_to_dict(
+            EventFactory.build(person=SportPersonFactory(), event_type=event_type, match=match)
+        )
+        with self.assertRaisesMessage(
+            ValidationError, EventErrorMessages.wrong_event_type.value.format(match.sport.name)
+        ):
+            event_serializer = EventModelSerializer(data=event_data)
+            self.assertFalse(event_serializer.is_valid(raise_exception=True))
+
+
+@pytest.mark.django_db
+class TestLeaguePlayerStatisticsModelSerializer(APITestCase):
+    def test_league_player_statistics_serializer(self):
+        statistic_data = {"person_id": 1, "person_name": "Foo", "count": 1, "id": "id"}
+        statistic_serializer = LeaguePlayerStatisticsModelSerializer(data=statistic_data)
+        self.assertTrue(statistic_serializer.is_valid())
+
+
+@pytest.mark.django_db
+class TestLeagueTeamStatisticsModelSerializer(APITestCase):
+    def test_league_player_statistics_serializer(self):
+        statistic_data = {"team_id": 1, "team_name": "Foo", "count": 1, "id": "id"}
+        statistic_serializer = LeagueTeamStatisticsModelSerializer(data=statistic_data)
+        self.assertTrue(statistic_serializer.is_valid())

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

@@ -0,0 +1,13 @@
+import pytest
+from django.forms.models import model_to_dict
+from rest_framework.test import APITestCase
+from wbcore.contrib.example_app.factories import RoleFactory
+from wbcore.contrib.example_app.serializers import RoleModelSerializer
+
+
+@pytest.mark.django_db
+class TestRoleModelSerializer(APITestCase):
+    def test_role_serializer(self):
+        role_data: dict = model_to_dict(RoleFactory.build())
+        role_serializer = RoleModelSerializer(data=role_data)
+        self.assertTrue(role_serializer.is_valid())

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

@@ -0,0 +1,14 @@
+import pytest
+from django.forms.models import model_to_dict
+from rest_framework.test import APITestCase
+from wbcore.contrib.example_app.factories import SportFactory
+from wbcore.contrib.example_app.serializers import SportModelSerializer
+
+
+@pytest.mark.django_db
+class TestSportModelSerializer(APITestCase):
+    def test_sport_serializer(self):
+        sport_data: dict = model_to_dict(SportFactory.build())
+        sport_serializer = SportModelSerializer(data=sport_data)
+
+        self.assertTrue(sport_serializer.is_valid())

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

@@ -0,0 +1,14 @@
+import pytest
+from django.forms.models import model_to_dict
+from rest_framework.test import APITestCase
+from wbcore.contrib.example_app.factories import StadiumFactory
+from wbcore.contrib.example_app.serializers import StadiumModelSerializer
+
+
+@pytest.mark.django_db
+class TestStadiumModelSerializer(APITestCase):
+    def test_stadium_serializer(self):
+        stadium_data: dict = model_to_dict(StadiumFactory.build())
+        stadium_serializer = StadiumModelSerializer(data=stadium_data)
+
+        self.assertTrue(stadium_serializer.is_valid())

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.create()
+        league = LeagueFactory.create()
+        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.create()
+        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.create()))
+        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.create()))
+        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.create()
+        stadium = StadiumFactory.create()
+
+        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.create()
+        stadium = StadiumFactory.create()
+        team = TeamFactory.create(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.create()
+        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.create()
+        stadium = StadiumFactory.create()
+        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_utils.py

@@ -0,0 +1,26 @@
+import pytest
+
+from wbcore.contrib.example_app.factories import (
+    EventFactory,
+    EventTypeFactory,
+    LeagueFactory,
+)
+from wbcore.contrib.example_app.utils import get_event_types_for_league
+
+
+@pytest.mark.django_db
+class TestUtils:
+    def test_get_event_types_for_league(self):
+        league = LeagueFactory.create()
+        event_type1 = EventTypeFactory.create(sport=league.sport)
+        event_type2 = EventTypeFactory.create(sport=league.sport)
+        event_type3 = EventTypeFactory.create()
+        event_type4 = EventTypeFactory.create(sport=league.sport)
+        EventFactory.create(event_type=event_type1)
+        EventFactory.create(event_type=event_type2)
+        EventFactory.create(event_type=event_type3)
+        league_event_types = get_event_types_for_league(league.pk)
+        for event_type in league_event_types:
+            assert event_type["name"] in [event_type1.name, event_type2.name]
+            assert event_type["name"] not in [event_type3.name, event_type4.name]
+            assert " " not in event_type["slugified_name"]

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

@@ -0,0 +1,167 @@
+# 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.create(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)
+#         print(response.content)
+#         self.assertEqual(response.status_code, 200)
+#
+#     def test_create_view(self):
+#         event = EventFactory.create()
+#         response = get_create_view(self.client, event, self.user, self.list_url, EventModelViewSet)
+#         print(response.content)
+#         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.create()
+#         response = get_detail_view(self.client, instance.pk, self.detail_url_str)
+#         print(response.content)
+#         self.assertEqual(response.status_code, 200)
+#         self.assertEqual(response.data["instance"]["id"], instance.id)
+#
+#     def test_update_view(self):
+#         instance = EventFactory.create()
+#         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)
+#         print(response.content)
+#         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.create()
+#         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
+#         )
+#         print(response.content)
+#         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.create()
+#         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.create(minute=30)
+#         EventFactory.create(person=event1.person, minute=20, event_type=event1.event_type, match=event1.match)
+#         EventFactory.create(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.create(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.create()
+#         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.create()
+#         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.create()
+#         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.create()
+#         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.create()
+#         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.create(name="BBB")
+#         event_b = EventTypeFactory.create(name="AAA", sport=event_a.sport)
+#         event_c = EventTypeFactory.create(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.create()
+#         type_b = EventTypeFactory.create(sport=type_a.sport)
+#         type_c = EventTypeFactory.create()
+#         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")