← Back to branch summary

~ubuntu-branches/ubuntu/trusty/horizon/trusty-updates

« back to all changes in this revision

Viewing changes to openstack_dashboard/dashboards/project/networks/tests.py

  • Committer: Package Import Robot
  • Author(s): Adam Gandelman
  • Date: 2013-09-06 11:59:43 UTC
  • mfrom: (1.1.30)
  • Revision ID: package-import@ubuntu.com-20130906115943-h3td0l7tp16mb9oc
Tags: 1:2013.2~b3-0ubuntu1
* New upstream release.
* debian/control: Minimum python-openstack-auth version >= 1.1.1.
* debian/control: Add python-troveclient.
* debian/static: Refresh static assets for 2013.2~b3.
* debian/patches: ubuntu_local_settings.patch -> ubuntu_settings.patch, also
  patch location of secret key in openstack_dashboard/settings.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
openstack_dashboard/dashboards/project/networks/tests.py
14
14
#    License for the specific language governing permissions and limitations
15
15
#    under the License.
16
16
 
17
 
from django.core.urlresolvers import reverse
 
17
from django.core.urlresolvers import reverse  # noqa
18
18
from django import http
19
 
from django.utils.html import escape
20
 
 
21
 
from horizon.workflows.views import WorkflowView
22
 
 
23
 
from mox import IsA
 
19
from django.utils.html import escape  # noqa
 
20
 
 
21
from horizon.workflows import views
 
22
 
 
23
from mox import IsA  # noqa
24
24
 
25
25
from openstack_dashboard import api
26
26
from openstack_dashboard.test import helpers as test
27
27
 
28
 
from openstack_dashboard.dashboards.project.networks.workflows \
29
 
    import CreateNetwork
 
28
from openstack_dashboard.dashboards.project.networks import workflows
30
29
 
31
30
 
32
31
INDEX_URL = reverse('horizon:project:networks:index')
220
219
        self.assertItemsEqual(subnets, [self.subnets.first()])
221
220
        self.assertEqual(len(ports), 0)
222
221
 
 
222
    @test.create_stubs({api.neutron: ('profile_list',)})
223
223
    def test_network_create_get(self):
224
 
        # no api methods are called.
 
224
        # TODO(absubram): Remove if clause and create separate
 
225
        # test stubs for when profile_support is being used.
 
226
        # Additionally ensure those are always run even in default setting
 
227
        if api.neutron.is_port_profiles_supported():
 
228
            net_profiles = self.net_profiles.list()
 
229
            api.neutron.profile_list(IsA(http.HttpRequest),
 
230
                                     'network').AndReturn(net_profiles)
225
231
        self.mox.ReplayAll()
226
232
 
227
233
        url = reverse('horizon:project:networks:create')
228
234
        res = self.client.get(url)
229
235
 
230
236
        workflow = res.context['workflow']
231
 
        self.assertTemplateUsed(res, WorkflowView.template_name)
232
 
        self.assertEqual(workflow.name, CreateNetwork.name)
 
237
        self.assertTemplateUsed(res, views.WorkflowView.template_name)
 
238
        self.assertEqual(workflow.name, workflows.CreateNetwork.name)
233
239
        expected_objs = ['<CreateNetworkInfo: createnetworkinfoaction>',
234
240
                         '<CreateSubnetInfo: createsubnetinfoaction>',
235
241
                         '<CreateSubnetDetail: createsubnetdetailaction>']
236
242
        self.assertQuerysetEqual(workflow.steps, expected_objs)
237
243
 
238
 
    @test.create_stubs({api.neutron: ('network_create',)})
 
244
    @test.create_stubs({api.neutron: ('network_create',
 
245
                                      'profile_list',)})
239
246
    def test_network_create_post(self):
240
247
        network = self.networks.first()
241
 
        api.neutron.network_create(IsA(http.HttpRequest), name=network.name,
242
 
                                   admin_state_up=network.admin_state_up)\
