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

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

@@ -0,0 +1,87 @@
+import pytest
+from django.db import IntegrityError
+from wbcore.contrib.example_app.factories import (
+    EventFactory,
+    EventTypeFactory,
+    PlayerFactory,
+)
+
+
+@pytest.mark.django_db
+class TestEvent:
+    def test_str(self):
+        event = EventFactory(
+            minute=69,
+            person__first_name="Test",
+            person__last_name="Person",
+            event_type__name="Test Event Type",
+            match__sport__match_duration=90,
+        )
+        assert event.__str__() == "Test Event Type (69.) - Test Person"
+
+    @pytest.mark.parametrize(
+        "home, away, points, home_score, away_score", [(2, 1, 5, 7, 1), (0, 3, 2, 2, 3), (1, 1, 0, 1, 1)]
+    )
+    def test_save_home_scored(self, home, away, points, home_score, away_score):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__home=person.current_team,
+            match__score_home=home,
+            match__score_away=away,
+            event_type__points=points,
+        )
+        assert event.match.score_home == home_score
+        assert event.match.score_away == away_score
+
+    @pytest.mark.parametrize(
+        "home, away, points, home_score, away_score", [(41, 27, 4, 41, 31), (19, 0, 2, 19, 2), (22, 23, 0, 22, 23)]
+    )
+    def test_save_away_scored(self, home, away, points, home_score, away_score):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__away=person.current_team,
+            match__score_home=home,
+            match__score_away=away,
+            event_type__points=points,
+        )
+        assert event.match.score_home == home_score
+        assert event.match.score_away == away_score
+
+    def test_save_no_team(self):
+        person = PlayerFactory()
+        event = EventFactory(
+            person=person,
+            match__score_home=2,
+            match__score_away=1,
+            event_type__points=4,
+        )
+        assert event.match.score_home == 2
+        assert event.match.score_away == 1
+
+    def test_save_no_player(self):
+        event = EventFactory(
+            match__score_home=2,
+            match__score_away=1,
+            event_type__points=4,
+        )
+        assert event.match.score_home == 2
+        assert event.match.score_away == 1
+
+    def test_unique_constraint(self):
+        event = EventFactory()
+        with pytest.raises(IntegrityError):
+            EventFactory(person=event.person, minute=event.minute, event_type=event.event_type, match=event.match)
+
+
+@pytest.mark.django_db
+class TestEventType:
+    def test_str(self):
+        event_type = EventTypeFactory(name="Test Event Type")
+        assert event_type.__str__() == "Test Event Type"
+
+    def test_unique_constraint(self):
+        event_type = EventTypeFactory()
+        with pytest.raises(IntegrityError):
+            EventTypeFactory(name=event_type.name, sport=event_type.sport)

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

