← Back to branch summary

~ubuntu-branches/ubuntu/utopic/python-quantumclient/utopic

« back to all changes in this revision

Viewing changes to quantumclient/tests/unit/test_clientlib.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-16 12:45:43 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120816124543-5m96n37eik89sr2j
Tags: 1:2.0-0ubuntu1
* New upstream version.
* debian/control: Update build dependencies.
* debian/rules: Enable testsuite.

Show diffs side-by-side

added added

removed removed

Lines of Context:
quantumclient/tests/unit/test_clientlib.py
1
 
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
 
 
3
 
# Copyright 2011 Cisco Systems
4
 
# All Rights Reserved.
5
 
#
6
 
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
7
 
#    not use this file except in compliance with the License. You may obtain
8
 
#    a copy of the License at
9
 
#
10
 
#         http://www.apache.org/licenses/LICENSE-2.0
11
 
#
12
 
#    Unless required by applicable law or agreed to in writing, software
13
 
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14
 
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15
 
#    License for the specific language governing permissions and limitations
16
 
#    under the License.
17
 
#    @author: Tyler Smith, Cisco Systems
18
 
 
19
 
import logging
20
 
import re
21
 
import unittest
22
 
 
23
 
from quantumclient.common import exceptions
24
 
from quantumclient.common.serializer import Serializer
25
 
from quantumclient import Client
26
 
 
27
 
 
28
 
LOG = logging.getLogger('quantumclient.tests.test_api')
29
 
 
30
 
 
31
 
# Set a couple tenants to use for testing
32
 
TENANT_1 = 'totore'
33
 
TENANT_2 = 'totore2'
34
 
 
35
 
 
36
 
class ServerStub():
37
 
    """This class stubs a basic server for the API client to talk to"""
38
 
 
39
 
    class Response(object):
40
 
        """This class stubs a basic response to send the API client"""
41
 
        def __init__(self, content=None, status=None):
42
 
            self.content = content
43
 
            self.status = status
44
 
 
45
 
        def read(self):
46
 
            return self.content
47
 
 
48
 
        def status(self):
49
 
            return self.status
50
 
 
51
 
    # To test error codes, set the host to 10.0.0.1, and the port to the code
52
 
    def __init__(self, host, port=9696, key_file="", cert_file=""):
53
 
        self.host = host
54
 
        self.port = port
55
 
        self.key_file = key_file
56
 
        self.cert_file = cert_file
57
 
 
58
 
    def request(self, method, action, body, headers):
59
 
        self.method = method
60
 
        self.action = action
61
 
        self.body = body
62
 
 
63
 
    def status(self, status=None):
64
 
        return status or 200
65
 
 
66
 
    def getresponse(self):
67
 
        res = self.Response(status=self.status())
68
 
 
69
 
        # If the host is 10.0.0.1, return the port as an error code
70
 
        if self.host == "10.0.0.1":
71
 
            res.status = self.port
72
 
            return res
73
 
 
74
 
        # Extract important information from the action string to assure sanity
75
 
        match = re.search('tenants/(.+?)/(.+)\.(json|xml)$', self.action)
76
 
 
77
 
        tenant = match.group(1)
78
 
        path = match.group(2)
79
 
        format = match.group(3)
80
 
 
81
 
        data = {'data': {'method': self.method, 'action': self.action,
82
 
                         'body': self.body, 'tenant': tenant, 'path': path,
83
 
                         'format': format, 'key_file': self.key_file,
84
 
                         'cert_file': self.cert_file}}
85
 
 
86
 
        # Serialize it to the proper format so the API client can handle it
87
 
        if data['data']['format'] == 'json':
88
 
            res.content = Serializer().serialize(data, "application/json")
89
 
        else:
90
 
            res.content = Serializer().serialize(data, "application/xml")
91
 
        return res
92
 
 
93
 
 
94
 
class APITest(unittest.TestCase):
95
 
 
96
 
    def setUp(self):
97
 
        """ Setups a test environment for the API client """
98
 
        HOST = '127.0.0.1'