243
 
            .AndReturn(network)
 
248
        params = {'name': network.name,
 
249
                  'admin_state_up': network.admin_state_up}
 
250
        # TODO(absubram): Remove if clause and create separate
 
251
        # test stubs for when profile_support is being used.
 
252
        # Additionally ensure those are always run even in default setting
 
253
        if api.neutron.is_port_profiles_supported():
 
254
            net_profiles = self.net_profiles.list()
 
255
            net_profile_id = self.net_profiles.first().id
 
256
            api.neutron.profile_list(IsA(http.HttpRequest),
 
257
                                     'network').AndReturn(net_profiles)
 
258
            params['net_profile_id'] = net_profile_id
 
259
        api.neutron.network_create(IsA(http.HttpRequest),
 
260
                                   **params).AndReturn(network)
244
261
        self.mox.ReplayAll()
245
262
 
246
263
        form_data = {'net_name': network.name,
247
264
                     'admin_state': network.admin_state_up,
248
265
                     # subnet
249
266
                     'with_subnet': False}
 
267
        if api.neutron.is_port_profiles_supported():
 
268
            form_data['net_profile_id'] = net_profile_id
250
269
        form_data.update(form_data_no_subnet())
251
270
        url = reverse('horizon:project:networks:create')
252
271
        res = self.client.post(url, form_data)
255
274
        self.assertRedirectsNoFollow(res, INDEX_URL)
256
275
 
257
276
    @test.create_stubs({api.neutron: ('network_create',
258
 
                                      'subnet_create',)})
 
277
                                      'subnet_create',
 
278
                                      'profile_list',)})
259
279
    def test_network_create_post_with_subnet(self):
260
280
        network = self.networks.first()
261
281
        subnet = self.subnets.first()
262
 
        api.neutron.network_create(IsA(http.HttpRequest), name=network.name,
263
 
                                   admin_state_up=network.admin_state_up)\
264
 
            .AndReturn(network)
 
282
        params = {'name': network.name,
 
283
                  'admin_state_up': network.admin_state_up}
 
284
        # TODO(absubram): Remove if clause and create separate
 
285
        # test stubs for when profile_support is being used.
 
286
        # Additionally ensure those are always run even in default setting
 
287
        if api.neutron.is_port_profiles_supported():
 
288
            net_profiles = self.net_profiles.list()
 
289
            net_profile_id = self.net_profiles.first().id
 
290
            api.neutron.profile_list(IsA(http.HttpRequest),
 
291
                                     'network').AndReturn(net_profiles)
 
292
            params['net_profile_id'] = net_profile_id
 
293
        api.neutron.network_create(IsA(http.HttpRequest),
 
294
                                   **params).AndReturn(network)
