Coverage for website/photos/tests/test_services.py: 100.00%

1from django.test import RequestFactory, TestCase, override_settings 

2from django.utils.timezone import datetime 

3 

4from freezegun import freeze_time 

5 

6from members.models import Member, Membership 

7from photos.models import Album 

8from photos.services import get_annotated_accessible_albums, is_album_accessible 

9 

10 

11@override_settings(SUSPEND_SIGNALS=True) 

12class IsAlbumAccesibleTest(TestCase): 

13 fixtures = ["members.json"] 

14 

15 @classmethod 

16 def setUpTestData(cls): 

17 cls.member = Member.objects.filter(username="testuser").first() 

18 

19 def setUp(self): 

20 self.rf = RequestFactory() 

21 

22 @freeze_time("2017-01-01") 

23 def test_is_album_accessible(self): 

24 request = self.rf.get("/") 

25 request.member = None 

26 album = Album(date=datetime(year=2017, month=1, day=1), slug="test") 

27 

28 with self.subTest(membership=None): 

29 self.assertFalse(is_album_accessible(request, album)) 

30 

31 request.member = self.member 

32 with self.subTest(membership=None): 

33 self.assertFalse(is_album_accessible(request, album)) 

34 

35 membership = Membership.objects.create( 

36 user=self.member, 

37 type=Membership.MEMBER, 

38 since=datetime(year=2016, month=1, day=1), 

39 ) 

40 self.member.refresh_from_db() # Clear the cached membership 

41 

42 with self.subTest( 

43 membership_since=membership.since, membership_until=membership.until 

44 ): 

45 self.assertTrue(is_album_accessible(request, album)) 

46 

47 membership.until = datetime(year=2016, month=1, day=1) 

48 membership.save() 

49 self.member.refresh_from_db() # Clear the cached membership 

50 

51 with self.subTest( 

52 membership_since=membership.since, membership_until=membership.until 

53 ): 

54 self.assertFalse(is_album_accessible(request, album)) 

55 

56 membership.until = datetime(year=2017, month=1, day=1) 

57 membership.save() 

58 self.member.refresh_from_db() # Clear the cached membership 

59 

60 with self.subTest( 

61 membership_since=membership.since, membership_until=membership.until 

62 ): 

63 self.assertTrue(is_album_accessible(request, album)) 

64 

65 

66@override_settings(SUSPEND_SIGNALS=True) 

67class GetAnnotatedAccessibleAlbumsTest(TestCase): 

68 fixtures = ["members.json"] 

69 

70 @classmethod 

71 def setUpTestData(cls): 

72 cls.member = Member.objects.filter(username="testuser").first() 

73 

74 def setUp(self): 

75 self.rf = RequestFactory() 

76 

77 @freeze_time("2017-01-01") 

78 def test_get_annotated_accessible_albums(self): 

79 request = self.rf.get("/") 

80 request.member = None 

81 album = Album( 

82 title="test_case", date=datetime(year=2017, month=1, day=1), slug="test" 

83 ) 

84 album.save() 

85 

86 self.assertEqual(Album.objects.count(), 1) 

87 

88 with self.subTest(membership=None): 

89 albums = Album.objects.all() 

90 albums = get_annotated_accessible_albums(request, albums) 

91 for album in albums: 

92 self.assertFalse(album.accessible) 

93 

94 request.member = self.member 

95 with self.subTest(membership=None): 

96 albums = Album.objects.all() 

97 albums = get_annotated_accessible_albums(request, albums) 

98 for album in albums: 

99 self.assertFalse(album.accessible) 

100 

101 membership = Membership.objects.create( 

102 user=self.member, 

103 type=Membership.MEMBER, 

104 since=datetime(year=2016, month=1, day=1), 

105 ) 

106 self.member.refresh_from_db() # Clear the cached membership 

107 

108 with self.subTest( 

109 membership_since=membership.since, membership_until=membership.until 

110 ): 

111 albums = Album.objects.all() 

112 albums = get_annotated_accessible_albums(request, albums) 

113 for album in albums: 

114 self.assertTrue(album.accessible) 

115 

116 membership.until = datetime(year=2016, month=1, day=1) 

117 membership.save() 

118 self.member.refresh_from_db() # Clear the cached membership 

119 

120 with self.subTest( 

121 membership_since=membership.since, membership_until=membership.until 

122 ): 

123 albums = Album.objects.all() 

124 albums = get_annotated_accessible_albums(request, albums) 

125 for album in albums: 

126 self.assertFalse(album.accessible) 

127 

128 membership.until = datetime(year=2017, month=1, day=1) 

129 membership.save() 

130 self.member.refresh_from_db() # Clear the cached membership 

131 

132 with self.subTest( 

133 membership_since=membership.since, membership_until=membership.until 

134 ): 

135 albums = Album.objects.all() 

136 albums = get_annotated_accessible_albums(request, albums) 

137 for album in albums: 

138 self.assertTrue(album.accessible)