Coverage for src/tests/api/v1/teams/test_presenters.py: 100%

1"""Module for testing teams schemas.""" 

2 

3import json 

4 

5from typing import Any 

6 

7import pytest 

8 

9from deepdiff import DeepDiff 

10from kwai_api.v1.teams.presenters import ( 

11 JsonApiTeamMemberPresenter, 

12 JsonApiTeamPresenter, 

13) 

14from kwai_bc_club.domain.value_objects import Birthdate, Gender, License 

15from kwai_bc_teams.domain.team import TeamEntity, TeamIdentifier, TeamMembers 

16from kwai_bc_teams.domain.team_member import ( 

17 MemberEntity, 

18 MemberIdentifier, 

19 TeamMember, 

20) 

21from kwai_core.domain.value_objects.date import Date 

22from kwai_core.domain.value_objects.name import Name 

23from kwai_core.domain.value_objects.traceable_time import TraceableTime 

24from kwai_core.domain.value_objects.unique_id import UniqueId 

25 

26from tests.fixtures.club.countries import * # noqa 

27 

28 

29@pytest.fixture 

30def team_member(country_japan) -> TeamMember: 

31 """A fixture for a team member.""" 

32 return TeamMember( 

33 active=True, 

34 member=MemberEntity( 

35 id=MemberIdentifier(1), 

36 name=Name(first_name="Jigoro", last_name="Kano"), 

37 uuid=UniqueId.generate(), 

38 license=License(number="1234", end_date=Date.today().add(years=1)), 

39 birthdate=Birthdate(Date.create(year=1860, month=10, day=28)), 

40 gender=Gender.MALE, 

41 nationality=country_japan, 

42 active_in_club=True, 

43 ), 

44 traceable_time=TraceableTime(), 

45 ) 

46 

47 

48@pytest.fixture 

49def expected_team_member_json(team_member: TeamMember) -> dict[str, Any]: 

50 """A fixture for a JSON:API resource of a team member.""" 

51 return { 

52 "data": { 

53 "id": str(team_member.member.uuid), 

54 "type": "team_members", 

55 "meta": { 

56 "created_at": str(team_member.traceable_time.created_at), 

57 "updated_at": None, 

58 }, 

59 "attributes": { 

60 "active": True, 

61 "first_name": "Jigoro", 

62 "last_name": "Kano", 

63 "gender": team_member.member.gender.value, 

64 "birthdate": str(team_member.member.birthdate), 

65 "license_number": team_member.member.license.number, 

66 "license_end_date": str(team_member.member.license.end_date), 

67 "active_in_club": True, 

68 }, 

69 "relationships": { 

70 "nationality": { 

71 "data": { 

72 "id": str(team_member.member.nationality.id), 

73 "type": "countries", 

74 } 

75 }, 

76 "team": {"data": None}, 

77 }, 

78 }, 

79 "included": [ 

80 { 

81 "id": str(team_member.member.nationality.id), 

82 "type": "countries", 

83 "attributes": {"iso_2": "JP", "iso_3": "JPN", "name": "Japan"}, 

84 } 

85 ], 

86 } 

87 

88 

89def test_create_team_member_document( 

90 team_member: TeamMember, expected_team_member_json: dict[str, Any] 

91): 

92 """Test the creation of a JSON:API document for a team member resource.""" 

93 team_member_document = ( 

94 JsonApiTeamMemberPresenter().present((team_member, None)).get_document() 

95 ) 

96 json_resource = json.loads(team_member_document.model_dump_json()) 

97 

98 diff = DeepDiff(json_resource, expected_team_member_json, ignore_order=True) 

99 assert not diff, f"JSON structure is not expected:{diff}" 

100 

101 

102@pytest.fixture 

103def team(team_member: TeamMember) -> TeamEntity: 

104 """A fixture for a team entity.""" 

105 return TeamEntity( 

106 id=TeamIdentifier(1), 

107 name="U11", 

108 members=TeamMembers({team_member.member.uuid: team_member}), 

109 ) 

110 

111 

112@pytest.fixture 

113def expected_team_json(team: TeamEntity, expected_team_member_json) -> dict[str, Any]: 

114 """A fixture for a JSON:API resource of a team.""" 

115 return { 

116 "data": { 

117 "id": "1", 

118 "type": "teams", 

119 "meta": { 

120 "created_at": str(team.traceable_time.created_at), 

121 "updated_at": None, 

122 }, 

123 "attributes": {"name": "U11", "remark": "", "active": True}, 

124 "relationships": { 

125 "team_members": { 

126 "data": [ 

127 { 

128 "id": expected_team_member_json["data"]["id"], 

129 "type": expected_team_member_json["data"]["type"], 

130 } 

131 ] 

132 } 

133 }, 

134 }, 

135 "included": [ 

136 expected_team_member_json["data"], 

137 *expected_team_member_json["included"], 

138 ], 

139 } 

140 

141 

142def test_create_team_document(team: TeamEntity, expected_team_json: dict[str, Any]): 

143 """Test the creation of a JSON:API document for a team entity.""" 

144 team_document = JsonApiTeamPresenter().present(team).get_document() 

145 json_resource = json.loads(team_document.model_dump_json()) 

146 

147 diff = DeepDiff(json_resource, expected_team_json, ignore_order=True) 

148 assert not diff, f"JSON structure is not expected:{diff}"