Coverage for src/tests/modules/training/trainings/test_training_db_query.py: 100%

1"""Module for testing TrainingDbQuery.""" 

2 

3from datetime import time 

4 

5import pytest 

6 

7from kwai_bc_training.coaches.coach import CoachEntity 

8from kwai_bc_training.teams.team import TeamEntity 

9from kwai_bc_training.trainings.training import TrainingIdentifier 

10from kwai_bc_training.trainings.training_db_query import TrainingDbQuery 

11from kwai_bc_training.trainings.training_schedule import ( 

12 TrainingScheduleEntity, 

13 TrainingScheduleIdentifier, 

14) 

15from kwai_core.db.database import Database 

16from kwai_core.domain.value_objects.identifier import IntIdentifier 

17from kwai_core.domain.value_objects.name import Name 

18from kwai_core.domain.value_objects.owner import Owner 

19from kwai_core.domain.value_objects.time_period import TimePeriod 

20from kwai_core.domain.value_objects.timestamp import Timestamp 

21from kwai_core.domain.value_objects.unique_id import UniqueId 

22from kwai_core.domain.value_objects.weekday import Weekday 

23 

24 

25pytestmark = pytest.mark.db 

26 

27 

28async def test_filter_by_id(database: Database): 

29 """Test filtering on id.""" 

30 query = TrainingDbQuery(database) 

31 query.filter_by_id(TrainingIdentifier(1)) 

32 

33 count = await query.count() 

34 assert count >= 0, "There should be 0 or more trainings." 

35 

36 

37async def test_filter_by_year(database: Database): 

38 """Test filtering on id.""" 

39 query = TrainingDbQuery(database) 

40 query.filter_by_year_month(2022) 

41 

42 count = await query.count() 

43 assert count >= 0, "There should be 0 or more trainings." 

44 

45 

46async def test_filter_by_year_month(database: Database): 

47 """Test filtering on id.""" 

48 query = TrainingDbQuery(database) 

49 query.filter_by_year_month(2022, 1) 

50 

51 count = await query.count() 

52 assert count >= 0, "There should be 0 or more trainings." 

53 

54 

55async def test_filter_by_dates(database: Database): 

56 """Test filtering on dates.""" 

57 query = TrainingDbQuery(database) 

58 query.filter_by_dates(Timestamp.create_now(), Timestamp.create_with_delta(days=1)) 

59 count = await query.count() 

60 assert count >= 0, "There should be 0 or more trainings." 

61 

62 

63async def test_filter_by_coach(database: Database): 

64 """Test filtering on coach.""" 

65 query = TrainingDbQuery(database) 

66 query.filter_by_coach( 

67 CoachEntity( 

68 id=IntIdentifier(1), 

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

70 active=True, 

71 uuid=UniqueId.generate(), 

72 ) 

73 ) 

74 count = await query.count() 

75 assert count >= 0, "There should be 0 or more trainings." 

76 

77 

78async def test_filter_by_team(database: Database): 

79 """Test filtering on team.""" 

80 query = TrainingDbQuery(database) 

81 query.filter_by_team(TeamEntity(id=IntIdentifier(1), name="U18")) 

82 count = await query.count() 

83 assert count >= 0, "There should be 0 or more trainings." 

84 

85 

86async def test_filter_by_schema(database: Database): 

87 """Test filtering on a training schema.""" 

88 query = TrainingDbQuery(database) 

89 query.filter_by_training_schedule( 

90 TrainingScheduleEntity( 

91 id=TrainingScheduleIdentifier(1), 

92 name="Test", 

93 description="Test", 

94 weekday=Weekday.MONDAY, 

95 owner=Owner( 

96 id=IntIdentifier(1), 

97 uuid=UniqueId.generate(), 

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

99 ), 

100 period=TimePeriod(start=time(hour=20), end=time(hour=21)), 

101 ) 

102 ) 

103 count = await query.count() 

104 assert count >= 0, "There should be 0 or more trainings." 

105 

106 

107async def test_filter_active(database: Database): 

108 """Test filtering only active trainings.""" 

109 query = TrainingDbQuery(database) 

110 query.filter_active() 

111 

112 count = await query.count() 

113 assert count >= 0, "There should be 0 or more trainings."