99
 
        PORT = 9696
100
 
        USE_SSL = False
101
 
 
102
 
        self.client = Client(HOST, PORT, USE_SSL, TENANT_1, 'json', ServerStub)
103
 
 
104
 
    def _assert_sanity(self, call, status, method, path, data=[], params={}):
105
 
        """ Perform common assertions to test the sanity of client requests """
106
 
 
107
 
        # Handle an error case first
108
 
        if status != 200:
109
 
            (self.client.host, self.client.port) = ("10.0.0.1", status)
110
 
            self.assertRaises(Exception, call, *data, **params)
111
 
            return
112
 
 
113
 
        # Make the call, then get the data from the root node and assert it
114
 
        data = call(*data, **params)['data']
115
 
 
116
 
        self.assertEqual(data['method'], method)
117
 
        self.assertEqual(data['format'], params['format'])
118
 
        self.assertEqual(data['tenant'], params['tenant'])
119
 
        self.assertEqual(data['path'], path)
120
 
 
121
 
        return data
122
 
 
123
 
    def _test_list_networks(self, tenant=TENANT_1, format='json', status=200):
124
 
        LOG.debug("_test_list_networks - tenant:%s "
125
 
                  "- format:%s - START", format, tenant)
126
 
 
127
 
        self._assert_sanity(self.client.list_networks,
128
 
                            status,
129
 
                            "GET",
130
 
                            "networks",
131
 
                            data=[],
132
 
                            params={'tenant': tenant, 'format': format})
133
 
 
134
 
        LOG.debug("_test_list_networks - tenant:%s - format:%s - END",
135
 
                  format, tenant)
136
 
 
137
 
    def _test_list_networks_details(self,
138
 
                                    tenant=TENANT_1, format='json',
139
 
                                    status=200):
140
 
        LOG.debug("_test_list_networks_details - tenant:%s "
141
 
                  "- format:%s - START", format, tenant)
142
 
 
143
 
        self._assert_sanity(self.client.list_networks_details,
144
 
                            status,
145
 
                            "GET",
146
 
                            "networks/detail",
147
 
                            data=[],
148
 
                            params={'tenant': tenant, 'format': format})
149
 
 
150
 
        LOG.debug("_test_list_networks_details - tenant:%s "
151
 
                  "- format:%s - END", format, tenant)
152
 
 
153
 
    def _test_show_network(self,
154
 
                           tenant=TENANT_1, format='json', status=200):
155
 
        LOG.debug("_test_show_network - tenant:%s "
156
 
                  "- format:%s - START", format, tenant)
157
 
 
158
 
        self._assert_sanity(self.client.show_network,
159
 
                            status,
160
 
                            "GET",
161
 
                            "networks/001",
162
 
                            data=["001"],
163
 
                            params={'tenant': tenant, 'format': format})
164
 
 
165
 
        LOG.debug("_test_show_network - tenant:%s "
166
 
                  "- format:%s - END", format, tenant)
167
 
 
168
 
    def _test_show_network_details(self,
169
 
                                   tenant=TENANT_1, format='json', status=200):
170
 
        LOG.debug("_test_show_network_details - tenant:%s "
171
 
                  "- format:%s - START", format, tenant)
172
 
 
173
 
        self._assert_sanity(self.client.show_network_details,
174
 
                            status,
175
 
                            "GET",
176
 
                            "networks/001/detail",
177
 
                            data=["001"],
178
 
                            params={'tenant': tenant, 'format': format})
179
 
 
180
 
        LOG.debug("_test_show_network_details - tenant:%s "
181
 
                  "- format:%s - END", format, tenant)
182
 
 
183
 
    def _test_create_network(self, tenant=TENANT_1, format='json', status=200):
184
 
        LOG.debug("_test_create_network - tenant:%s "
185
 
                  "- format:%s - START", format, tenant)
186
 
 
187
 
        self._assert_sanity(self.client.create_network,
188
 
                            status,
189
 
                            "POST",
190
 
                            "networks",
191
 
                            data=[{'network': {'net-name': 'testNetwork'}}],
192
 
                            params={'tenant': tenant, 'format': format})