@@ -0,0 +1,210 @@
+from datetime import datetime
+from unittest.mock import patch
+
+import pytest
+import pytz
+from django.db import IntegrityError
+from django.db.models import Q
+from faker import Faker
+from wbcore.contrib.authentication.factories import SuperUserFactory, UserFactory
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.example_app.factories import (
+    LeagueFactory,
+    MatchFactory,
+    TeamFactory,
+)
+from wbcore.contrib.example_app.models import (
+    Match,
+    SportPerson,
+    TeamResults,
+    start_match,
+)
+
+
+@pytest.mark.django_db
+class TestMatch:
+    def test_has_permissions_superuser(self):
+        user = SuperUserFactory()
+        match = MatchFactory()
+        assert match.has_permissions(user) is True
+
+    def test_has_permissions_custom_perm(self):
+        match = MatchFactory()
+        user = UserFactory(user_permissions=["wbcore.change_match_status"])
+        assert match.has_permissions(user) is True
+
+    def test_str(self):
+        match = MatchFactory(home__name="Home Team", away__name="Away Team")
+        assert match.__str__() == "Home Team vs. Away Team"
+
+    @patch("wbcore.contrib.example_app.models.start_match.apply_async")
+    @patch("wbcore.contrib.example_app.models.current_app.control.revoke")
+    def test_reschedule_existing_task(self, mock_revoke, mock_start):
+        user = UserFactory()
+        # we just need an object with a .id method
+        mock_start.return_value = user
+        match = MatchFactory()
+        old_task_id = match.task_id
+        match.reschedule_task()
+        assert mock_revoke.call_args.args == (old_task_id,)
+        assert mock_revoke.call_args.kwargs == {"terminate": True}
+        assert mock_start.call_args.kwargs == {"eta": match.date_time, "args": [match.pk]}
+        assert match.task_id == user.pk
+
+    @patch("wbcore.contrib.example_app.models.start_match.apply_async")
+    @patch("wbcore.contrib.example_app.models.current_app.control.revoke")
+    def test_reschedule_new_task(self, mock_revoke, mock_start):
+        user = UserFactory()
+        # we just need an object with a .id method
+        mock_start.return_value = user
+        match = MatchFactory()
+        match.task_id = None
+        match.reschedule_task()
+        assert mock_revoke.call_count == 1
+        assert mock_start.call_args.kwargs == {"eta": match.date_time, "args": [match.pk]}
+        assert match.task_id == user.pk
+
+    def test_save_calendar_item(self):
+        match = MatchFactory(league__sport__match_duration=120, date_time=datetime(2023, 5, 20, 19, 15))
+
+        home_sport_persons = SportPerson.objects.filter(
+            Q(id__in=match.home.current_players.all()) | Q(coached_team=match.home)
+        )
+        away_sport_persons = SportPerson.objects.filter(
+            Q(id__in=match.away.current_players.all()) | Q(coached_team=match.away)
+        )
+        referee = SportPerson.objects.filter(id=match.referee.id)
+        match_persons = home_sport_persons.union(away_sport_persons, referee)
+
+        persons = Person.objects.filter(id__in=match_persons.values_list("profile", flat=True))
+        entities_id_list = list(persons.values_list("pk", flat=True))
+        entities_id_list.extend([match.home.id, match.away.id])
+
+        assert match.period.upper == datetime(2023, 5, 20, 21, 15)
+        assert set(match.entities.values_list("id", flat=True)) == set(entities_id_list)
+
+    @patch("wbcore.contrib.example_app.models.Match.reschedule_task")
+    def test_save_trigger_rescheduling(self, mock_reschedule):
+        match = MatchFactory()
+        match.date_time = Faker().date_time(tzinfo=pytz.utc)
+        match.save()
+        assert mock_reschedule.call_count == 2
+
+    @patch("wbcore.contrib.example_app.models.Match.reschedule_task")
+    def test_save_no_rescheduling(self, mock_reschedule):
+        match = MatchFactory()
+        match.title = "Test"
+        match.save()
+        assert mock_reschedule.call_count == 1
+
+    def test_save_update_teamresults(self):
+        league = LeagueFactory(points_per_win=5, points_per_draw=2, points_per_loss=1)
+        home_team = TeamFactory()
+        away_team = TeamFactory()
+
+        # Home win
+        match1 = MatchFactory(
+            home=home_team,
+            away=away_team,
+            status=Match.MatchStatus.FINISHED,
+            score_home=3,
+            score_away=1,
+            league=league,
+        )
+        assert set(TeamResults.objects.values_list("team__name", flat=True)) == {home_team.name, away_team.name}
+        home_results = TeamResults.objects.get(team=home_team)
+        away_results = TeamResults.objects.get(team=away_team)
+        assert home_results.wins == 1
+        assert home_results.draws == 0
+        assert home_results.losses == 0
+        assert home_results.form == "----W"
+        assert home_results.points == 5
+        assert home_results.match_points_for == 3
+        assert home_results.match_points_against == 1
+        assert away_results.wins == 0
+        assert away_results.draws == 0
+        assert away_results.losses == 1
+        assert away_results.form == "----L"
+        assert away_results.points == 1
+        assert away_results.match_points_for == 1
+        assert away_results.match_points_against == 3
+        assert match1.task_id == ""
+
+        # Home Loss
+        match2 = MatchFactory(
+            home=home_team,
+            away=away_team,
+            status=Match.MatchStatus.FINISHED,
+            score_home=21,
+            score_away=37,
+            league=league,
+        )
+        home_results = TeamResults.objects.get(team=home_team)
+        away_results = TeamResults.objects.get(team=away_team)
+        assert home_results.wins == 1
+        assert home_results.draws == 0
+        assert home_results.losses == 1
+        assert home_results.form == "---WL"
+        assert home_results.points == 6
+        assert home_results.match_points_for == 24
+        assert home_results.match_points_against == 38
+        assert away_results.wins == 1
+        assert away_results.draws == 0
+        assert away_results.losses == 1
+        assert away_results.form == "---LW"
+        assert away_results.points == 6
+        assert away_results.match_points_for == 38
+        assert away_results.match_points_against == 24
+        assert match2.task_id == ""
+
+        # Draw
+        match3 = MatchFactory(
+            home=home_team,
+            away=away_team,
+            status=Match.MatchStatus.FINISHED,
+            score_home=2,
+            score_away=2,
+            league=league,
+        )
+        home_results = TeamResults.objects.get(team=home_team)
+        away_results = TeamResults.objects.get(team=away_team)
+        assert home_results.wins == 1
+        assert home_results.draws == 1
+        assert home_results.losses == 1
+        assert home_results.form == "--WLD"
+        assert home_results.points == 8
+        assert home_results.match_points_for == 26
+        assert home_results.match_points_against == 40
+        assert away_results.wins == 1
+        assert away_results.draws == 1
+        assert away_results.losses == 1
+        assert away_results.form == "--LWD"
+        assert away_results.points == 8
+        assert away_results.match_points_for == 40
+        assert away_results.match_points_against == 26
+        assert match3.task_id == ""
+
+    @patch("wbcore.contrib.example_app.models.Match.reschedule_task")
+    def test_save_no_task_id(self, mock_reschedule):
+        MatchFactory(status=Match.MatchStatus.FINISHED, score_home=3, score_away=1, task_id="")
+        assert not TeamResults.objects.exists()
+
+    def test_unique_constraint(self):
+        match = MatchFactory()
+        with pytest.raises(IntegrityError):
+            MatchFactory(home=match.home, away=match.away, date_time=match.date_time)
+
+    def test_check_constraint(self):
+        team = TeamFactory()
+        with pytest.raises(IntegrityError):
+            MatchFactory(home=team, away=team)
+
+    def test_start_match_scheduled(self):
+        match = MatchFactory(status=Match.MatchStatus.SCHEDULED)
+        start_match(match.pk)
+        assert Match.objects.get(id=match.pk).status == Match.MatchStatus.ONGOING
+
+    def test_start_match_finished(self):
+        match = MatchFactory(status=Match.MatchStatus.FINISHED)
+        start_match(match.pk)
+        assert Match.objects.get(id=match.pk).status != Match.MatchStatus.ONGOING

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

