Redirect to login view instead of partially reimplementing it. Remove unusable flows...
[django-cas-provider.git] / cas_provider_examples / simple / tests.py
1 from io import StringIO
2 from urllib.parse import urlparse, parse_qsl, parse_qs, urlencode
3 from urllib.request import install_opener
4 from xml import etree
5 from xml.etree import ElementTree
6 import cas_provider
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
16
17
18 class DummyOpener(object):
19     url = None
20
21     @staticmethod
22     def open(url, *args, **kwargs):
23         DummyOpener.url = url
24
25
26 class ViewsTest(TestCase):
27
28     fixtures = ['cas_users', ]
29
30
31
32     def setUp(self):
33         self.service = 'http://example.com/'
34
35
36     def test_successful_login_with_proxy(self):
37         install_opener(DummyOpener) # Don't really open any URLs
38         proxyTarget = "http://my.sweet.service"
39
40         response = self._login_user('root', '123')
41         response = self._validate_cas2(response, True, proxyTarget )
42
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'))
52
53         pgtId = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
54
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");
61
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')))
65
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
70         
71         self.assertEqual(user.text, user_2.text)
72
73
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"
78
79         response = self._login_user('root', '123')
80         response = self._validate_cas2(response, True, proxyTarget_1 )
81
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'))
91
92         pgtId_1 = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
93
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");
100
101         #Step 3: I'm backend service 1 - I have the proxy ticket - I want to talk to back service 2
102         #
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')))
105
106         auth_success_2 = proxyValidateResponseXml_1.find(CAS + 'authenticationSuccess')
107         user_2 = auth_success_2.find(CAS + "user")
108
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)
113
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'))
119
120         pgtId_2 = parse_qs(urlparse(DummyOpener.url).query)['pgtId']
121
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")
128
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')))
131
132         auth_success_3 = proxyValidateResponseXml_3.find(CAS + 'authenticationSuccess')
133         user_3 = auth_success_3.find(CAS + "user")
134
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 )
139
140         self.assertIsNotNone(auth_success_2)
141         self.assertEqual('root', user_3.text)
142
143
144     def test_succeessful_login(self):
145         response = self._login_user('root', '123')
146         self._validate_cas1(response, True)
147
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))
151
152         response = self.client.get(reverse('cas_login'), follow=False)
153         self.assertEqual(response.status_code, 302)
154         self.assertTrue(response['location'].startswith('/'))
155
156         response = self.client.get(response['location'], follow=False)
157         self.assertIn(response.status_code, [302, 200])
158
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')
162
163
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)
169
170         response = self.client.get(login_url)
171         self.assertEqual(response.status_code, 200)
172         self.assertTemplateUsed(response, 'registration/login.html')
173
174         response = self.client.post(login_url, {'username': 'root', 'password': '123'})
175         self.assertEqual(response.status_code, 302)
176         self.assertEqual(
177             response['location'],
178             reverse('cas_login') + '?' + urlencode({'service': self.service, 'warn': 'true'}))
179
180         response = self.client.get(response['location'])
181         self.assertEqual(response.status_code, 200)
182         self.assertTemplateUsed(response, 'cas/warn.html')
183
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())
190
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})
195
196     def _cas_logout(self):
197         response = self.client.get(reverse('cas_logout'), follow=False)
198         self.assertEqual(response.status_code, 200)
199
200
201     def test_logout(self):
202         response = self._login_user('root', '123')
203         self._validate_cas1(response, True)
204
205         self._cas_logout()
206
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)
211
212
213     def test_broken_pwd(self):
214         self._fail_login('root', '321')
215
216     def test_broken_username(self):
217         self._fail_login('notroot', '123')
218
219     def test_nonactive_user_login(self):
220         self._fail_login('nonactive', '123')
221
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)
227
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)
233
234         response2 = self._validate_cas2(response, True)
235         self.assertEqual(response2.content, _cas2_error_response(INVALID_TICKET).content)
236
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)
243
244         response2 = self._validate_cas2(response, True, proxyTarget)
245         self.assertEqual(response2.content, _cas2_error_response(INVALID_TICKET).content)
246
247     def test_cas2_custom_attrs(self):
248         cas_collect_custom_attributes.connect(cas_mapping)
249         response = self._login_user('editor', '123')
250         self.maxDiff=None
251
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>''')
266
267         self._cas_logout()
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>''')
282
283         self._cas_logout()
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>''')
298
299
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)
304
305
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'
309
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)
314
315         calledUrl = DummyOpener.url
316         parsedUrl = urlparse(calledUrl)
317         params = parse_qs(parsedUrl.query)
318         self.assertIsNotNone(params['pgtId'])
319         self.assertIsNotNone(params['pgtIou'])
320
321
322
323     def _fail_login(self, username, password):
324         response = self._login_user(username, password)
325         self._validate_cas1(response, False)
326
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))
333
334
335
336     def _login_user(self, username, password):
337         """Go through the CAS login endpoint and the regular login view.
338
339         Returns the response of the CAS login endpoint after logging in,
340         or the login form response if the login failed.
341         """
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,
349         }, follow=False)
350         if response.status_code != 302:
351             return response
352         return self.client.get(response['location'], follow=False)
353
354
355     def _validate_cas1(self, response, is_correct=True):
356         if is_correct:
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]
361
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)
365         else:
366             self.assertEqual(response.status_code, 200)
367             self.assertEqual(len(response.context['form'].non_field_errors()), 1)
368
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')
372
373
374     def _validate_cas2(self, response, is_correct=True, pgtUrl = None):
375         if is_correct:
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]
380             if pgtUrl:
381                 response = self.client.get(reverse('cas_service_validate'), {'ticket': ticket, 'service': self.service, 'pgtUrl': pgtUrl}, follow=False)
382             else:
383                 response = self.client.get(reverse('cas_service_validate'), {'ticket': ticket, 'service': self.service}, follow=False)
384             self.assertEqual(response.status_code, 200)
385         else:
386             self.assertEqual(response.status_code, 200)
387             self.assertEqual(len(response.context['form'].non_field_errors()), 1)
388
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)
392         return response
393
394 class ModelsTestCase(TestCase):
395
396     fixtures = ['cas_users.json', ]
397
398     def setUp(self):
399         self.user = User.objects.get(username='root')
400
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__)
404
405
406 def cas_mapping(sender, user, **kwargs):
407     return {
408         'is_staff': str(user.is_staff),
409         'is_active': str(user.is_active),
410         'email': user.email,
411         'group': [g.name for g in user.groups.all()]
412     }