193
 
 
194
 
        LOG.debug("_test_create_network - tenant:%s "
195
 
                  "- format:%s - END", format, tenant)
196
 
 
197
 
    def _test_update_network(self, tenant=TENANT_1, format='json', status=200):
198
 
        LOG.debug("_test_update_network - tenant:%s "
199
 
                  "- format:%s - START", format, tenant)
200
 
 
201
 
        self._assert_sanity(self.client.update_network,
202
 
                            status,
203
 
                            "PUT",
204
 
                            "networks/001",
205
 
                            data=["001",
206
 
                                  {'network': {'net-name': 'newName'}}],
207
 
                            params={'tenant': tenant, 'format': format})
208
 
 
209
 
        LOG.debug("_test_update_network - tenant:%s "
210
 
                  "- format:%s - END", format, tenant)
211
 
 
212
 
    def _test_delete_network(self, tenant=TENANT_1, format='json', status=200):
213
 
        LOG.debug("_test_delete_network - tenant:%s "
214
 
                  "- format:%s - START", format, tenant)
215
 
 
216
 
        self._assert_sanity(self.client.delete_network,
217
 
                            status,
218
 
                            "DELETE",
219
 
                            "networks/001",
220
 
                            data=["001"],
221
 
                            params={'tenant': tenant, 'format': format})
222
 
 
223
 
        LOG.debug("_test_delete_network - tenant:%s "
224
 
                  "- format:%s - END", format, tenant)
225
 
 
226
 
    def _test_list_ports(self, tenant=TENANT_1, format='json', status=200):
227
 
        LOG.debug("_test_list_ports - tenant:%s "
228
 
                  "- format:%s - START", format, tenant)
229
 
 
230
 
        self._assert_sanity(self.client.list_ports,
231
 
                            status,
232
 
                            "GET",
233
 
                            "networks/001/ports",
234
 
                            data=["001"],
235
 
                            params={'tenant': tenant, 'format': format})
236
 
 
237
 
        LOG.debug("_test_list_ports - tenant:%s "
238
 
                  "- format:%s - END", format, tenant)
239
 
 
240
 
    def _test_list_ports_details(self,
241
 
                                 tenant=TENANT_1, format='json', status=200):
242
 
        LOG.debug("_test_list_ports_details - tenant:%s "
243
 
                  "- format:%s - START", format, tenant)
244
 
 
245
 
        self._assert_sanity(self.client.list_ports_details,
246
 
                            status,
247
 
                            "GET",
248
 
                            "networks/001/ports/detail",
249
 
                            data=["001"],
250
 
                            params={'tenant': tenant, 'format': format})
251
 
 
252
 
        LOG.debug("_test_list_ports_details - tenant:%s "
253
 
                  "- format:%s - END", format, tenant)
254
 
 
255
 
    def _test_show_port(self, tenant=TENANT_1, format='json', status=200):
256
 
        LOG.debug("_test_show_port - tenant:%s "
257
 
                  "- format:%s - START", format, tenant)
258
 
 
259
 
        self._assert_sanity(self.client.show_port,
260
 
                            status,
261
 
                            "GET",
262
 
                            "networks/001/ports/001",
263
 
                            data=["001", "001"],
264
 
                            params={'tenant': tenant, 'format': format})
265
 
 
266
 
        LOG.debug("_test_show_port - tenant:%s "
267
 
                  "- format:%s - END", format, tenant)
268
 
 
269
 
    def _test_show_port_details(self,
270
 
                                tenant=TENANT_1, format='json', status=200):
271
 
        LOG.debug("_test_show_port_details - tenant:%s "
272
 
                  "- format:%s - START", format, tenant)
273
 
 
274
 
        self._assert_sanity(self.client.show_port_details,
275
 
                            status,
276
 
                            "GET",
277
 
                            "networks/001/ports/001/detail",
278
 
                            data=["001", "001"],
279
 
                            params={'tenant': tenant, 'format': format})
