← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python-keystoneclient/trusty-proposed

« back to all changes in this revision

Viewing changes to tests/v2_0/test_auth.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-01-18 07:44:54 UTC
  • mfrom: (1.1.17)
  • Revision ID: package-import@ubuntu.com-20130118074454-g7w5blpynohn1s48
Tags: 1:0.2.2-0ubuntu1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/v2_0/test_auth.py
1
 
import httplib2
 
1
import copy
2
2
import json
3
3
 
 
4
import requests
 
5
 
4
6
from keystoneclient.v2_0 import client
5
7
from keystoneclient import exceptions
6
8
from tests import utils
7
9
 
8
10
 
9
 
def to_http_response(resp_dict):
10
 
    """
11
 
    Utility function to convert a python dictionary
12
 
    (e.g. {'status':status, 'body': body, 'headers':headers}
13
 
    to an httplib2 response.
14
 
    """
15
 
    resp = httplib2.Response(resp_dict)
16
 
    for k, v in resp_dict['headers'].items():
17
 
        resp[k] = v
18
 
    return resp
19
 
 
20
 
 
21
11
class AuthenticateAgainstKeystoneTests(utils.TestCase):
22
12
    def setUp(self):
23
13
        super(AuthenticateAgainstKeystoneTests, self).setUp()
55
45
        _cred = 'passwordCredentials'
56
46
        _pass = 'password'
57
47
        self.TEST_REQUEST_BODY[_auth][_cred][_pass] = 'bad_key'
