Coverage for website/members/tests/test_models.py: 100.00%

1from datetime import datetime 

2 

3from django.test import TestCase, override_settings 

4from django.utils import timezone 

5 

6from freezegun import freeze_time 

7 

8from members.models import Member, Profile 

9from members.models.membership import Membership 

10 

11 

12@override_settings(SUSPEND_SIGNALS=True) 

13class MemberBirthdayTest(TestCase): 

14 fixtures = ["members.json"] 

15 

16 def _make_date(self, date): 

17 return timezone.make_aware(datetime.strptime(date, "%Y-%m-%d")) 

18 

19 def _get_members(self, start, end): 

20 start_date = self._make_date(start) 

21 end_date = self._make_date(end) 

22 return Member.current_members.with_birthdays_in_range(start_date, end_date) 

23 

24 def _assert_none(self, start, end): 

25 members = self._get_members(start, end) 

26 self.assertEqual(len(members), 0) 

27 

28 def _assert_thom(self, start, end): 

29 members = self._get_members(start, end) 

30 self.assertEqual(len(members), 1) 

31 self.assertEqual(members[0].get_full_name(), "Thom Wiggers") 

32 

33 def test_one_year_contains_birthday(self): 

34 self._assert_thom("2016-03-02", "2016-08-08") 

35 

36 def test_one_year_not_contains_birthday(self): 

37 self._assert_none("2016-01-01", "2016-02-01") 

38 

39 def test_span_year_contains_birthday(self): 

40 self._assert_thom("2015-08-09", "2016-08-08") 

41 

42 def test_span_year_not_contains_birthday(self): 

43 self._assert_none("2015-12-25", "2016-03-01") 

44 

45 def test_span_multiple_years_contains_birthday(self): 

46 self._assert_thom("2012-12-31", "2016-01-01") 

47 

48 def test_range_before_person_born(self): 

49 self._assert_none("1985-12-12", "1985-12-13") 

50 

51 def test_person_born_in_range_in_one_year(self): 

52 self._assert_thom("1993-01-01", "1993-04-01") 

53 

54 def test_person_born_in_range_spanning_one_year(self): 

55 self._assert_thom("1992-12-31", "1993-04-01") 

56 

57 def test_person_born_in_range_spanning_multiple_years(self): 

58 self._assert_thom("1992-12-31", "1995-01-01") 

59 

60 

61@override_settings(SUSPEND_SIGNALS=True) 

62class MemberTest(TestCase): 

63 fixtures = ["members.json"] 

64 

65 def test_has_been_member(self): 

66 member = Member.objects.get(pk=1) 

67 

68 self.assertTrue(member.has_been_member()) 

69 

70 m1 = member.membership_set.all()[0] 

71 m1.type = "honorary" 

72 m1.save() 

73 self.assertFalse(member.has_been_member()) 

74 

75 def test_has_been_honorary_member(self): 

76 member = Member.objects.get(pk=1) 

77 

78 self.assertFalse(member.has_been_honorary_member()) 

79 

80 m1 = member.membership_set.all()[0] 

81 m1.type = "honorary" 

82 m1.save() 

83 self.assertTrue(member.has_been_honorary_member()) 

84 

85 def test_membership_properties(self): 

86 member = Member.objects.get(pk=1) 

87 member.membership_set.all().delete() 

88 

89 old_membership = Membership.objects.create( 

90 user=member, 

91 since="2022-09-01", 

92 until="2023-09-01", 

93 type=Membership.MEMBER, 

94 ) 

95 middle_membership = Membership.objects.create( 

96 user=member, 

97 since="2023-09-01", 

98 until="2024-09-01", 

99 type=Membership.MEMBER, 

100 ) 

101 latest_membership = Membership.objects.create( 

102 user=member, 

103 since="2024-09-01", 

104 until="2025-09-01", 

105 type=Membership.MEMBER, 

106 ) 

107 

108 with freeze_time("2022-08-25"): 

109 member.refresh_from_db() 

110 self.assertFalse(member.has_active_membership()) 

111 self.assertIsNone(member.current_membership) 

