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

1"""Module for defining factory fixtures for trainings.""" 

2 

3import pytest 

4 

5from kwai_bc_training.coaches.coach import CoachEntity 

6from kwai_bc_training.trainings.training import ( 

7 TrainingCoachEntity, 

8 TrainingEntity, 

9) 

10from kwai_bc_training.trainings.training_db_repository import TrainingDbRepository 

11from kwai_core.db.database import Database 

12from kwai_core.db.uow import UnitOfWork 

13from kwai_core.domain.value_objects.owner import Owner 

14from kwai_core.domain.value_objects.period import Period 

15from kwai_core.domain.value_objects.text import DocumentFormat, Locale, LocaleText 

16from kwai_core.domain.value_objects.unique_id import UniqueId 

17 

18 

19@pytest.fixture 

20def make_text( 

21 *, 

22 locale: Locale | None = None, 

23 format_: DocumentFormat | None = None, 

24 title: str = "Training Test", 

25 content: str = "This is a test training", 

26 summary: str = "Test", 

27 owner: Owner, 

28): 

29 """A factory fixture for a text.""" 

30 

31 def _make_text() -> LocaleText: 

32 return LocaleText( 

33 title=title, 

34 content=content, 

35 summary=summary, 

36 locale=locale or Locale.NL, 

37 format=format_ or DocumentFormat.MARKDOWN, 

38 author=owner, 

39 ) 

40 

41 return _make_text 

42 

43 

44@pytest.fixture 

45def make_training_coach(make_coach, owner: Owner): 

46 """A factory fixture for a training coach.""" 

47 

48 def _make_training_coach(coach: CoachEntity | None = None) -> TrainingCoachEntity: 

49 if coach is None: 

50 # make_coach returns a coach entity from the club module, so we need 

51 # to convert it to one for the training module. 

52 club_coach = make_coach() 

53 coach = CoachEntity( 

54 id=club_coach.id, 

55 name=club_coach.name, 

56 active=club_coach.active, 

57 uuid=UniqueId.generate(), 

58 ) 

59 return TrainingCoachEntity(coach=coach, owner=owner) 

60 

61 return _make_training_coach 

62 

63 

64@pytest.fixture 

65def make_training(make_text, make_training_coach): 

66 """A factory fixture for a training.""" 

67 

68 def _make_training( 

69 text: LocaleText | None = None, 

70 coach: TrainingCoachEntity | None = None, 

71 period: Period | None = None, 

72 active: bool = True, 

73 ) -> TrainingEntity: 

74 coach = coach or make_training_coach() 

75 text = text or make_text() 

76 period = period or Period.create_from_delta(hours=2) 

77 return TrainingEntity( 

78 texts=(text,), 

79 coaches=frozenset((coach,)), 

80 season=None, 

81 period=period, 

82 active=active, 

83 ) 

84 

85 return _make_training 

86 

87 

88@pytest.fixture 

89async def make_training_in_db( 

90 request, database: Database, make_training, make_coach_in_db, owner 

91): 

92 """A factory fixture for a training in the database.""" 

93 created_entities = [] 

94 

95 async def _make_training_in_db( 

96 training: TrainingEntity | None = None, 

97 coach: TrainingCoachEntity | None = None, 

98 ) -> TrainingEntity: 

99 if coach is None: 

100 club_coach = await make_coach_in_db() 

101 coach = TrainingCoachEntity( 

102 coach=CoachEntity( 

103 id=club_coach.id, 

104 name=club_coach.name, 

105 active=True, 

106 uuid=club_coach.member.uuid, 

107 ), 

108 owner=owner, 

109 ) 

110 training = training or make_training(coach=coach) 

111 

112 repo = TrainingDbRepository(database) 

113 async with UnitOfWork(database): 

114 training = await repo.create(training) 

115 created_entities.append(training) 

116 

117 return training 

118 

119 yield _make_training_in_db 

120 

121 repo = TrainingDbRepository(database) 

122 for entity in created_entities: 

123 async with UnitOfWork(database): 

124 await repo.delete(entity)