280
 
 
281
 
        LOG.debug("_test_show_port_details - tenant:%s "
282
 
                  "- format:%s - END", format, tenant)
283
 
 
284
 
    def _test_create_port(self, tenant=TENANT_1, format='json', status=200):
285
 
        LOG.debug("_test_create_port - tenant:%s "
286
 
                  "- format:%s - START", format, tenant)
287
 
 
288
 
        self._assert_sanity(self.client.create_port,
289
 
                            status,
290
 
                            "POST",
291
 
                            "networks/001/ports",
292
 
                            data=["001"],
293
 
                            params={'tenant': tenant, 'format': format})
294
 
 
295
 
        LOG.debug("_test_create_port - tenant:%s "
296
 
                  "- format:%s - END", format, tenant)
297
 
 
298
 
    def _test_delete_port(self, tenant=TENANT_1, format='json', status=200):
299
 
        LOG.debug("_test_delete_port - tenant:%s "
300
 
                  "- format:%s - START", format, tenant)
301
 
 
302
 
        self._assert_sanity(self.client.delete_port,
303
 
                            status,
304
 
                            "DELETE",
305
 
                            "networks/001/ports/001",
306
 
                            data=["001", "001"],
307
 
                            params={'tenant': tenant, 'format': format})
308
 
 
309
 
        LOG.debug("_test_delete_port - tenant:%s "
310
 
                  "- format:%s - END", format, tenant)
311
 
 
312
 
    def _test_update_port(self, tenant=TENANT_1, format='json', status=200):
313
 
        LOG.debug("_test_update_port - tenant:%s "
314
 
                  "- format:%s - START", format, tenant)
315
 
 
316
 
        self._assert_sanity(self.client.update_port,
317
 
                            status,
318
 
                            "PUT",
319
 
                            "networks/001/ports/001",
320
 
                            data=["001", "001",
321
 
                                  {'port': {'state': 'ACTIVE'}}],
322
 
                            params={'tenant': tenant, 'format': format})
323
 
 
324
 
        LOG.debug("_test_update_port - tenant:%s "
325
 
                  "- format:%s - END", format, tenant)
326
 
 
327
 
    def _test_show_port_attachment(self,
328
 
                                   tenant=TENANT_1, format='json', status=200):
329
 
        LOG.debug("_test_show_port_attachment - tenant:%s "
330
 
                  "- format:%s - START", format, tenant)
331
 
 
332
 
        self._assert_sanity(self.client.show_port_attachment,
333
 
                            status,
334
 
                            "GET",
335
 
                            "networks/001/ports/001/attachment",
336
 
                            data=["001", "001"],
337
 
                            params={'tenant': tenant, 'format': format})
338
 
 
339
 
        LOG.debug("_test_show_port_attachment - tenant:%s "
340
 
                  "- format:%s - END", format, tenant)
341
 
 
342
 
    def _test_attach_resource(self, tenant=TENANT_1,
343
 
                              format='json', status=200):
344
 
        LOG.debug("_test_attach_resource - tenant:%s "
345
 
                  "- format:%s - START", format, tenant)
346
 
 
347
 
        self._assert_sanity(self.client.attach_resource,
348
 
                            status,
349
 
                            "PUT",
350
 
                            "networks/001/ports/001/attachment",
351
 
                            data=["001", "001",
352
 
                                  {'resource': {'id': '1234'}}],
353
 
                            params={'tenant': tenant, 'format': format})
354
 
 
355
 
        LOG.debug("_test_attach_resource - tenant:%s "
356
 
                  "- format:%s - END", format, tenant)
357
 
 
358
 
    def _test_detach_resource(self, tenant=TENANT_1,
359
 
                              format='json', status=200):
360
 
        LOG.debug("_test_detach_resource - tenant:%s "
361
 
                  "- format:%s - START", format, tenant)
362
 
 
363
 
        self._assert_sanity(self.client.detach_resource,
364
 
                            status,
365
 
                            "DELETE",
366
 
                            "networks/001/ports/001/attachment",
367
 
                            data=["001", "001"],
368
 
                            params={'tenant': tenant, 'format': format})