112 self.assertEqual(member.latest_membership, latest_membership) 

113 

114 with freeze_time("2022-09-01"): 

115 member.refresh_from_db() 

116 self.assertTrue(member.has_active_membership()) 

117 self.assertEqual(member.current_membership, old_membership) 

118 self.assertEqual(member.latest_membership, latest_membership) 

119 

120 with freeze_time("2024-08-25"): 

121 # A membership has been renewed before the end of the current one. 

122 member.refresh_from_db() 

123 self.assertTrue(member.has_active_membership()) 

124 self.assertEqual(member.current_membership, middle_membership) 

125 self.assertEqual(member.latest_membership, latest_membership) 

126 

127 with freeze_time("2024-09-01"): 

128 member.refresh_from_db() 

129 self.assertTrue(member.has_active_membership()) 

130 self.assertEqual(member.current_membership, latest_membership) 

131 self.assertEqual(member.latest_membership, latest_membership) 

132 

133 with freeze_time("2025-09-01"): 

134 member.refresh_from_db() 

135 self.assertFalse(member.has_active_membership()) 

136 self.assertIsNone(member.current_membership) 

137 self.assertEqual(member.latest_membership, latest_membership) 

138 

139 

140class MemberDisplayNameTest(TestCase): 

141 @classmethod 

142 def setUpTestData(cls): 

143 cls.member = Member.objects.create( 

144 username="johnnytest", first_name="", last_name="" 

145 ) 

146 cls.profile = Profile.objects.create( 

147 user_id=cls.member.pk, 

148 initials=None, 

149 nickname=None, 

150 display_name_preference="full", 

151 ) 

152 

153 def setUp(self): 

154 self.profile.display_name_preference = "full" 

155 # Assuming we always have a first and last name 

156 self.profile.user.first_name = "Johnny" 

157 self.profile.user.last_name = "Test" 

158 self.profile.nickname = None 

159 self.profile.initials = None 

160 

161 def test_check_display_name_full(self): 

162 self.assertEqual("Johnny Test", self.profile.display_name()) 

163 self.assertEqual("Johnny", self.profile.short_display_name()) 

164 

165 def test_check_display_name_nickname(self): 

166 self.profile.display_name_preference = "nickname" 

167 self.assertEqual("Johnny Test", self.profile.display_name()) 

168 self.assertEqual("Johnny", self.profile.short_display_name()) 

169 self.profile.nickname = "John" 

170 self.assertEqual("'John'", self.profile.display_name()) 

171 self.assertEqual("'John'", self.profile.short_display_name()) 

172 

173 def test_check_display_name_firstname(self): 

174 self.profile.display_name_preference = "firstname" 

175 self.assertEqual("Johnny", self.profile.display_name()) 

176 self.assertEqual("Johnny", self.profile.short_display_name()) 

177 

178 def test_check_display_name_initials(self): 

179 self.profile.display_name_preference = "initials" 

180 self.assertEqual("Test", self.profile.display_name()) 

181 self.assertEqual("Test", self.profile.short_display_name()) 

182 self.profile.initials = "J" 

183 self.assertEqual("J Test", self.profile.display_name()) 

184 self.assertEqual("J Test", self.profile.short_display_name()) 

185 

186 def test_check_display_name_fullnick(self): 

187 self.profile.display_name_preference = "fullnick" 

188 self.assertEqual("Johnny Test", self.profile.display_name()) 

189 self.assertEqual("Johnny", self.profile.short_display_name()) 

190 self.profile.nickname = "John" 

191 self.assertEqual("Johnny 'John' Test", self.profile.display_name()) 

192 self.assertEqual("Johnny", self.profile.short_display_name()) 

193 

194 def test_check_display_name_nicklast(self): 

195 self.profile.display_name_preference = "nicklast" 

196 self.assertEqual("Johnny Test", self.profile.display_name()) 

197 self.assertEqual("Johnny", self.profile.short_display_name()) 

198 self.profile.nickname = "John" 

199 self.assertEqual("'John' Test", self.profile.display_name()) 

200 self.assertEqual("'John'", self.profile.short_display_name())