265
295
        api.neutron.subnet_create(IsA(http.HttpRequest),
266
296
                                  network_id=network.id,
267
297
                                  name=subnet.name,
275
305
        form_data = {'net_name': network.name,
276
306
                     'admin_state': network.admin_state_up,
277
307
                     'with_subnet': True}
 
308
        if api.neutron.is_port_profiles_supported():
 
309
            form_data['net_profile_id'] = net_profile_id
278
310
        form_data.update(form_data_subnet(subnet, allocation_pools=[]))
279
311
        url = reverse('horizon:project:networks:create')
280
312
        res = self.client.post(url, form_data)
282
314
        self.assertNoFormErrors(res)
283
315
        self.assertRedirectsNoFollow(res, INDEX_URL)
284
316
 
285
 
    @test.create_stubs({api.neutron: ('network_create',)})
 
317
    @test.create_stubs({api.neutron: ('network_create',
 
318
                                      'profile_list',)})
286
319
    def test_network_create_post_network_exception(self):
287
320
        network = self.networks.first()
288
 
        api.neutron.network_create(IsA(http.HttpRequest), name=network.name,
289
 
                                   admin_state_up=network.admin_state_up)\
290
 
            .AndRaise(self.exceptions.neutron)
 
321
        params = {'name': network.name,
 
322
                  'admin_state_up': network.admin_state_up}
 
323
        # TODO(absubram): Remove if clause and create separate
 
324
        # test stubs for when profile_support is being used.
 
325
        # Additionally ensure those are always run even in default setting
 
326
        if api.neutron.is_port_profiles_supported():
 
327
            net_profiles = self.net_profiles.list()
 
328
            net_profile_id = self.net_profiles.first().id
 
329
            api.neutron.profile_list(IsA(http.HttpRequest),
 
330
                                     'network').AndReturn(net_profiles)
 
331
            params['net_profile_id'] = net_profile_id
 
332
        api.neutron.network_create(IsA(http.HttpRequest),
 
333
                                   **params).AndRaise(self.exceptions.neutron)
291
334
        self.mox.ReplayAll()
292
335
 
293
336
        form_data = {'net_name': network.name,
294
337
                     'admin_state': network.admin_state_up,
295
338
                     # subnet
296
339
                     'with_subnet': False}
 
340
        if api.neutron.is_port_profiles_supported():
 
341
            form_data['net_profile_id'] = net_profile_id
297
342
        form_data.update(form_data_no_subnet())
298
343
        url = reverse('horizon:project:networks:create')
299
344
        res = self.client.post(url, form_data)
301
346
        self.assertNoFormErrors(res)
302
347
        self.assertRedirectsNoFollow(res, INDEX_URL)
303
348
 
304
 
    @test.create_stubs({api.neutron: ('network_create',)})
 
349
    @test.create_stubs({api.neutron: ('network_create',
 
350
                                      'profile_list')})
305
351
    def test_network_create_post_with_subnet_network_exception(self):
306
352
        network = self.networks.first()
307
353
        subnet = self.subnets.first()
308
 
        api.neutron.network_create(IsA(http.HttpRequest), name=network.name,
309
 
                                   admin_state_up=network.admin_state_up)\
310
 
            .AndRaise(self.exceptions.neutron)
 
354
        params = {'name': network.name,
 
355
                  'admin_state_up': network.admin_state_up}
 
356
        # TODO(absubram): Remove if clause and create separate
 
357
        # test stubs for when profile_support is being used.
 
358
        # Additionally ensure those are always run even in default setting
 
359
        if api.neutron.is_port_profiles_supported():
 
360
            net_profiles = self.net_profiles.list()
 
361
            net_profile_id = self.net_profiles.first().id
 
362
            api.neutron.profile_list(IsA(http.HttpRequest),
 
363
                                     'network').AndReturn(net_profiles)
 
364
            params['net_profile_id'] = net_profile_id
 
365
        api.neutron.network_create(IsA(http.HttpRequest),
 
366
                                   **params).AndRaise(self.exceptions.neutron)
311
367
        self.mox.ReplayAll()
312
368
 
313
369
        form_data = {'net_name': network.name,
314
370
                     'admin_state': network.admin_state_up,
315
371
                     'with_subnet': True}
 
372
        if api.neutron.is_port_profiles_supported():
 
373
            form_data['net_profile_id'] = net_profile_id
316
374
        form_data.update(form_data_subnet(subnet, allocation_pools=[]))
317
375
        url = reverse('horizon:project:networks:create')
318
376
        res = self.client.post(url, form_data)
322
380
 
323
381
    @test.create_stubs({api.neutron: ('network_create',
324
382
                                      'network_delete',
325
 
                                      'subnet_create',)})
 
383
                                      'subnet_create',
 
384
                                      'profile_list')})
326
385
    def test_network_create_post_with_subnet_subnet_exception(self):
327
386
        network = self.networks.first()
328
387
        subnet = self.subnets.first()
329
 
        api.neutron.network_create(IsA(http.HttpRequest), name=network.name,
330
 
                                   admin_state_up=network.admin_state_up)\
331
 
            .AndReturn(network)
 