369
 
 
370
 
        LOG.debug("_test_detach_resource - tenant:%s "
371
 
                  "- format:%s - END", format, tenant)
372
 
 
373
 
    def _test_ssl_certificates(self, tenant=TENANT_1,
374
 
                               format='json', status=200):
375
 
        LOG.debug("_test_ssl_certificates - tenant:%s "
376
 
                  "- format:%s - START", format, tenant)
377
 
 
378
 
        # Set SSL, and our cert file
379
 
        self.client.use_ssl = True
380
 
        cert_file = "/fake.cert"
381
 
        self.client.key_file = self.client.cert_file = cert_file
382
 
 
383
 
        data = self._assert_sanity(self.client.list_networks,
384
 
                                   status,
385
 
                                   "GET",
386
 
                                   "networks",
387
 
                                   data=[],
388
 
                                   params={'tenant': tenant, 'format': format})
389
 
 
390
 
        self.assertEquals(data["key_file"], cert_file)
391
 
        self.assertEquals(data["cert_file"], cert_file)
392
 
 
393
 
        LOG.debug("_test_ssl_certificates - tenant:%s "
394
 
                  "- format:%s - END", format, tenant)
395
 
 
396
 
    def test_list_networks_json(self):
397
 
        self._test_list_networks(format='json')
398
 
 
399
 
    def test_list_networks_xml(self):
400
 
        self._test_list_networks(format='xml')
401
 
 
402
 
    def test_list_networks_alt_tenant(self):
403
 
        self._test_list_networks(tenant=TENANT_2)
404
 
 
405
 
    def test_list_networks_error_470(self):
406
 
        self._test_list_networks(status=470)
407
 
 
408
 
    def test_list_networks_error_401(self):
409
 
        self._test_list_networks(status=401)
410
 
 
411
 
    def test_list_networks_details_json(self):
412
 
        self._test_list_networks_details(format='json')
413
 
 
414
 
    def test_list_networks_details_xml(self):
415
 
        self._test_list_networks_details(format='xml')
416
 
 
417
 
    def test_list_networks_details_alt_tenant(self):
418
 
        self._test_list_networks_details(tenant=TENANT_2)
419
 
 
420
 
    def test_list_networks_details_error_470(self):
421
 
        self._test_list_networks_details(status=470)
422
 
 
423
 
    def test_list_networks_details_error_401(self):
424
 
        self._test_list_networks_details(status=401)
425
 
 
426
 
    def test_show_network_json(self):
427
 
        self._test_show_network(format='json')
428
 
 
429
 
    def test_show_network__xml(self):
430
 
        self._test_show_network(format='xml')
431
 
 
432
 
    def test_show_network_alt_tenant(self):
433
 
        self._test_show_network(tenant=TENANT_2)
434
 
 
435
 
    def test_show_network_error_470(self):
436
 
        self._test_show_network(status=470)
437
 
 
438
 
    def test_show_network_error_401(self):
439
 
        self._test_show_network(status=401)
440
 
 
441
 
    def test_show_network_error_420(self):
442
 
        self._test_show_network(status=420)
443
 
 
444
 
    def test_show_network_details_json(self):
445
 
        self._test_show_network_details(format='json')
446
 
 
447
 
    def test_show_network_details_xml(self):
448
 
        self._test_show_network_details(format='xml')
449
 
 
450
 
    def test_show_network_details_alt_tenant(self):
451
 
        self._test_show_network_details(tenant=TENANT_2)
452
 
 
453
 
    def test_show_network_details_error_470(self):
454
 
        self._test_show_network_details(status=470)
455
 
 
456
 
    def test_show_network_details_error_401(self):
457
 
        self._test_show_network_details(status=401)
458
 
 
459
 
    def test_show_network_details_error_420(self):
460
 
        self._test_show_network_details(status=420)
461
 
 
462
 
    def test_create_network_json(self):
463
 
        self._test_create_network(format='json')