58
 
        resp = httplib2.Response({
59
 
            "status": 401,
60
 
            "body": json.dumps({
 
48
        resp = utils.TestResponse({
 
49
            "status_code": 401,
 
50
            "text": json.dumps({
61
51
                "unauthorized": {
62
52
                    "message": "Unauthorized",
63
53
                    "code": "401",
65
55
            }),
66
56
        })
67
57
 
68
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
69
 
                              'POST',
70
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
71
 
                              headers=self.TEST_REQUEST_HEADERS) \
72
 
            .AndReturn((resp, resp['body']))
 
58
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
59
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
60
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
61
        requests.request('POST',
 
62
                         self.TEST_URL + "/tokens",
 
63
                         **kwargs).AndReturn((resp))
73
64
        self.mox.ReplayAll()
74
65
 
75
66
        # Workaround for issue with assertRaises on python2.6
90
81
                "headers": {
91
82
                    'location': self.TEST_ADMIN_URL + "/tokens",
92
83
                },
93
 
                "status": 305,
94
 
                "body": "Use proxy",
 
84
                "status_code": 305,
 
85
                "text": "Use proxy",
95
86
            },
96
87
            {
97
88
                "headers": {},
98
 
                "status": 200,
99
 
                "body": correct_response,
 
89
                "status_code": 200,
 
90
                "text": correct_response,
100
91
            },
101
92
        ]
102
 
        responses = [(to_http_response(resp), resp['body'])
 
93
        responses = [(utils.TestResponse(resp))
103
94
                     for resp in dict_responses]
104
95
 
105
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
106
 
                              'POST',
107
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
108
 
                              headers=self.TEST_REQUEST_HEADERS) \
109
 
            .AndReturn(responses[0])
110
 
        httplib2.Http.request(self.TEST_ADMIN_URL + "/tokens",
111
 
                              'POST',
112
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
113
 
                              headers=self.TEST_REQUEST_HEADERS) \
114
 
            .AndReturn(responses[1])
 
96
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
97
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
98
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
99
        requests.request('POST',
 
100
                         self.TEST_URL + "/tokens",
 
101
                         **kwargs).AndReturn(responses[0])
 
102
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
103
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
104
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
105
        requests.request('POST',
 
106
                         self.TEST_ADMIN_URL + "/tokens",
 
107
                         **kwargs).AndReturn(responses[1])
115
108
        self.mox.ReplayAll()
116
109
 
117
110
        cs = client.Client(username=self.TEST_USER,
126
119
                         self.TEST_RESPONSE_DICT["access"]["token"]["id"])
127
120
 
128
121
    def test_authenticate_success_password_scoped(self):
129
 
        resp = httplib2.Response({
130
 
            "status": 200,
131
 
            "body": json.dumps(self.TEST_RESPONSE_DICT),
 
122
        resp = utils.TestResponse({
 
123
            "status_code": 200,
 
124
            "text": json.dumps(self.TEST_RESPONSE_DICT),
132
125
        })
133
126
 
134
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
135
 
                              'POST',
136
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
137
 
                              headers=self.TEST_REQUEST_HEADERS) \
138
 
            .AndReturn((resp, resp['body']))
 
127
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
128
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
129
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
130
        requests.request('POST',
 
131
                         self.TEST_URL + "/tokens",
 
132
                         **kwargs).AndReturn((resp))
139
133
        self.mox.ReplayAll()
140
134
 
141
135
        cs = client.Client(username=self.TEST_USER,
151
145
    def test_authenticate_success_password_unscoped(self):
152
146
        del self.TEST_RESPONSE_DICT['access']['serviceCatalog']
153
147
        del self.TEST_REQUEST_BODY['auth']['tenantId']
154
 
        resp = httplib2.Response({
155
 
            "status": 200,
156
 
            "body": json.dumps(self.TEST_RESPONSE_DICT),
 
148
        resp = utils.TestResponse({
 
149
            "status_code": 200,
 
150
            "text": json.dumps(self.TEST_RESPONSE_DICT),
157
151
        })
158
152
 
159
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
160
 
                              'POST',
161
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
162
 
                              headers=self.TEST_REQUEST_HEADERS) \
163
 
            .AndReturn((resp, resp['body']))
 
153
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
154
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
155
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
156
        requests.request('POST',
 
157
                         self.TEST_URL + "/tokens",
 
158
                         **kwargs).AndReturn((resp))
164
159
        self.mox.ReplayAll()
165
160
 
166
161
        cs = client.Client(username=self.TEST_USER,
174
169
        del self.TEST_REQUEST_BODY['auth']['passwordCredentials']
175
170
        self.TEST_REQUEST_BODY['auth']['token'] = {'id': self.TEST_TOKEN}
176
171
        self.TEST_REQUEST_HEADERS['X-Auth-Token'] = self.TEST_TOKEN
177
 
        resp = httplib2.Response({
178
 
            "status": 200,
179
 
            "body": json.dumps(self.TEST_RESPONSE_DICT),
 
172
        resp = utils.TestResponse({
 
173
            "status_code": 200,
 
174
            "text": json.dumps(self.TEST_RESPONSE_DICT),
180
175
        })
181
176
 
182
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
183
 
                              'POST',
184
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
185
 
                              headers=self.TEST_REQUEST_HEADERS) \
186
 
            .AndReturn((resp, resp['body']))
 
177
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
178
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
179
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
180
        requests.request('POST',
 
181
                         self.TEST_URL + "/tokens",
 
182
                         **kwargs).AndReturn((resp))
187
183
        self.mox.ReplayAll()
188
184
 
189
185
        cs = client.Client(token=self.TEST_TOKEN,
201
197
        del self.TEST_RESPONSE_DICT['access']['serviceCatalog']
202
198
        self.TEST_REQUEST_BODY['auth']['token'] = {'id': self.TEST_TOKEN}
203
199
        self.TEST_REQUEST_HEADERS['X-Auth-Token'] = self.TEST_TOKEN
204
 
        resp = httplib2.Response({
205
 
            "status": 200,
206
 
            "body": json.dumps(self.TEST_RESPONSE_DICT),
 
200
        resp = utils.TestResponse({
 
201
            "status_code": 200,
 
202
            "text": json.dumps(self.TEST_RESPONSE_DICT),
207
203
        })
208
204
 
209
 
        httplib2.Http.request(self.TEST_URL + "/tokens",
210
 
                              'POST',
211
 
                              body=json.dumps(self.TEST_REQUEST_BODY),
212
 
                              headers=self.TEST_REQUEST_HEADERS) \
213
 
            .AndReturn((resp, resp['body']))
 
205
        kwargs = copy.copy(self.TEST_REQUEST_BASE)
 
206
        kwargs['headers'] = self.TEST_REQUEST_HEADERS
 
207
        kwargs['data'] = json.dumps(self.TEST_REQUEST_BODY)
 
208
        requests.request('POST',
 
209
                         self.TEST_URL + "/tokens",
 
210
                         **kwargs).AndReturn((resp))
214
211
        self.mox.ReplayAll()
215
212
 
216
213
        cs = client.Client(token=self.TEST_TOKEN,