388
        params = {'name': network.name,
 
389
                  'admin_state_up': network.admin_state_up}
 
390
        # TODO(absubram): Remove if clause and create separate
 
391
        # test stubs for when profile_support is being used.
 
392
        # Additionally ensure those are always run even in default setting
 
393
        if api.neutron.is_port_profiles_supported():
 
394
            net_profiles = self.net_profiles.list()
 
395
            net_profile_id = self.net_profiles.first().id
 
396
            api.neutron.profile_list(IsA(http.HttpRequest),
 
397
                                     'network').AndReturn(net_profiles)
 
398
            params['net_profile_id'] = net_profile_id
 
399
        api.neutron.network_create(IsA(http.HttpRequest),
 
400
                                   **params).AndReturn(network)
332
401
        api.neutron.subnet_create(IsA(http.HttpRequest),
333
402
                                  network_id=network.id,
334
403
                                  name=subnet.name,
344
413
        form_data = {'net_name': network.name,
345
414
                     'admin_state': network.admin_state_up,
346
415
                     'with_subnet': True}
 
416
        if api.neutron.is_port_profiles_supported():
 
417
            form_data['net_profile_id'] = net_profile_id
347
418
        form_data.update(form_data_subnet(subnet, allocation_pools=[]))
348
419
        url = reverse('horizon:project:networks:create')
349
420
        res = self.client.post(url, form_data)
351
422
        self.assertNoFormErrors(res)
352
423
        self.assertRedirectsNoFollow(res, INDEX_URL)
353
424
 
 
425
    @test.create_stubs({api.neutron: ('profile_list',)})
354
426
    def test_network_create_post_with_subnet_nocidr(self):
355
427
        network = self.networks.first()
356
428
        subnet = self.subnets.first()
 
429
        # TODO(absubram): Remove if clause and create separate
 
430
        # test stubs for when profile_support is being used.
 
431
        # Additionally ensure those are always run even in default setting
 
432
        if api.neutron.is_port_profiles_supported():
 
433
            net_profiles = self.net_profiles.list()
 
434
            net_profile_id = self.net_profiles.first().id
 
435
            api.neutron.profile_list(IsA(http.HttpRequest),
 
436
                                     'network').AndReturn(net_profiles)
357
437
        self.mox.ReplayAll()
358
438
 
359
439
        form_data = {'net_name': network.name,
360
440
                     'admin_state': network.admin_state_up,
361
441
                     'with_subnet': True}
 
442
        if api.neutron.is_port_profiles_supported():
 
443
            form_data['net_profile_id'] = net_profile_id
362
444
        form_data.update(form_data_subnet(subnet, cidr='',
363
445
                                          allocation_pools=[]))
364
446
        url = reverse('horizon:project:networks:create')
367
449
        self.assertContains(res, escape('Specify "Network Address" or '
368
450
                                        'clear "Create Subnet" checkbox.'))
369
451
 
 
452
    @test.create_stubs({api.neutron: ('profile_list',)})
370
453
    def test_network_create_post_with_subnet_cidr_without_mask(self):
371
454
        network = self.networks.first()
372
455
        subnet = self.subnets.first()
 
456
        # TODO(absubram): Remove if clause and create separate
 
457
        # test stubs for when profile_support is being used.
 
458
        # Additionally ensure those are always run even in default setting
 
459
        if api.neutron.is_port_profiles_supported():
 
460
            net_profiles = self.net_profiles.list()
 
461
            net_profile_id = self.net_profiles.first().id
 
462
            api.neutron.profile_list(IsA(http.HttpRequest),
 
463
                                     'network').AndReturn(net_profiles)
 
464
            self.mox.ReplayAll()
373
465
 
374
466
        form_data = {'net_name': network.name,
375
467
                     'admin_state': network.admin_state_up,
376
468
                     'with_subnet': True}
 
469
        if api.neutron.is_port_profiles_supported():
 
470
            form_data['net_profile_id'] = net_profile_id
377
471
        form_data.update(form_data_subnet(subnet, cidr='10.0.0.0',
378
472
                                          allocation_pools=[]))
379
473
        url = reverse('horizon:project:networks:create')
382
476
        expected_msg = "The subnet in the Network Address is too small (/32)."
383
477
        self.assertContains(res, expected_msg)
384
478
 
 
479
    @test.create_stubs({api.neutron: ('profile_list',)})
385
480
    def test_network_create_post_with_subnet_cidr_inconsistent(self):
386
481
        network = self.networks.first()
387
482
        subnet = self.subnets.first()
 
483
        # TODO(absubram): Remove if clause and create separate
 
484
        # test stubs for when profile_support is being used.
 
485
        # Additionally ensure those are always run even in default setting
 
486
        if api.neutron.is_port_profiles_supported():
 
487
            net_profiles = self.net_profiles.list()
 
488
            net_profile_id = self.net_profiles.first().id
 
489
            api.neutron.profile_list(IsA(http.HttpRequest),
 
490
                                     'network').AndReturn(net_profiles)
388
491
        self.mox.ReplayAll()
389
492
 
390
493
        # dummy IPv6 address
392
495
        form_data = {'net_name': network.name,
393
496
                     'admin_state': network.admin_state_up,
394
497
                     'with_subnet': True}
 
498
        if api.neutron.is_port_profiles_supported():
 
499
            form_data['net_profile_id'] = net_profile_id
395
500
        form_data.update(form_data_subnet(subnet, cidr=cidr,
396
501
                                          allocation_pools=[]))
397
502
        url = reverse('horizon:project:networks:create')
400
505
        expected_msg = 'Network Address and IP version are inconsistent.'
401
506
        self.assertContains(res, expected_msg)
402
507
 
 
508
    @test.create_stubs({api.neutron: ('profile_list',)})
403
509
    def test_network_create_post_with_subnet_gw_inconsistent(self):
404
510
        network = self.networks.first()
405
511
        subnet = self.subnets.first()
 
512
        # TODO(absubram): Remove if clause and create separate
 
513
        # test stubs for when profile_support is being used.
 
514
        # Additionally ensure those are always run even in default setting
 
515
        if api.neutron.is_port_profiles_supported():
 
516
            net_profiles = self.net_profiles.list()
 
517
            net_profile_id = self.net_profiles.first().id
 
518
            api.neutron.profile_list(IsA(http.HttpRequest),
 
519
                                     'network').AndReturn(net_profiles)
406
520
        self.mox.ReplayAll()
407
521
 
408
522
        # dummy IPv6 address
410
524
        form_data = {'net_name': network.name,
411
525
                     'admin_state': network.admin_state_up,
412
526
                     'with_subnet': True}
 
527
        if api.neutron.is_port_profiles_supported():
 
528
            form_data['net_profile_id'] = net_profile_id
413
529
        form_data.update(form_data_subnet(subnet, gateway_ip=gateway_ip,
414
530
                                          allocation_pools=[]))
415
531
        url = reverse('horizon:project:networks:create')
605
721
                      args=[network.id])
606
722
        res = self.client.get(url)
607
723
 
608
 
        self.assertTemplateUsed(res, WorkflowView.template_name)
 
724
        self.assertTemplateUsed(res, views.WorkflowView.template_name)
609
725
 
610
726
    @test.create_stubs({api.neutron: ('network_get',
611
727
                                      'subnet_create',)})
762
878
 
763
879
        expected_msg = 'Network Address and IP version are inconsistent.'
764
880
        self.assertFormErrors(res, 1, expected_msg)
765
 
        self.assertTemplateUsed(res, WorkflowView.template_name)
 
881
        self.assertTemplateUsed(res, views.WorkflowView.template_name)
766
882
 
767
883
    @test.create_stubs({api.neutron: ('network_get',)})
768
884
    def test_subnet_create_post_gw_inconsistent(self):