464
 
 
465
 
    def test_create_network_xml(self):
466
 
        self._test_create_network(format='xml')
467
 
 
468
 
    def test_create_network_alt_tenant(self):
469
 
        self._test_create_network(tenant=TENANT_2)
470
 
 
471
 
    def test_create_network_error_470(self):
472
 
        self._test_create_network(status=470)
473
 
 
474
 
    def test_create_network_error_401(self):
475
 
        self._test_create_network(status=401)
476
 
 
477
 
    def test_create_network_error_400(self):
478
 
        self._test_create_network(status=400)
479
 
 
480
 
    def test_create_network_error_422(self):
481
 
        self._test_create_network(status=422)
482
 
 
483
 
    def test_update_network_json(self):
484
 
        self._test_update_network(format='json')
485
 
 
486
 
    def test_update_network_xml(self):
487
 
        self._test_update_network(format='xml')
488
 
 
489
 
    def test_update_network_alt_tenant(self):
490
 
        self._test_update_network(tenant=TENANT_2)
491
 
 
492
 
    def test_update_network_error_470(self):
493
 
        self._test_update_network(status=470)
494
 
 
495
 
    def test_update_network_error_401(self):
496
 
        self._test_update_network(status=401)
497
 
 
498
 
    def test_update_network_error_400(self):
499
 
        self._test_update_network(status=400)
500
 
 
501
 
    def test_update_network_error_420(self):
502
 
        self._test_update_network(status=420)
503
 
 
504
 
    def test_update_network_error_422(self):
505
 
        self._test_update_network(status=422)
506
 
 
507
 
    def test_delete_network_json(self):
508
 
        self._test_delete_network(format='json')
509
 
 
510
 
    def test_delete_network_xml(self):
511
 
        self._test_delete_network(format='xml')
512
 
 
513
 
    def test_delete_network_alt_tenant(self):
514
 
        self._test_delete_network(tenant=TENANT_2)
515
 
 
516
 
    def test_delete_network_error_470(self):
517
 
        self._test_delete_network(status=470)
518
 
 
519
 
    def test_delete_network_error_401(self):
520
 
        self._test_delete_network(status=401)
521
 
 
522
 
    def test_delete_network_error_420(self):
523
 
        self._test_delete_network(status=420)
524
 
 
525
 
    def test_delete_network_error_421(self):
526
 
        self._test_delete_network(status=421)
527
 
 
528
 
    def test_list_ports_json(self):
529
 
        self._test_list_ports(format='json')
530
 
 
531
 
    def test_list_ports_xml(self):
532
 
        self._test_list_ports(format='xml')
533
 
 
534
 
    def test_list_ports_alt_tenant(self):
535
 
        self._test_list_ports(tenant=TENANT_2)
536
 
 
537
 
    def test_list_ports_error_470(self):
538
 
        self._test_list_ports(status=470)
539
 
 
540
 
    def test_list_ports_error_401(self):
541
 
        self._test_list_ports(status=401)
542
 
 
543
 
    def test_list_ports_error_420(self):
544
 
        self._test_list_ports(status=420)
545
 
 
546
 
    def test_list_ports_details_json(self):
547
 
        self._test_list_ports_details(format='json')
548
 
 
549
 
    def test_list_ports_details_xml(self):
550
 
        self._test_list_ports_details(format='xml')
551
 
 
552
 
    def test_list_ports_details_alt_tenant(self):
553
 
        self._test_list_ports_details(tenant=TENANT_2)
554
 
 
555
 
    def test_list_ports_details_error_470(self):
556
 
        self._test_list_ports_details(status=470)
557
 
 
558
 
    def test_list_ports_details_error_401(self):
559
 
        self._test_list_ports_details(status=401)
560
 
 
561
 
    def test_list_ports_details_error_420(self):
562
 
        self._test_list_ports_details(status=420)
563
 
 
564
 
    def test_show_port_json(self):
565
 
        self._test_show_port(format='json')
566
 
 
567
 
    def test_show_port_xml(self):
