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 head=False, 

73 ) 

74 ) 

75 count = await query.count() 

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

77 

78 

79async def test_filter_by_team(database: Database): 

80 """Test filtering on team.""" 

81 query = TrainingDbQuery(database) 

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

83 count = await query.count() 

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

85 

86 

87async def test_filter_by_schema(database: Database): 

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

89 query = TrainingDbQuery(database) 

90 query.filter_by_training_schedule( 

91 TrainingScheduleEntity( 

92 id=TrainingScheduleIdentifier(1), 

93 name="Test", 

94 description="Test", 

95 weekday=Weekday.MONDAY, 

96 owner=Owner( 

97 id=IntIdentifier(1), 

98 uuid=UniqueId.generate(), 

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

100 ), 

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

102 ) 

103 ) 

104 count = await query.count() 

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

106 

107 

108async def test_filter_active(database: Database): 

109 """Test filtering only active trainings.""" 

110 query = TrainingDbQuery(database) 

111 query.filter_active() 

112 

113 count = await query.count() 

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