Coverage for ivatar/ivataraccount/test_views_bluesky.py: 100%

1# -*- coding: utf-8 -*- 

2""" 

3Test our views in ivatar.ivataraccount.views and ivatar.views 

4""" 

5 

6import contextlib 

7 

8# pylint: disable=too-many-lines 

9import os 

10import django 

11from django.test import TestCase 

12from django.test import Client 

13 

14from django.urls import reverse 

15from django.contrib.auth.models import User 

16 

17# from django.contrib.auth import authenticate 

18 

19os.environ["DJANGO_SETTINGS_MODULE"] = "ivatar.settings" 

20django.setup() 

21 

22# pylint: disable=wrong-import-position 

23from ivatar import settings 

24from ivatar.ivataraccount.models import ConfirmedOpenId, ConfirmedEmail 

25from ivatar.utils import random_string 

26 

27from libravatar import libravatar_url 

28 

29 

30class Tester(TestCase): # pylint: disable=too-many-public-methods 

31 """ 

32 Main test class 

33 """ 

34 

35 client = Client() 

36 user = None 

37 username = random_string() 

38 password = random_string() 

39 email = "%s@%s.%s" % (username, random_string(), random_string(2)) 

40 # Dunno why random tld doesn't work, but I'm too lazy now to investigate 

41 openid = "http://%s.%s.%s/" % (username, random_string(), "org") 

42 first_name = random_string() 

43 last_name = random_string() 

44 bsky_test_account = "libravatar.org" 

45 

46 def login(self): 

47 """ 

48 Login as user 

49 """ 

50 self.client.login(username=self.username, password=self.password) 

51 

52 def setUp(self): 

53 """ 

54 Prepare for tests. 

55 - Create user 

56 """ 

57 self.user = User.objects.create_user( 

58 username=self.username, 

59 password=self.password, 

60 first_name=self.first_name, 

61 last_name=self.last_name, 

62 ) 

63 settings.EMAIL_BACKEND = "django.core.mail.backends.dummy.EmailBackend" 

64 

65 def create_confirmed_openid(self): 

66 """ 

67 Create a confirmed openid 

68 """ 

69 return ConfirmedOpenId.objects.create( 

70 user=self.user, 

71 ip_address="127.0.0.1", 

72 openid=self.openid, 

73 ) 

74 

75 def create_confirmed_email(self): 

76 """ 

77 Create a confirmed email 

78 """ 

79 return ConfirmedEmail.objects.create( 

80 email=self.email, 

81 user=self.user, 

82 ) 

83 

84 # The following tests need to be moved over to the model tests 

85 # and real web UI tests added 

86 def test_bluesky_handle_for_mail_via_model_handle_does_not_exist(self): 

87 """ 

88 Add Bluesky handle to a confirmed mail address 

89 """ 

90 self.login() 

91 confirmed = self.create_confirmed_email() 

92 confirmed.set_bluesky_handle(self.bsky_test_account) 

93 

94 with contextlib.suppress(Exception): 

95 confirmed.set_bluesky_handle(f"{self.bsky_test_account}1") 

96 self.assertNotEqual( 

97 confirmed.bluesky_handle, 

98 f"{self.bsky_test_account}1", 

99 "Setting Bluesky handle that doesn't exist works?", 

100 ) 

101 

102 def test_bluesky_handle_for_mail_via_model_handle_exists(self): 

103 """ 

104 Add Bluesky handle to a confirmed mail address 

105 """ 

106 self.login() 

107 confirmed = self.create_confirmed_email() 

108 confirmed.set_bluesky_handle(self.bsky_test_account) 

109 

110 self.assertEqual( 

111 confirmed.bluesky_handle, 

112 self.bsky_test_account, 

113 "Setting Bluesky handle doesn't work?", 

114 ) 

115 

116 def test_bluesky_handle_for_openid_via_model_handle_does_not_exist(self): 

117 """ 

118 Add Bluesky handle to a confirmed openid address 

119 """ 

120 self.login() 

121 confirmed = self.create_confirmed_openid() 

122 confirmed.set_bluesky_handle(self.bsky_test_account) 

123 

124 with contextlib.suppress(Exception): 

125 confirmed.set_bluesky_handle(f"{self.bsky_test_account}1") 

126 self.assertNotEqual( 

127 confirmed.bluesky_handle, 

128 f"{self.bsky_test_account}1", 

129 "Setting Bluesky handle that doesn't exist works?", 

130 ) 

131 

132 def test_bluesky_handle_for_openid_via_model_handle_exists(self): 

133 """ 

134 Add Bluesky handle to a confirmed openid address 

135 """ 

136 self.login() 

137 confirmed = self.create_confirmed_openid() 