568
 
        self._test_show_port(format='xml')
569
 
 
570
 
    def test_show_port_alt_tenant(self):
571
 
        self._test_show_port(tenant=TENANT_2)
572
 
 
573
 
    def test_show_port_error_470(self):
574
 
        self._test_show_port(status=470)
575
 
 
576
 
    def test_show_port_error_401(self):
577
 
        self._test_show_port(status=401)
578
 
 
579
 
    def test_show_port_error_420(self):
580
 
        self._test_show_port(status=420)
581
 
 
582
 
    def test_show_port_error_430(self):
583
 
        self._test_show_port(status=430)
584
 
 
585
 
    def test_show_port_details_json(self):
586
 
        self._test_show_port_details(format='json')
587
 
 
588
 
    def test_show_port_details_xml(self):
589
 
        self._test_show_port_details(format='xml')
590
 
 
591
 
    def test_show_port_details_alt_tenant(self):
592
 
        self._test_show_port_details(tenant=TENANT_2)
593
 
 
594
 
    def test_show_port_details_error_470(self):
595
 
        self._test_show_port_details(status=470)
596
 
 
597
 
    def test_show_port_details_error_401(self):
598
 
        self._test_show_port_details(status=401)
599
 
 
600
 
    def test_show_port_details_error_420(self):
601
 
        self._test_show_port_details(status=420)
602
 
 
603
 
    def test_show_port_details_error_430(self):
604
 
        self._test_show_port_details(status=430)
605
 
 
606
 
    def test_create_port_json(self):
607
 
        self._test_create_port(format='json')
608
 
 
609
 
    def test_create_port_xml(self):
610
 
        self._test_create_port(format='xml')
611
 
 
612
 
    def test_create_port_alt_tenant(self):
613
 
        self._test_create_port(tenant=TENANT_2)
614
 
 
615
 
    def test_create_port_error_470(self):
616
 
        self._test_create_port(status=470)
617
 
 
618
 
    def test_create_port_error_401(self):
619
 
        self._test_create_port(status=401)
620
 
 
621
 
    def test_create_port_error_400(self):
622
 
        self._test_create_port(status=400)
623
 
 
624
 
    def test_create_port_error_420(self):
625
 
        self._test_create_port(status=420)
626
 
 
627
 
    def test_create_port_error_430(self):
628
 
        self._test_create_port(status=430)
629
 
 
630
 
    def test_create_port_error_431(self):
631
 
        self._test_create_port(status=431)
632
 
 
633
 
    def test_delete_port_json(self):
634
 
        self._test_delete_port(format='json')
635
 
 
636
 
    def test_delete_port_xml(self):
637
 
        self._test_delete_port(format='xml')
638
 
 
639
 
    def test_delete_port_alt_tenant(self):
640
 
        self._test_delete_port(tenant=TENANT_2)
641
 
 
642
 
    def test_delete_port_error_470(self):
643
 
        self._test_delete_port(status=470)
644
 
 
645
 
    def test_delete_port_error_401(self):
646
 
        self._test_delete_port(status=401)
647
 
 
648
 
    def test_delete_port_error_420(self):
649
 
        self._test_delete_port(status=420)
650
 
 
651
 
    def test_delete_port_error_430(self):
652
 
        self._test_delete_port(status=430)
653
 
 
654
 
    def test_delete_port_error_432(self):
655
 
        self._test_delete_port(status=432)
656
 
 
657
 
    def test_update_port_json(self):
658
 
        self._test_update_port(format='json')
659
 
 
660
 
    def test_update_port_xml(self):
661
 
        self._test_update_port(format='xml')
662
 
 
663
 
    def test_update_port_alt_tenant(self):
664
 
        self._test_update_port(tenant=TENANT_2)
665
 
 
666
 
    def test_update_port_error_470(self):
667
 
        self._test_update_port(status=470)
668
 
 
669
 
    def test_update_port_error_401(self):
670
 
        self._test_update_port(status=401)
671
 
 
672
 
    def test_update_port_error_400(self):