@@ -0,0 +1,159 @@
+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(first_name="Test", last_name="Name")
+        assert person.str_full() == "Test Name"
+
+    def test_str_full_coach(self):
+        person = SportPersonFactory(first_name="Test", last_name="Name")
+        TeamFactory(coach=person, name="Test Team")
+        assert person.str_full() == "Test Name (Coach of Test Team)"
+
+    def test_str_full_commissioner(self):
+        commissioner = SportPersonFactory(first_name="Test", last_name="Name")
+        LeagueFactory(commissioner=commissioner, name="Test League")
+        assert commissioner.str_full() == "Test Name (Commissioner of Test League)"
+
+    def test_get_player_fail(self):
+        person = SportPersonFactory()
+        assert person.get_player() is None
+
+    def test_get_player_sucess(self):
+        player = PlayerFactory()
+        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(first_name="Test", last_name="Name", current_team=None)
+        assert player.str_full() == "Test Name"
+
+    def test_str_full_team(self):
+        player = PlayerFactory(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(
+            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(title="Test Role")
+        assert role.__str__() == "Test Role"
+
+
+@pytest.mark.django_db
+class TestSport:
+    def test_str(self):
+        sport = SportFactory(name="Test Sport")
+        assert sport.__str__() == "Test Sport"
+
+    def test_post_save(self):
+        sport = SportFactory()
+        league1 = LeagueFactory(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()
+        with pytest.raises(IntegrityError):
+            LeagueFactory(name=league.name, sport=league.sport)
+
+    def test_post_save(self):
+        commissioner = SportPersonFactory()
+        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()
+        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()
+        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()
+        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()
+        league = LeagueFactory(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()
+        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,134 @@
+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(), home=TeamFactory(), sport=SportFactory(), stadium=StadiumFactory())
+        )
+        match_serializer = MatchModelSerializer(data=match_data)
+        self.assertTrue(match_serializer.is_valid())
+
+    def test_match_same_teams(self):
+        team = TeamFactory()
+        match_data: dict = model_to_dict(
+            MatchFactory.build(away=team, home=team, sport=SportFactory(), stadium=StadiumFactory())
+        )
+        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()
+        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())