1 from io import StringIO
2 from urllib.parse import urlparse, parse_qsl, parse_qs, urlencode
3 from urllib.request import install_opener
5 from xml.etree import ElementTree
7 from cas_provider.attribute_formatters import CAS
8 from cas_provider.models import ServiceTicket
9 from cas_provider.signals import cas_collect_custom_attributes
10 from cas_provider.views import _cas2_sucess_response, INVALID_TICKET, _cas2_error_response, generate_proxy_granting_ticket
11 from django.contrib.auth.models import User, UserManager
12 from django.test import TestCase
13 from django.conf import settings
14 from django.core.exceptions import ImproperlyConfigured
15 from django.urls import reverse
18 class DummyOpener(object):
22 def open(url, *args, **kwargs):
26 class ViewsTest(TestCase):
28 fixtures = ['cas_users', ]
33 self.service = 'http://example.com/'
36 def test_successful_login_with_proxy(self):
37 install_opener(DummyOpener) # Don't really open any URLs
38 proxyTarget = "http://my.sweet.service"
40 response = self._login_user('root', '123')
41 response = self._validate_cas2(response, True, proxyTarget )
43 # Test: I'm acting as the service that will call another service
44 # Step 1: Get the proxy granting ticket
45 responseXml = ElementTree.parse(StringIO(response.content.decode('utf-8')))
46 auth_success = responseXml.find(CAS + 'authenticationSuccess')
47 pgt = auth_success.find(CAS + "proxyGrantingTicket")
48 user = auth_success.find(CAS + "user")
49 self.assertEqual('root', user.text)
50 self.assertIsNotNone(pgt.text)
51 self.assertTrue(pgt.text.startswith('PGTIOU'))
53 pgtId = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
55 #Step 2: Get the actual proxy ticket
56 proxyTicketResponse = self.client.get(reverse('proxy'), {'targetService': proxyTarget, 'pgt': pgtId}, follow=False)
57 proxyTicketResponseXml = ElementTree.parse(StringIO(proxyTicketResponse.content.decode('utf-8')))
58 self.assertIsNotNone(proxyTicketResponseXml.find(CAS + "proxySuccess"))
59 self.assertIsNotNone(proxyTicketResponseXml.find(CAS + "proxySuccess/" + CAS + "proxyTicket"))
60 proxyTicket = proxyTicketResponseXml.find(CAS + "proxySuccess/" + CAS + "proxyTicket");
62 #Step 3: I have the proxy ticket I can talk to some other backend service as the currently logged in user!
63 proxyValidateResponse = self.client.get(reverse('cas_proxy_validate'), {'ticket': proxyTicket.text, 'service': proxyTarget})
64 proxyValidateResponseXml = ElementTree.parse(StringIO(proxyValidateResponse.content.decode('utf-8')))
66 auth_success_2 = proxyValidateResponseXml.find(CAS + 'authenticationSuccess')
67 user_2 = auth_success.find(CAS + "user")
68 proxies_1 = auth_success_2.find(CAS + "proxies")
69 self.assertIsNone(proxies_1) # there are no proxies. I am issued by a Service Ticket
71 self.assertEqual(user.text, user_2.text)
74 def test_successful_proxy_chaining(self):
75 install_opener(DummyOpener) # Don't really open any URLs
76 proxyTarget_1 = "http://my.sweet.service_1"
77 proxyTarget_2 = "http://my.sweet.service_2"
79 response = self._login_user('root', '123')
80 response = self._validate_cas2(response, True, proxyTarget_1 )
82 # Test: I'm acting as the service that will call another service
83 # Step 1: Get the proxy granting ticket
84 responseXml = ElementTree.parse(StringIO(response.content.decode('utf-8')))
85 auth_success_1 = responseXml.find(CAS + 'authenticationSuccess')
86 pgt_1 = auth_success_1.find(CAS + "proxyGrantingTicket")
87 user_1 = auth_success_1.find(CAS + "user")
88 self.assertEqual('root', user_1.text)
89 self.assertIsNotNone(pgt_1.text)
90 self.assertTrue(pgt_1.text.startswith('PGTIOU'))
92 pgtId_1 = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
94 #Step 2: Get the actual proxy ticket
95 proxyTicketResponse_1 = self.client.get(reverse('proxy'), {'targetService': proxyTarget_1, 'pgt': pgtId_1}, follow=False)
96 proxyTicketResponseXml_1 = ElementTree.parse(StringIO(proxyTicketResponse_1.content.decode('utf-8')))
97 self.assertIsNotNone(proxyTicketResponseXml_1.find(CAS + "proxySuccess"))
98 self.assertIsNotNone(proxyTicketResponseXml_1.find(CAS + "proxySuccess/" + CAS + "proxyTicket"))
99 proxyTicket_1 = proxyTicketResponseXml_1.find(CAS + "proxySuccess/" + CAS +"proxyTicket");
101 #Step 3: I'm backend service 1 - I have the proxy ticket - I want to talk to back service 2
103 proxyValidateResponse_1 = self.client.get(reverse('cas_proxy_validate'), {'ticket': proxyTicket_1.text, 'service': proxyTarget_1, 'pgtUrl': proxyTarget_2})
104 proxyValidateResponseXml_1 = ElementTree.parse(StringIO(proxyValidateResponse_1.content.decode('utf-8')))
106 auth_success_2 = proxyValidateResponseXml_1.find(CAS + 'authenticationSuccess')
107 user_2 = auth_success_2.find(CAS + "user")
109 proxies_1 = auth_success_2.find(CAS + "proxies")
110 self.assertIsNone(proxies_1) # there are no proxies. I am issued by a Service Ticket
111 self.assertIsNotNone(auth_success_2)
112 self.assertEqual('root', user_2.text)
114 pgt_2 = auth_success_2.find(CAS + "proxyGrantingTicket")
115 user = auth_success_2.find(CAS + "user")
116 self.assertEqual('root', user.text)
117 self.assertIsNotNone(pgt_2.text)
118 self.assertTrue(pgt_2.text.startswith('PGTIOU'))
120 pgtId_2 = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
122 #Step 4: Get the second proxy ticket
123 proxyTicketResponse_2 = self.client.get(reverse('proxy'), {'targetService': proxyTarget_2, 'pgt': pgtId_2})
124 proxyTicketResponseXml_2 = ElementTree.parse(StringIO(proxyTicketResponse_2.content.decode('utf-8')))
125 self.assertIsNotNone(proxyTicketResponseXml_2.find(CAS + "proxySuccess"))
126 self.assertIsNotNone(proxyTicketResponseXml_2.find(CAS + "proxySuccess/" + CAS + "proxyTicket"))
127 proxyTicket_2 = proxyTicketResponseXml_2.find(CAS + "proxySuccess/" + CAS + "proxyTicket")
129 proxyValidateResponse_3 = self.client.get(reverse('cas_proxy_validate'), {'ticket': proxyTicket_2.text, 'service': proxyTarget_2, 'pgtUrl': ''})
130 proxyValidateResponseXml_3 = ElementTree.parse(StringIO(proxyValidateResponse_3.content.decode('utf-8')))
132 auth_success_3 = proxyValidateResponseXml_3.find(CAS + 'authenticationSuccess')
133 user_3 = auth_success_3.find(CAS + "user")
135 proxies_3 = auth_success_3.find(CAS + "proxies")
136 self.assertIsNotNone(proxies_3) # there should be a proxy. I am issued by a Proxy Ticket
137 proxy_3 = proxies_3.find(CAS + "proxy")
138 self.assertEqual(proxyTarget_1, proxy_3.text )
140 self.assertIsNotNone(auth_success_2)
141 self.assertEqual('root', user_3.text)
144 def test_succeessful_login(self):
145 response = self._login_user('root', '123')
146 self._validate_cas1(response, True)
148 response = self.client.get(reverse('cas_login'), {'service': self.service}, follow=False)
149 self.assertEqual(response.status_code, 302)
150 self.assertTrue(response['location'].startswith('%s?ticket=' % self.service))
152 response = self.client.get(reverse('cas_login'), follow=False)
153 self.assertEqual(response.status_code, 302)
154 self.assertTrue(response['location'].startswith('/'))
156 response = self.client.get(response['location'], follow=False)
157 self.assertIn(response.status_code, [302, 200])
159 response = self.client.get(reverse('cas_login'), {'service': self.service, 'warn': True}, follow=False)
160 self.assertEqual(response.status_code, 200)
161 self.assertTemplateUsed(response, 'cas/warn.html')
164 def test_login_redirects_to_login_url(self):
165 response = self.client.get(reverse('cas_login'), {'service': self.service, 'warn': 'true'})
166 self.assertEqual(response.status_code, 302)
167 login_url = response['location']
168 self.assertTrue(login_url.startswith(settings.LOGIN_URL + '?next='), login_url)
170 response = self.client.get(login_url)
171 self.assertEqual(response.status_code, 200)
172 self.assertTemplateUsed(response, 'registration/login.html')
174 response = self.client.post(login_url, {'username': 'root', 'password': '123'})
175 self.assertEqual(response.status_code, 302)
177 response['location'],
178 reverse('cas_login') + '?' + urlencode({'service': self.service, 'warn': 'true'}))
180 response = self.client.get(response['location'])
181 self.assertEqual(response.status_code, 200)
182 self.assertTemplateUsed(response, 'cas/warn.html')
184 def test_login_empty_service(self):
185 self.client.login(username='root', password='123')
186 response = self.client.get(reverse('cas_login'), {'service': ''}, follow=False)
187 self.assertEqual(response.status_code, 302)
188 self.assertEqual(response['location'], settings.LOGIN_REDIRECT_URL)
189 self.assertFalse(ServiceTicket.objects.exists())
191 def test_login_url_loop(self):
192 with self.settings(LOGIN_URL=reverse('cas_login')):
193 with self.assertRaises(ImproperlyConfigured):
194 self.client.get(reverse('cas_login'), {'service': self.service})
196 def _cas_logout(self):
197 response = self.client.get(reverse('cas_logout'), follow=False)
198 self.assertEqual(response.status_code, 200)
201 def test_logout(self):
202 response = self._login_user('root', '123')
203 self._validate_cas1(response, True)
207 response = self.client.get(reverse('cas_login'), follow=False)
208 self.assertEqual(response.status_code, 302)
209 self.assertTrue(response['location'].startswith(settings.LOGIN_URL))
210 self.assertNotIn('_auth_user_id', self.client.session)
213 def test_broken_pwd(self):
214 self._fail_login('root', '321')
216 def test_broken_username(self):
217 self._fail_login('notroot', '123')
219 def test_nonactive_user_login(self):
220 self._fail_login('nonactive', '123')
222 def test_cas2_success_validate(self):
223 response = self._login_user('root', '123')
224 response = self._validate_cas2(response, True)
225 user = User.objects.get(username=self.username)
226 self.assertEqual(response.content, _cas2_sucess_response(user).content)
228 def test_cas2_validate_twice(self):
229 response = self._login_user('root', '123')
230 response2 = self._validate_cas2(response, True)
231 user = User.objects.get(username=self.username)
232 self.assertEqual(response2.content, _cas2_sucess_response(user).content)
234 response2 = self._validate_cas2(response, True)
235 self.assertEqual(response2.content, _cas2_error_response(INVALID_TICKET).content)
237 def test_cas2_validate_twice_with_pgt(self):
238 proxyTarget = "http://my.sweet.service_1"
239 response = self._login_user('root', '123')
240 response2 = self._validate_cas2(response, True, proxyTarget)
241 user = User.objects.get(username=self.username)
242 self.assertEqual(response2.content, _cas2_sucess_response(user).content)
244 response2 = self._validate_cas2(response, True, proxyTarget)
245 self.assertEqual(response2.content, _cas2_error_response(INVALID_TICKET).content)
247 def test_cas2_custom_attrs(self):
248 cas_collect_custom_attributes.connect(cas_mapping)
249 response = self._login_user('editor', '123')
252 response = self._validate_cas2(response, True)
253 self.assertEqual(response.content.decode('utf-8'),
254 '''<cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">'''
255 '''<cas:authenticationSuccess>'''
256 '''<cas:user>editor</cas:user>'''
257 '''<cas:attributes>'''
258 '''<cas:attraStyle>Jasig</cas:attraStyle>'''
259 '''<cas:email>editor@exapmle.com</cas:email>'''
260 '''<cas:group>editor</cas:group>'''
261 '''<cas:is_active>True</cas:is_active>'''
262 '''<cas:is_staff>True</cas:is_staff>'''
263 '''</cas:attributes>'''
264 '''</cas:authenticationSuccess>'''
265 '''</cas:serviceResponse>''')
268 response = self._login_user('editor', '123')
269 settings.CAS_CUSTOM_ATTRIBUTES_FORMATER = 'cas_provider.attribute_formatters.ruby_cas'
270 response = self._validate_cas2(response, True)
271 self.assertEqual(response.content.decode('utf-8'),
272 '''<cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">'''
273 '''<cas:authenticationSuccess>'''
274 '''<cas:user>editor</cas:user>'''
275 '''<cas:attraStyle>RubyCAS</cas:attraStyle>'''
276 '''<cas:email>editor@exapmle.com</cas:email>'''
277 '''<cas:group>editor</cas:group>'''
278 '''<cas:is_active>True</cas:is_active>'''
279 '''<cas:is_staff>True</cas:is_staff>'''
280 '''</cas:authenticationSuccess>'''
281 '''</cas:serviceResponse>''')
284 response = self._login_user('editor', '123')
285 settings.CAS_CUSTOM_ATTRIBUTES_FORMATER = 'cas_provider.attribute_formatters.name_value'
286 response = self._validate_cas2(response, True)
287 self.assertEqual(response.content.decode('utf-8'),
288 '''<cas:serviceResponse xmlns:cas="http://www.yale.edu/tp/cas">'''
289 '''<cas:authenticationSuccess>'''
290 '''<cas:user>editor</cas:user>'''
291 '''<cas:attribute name="attraStyle" value="Name-Value"/>'''
292 '''<cas:attribute name="email" value="editor@exapmle.com"/>'''
293 '''<cas:attribute name="group" value="editor"/>'''
294 '''<cas:attribute name="is_active" value="True"/>'''
295 '''<cas:attribute name="is_staff" value="True"/>'''
296 '''</cas:authenticationSuccess>'''
297 '''</cas:serviceResponse>''')
300 def test_cas2_fail_validate(self):
301 for user, pwd in (('root', '321'), ('notroot', '123'), ('nonactive', '123')):
302 response = self._login_user(user, pwd)
303 self._validate_cas2(response, False)
306 def test_generate_proxy_granting_ticket(self):
307 install_opener(DummyOpener) # Don't really open any URLs
308 url = 'http://my.call.back/callhere'
310 user = User.objects.get(username = 'root')
311 st = ServiceTicket.objects.create(user = user )
312 pgt = generate_proxy_granting_ticket(url, st)
313 self.assertIsNotNone(pgt)
315 calledUrl = DummyOpener.url
316 parsedUrl = urlparse(calledUrl)
317 params = parse_qs(parsedUrl.query)
318 self.assertIsNotNone(params['pgtId'])
319 self.assertIsNotNone(params['pgtIou'])
323 def _fail_login(self, username, password):
324 response = self._login_user(username, password)
325 self._validate_cas1(response, False)
327 response = self.client.get(reverse('cas_login'), {'service': self.service}, follow=False)
328 self.assertEqual(response.status_code, 302)
329 self.assertTrue(response['location'].startswith(settings.LOGIN_URL))
330 response = self.client.get(reverse('cas_login'), follow=False)
331 self.assertEqual(response.status_code, 302)
332 self.assertTrue(response['location'].startswith(settings.LOGIN_URL))
336 def _login_user(self, username, password):
337 """Go through the CAS login endpoint and the regular login view.
339 Returns the response of the CAS login endpoint after logging in,
340 or the login form response if the login failed.
342 self.username = username
343 response = self.client.get(reverse('cas_login'), {'service': self.service})
344 self.assertEqual(response.status_code, 302)
345 login_url = response['location']
346 response = self.client.post(login_url, {
347 'username': username,
348 'password': password,
350 if response.status_code != 302:
352 return self.client.get(response['location'], follow=False)
355 def _validate_cas1(self, response, is_correct=True):
357 self.assertEqual(response.status_code, 302)
358 self.assertTrue(response.has_header('location'))
359 location = urlparse(response['location'])
360 ticket = location.query.split('=')[1]
362 response = self.client.get(reverse('cas_validate'), {'ticket': ticket, 'service': self.service}, follow=False)
363 self.assertEqual(response.status_code, 200)
364 self.assertEqual(response.content.decode('utf-8'), 'yes\n%s\n' % self.username)
366 self.assertEqual(response.status_code, 200)
367 self.assertEqual(len(response.context['form'].non_field_errors()), 1)
369 response = self.client.get(reverse('cas_validate'), {'ticket': 'ST-12312312312312312312312', 'service': self.service}, follow=False)
370 self.assertEqual(response.status_code, 200)
371 self.assertEqual(response.content.decode('utf-8'), 'no\n\n')
374 def _validate_cas2(self, response, is_correct=True, pgtUrl = None):
376 self.assertEqual(response.status_code, 302)
377 self.assertTrue(response.has_header('location'))
378 location = urlparse(response['location'])
379 ticket = location.query.split('=')[1]
381 response = self.client.get(reverse('cas_service_validate'), {'ticket': ticket, 'service': self.service, 'pgtUrl': pgtUrl}, follow=False)
383 response = self.client.get(reverse('cas_service_validate'), {'ticket': ticket, 'service': self.service}, follow=False)
384 self.assertEqual(response.status_code, 200)
386 self.assertEqual(response.status_code, 200)
387 self.assertEqual(len(response.context['form'].non_field_errors()), 1)
389 response = self.client.get(reverse('cas_service_validate'), {'ticket': 'ST-12312312312312312312312', 'service': self.service}, follow=False)
390 self.assertEqual(response.status_code, 200)
391 self.assertEqual(response.content, _cas2_error_response(INVALID_TICKET).content)
394 class ModelsTestCase(TestCase):
396 fixtures = ['cas_users.json', ]
399 self.user = User.objects.get(username='root')
401 def test_redirects(self):
402 ticket = ServiceTicket.objects.create(service='http://example.com', user=self.user)
403 self.assertEqual(ticket.get_redirect_url(), '%(service)s?ticket=%(ticket)s' % ticket.__dict__)
406 def cas_mapping(sender, user, **kwargs):
408 'is_staff': str(user.is_staff),
409 'is_active': str(user.is_active),
411 'group': [g.name for g in user.groups.all()]