673
 
        self._test_update_port(status=400)
674
 
 
675
 
    def test_update_port_error_420(self):
676
 
        self._test_update_port(status=420)
677
 
 
678
 
    def test_update_port_error_430(self):
679
 
        self._test_update_port(status=430)
680
 
 
681
 
    def test_update_port_error_431(self):
682
 
        self._test_update_port(status=431)
683
 
 
684
 
    def test_show_port_attachment_json(self):
685
 
        self._test_show_port_attachment(format='json')
686
 
 
687
 
    def test_show_port_attachment_xml(self):
688
 
        self._test_show_port_attachment(format='xml')
689
 
 
690
 
    def test_show_port_attachment_alt_tenant(self):
691
 
        self._test_show_port_attachment(tenant=TENANT_2)
692
 
 
693
 
    def test_show_port_attachment_error_470(self):
694
 
        self._test_show_port_attachment(status=470)
695
 
 
696
 
    def test_show_port_attachment_error_401(self):
697
 
        self._test_show_port_attachment(status=401)
698
 
 
699
 
    def test_show_port_attachment_error_400(self):
700
 
        self._test_show_port_attachment(status=400)
701
 
 
702
 
    def test_show_port_attachment_error_420(self):
703
 
        self._test_show_port_attachment(status=420)
704
 
 
705
 
    def test_show_port_attachment_error_430(self):
706
 
        self._test_show_port_attachment(status=430)
707
 
 
708
 
    def test_attach_resource_json(self):
709
 
        self._test_attach_resource(format='json')
710
 
 
711
 
    def test_attach_resource_xml(self):
712
 
        self._test_attach_resource(format='xml')
713
 
 
714
 
    def test_attach_resource_alt_tenant(self):
715
 
        self._test_attach_resource(tenant=TENANT_2)
716
 
 
717
 
    def test_attach_resource_error_470(self):
718
 
        self._test_attach_resource(status=470)
719
 
 
720
 
    def test_attach_resource_error_401(self):
721
 
        self._test_attach_resource(status=401)
722
 
 
723
 
    def test_attach_resource_error_400(self):
724
 
        self._test_attach_resource(status=400)
725
 
 
726
 
    def test_attach_resource_error_420(self):
727
 
        self._test_attach_resource(status=420)
728
 
 
729
 
    def test_attach_resource_error_430(self):
730
 
        self._test_attach_resource(status=430)
731
 
 
732
 
    def test_attach_resource_error_432(self):
733
 
        self._test_attach_resource(status=432)
734
 
 
735
 
    def test_attach_resource_error_440(self):
736
 
        self._test_attach_resource(status=440)
737
 
 
738
 
    def test_detach_resource_json(self):
739
 
        self._test_detach_resource(format='json')
740
 
 
741
 
    def test_detach_resource_xml(self):
742
 
        self._test_detach_resource(format='xml')
743
 
 
744
 
    def test_detach_resource_alt_tenant(self):
745
 
        self._test_detach_resource(tenant=TENANT_2)
746
 
 
747
 
    def test_detach_resource_error_470(self):
748
 
        self._test_detach_resource(status=470)
749
 
 
750
 
    def test_detach_resource_error_401(self):
751
 
        self._test_detach_resource(status=401)
752
 
 
753
 
    def test_detach_resource_error_420(self):
754
 
        self._test_detach_resource(status=420)
755
 
 
756
 
    def test_detach_resource_error_430(self):
757
 
        self._test_detach_resource(status=430)
758
 
 
759
 
    def test_ssl_certificates(self):
760
 
        self._test_ssl_certificates()
761
 
 
762
 
    def test_connection_retry_failure(self):
763
 
        self.client = Client(port=55555, tenant=TENANT_1, retries=1,
764
 
                             retry_interval=0)
765
 
        try:
766
 
            self.client.list_networks()
767
 
        except exceptions.ConnectionFailed as exc:
768
 
            self.assertTrue('Maximum attempts reached' in str(exc))
769
 
        else:
770
 
            self.fail('ConnectionFailed not raised')