138 confirmed.set_bluesky_handle(self.bsky_test_account) 

139 

140 self.assertEqual( 

141 confirmed.bluesky_handle, 

142 self.bsky_test_account, 

143 "Setting Bluesky handle doesn't work?", 

144 ) 

145 

146 def test_bluesky_fetch_mail(self): 

147 """ 

148 Check if we can successfully fetch a Bluesky avatar via email 

149 """ 

150 self.login() 

151 confirmed = self.create_confirmed_email() 

152 confirmed.set_bluesky_handle(self.bsky_test_account) 

153 lu = libravatar_url(confirmed.email, https=True) 

154 lu = lu.replace("https://seccdn.libravatar.org/", reverse("home")) 

155 

156 response = self.client.get(lu) 

157 # This is supposed to redirect to the Bluesky proxy 

158 self.assertEqual(response.status_code, 302) 

159 self.assertEqual(response["Location"], f"/blueskyproxy/{confirmed.digest}") 

160 

161 def test_bluesky_fetch_openid(self): 

162 """ 

163 Check if we can successfully fetch a Bluesky avatar via OpenID 

164 """ 

165 self.login() 

166 confirmed = self.create_confirmed_openid() 

167 confirmed.set_bluesky_handle(self.bsky_test_account) 

168 lu = libravatar_url(openid=confirmed.openid, https=True) 

169 lu = lu.replace("https://seccdn.libravatar.org/", reverse("home")) 

170 

171 response = self.client.get(lu) 

172 # This is supposed to redirect to the Bluesky proxy 

173 self.assertEqual(response.status_code, 302) 

174 self.assertEqual(response["Location"], f"/blueskyproxy/{confirmed.digest}") 

175 

176 def test_assign_bluesky_handle_to_openid(self): 

177 """ 

178 Assign a Bluesky handle to an OpenID 

179 """ 

180 self.login() 

181 confirmed = self.create_confirmed_openid() 

182 self._assign_handle_to( 

183 "assign_bluesky_handle_to_openid", 

184 confirmed, 

185 "Adding Bluesky handle to OpenID fails?", 

186 ) 

187 

188 def test_assign_bluesky_handle_to_email(self): 

189 """ 

190 Assign a Bluesky handle to an email 

191 

192 """ 

193 self.login() 

194 confirmed = self.create_confirmed_email() 

195 self._assign_handle_to( 

196 "assign_bluesky_handle_to_email", 

197 confirmed, 

198 "Adding Bluesky handle to Email fails?", 

199 ) 

200 

201 def _assign_handle_to(self, endpoint, confirmed, message): 

202 """ 

203 Helper method to assign a handle to reduce code duplication 

204 Since the endpoints are similar, we can reuse the code 

205 """ 

206 url = reverse(endpoint, args=[confirmed.id]) 

207 response = self.client.post( 

208 url, {"bluesky_handle": self.bsky_test_account}, follow=True 

209 ) 

210 self.assertEqual(response.status_code, 200, message) 

211 confirmed.refresh_from_db(fields=["bluesky_handle"]) 

212 self.assertEqual( 

213 confirmed.bluesky_handle, 

214 self.bsky_test_account, 

215 "Setting Bluesky handle doesn't work?", 

216 ) 

217 

218 def test_assign_photo_to_mail_removes_bluesky_handle(self): 

219 """ 

220 Assign a Photo to a mail, removes Bluesky handle 

221 """ 

222 self.login() 

223 confirmed = self.create_confirmed_email() 

224 self._assign_bluesky_handle(confirmed, "assign_photo_email") 

225 

226 def test_assign_photo_to_openid_removes_bluesky_handle(self): 

227 """ 

228 Assign a Photo to a OpenID, removes Bluesky handle 

229 """ 

230 self.login() 

231 confirmed = self.create_confirmed_openid() 

232 self._assign_bluesky_handle(confirmed, "assign_photo_openid") 

233 

234 def _assign_bluesky_handle(self, confirmed, endpoint): 

235 """ 

236 Helper method to assign a Bluesky handle 

237 Since the endpoints are similar, we can reuse the code 

238 """ 

239 confirmed.bluesky_handle = self.bsky_test_account 

240 confirmed.save() 

241 url = reverse(endpoint, args=[confirmed.id]) 

242 response = self.client.post(url, {"photoNone": True}, follow=True) 

243 self.assertEqual(response.status_code, 200, "Unassigning Photo doesn't work?") 

244 confirmed.refresh_from_db(fields=["bluesky_handle"]) 

245 self.assertEqual( 

246 confirmed.bluesky_handle, None, "Removing Bluesky handle doesn't work?" 

247 )