Statistics
| Branch: | Tag: | Revision:

root / aai / tests.py @ 60de282a

History | View | Annotate | Download (5.5 kB)

1
#
2
# Unit Tests for aai
3
#
4
# Provides automated tests for aai module. The tests
5
#
6
# Copyright 2011 Greek Research and Technology Network
7
#
8

    
9
from django.test import TestCase
10
from django.test.client import Client
11
from django.conf import settings
12

    
13
from synnefo.aai.shibboleth import Tokens, NoUniqueToken
14
from synnefo.db.models import SynnefoUser
15

    
16
from datetime import datetime, timedelta
17

    
18
class AuthTestCase(TestCase):
19
    fixtures = ['api_test_data', 'auth_test_data']
20
    apibase = '/api/v1.1'
21

    
22
    def setUp(self):
23
        self.client = Client()
24

    
25
    def test_shibboleth_correct_request(self):
26
        """test request that should succeed and register a user
27
        """
28
        response = self.client.get(self.apibase + '/servers', {},
29
                                   **{Tokens.SIB_GIVEN_NAME: 'Jimmy',
30
                                      Tokens.SIB_EDU_PERSON_PRINCIPAL_NAME: 'jh@gmail.com',
31
                                      Tokens.SIB_DISPLAY_NAME: 'Jimmy Hendrix',
32
                                      'TEST-AAI' : 'true'})
33
        user = None
34
        try:
35
            user = SynnefoUser.objects.get(uniq = "jh@gmail.com")
36
        except SynnefoUser.DoesNotExist:
37
            self.assertNotEqual(user, None)
38
        self.assertNotEqual(user, None)
39
        self.assertEquals(response.status_code, 302)
40
        self.assertEquals(response['Location'], "http://testserver/")
41
        self.assertTrue('X-Auth-Token' in response)
42
        self.assertEquals(response['X-Auth-Token'], user.auth_token)
43

    
44
    def test_shibboleth_no_uniq_request(self):
45
        """test a request with no unique field
46
        """
47
        response = self.client.get(self.apibase + '/servers', {},
48
                                    **{Tokens.SIB_GIVEN_NAME: 'Jimmy',
49
                                    Tokens.SIB_DISPLAY_NAME: 'Jimmy Hendrix',
50
                                    'TEST-AAI' : 'true'})
51
        self._test_redirect(response)
52

    
53
    def test_shibboleth_wrong_from_request(self):
54
        """ test request from wrong host
55
        """
56
        response = self.client.get(self.apibase + '/servers', {},
57
                                   **{Tokens.SIB_GIVEN_NAME: 'Jimmy',
58
                                      Tokens.SIB_EDU_PERSON_PRINCIPAL_NAME: 'jh@gmail.com',
59
                                      Tokens.SIB_DISPLAY_NAME: 'Jimmy Hendrix',
60
                                      'REMOTE_ADDR': '1.2.3.4',
61
                                      'SERVER_NAME': 'nohost.nodomain',
62
                                      'TEST-AAI' : 'true'})
63
        self._test_redirect(response)
64

    
65
    def test_shibboleth_expired_token(self):
66
        """ test request from expired token
67
        """
68
        user = SynnefoUser.objects.get(uniq = "test@synnefo.gr")
69
        self.assertNotEqual(user.auth_token_created, None)
70
        self._update_user_ts(user)
71
        response = self.client.get(self.apibase + '/servers', {},
72
                                   **{'X-Auth-Token': user.auth_token,
73
                                      'TEST-AAI' : 'true'})
74
        self._test_redirect(response)
75

    
76
    def test_shibboleth_redirect(self):
77
        """ test redirect to Sibboleth page
78
        """
79
        response = self.client.get(self.apibase + '/servers', {}, **{'TEST-AAI' : 'true'})
80
        self._test_redirect(response)
81

    
82
    def test_shibboleth_auth(self):
83
        """ test authentication with X-Auth-Token
84
        """
85
        user = SynnefoUser.objects.get(uniq = "test@synnefo.gr")
86
        response = self.client.get(self.apibase + '/servers', {},
87
                                   **{'X-Auth-Token': user.auth_token,
88
                                      'TEST-AAI' : 'true'})
89
        self.assertTrue(response.status_code, 200)
90
        self.assertTrue('Vary' in response)
91
        self.assertTrue('X-Auth-Token' in response['Vary'])
92

    
93

    
94
    def test_shibboleth_redirect_loop(self):
95
        """
96
        """
97
        response = self.client.get(self.apibase + '/servers', {},
98
                                    **{'Referer' : settings.LOGIN_PATH,
99
                                    'TEST-AAI' : 'true'})
100
        self.assertEquals(response.status_code, 200)
101
        
102

    
103
    def test_fail_oapi_auth(self):
104
        """ test authentication from not registered user using OpenAPI
105
        """
106
        response = self.client.get(self.apibase + '/servers', {},
107
                                   **{'X-Auth-User': 'notme',
108
                                      'X-Auth-Key': '0xdeadbabe',
109
                                      'TEST-AAI' : 'true'})
110
        self.assertEquals(response.status_code, 401)
111

    
112
    def test_oapi_auth(self):
113
        """authentication with user registration
114
        """
115
        response = self.client.get(self.apibase + '/', {},
116
                                   **{'X-Auth-User': 'testdbuser',
117
                                      'X-Auth-Key': 'test@synnefo.gr',
118
                                      'TEST-AAI' : 'true'})
119
        self.assertEquals(response.status_code, 204)
120
        self.assertNotEqual(response['X-Auth-Token'], None)
121
        self.assertEquals(response['X-Server-Management-Url'], '')
122
        self.assertEquals(response['X-Storage-Url'], '')
123
        self.assertEquals(response['X-CDN-Management-Url'], '')
124

    
125
    def _test_redirect(self, response):
126
        self.assertEquals(response.status_code, 302)
127
        self.assertTrue('Location' in response)
128
        self.assertTrue(response['Location'].endswith(settings.LOGIN_PATH))
129

    
130
    def _update_user_ts(self, user):
131
        user.auth_token_created = (datetime.now() -
132
                                   timedelta(hours = settings.AUTH_TOKEN_DURATION))
133
        user.save()
134

    
135