← Back to branch summary

~ubuntu-branches/ubuntu/utopic/horizon/utopic

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2014-07-25 11:39:09 UTC
  • mfrom: (1.1.42)
  • Revision ID: package-import@ubuntu.com-20140725113909-b8920pdy87itn1ro
Tags: 1:2014.2~b2-0ubuntu1
* New upstream release.
* debian/patches/ubuntu_settings.patch: Refresed
* debian/patches/fix-dashboard-manage.patch: Refreshed
* debian/patches/fix-dashboard-django-wsgi.patch: Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
openstack_dashboard/dashboards/project/instances/tests.py
24
24
from django import http
25
25
from django.test import utils as test_utils
26
26
from django.utils.datastructures import SortedDict
 
27
from django.utils import encoding
27
28
from django.utils.http import urlencode
28
29
 
29
30
from mox import IgnoreArg  # noqa
65
66
        api.nova.flavor_list(IsA(http.HttpRequest)) \
66
67
            .AndReturn(self.flavors.list())
67
68
        api.glance.image_list_detailed(IgnoreArg()) \
68
 
            .AndReturn((self.images.list(), False))
 
69
            .AndReturn((self.images.list(), False, False))
69
70
        search_opts = {'marker': None, 'paginate': True}
70
71
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
71
72
            .AndReturn([servers, False])
126
127
        api.nova.flavor_list(IsA(http.HttpRequest)) \
127
128
            .AndRaise(self.exceptions.nova)
128
129
        api.glance.image_list_detailed(IgnoreArg()) \
129
 
            .AndReturn((self.images.list(), False))
 
130
            .AndReturn((self.images.list(), False, False))
130
131
        for server in servers:
131
132
            api.nova.flavor_get(IsA(http.HttpRequest), server.flavor["id"]). \
132
133
                AndReturn(full_flavors[server.flavor["id"]])
171
172
        api.network.servers_update_addresses(IsA(http.HttpRequest), servers)
172
173
        api.nova.flavor_list(IsA(http.HttpRequest)).AndReturn(flavors)
173
174
        api.glance.image_list_detailed(IgnoreArg()) \
174
 
            .AndReturn((self.images.list(), False))
 
175
            .AndReturn((self.images.list(), False, False))
175
176
        for server in servers:
176
177
            api.nova.flavor_get(IsA(http.HttpRequest), server.flavor["id"]). \
177
178
                AndRaise(self.exceptions.nova)
212
213
        api.nova.flavor_list(IsA(http.HttpRequest)) \
213
214
            .AndReturn(self.flavors.list())
214
215
        api.glance.image_list_detailed(IgnoreArg()) \
215
 
            .AndReturn((self.images.list(), False))
 
216
            .AndReturn((self.images.list(), False, False))
216
217
        search_opts = {'marker': None, 'paginate': True}
217
218
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
218
219
            .AndReturn([servers, False])
246
247
        api.network.servers_update_addresses(IsA(http.HttpRequest), servers)
247
248
        api.nova.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
248
249
        api.glance.image_list_detailed(IgnoreArg()) \
249
 
            .AndReturn((self.images.list(), False))
 
250
            .AndReturn((self.images.list(), False, False))
250
251
        api.nova.server_delete(IsA(http.HttpRequest), server.id)
251
252
        self.mox.ReplayAll()
252
253
 
270
271
        api.network.servers_update_addresses(IsA(http.HttpRequest), servers)
271
272
        api.nova.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
272
273
        api.glance.image_list_detailed(IgnoreArg()) \
273
 
            .AndReturn((self.images.list(), False))
 
274
            .AndReturn((self.images.list(), False, False))
274
275
        api.nova.server_delete(IsA(http.HttpRequest), server.id) \
275
276
                          .AndRaise(self.exceptions.nova)
276
277
 
297
298
        api.nova.flavor_list(IsA(http.HttpRequest)) \
298
299
            .AndReturn(self.flavors.list())
299
300
        api.glance.image_list_detailed(IgnoreArg()) \
300
 
            .AndReturn((self.images.list(), False))
 
301
            .AndReturn((self.images.list(), False, False))
301
302
        search_opts = {'marker': None, 'paginate': True}
302
303
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
303
304
            .AndReturn([servers, False])
327
328
        api.nova.flavor_list(IsA(http.HttpRequest)) \
328
329
            .AndReturn(self.flavors.list())
329
330
        api.glance.image_list_detailed(IgnoreArg()) \
330
 
            .AndReturn((self.images.list(), False))
 
331
            .AndReturn((self.images.list(), False, False))
331
332
        search_opts = {'marker': None, 'paginate': True}
332
333
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
333
334
            .AndReturn([servers, False])
358
359
        api.nova.flavor_list(IsA(http.HttpRequest)) \
359
360
            .AndReturn(self.flavors.list())
360
361
        api.glance.image_list_detailed(IgnoreArg()) \
361
 
            .AndReturn((self.images.list(), False))
 
362
            .AndReturn((self.images.list(), False, False))
362
363
        search_opts = {'marker': None, 'paginate': True}
363
364
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
364
365
            .AndReturn([servers, False])
389
390
        api.nova.flavor_list(IsA(http.HttpRequest)) \
390
391
            .AndReturn(self.flavors.list())
391
392
        api.glance.image_list_detailed(IgnoreArg()) \
392
 
            .AndReturn((self.images.list(), False))
 
393
            .AndReturn((self.images.list(), False, False))
393
394
        search_opts = {'marker': None, 'paginate': True}
394
395
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
395
396
            .AndReturn([servers, False])
415
416
        api.nova.flavor_list(IsA(http.HttpRequest)) \
416
417
            .AndReturn(self.flavors.list())
417
418
        api.glance.image_list_detailed(IgnoreArg()) \
418
 
            .AndReturn((self.images.list(), False))
 
419
            .AndReturn((self.images.list(), False, False))
419
420
        search_opts = {'marker': None, 'paginate': True}
420
421
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
421
422
            .AndReturn([servers, False])
442
443
        api.nova.flavor_list(IsA(http.HttpRequest)) \
443
444
            .AndReturn(self.flavors.list())
444
445
        api.glance.image_list_detailed(IgnoreArg()) \
445
 
            .AndReturn((self.images.list(), False))
 
446
            .AndReturn((self.images.list(), False, False))
446
447
        search_opts = {'marker': None, 'paginate': True}
447
448
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
448
449
            .AndReturn([servers, False])
470
471
        api.nova.flavor_list(IsA(http.HttpRequest)) \
471
472
            .AndReturn(self.flavors.list())
472
473
        api.glance.image_list_detailed(IgnoreArg()) \
473
 
            .AndReturn((self.images.list(), False))
 
474
            .AndReturn((self.images.list(), False, False))
474
475
        search_opts = {'marker': None, 'paginate': True}
475
476
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
476
477
            .AndReturn([servers, False])
501
502
        api.nova.flavor_list(IsA(http.HttpRequest)) \
502
503
            .AndReturn(self.flavors.list())
503
504
        api.glance.image_list_detailed(IgnoreArg()) \
504
 
            .AndReturn((self.images.list(), False))
 
505
            .AndReturn((self.images.list(), False, False))
505
506
        search_opts = {'marker': None, 'paginate': True}
506
507
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
507
508
            .AndReturn([servers, False])
531
532
        api.nova.flavor_list(IsA(http.HttpRequest)) \
532
533
            .AndReturn(self.flavors.list())
533
534
        api.glance.image_list_detailed(IgnoreArg()) \
534
 
            .AndReturn((self.images.list(), False))
 
535
            .AndReturn((self.images.list(), False, False))
535
536
        search_opts = {'marker': None, 'paginate': True}
536
537
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
537
538
            .AndReturn([servers, False])
563
564
        api.nova.flavor_list(IsA(http.HttpRequest)) \
564
565
            .AndReturn(self.flavors.list())
565
566
        api.glance.image_list_detailed(IgnoreArg()) \
566
 
            .AndReturn((self.images.list(), False))
 
567
            .AndReturn((self.images.list(), False, False))
567
568
        search_opts = {'marker': None, 'paginate': True}
568
569
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
569
570
            .AndReturn([servers, False])
594
595
        api.nova.flavor_list(IsA(http.HttpRequest)) \
595
596
            .AndReturn(self.flavors.list())
596
597
        api.glance.image_list_detailed(IgnoreArg()) \
597
 
            .AndReturn((self.images.list(), False))
 
598
            .AndReturn((self.images.list(), False, False))
598
599
        search_opts = {'marker': None, 'paginate': True}
599
600
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
600
601
            .AndReturn([servers, False])
947
948
                                 "snapshot1").AndReturn(self.snapshots.first())
948
949
 
949
950
        api.glance.image_list_detailed(IsA(http.HttpRequest),
950
 
                                       marker=None).AndReturn([[], False])
 
951
                                       marker=None).AndReturn([[], False,
 
952
                                       False])
951
953
 
952
954
        self.mox.ReplayAll()
953
955
 
985
987
        api.nova.flavor_list(IsA(http.HttpRequest)) \
986
988
            .AndReturn(self.flavors.list())
987
989
        api.glance.image_list_detailed(IgnoreArg()) \
988
 
            .AndReturn((self.images.list(), False))
 
990
            .AndReturn((self.images.list(), False, False))
989
991
        search_opts = {'marker': None, 'paginate': True}
990
992
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
991
993
            .AndReturn([servers, False])
1173
1175
                                 block_device_mapping_v2=True,
1174
1176
                                 custom_flavor_sort=None,
1175
1177
                                 only_one_network=False,
1176
 
                                 disk_config=True):
 
1178
                                 disk_config=True,
 
1179
                                 test_with_profile=False):
1177
1180
        image = self.images.first()
1178
1181
 
1179
1182
        api.nova.extension_supported('BlockDeviceMappingV2Boot',
1186
1189
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1187
1190
                                       filters={'is_public': True,
1188
1191
                                                'status': 'active'}) \
1189
 
            .AndReturn([self.images.list(), False])
 
1192
            .AndReturn([self.images.list(), False, False])
1190
1193
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1191
1194
                            filters={'property-owner_id': self.tenant.id,
1192
1195
                                     'status': 'active'}) \
1193
 
                .AndReturn([[], False])
 
1196
                .AndReturn([[], False, False])
1194
1197
        api.neutron.network_list(IsA(http.HttpRequest),
1195
1198
                                 tenant_id=self.tenant.id,
1196
1199
                                 shared=False) \
1202
1205
            api.neutron.network_list(IsA(http.HttpRequest),
1203
1206
                                     shared=True) \
1204
1207
                .AndReturn(self.networks.list()[1:])
1205
 
        # TODO(absubram): Remove if clause and create separate
1206
 
        # test stubs for when profile_support is being used.
1207
 
        # Additionally ensure those are always run even in default setting
1208
 
        if api.neutron.is_port_profiles_supported():
 
1208
        if test_with_profile:
1209
1209
            policy_profiles = self.policy_profiles.list()
1210
1210
            api.neutron.profile_list(IsA(http.HttpRequest),
1211
1211
                                     'policy').AndReturn(policy_profiles)
1348
1348
    def test_launch_instance_get_with_only_one_network(self):
1349
1349
        self.test_launch_instance_get(only_one_network=True)
1350
1350
 
 
1351
    @test_utils.override_settings(
 
1352
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1353
    def test_launch_instance_get_with_profile(self):
 
1354
        self.test_launch_instance_get(test_with_profile=True)
 
1355
 
1351
1356
    @test.create_stubs({api.nova: ('extension_supported',
1352
1357
                                   'flavor_list',
1353
1358
                                   'keypair_list',
1362
1367
    def test_launch_instance_get_bootable_volumes(self,
1363
1368
                                 block_device_mapping_v2=True,
1364
1369
                                 only_one_network=False,
1365
 
                                 disk_config=True):
 
1370
                                 disk_config=True,
 
1371
                                 test_with_profile=False):
1366
1372
        api.nova.extension_supported('BlockDeviceMappingV2Boot',
1367
1373
                                     IsA(http.HttpRequest)) \
1368
1374
                .AndReturn(block_device_mapping_v2)
1373
1379
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1374
1380
                                       filters={'is_public': True,
1375
1381
                                                'status': 'active'}) \
1376
 
            .AndReturn([self.images.list(), False])
 
1382
            .AndReturn([self.images.list(), False, False])
1377
1383
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1378
1384
                            filters={'property-owner_id': self.tenant.id,
1379
1385
                                     'status': 'active'}) \
1380
 
                .AndReturn([[], False])
 
1386
                .AndReturn([[], False, False])
1381
1387
        api.neutron.network_list(IsA(http.HttpRequest),
1382
1388
                                 tenant_id=self.tenant.id,
1383
1389
                                 shared=False) \
1390
1396
                                     shared=True) \
1391
1397
                .AndReturn(self.networks.list()[1:])
1392
1398
 
1393
 
        if api.neutron.is_port_profiles_supported():
 
1399
        if test_with_profile:
1394
1400
            policy_profiles = self.policy_profiles.list()
1395
1401
            api.neutron.profile_list(IsA(http.HttpRequest),
1396
1402
                                     'policy').AndReturn(policy_profiles)
1431
1437
        for volume in bootable_volumes:
1432
1438
            self.assertTrue(volume in volume_sources_ids)
1433
1439
 
 
1440
    @test_utils.override_settings(
 
1441
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1442
    def test_launch_instance_get_bootable_volumes_with_profile(self):
 
1443
        self.test_launch_instance_get_bootable_volumes(test_with_profile=True)
 
1444
 
1434
1445
    @test.create_stubs({api.glance: ('image_list_detailed',),
1435
1446
                        api.neutron: ('network_list',
1436
1447
                                      'profile_list',
1445
1456
                                 'volume_snapshot_list',),
1446
1457
                        quotas: ('tenant_quota_usages',)})
1447
1458
    def test_launch_instance_post(self,
1448
 
                                  disk_config=True):
 
1459
                                  disk_config=True,
 
1460
                                  test_with_profile=False):
1449
1461
        flavor = self.flavors.first()
1450
1462
        image = self.images.first()
1451
1463
        keypair = self.keypairs.first()
1470
1482
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1471
1483
                                       filters={'is_public': True,
1472
1484
                                                'status': 'active'}) \
1473
 
                  .AndReturn([self.images.list(), False])
 
1485
                  .AndReturn([self.images.list(), False, False])
1474
1486
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1475
1487
                            filters={'property-owner_id': self.tenant.id,
1476
1488
                                     'status': 'active'}) \
1477
 
                  .AndReturn([[], False])
 
1489
                  .AndReturn([[], False, False])
1478
1490
        api.neutron.network_list(IsA(http.HttpRequest),
1479
1491
                                 tenant_id=self.tenant.id,
1480
1492
                                 shared=False) \
1482
1494
        api.neutron.network_list(IsA(http.HttpRequest),
1483
1495
                                 shared=True) \
1484
1496
                .AndReturn(self.networks.list()[1:])
1485
 
        # TODO(absubram): Remove if clause and create separate
1486
 
        # test stubs for when profile_support is being used.
1487
 
        # Additionally ensure those are always run even in default setting
1488
 
        if api.neutron.is_port_profiles_supported():
 
1497
        if test_with_profile:
1489
1498
            policy_profiles = self.policy_profiles.list()
1490
1499
            policy_profile_id = self.policy_profiles.first().id
1491
1500
            port = self.ports.first()
1494
1503
                'policy').AndReturn(policy_profiles)
1495
1504
            api.neutron.port_create(
1496
1505
                IsA(http.HttpRequest),
1497
 
                network_id=self.networks.first().id,
 
1506
                self.networks.first().id,
1498
1507
                policy_profile_id=policy_profile_id).AndReturn(port)
 
1508
            nics = [{"port-id": port.id}]
1499
1509
        api.nova.extension_supported('DiskConfig',
1500
1510
                                     IsA(http.HttpRequest)) \
1501
1511
                .AndReturn(disk_config)
1542
1552
                     'count': 1}
1543
1553
        if disk_config:
1544
1554
            form_data['disk_config'] = 'AUTO'
 
1555
        if test_with_profile:
 
1556
            form_data['profile'] = self.policy_profiles.first().id
1545
1557
        url = reverse('horizon:project:instances:launch')
1546
1558
        res = self.client.post(url, form_data)
1547
1559
 
1551
1563
    def test_launch_instance_post_no_disk_config_supported(self):
1552
1564
        self.test_launch_instance_post(disk_config=False)
1553
1565
 
 
1566
    @test_utils.override_settings(
 
1567
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1568
    def test_launch_instance_post_with_profile(self):
 
1569
        self.test_launch_instance_post(test_with_profile=True)
 
1570
 
1554
1571
    @test.create_stubs({api.glance: ('image_list_detailed',),
1555
1572
                        api.neutron: ('network_list',
1556
 
                                      'profile_list',),
 
1573
                                      'profile_list',
 
1574
                                      'port_create',),
1557
1575
                        api.nova: ('extension_supported',
1558
1576
                                   'flavor_list',
1559
1577
                                   'keypair_list',
1563
1581
                        cinder: ('volume_list',
1564
1582
                                 'volume_snapshot_list',),
1565
1583
                        quotas: ('tenant_quota_usages',)})
1566
 
    def test_launch_instance_post_boot_from_volume(self):
 
1584
    def test_launch_instance_post_boot_from_volume(self,
 
1585
                                                   test_with_profile=False):
1567
1586
        flavor = self.flavors.first()
1568
1587
        keypair = self.keypairs.first()
1569
1588
        server = self.servers.first()
1591
1610
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1592
1611
                                       filters={'is_public': True,
1593
1612
                                                'status': 'active'}) \
1594
 
                  .AndReturn([self.images.list(), False])
 
1613
                  .AndReturn([self.images.list(), False, False])
1595
1614
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1596
1615
                            filters={'property-owner_id': self.tenant.id,
1597
1616
                                     'status': 'active'}) \
1598
 
                  .AndReturn([[], False])
 
1617
                  .AndReturn([[], False, False])
1599
1618
        api.neutron.network_list(IsA(http.HttpRequest),
1600
1619
                                 tenant_id=self.tenant.id,
1601
1620
                                 shared=False) \
1603
1622
        api.neutron.network_list(IsA(http.HttpRequest),
1604
1623
                                 shared=True) \
1605
1624
                .AndReturn(self.networks.list()[1:])
1606
 
        # TODO(absubram): Remove if clause and create separate
1607
 
        # test stubs for when profile_support is being used.
1608
 
        # Additionally ensure those are always run even in default setting
1609
 
        if api.neutron.is_port_profiles_supported():
 
1625
        if test_with_profile:
1610
1626
            policy_profiles = self.policy_profiles.list()
1611
1627
            policy_profile_id = self.policy_profiles.first().id
1612
1628
            port = self.ports.first()
1615
1631
                'policy').AndReturn(policy_profiles)
1616
1632
            api.neutron.port_create(
1617
1633
                IsA(http.HttpRequest),
1618
 
                network_id=self.networks.first().id,
 
1634
                self.networks.first().id,
1619
1635
                policy_profile_id=policy_profile_id).AndReturn(port)
1620
1636
            nics = [{"port-id": port.id}]
1621
1637
        api.nova.extension_supported('DiskConfig',
1659
1675
                     'network': self.networks.first().id,
1660
1676
                     'count': 1,
1661
1677
                     'disk_config': 'AUTO'}
 
1678
        if test_with_profile:
 
1679
            form_data['profile'] = self.policy_profiles.first().id
1662
1680
        url = reverse('horizon:project:instances:launch')
1663
1681
        res = self.client.post(url, form_data)
1664
1682
 
1665
1683
        self.assertNoFormErrors(res)
1666
1684
        self.assertRedirectsNoFollow(res, INDEX_URL)
1667
1685
 
 
1686
    @test_utils.override_settings(
 
1687
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1688
    def test_launch_instance_post_boot_from_volume_with_profile(self):
 
1689
        self.test_launch_instance_post_boot_from_volume(test_with_profile=True)
 
1690
 
1668
1691
    @test.create_stubs({api.glance: ('image_list_detailed',),
1669
1692
                        api.neutron: ('network_list',
1670
1693
                                      'profile_list',
1679
1702
                        cinder: ('volume_list',
1680
1703
                                 'volume_snapshot_list',),
1681
1704
                        quotas: ('tenant_quota_usages',)})
1682
 
    def test_launch_instance_post_no_images_available_boot_from_volume(self):
 
1705
    def test_launch_instance_post_no_images_available_boot_from_volume(
 
1706
        self,
 
1707
        test_with_profile=False):
1683
1708
        flavor = self.flavors.first()
1684
1709
        keypair = self.keypairs.first()
1685
1710
        server = self.servers.first()
1707
1732
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1708
1733
                                       filters={'is_public': True,
1709
1734
                                                'status': 'active'}) \
1710
 
                  .AndReturn([self.images.list(), False])
 
1735
                  .AndReturn([self.images.list(), False, False])
1711
1736
 
1712
1737
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1713
1738
                            filters={'property-owner_id': self.tenant.id,
1714
1739
                                     'status': 'active'}) \
1715
 
                  .AndReturn([[], False])
 
1740
                  .AndReturn([[], False, False])
1716
1741
        api.neutron.network_list(IsA(http.HttpRequest),
1717
1742
                                 tenant_id=self.tenant.id,
1718
1743
                                 shared=False) \
1720
1745
        api.neutron.network_list(IsA(http.HttpRequest),
1721
1746
                                 shared=True) \
1722
1747
                .AndReturn(self.networks.list()[1:])
1723
 
        # TODO(absubram): Remove if clause and create separate
1724
 
        # test stubs for when profile_support is being used.
1725
 
        # Additionally ensure those are always run even in default setting
1726
 
        if api.neutron.is_port_profiles_supported():
 
1748
        if test_with_profile:
1727
1749
            policy_profiles = self.policy_profiles.list()
1728
1750
            policy_profile_id = self.policy_profiles.first().id
1729
1751
            port = self.ports.first()
1732
1754
                'policy').AndReturn(policy_profiles)
1733
1755
            api.neutron.port_create(
1734
1756
                IsA(http.HttpRequest),
1735
 
                network_id=self.networks.first().id,
 
1757
                self.networks.first().id,
1736
1758
                policy_profile_id=policy_profile_id).AndReturn(port)
1737
1759
            nics = [{"port-id": port.id}]
1738
1760
        api.nova.extension_supported('DiskConfig',
1777
1799
                     'device_name': device_name,
1778
1800
                     'count': 1,
1779
1801
                     'disk_config': 'MANUAL'}
 
1802
        if test_with_profile:
 
1803
            form_data['profile'] = self.policy_profiles.first().id
1780
1804
        url = reverse('horizon:project:instances:launch')
1781
1805
        res = self.client.post(url, form_data)
1782
1806
 
1783
1807
        self.assertNoFormErrors(res)
1784
1808
        self.assertRedirectsNoFollow(res, INDEX_URL)
1785
1809
 
 
1810
    @test_utils.override_settings(
 
1811
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1812
    def test_lnch_inst_post_no_images_avail_boot_from_vol_with_profile(self):
 
1813
        self.test_launch_instance_post_no_images_available_boot_from_volume(
 
1814
            test_with_profile=True)
 
1815
 
1786
1816
    @test.create_stubs({api.glance: ('image_list_detailed',),
1787
1817
                        api.neutron: ('network_list',
1788
1818
                                      'profile_list',),
1795
1825
                        cinder: ('volume_list',
1796
1826
                                 'volume_snapshot_list',),
1797
1827
                        quotas: ('tenant_quota_usages',)})
1798
 
    def test_launch_instance_post_no_images_available(self):
 
1828
    def test_launch_instance_post_no_images_available(self,
 
1829
                                                      test_with_profile=False):
1799
1830
        flavor = self.flavors.first()
1800
1831
        keypair = self.keypairs.first()
1801
1832
        server = self.servers.first()
1814
1845
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1815
1846
                                       filters={'is_public': True,
1816
1847
                                                'status': 'active'}) \
1817
 
                .AndReturn([[], False])
 
1848
                .AndReturn([[], False, False])
1818
1849
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1819
1850
                            filters={'property-owner_id': self.tenant.id,
1820
1851
                                     'status': 'active'}) \
1821
 
                .AndReturn([[], False])
 
1852
                .AndReturn([[], False, False])
1822
1853
        api.neutron.network_list(IsA(http.HttpRequest),
1823
1854
                                 tenant_id=self.tenant.id,
1824
1855
                                 shared=False) \
1826
1857
        api.neutron.network_list(IsA(http.HttpRequest),
1827
1858
                                 shared=True) \
1828
1859
                .AndReturn(self.networks.list()[1:])
1829
 
        # TODO(absubram): Remove if clause and create separate
1830
 
        # test stubs for when profile_support is being used.
1831
 
        # Additionally ensure those are always run even in default setting
1832
 
        if api.neutron.is_port_profiles_supported():
 
1860
        if test_with_profile:
1833
1861
            policy_profiles = self.policy_profiles.list()
1834
1862
            api.neutron.profile_list(IsA(http.HttpRequest),
1835
1863
                                     'policy').AndReturn(policy_profiles)
1870
1898
        self.assertFormErrors(res, 1, "You must select an image.")
1871
1899
        self.assertTemplateUsed(res, views.WorkflowView.template_name)
1872
1900
 
 
1901
    @test_utils.override_settings(
 
1902
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1903
    def test_launch_instance_post_no_images_available_with_profile(self):
 
1904
        self.test_launch_instance_post_no_images_available(
 
1905
            test_with_profile=True)
 
1906
 
1873
1907
    @test.create_stubs({api.glance: ('image_list_detailed',),
1874
1908
                        api.neutron: ('network_list',
1875
1909
                                      'profile_list',),
1881
1915
                                   'keypair_list',
1882
1916
                                   'tenant_absolute_limits',
1883
1917
                                   'availability_zone_list',)})
1884
 
    def test_launch_flavorlist_error(self):
 
1918
    def test_launch_flavorlist_error(self,
 
1919
                                     test_with_profile=False):
1885
1920
        api.nova.extension_supported('BlockDeviceMappingV2Boot',
1886
1921
                                     IsA(http.HttpRequest)) \
1887
1922
                .AndReturn(True)
1892
1927
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1893
1928
                                       filters={'is_public': True,
1894
1929
                                                'status': 'active'}) \
1895
 
                  .AndReturn([self.images.list(), False])
 
1930
                  .AndReturn([self.images.list(), False, False])
1896
1931
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1897
1932
                            filters={'property-owner_id': self.tenant.id,
1898
1933
                                     'status': 'active'}) \
1899
 
                  .AndReturn([[], False])
 
1934
                  .AndReturn([[], False, False])
1900
1935
        api.neutron.network_list(IsA(http.HttpRequest),
1901
1936
                                 tenant_id=self.tenant.id,
1902
1937
                                 shared=False) \
1904
1939
        api.neutron.network_list(IsA(http.HttpRequest),
1905
1940
                                 shared=True) \
1906
1941
                .AndReturn(self.networks.list()[1:])
1907
 
        # TODO(absubram): Remove if clause and create separate
1908
 
        # test stubs for when profile_support is being used.
1909
 
        # Additionally ensure those are always run even in default setting
1910
 
        if api.neutron.is_port_profiles_supported():
 
1942
        if test_with_profile:
1911
1943
            policy_profiles = self.policy_profiles.list()
1912
1944
            api.neutron.profile_list(IsA(http.HttpRequest),
1913
1945
                                     'policy').AndReturn(policy_profiles)
1934
1966
 
1935
1967
        self.assertTemplateUsed(res, views.WorkflowView.template_name)
1936
1968
 
 
1969
    @test_utils.override_settings(
 
1970
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
1971
    def test_launch_flavorlist_error_with_profile(self):
 
1972
        self.test_launch_flavorlist_error(test_with_profile=True)
 
1973
 
1937
1974
    @test.create_stubs({api.glance: ('image_list_detailed',),
1938
1975
                        api.neutron: ('network_list',
1939
1976
                                      'profile_list',
1947
1984
                        cinder: ('volume_list',
1948
1985
                                 'volume_snapshot_list',),
1949
1986
                        quotas: ('tenant_quota_usages',)})
1950
 
    def test_launch_form_keystone_exception(self):
 
1987
    def test_launch_form_keystone_exception(self,
 
1988
                                            test_with_profile=False):
1951
1989
        flavor = self.flavors.first()
1952
1990
        image = self.images.first()
1953
1991
        keypair = self.keypairs.first()
1972
2010
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1973
2011
                                       filters={'is_public': True,
1974
2012
                                                'status': 'active'}) \
1975
 
                  .AndReturn([self.images.list(), False])
 
2013
                  .AndReturn([self.images.list(), False, False])
1976
2014
        api.glance.image_list_detailed(IsA(http.HttpRequest),
1977
2015
                            filters={'property-owner_id': self.tenant.id,
1978
2016
                                     'status': 'active'}) \
1979
 
                  .AndReturn([[], False])
 
2017
                  .AndReturn([[], False, False])
1980
2018
        api.neutron.network_list(IsA(http.HttpRequest),
1981
2019
                                 tenant_id=self.tenant.id,
1982
2020
                                 shared=False) \
1984
2022
        api.neutron.network_list(IsA(http.HttpRequest),
1985
2023
                                 shared=True) \
1986
2024
                .AndReturn(self.networks.list()[1:])
1987
 
        # TODO(absubram): Remove if clause and create separate
1988
 
        # test stubs for when profile_support is being used.
1989
 
        # Additionally ensure those are always run even in default setting
1990
 
        if api.neutron.is_port_profiles_supported():
 
2025
        if test_with_profile:
1991
2026
            policy_profiles = self.policy_profiles.list()
1992
2027
            policy_profile_id = self.policy_profiles.first().id
1993
2028
            port = self.ports.first()
1996
2031
                'policy').AndReturn(policy_profiles)
1997
2032
            api.neutron.port_create(
1998
2033
                IsA(http.HttpRequest),
1999
 
                network_id=self.networks.first().id,
 
2034
                self.networks.first().id,
2000
2035
                policy_profile_id=policy_profile_id).AndReturn(port)
2001
2036
            nics = [{"port-id": port.id}]
2002
2037
        api.nova.extension_supported('DiskConfig',
2043
2078
                     'admin_pass': 'password',
2044
2079
                     'confirm_admin_pass': 'password',
2045
2080
                     'disk_config': 'AUTO'}
 
2081
        if test_with_profile:
 
2082
            form_data['profile'] = self.policy_profiles.first().id
2046
2083
        url = reverse('horizon:project:instances:launch')
2047
2084
        res = self.client.post(url, form_data)
2048
2085
 
2049
2086
        self.assertRedirectsNoFollow(res, INDEX_URL)
2050
2087
 
 
2088
    @test_utils.override_settings(
 
2089
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2090
    def test_launch_form_keystone_exception_with_profile(self):
 
2091
        self.test_launch_form_keystone_exception(test_with_profile=True)
 
2092
 
2051
2093
    @test.create_stubs({api.glance: ('image_list_detailed',),
2052
2094
                        api.neutron: ('network_list',
2053
2095
                                      'profile_list',),
2060
2102
                        cinder: ('volume_list',
2061
2103
                                 'volume_snapshot_list',),
2062
2104
                        quotas: ('tenant_quota_usages',)})
2063
 
    def test_launch_form_instance_count_error(self):
 
2105
    def test_launch_form_instance_count_error(self,
 
2106
                                              test_with_profile=False):
2064
2107
        flavor = self.flavors.first()
2065
2108
        image = self.images.first()
2066
2109
        keypair = self.keypairs.first()
2087
2130
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2088
2131
                                       filters={'is_public': True,
2089
2132
                                                'status': 'active'}) \
2090
 
                  .AndReturn([self.images.list(), False])
 
2133
                  .AndReturn([self.images.list(), False, False])
2091
2134
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2092
2135
                            filters={'property-owner_id': self.tenant.id,
2093
2136
                                     'status': 'active'}) \
2094
 
                  .AndReturn([[], False])
 
2137
                  .AndReturn([[], False, False])
2095
2138
        api.neutron.network_list(IsA(http.HttpRequest),
2096
2139
                                 tenant_id=self.tenant.id,
2097
2140
                                 shared=False) \
2099
2142
        api.neutron.network_list(IsA(http.HttpRequest),
2100
2143
                                 shared=True) \
2101
2144
                .AndReturn(self.networks.list()[1:])
2102
 
        # TODO(absubram): Remove if clause and create separate
2103
 
        # test stubs for when profile_support is being used.
2104
 
        # Additionally ensure those are always run even in default setting
2105
 
        if api.neutron.is_port_profiles_supported():
 
2145
        if test_with_profile:
2106
2146
            policy_profiles = self.policy_profiles.list()
2107
2147
            api.neutron.profile_list(IsA(http.HttpRequest),
2108
2148
                                     'policy').AndReturn(policy_profiles)
2143
2183
 
2144
2184
        self.assertContains(res, "greater than or equal to 1")
2145
2185
 
 
2186
    @test_utils.override_settings(
 
2187
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2188
    def test_launch_form_instance_count_error_with_profile(self):
 
2189
        self.test_launch_form_instance_count_error(test_with_profile=True)
 
2190
 
2146
2191
    @test.create_stubs({api.glance: ('image_list_detailed',),
2147
2192
                        api.neutron: ('network_list',
2148
2193
                                      'profile_list',),
2155
2200
                        cinder: ('volume_list',
2156
2201
                                 'volume_snapshot_list',),
2157
2202
                        quotas: ('tenant_quota_usages',)})
2158
 
    def _test_launch_form_instance_requirement_error(self, image, flavor):
 
2203
    def _test_launch_form_instance_requirement_error(self, image, flavor,
 
2204
                                                     test_with_profile=False):
2159
2205
        keypair = self.keypairs.first()
2160
2206
        server = self.servers.first()
2161
2207
        volume = self.volumes.first()
2180
2226
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2181
2227
                                       filters={'is_public': True,
2182
2228
                                                'status': 'active'}) \
2183
 
                  .AndReturn([self.images.list(), False])
 
2229
                  .AndReturn([self.images.list(), False, False])
2184
2230
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2185
2231
                            filters={'property-owner_id': self.tenant.id,
2186
2232
                                     'status': 'active'}) \
2187
 
                  .AndReturn([[], False])
 
2233
                  .AndReturn([[], False, False])
2188
2234
        api.neutron.network_list(IsA(http.HttpRequest),
2189
2235
                                 tenant_id=self.tenant.id,
2190
2236
                                 shared=False) \
2192
2238
        api.neutron.network_list(IsA(http.HttpRequest),
2193
2239
                                 shared=True) \
2194
2240
                .AndReturn(self.networks.list()[1:])
2195
 
        # TODO(absubram): Remove if clause and create separate
2196
 
        # test stubs for when profile_support is being used.
2197
 
        # Additionally ensure those are always run even in default setting
2198
 
        if api.neutron.is_port_profiles_supported():
 
2241
        if test_with_profile:
2199
2242
            policy_profiles = self.policy_profiles.list()
2200
2243
            api.neutron.profile_list(IsA(http.HttpRequest),
2201
2244
                                     'policy').AndReturn(policy_profiles)
2237
2280
        msg = "The flavor '%s' is too small" % flavor.name
2238
2281
        self.assertContains(res, msg)
2239
2282
 
2240
 
    def test_launch_form_instance_requirement_error_disk(self):
 
2283
    def test_launch_form_instance_requirement_error_disk(
 
2284
        self,
 
2285
        test_with_profile=False):
2241
2286
        flavor = self.flavors.first()
2242
2287
        image = self.images.first()
2243
2288
        image.min_ram = flavor.ram
2244
2289
        image.min_disk = flavor.disk + 1
2245
 
        self._test_launch_form_instance_requirement_error(image, flavor)
 
2290
        self._test_launch_form_instance_requirement_error(image, flavor,
 
2291
                                                          test_with_profile)
2246
2292
 
2247
 
    def test_launch_form_instance_requirement_error_ram(self):
 
2293
    def test_launch_form_instance_requirement_error_ram(
 
2294
        self,
 
2295
        test_with_profile=False):
2248
2296
        flavor = self.flavors.first()
2249
2297
        image = self.images.first()
2250
2298
        image.min_ram = flavor.ram + 1
2251
2299
        image.min_disk = flavor.disk
2252
 
        self._test_launch_form_instance_requirement_error(image, flavor)
 
2300
        self._test_launch_form_instance_requirement_error(image, flavor,
 
2301
                                                          test_with_profile)
 
2302
 
 
2303
    @test_utils.override_settings(
 
2304
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2305
    def test_launch_form_instance_requirement_error_disk_with_profile(self):
 
2306
        self.test_launch_form_instance_requirement_error_disk(
 
2307
            test_with_profile=True)
 
2308
 
 
2309
    @test_utils.override_settings(
 
2310
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2311
    def test_launch_form_instance_requirement_error_ram_with_profile(self):
 
2312
        self.test_launch_form_instance_requirement_error_ram(
 
2313
            test_with_profile=True)
2253
2314
 
2254
2315
    @test.create_stubs({api.glance: ('image_list_detailed',),
2255
2316
                        api.neutron: ('network_list',
2263
2324
                        cinder: ('volume_list',
2264
2325
                                 'volume_snapshot_list',),
2265
2326
                        quotas: ('tenant_quota_usages',)})
2266
 
    def _test_launch_form_instance_volume_size(self, image, volume_size, msg):
 
2327
    def _test_launch_form_instance_volume_size(self, image, volume_size, msg,
 
2328
                                               test_with_profile=False):
2267
2329
        flavor = self.flavors.get(name='m1.massive')
2268
2330
        keypair = self.keypairs.first()
2269
2331
        server = self.servers.first()
2287
2349
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2288
2350
                                       filters={'is_public': True,
2289
2351
                                                'status': 'active'}) \
2290
 
                  .AndReturn([self.images.list(), False])
 
2352
                  .AndReturn([self.images.list(), False, False])
2291
2353
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2292
2354
                            filters={'property-owner_id': self.tenant.id,
2293
2355
                                     'status': 'active'}) \
2294
 
                  .AndReturn([[], False])
 
2356
                  .AndReturn([[], False, False])
2295
2357
        api.neutron.network_list(IsA(http.HttpRequest),
2296
2358
                                 tenant_id=self.tenant.id,
2297
2359
                                 shared=False) \
2299
2361
        api.neutron.network_list(IsA(http.HttpRequest),
2300
2362
                                 shared=True) \
2301
2363
                .AndReturn(self.networks.list()[1:])
2302
 
        # TODO(absubram): Remove if clause and create separate
2303
 
        # test stubs for when profile_support is being used.
2304
 
        # Additionally ensure those are always run even in default setting
2305
 
        if api.neutron.is_port_profiles_supported():
 
2364
        if test_with_profile:
2306
2365
            policy_profiles = self.policy_profiles.list()
2307
2366
            api.neutron.profile_list(IsA(http.HttpRequest),
2308
2367
                                     'policy').AndReturn(policy_profiles)
2344
2403
        res = self.client.post(url, form_data)
2345
2404
        self.assertContains(res, msg)
2346
2405
 
2347
 
    def test_launch_form_instance_volume_size_error(self):
 
2406
    def test_launch_form_instance_volume_size_error(self,
 
2407
                                                    test_with_profile=False):
2348
2408
        image = self.images.get(name='protected_images')
2349
2409
        volume_size = image.min_disk / 2
2350
2410
        msg = ("The Volume size is too small for the '%s' image" %
2351
2411
               image.name)
2352
 
        self._test_launch_form_instance_volume_size(image, volume_size, msg)
 
2412
        self._test_launch_form_instance_volume_size(image, volume_size, msg,
 
2413
                                                    test_with_profile)
2353
2414
 
2354
 
    def test_launch_form_instance_non_int_volume_size(self):
 
2415
    def test_launch_form_instance_non_int_volume_size(self,
 
2416
                                                      test_with_profile=False):
2355
2417
        image = self.images.get(name='protected_images')
2356
2418
        msg = "Enter a whole number."
2357
 
        self._test_launch_form_instance_volume_size(image, 1.5, msg)
 
2419
        self._test_launch_form_instance_volume_size(image, 1.5, msg,
 
2420
                                                    test_with_profile)
 
2421
 
 
2422
    @test_utils.override_settings(
 
2423
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2424
    def test_launch_form_instance_volume_size_error_with_profile(self):
 
2425
        self.test_launch_form_instance_volume_size_error(
 
2426
            test_with_profile=True)
 
2427
 
 
2428
    @test_utils.override_settings(
 
2429
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2430
    def test_launch_form_instance_non_int_volume_size_with_profile(self):
 
2431
        self.test_launch_form_instance_non_int_volume_size(
 
2432
            test_with_profile=True)
2358
2433
 
2359
2434
    @test.create_stubs({api.nova: ('flavor_list', 'server_list',
2360
2435
                                   'tenant_absolute_limits',
2375
2450
        api.nova.flavor_list(IsA(http.HttpRequest)) \
2376
2451
            .AndReturn(self.flavors.list())
2377
2452
        api.glance.image_list_detailed(IgnoreArg()) \
2378
 
            .AndReturn((self.images.list(), False))
 
2453
            .AndReturn((self.images.list(), False, False))
2379
2454
        search_opts = {'marker': None, 'paginate': True}
2380
2455
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
2381
2456
            .AndReturn([servers, False])
2392
2467
        classes = list(launch.get_default_classes()) + list(launch.classes)
2393
2468
        link_name = "%s (%s)" % (unicode(launch.verbose_name),
2394
2469
                                 "Quota exceeded")
2395
 
        expected_string = "<a href='%s' id='instances__action_launch' " \
2396
 
            "title='%s' class='%s disabled' data-update-url=" \
2397
 
            "'/project/instances/?action=launch&amp;table=instances'>%s</a>" \
2398
 
            % (url, link_name, " ".join(classes), link_name)
2399
2470
 
2400
2471
        res = self.client.get(INDEX_URL)
 
2472
        expected_string = encoding.smart_str(u'''
 
2473
            <a href="%s" id="instances__action_launch" title="%s"
 
2474
            class="%s disabled"
 
2475
            data-update-url =
 
2476
            "/project/instances/?action=launch&amp;table=instances">%s</a>
 
2477
            ''' % (url, link_name, " ".join(classes), link_name), res._charset)
 
2478
 
2401
2479
        self.assertContains(res, expected_string, html=True,
2402
2480
                            msg_prefix="The launch button is not disabled")
2403
2481
 
2419
2497
        api.nova.flavor_list(IsA(http.HttpRequest)) \
2420
2498
            .AndReturn(self.flavors.list())
2421
2499
        api.glance.image_list_detailed(IgnoreArg()) \
2422
 
            .AndReturn((self.images.list(), False))
 
2500
            .AndReturn((self.images.list(), False, False))
2423
2501
        search_opts = {'marker': None, 'paginate': True}
2424
2502
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
2425
2503
            .AndReturn([servers, False])
2446
2524
                        api.neutron: ('network_list',
2447
2525
                                      'profile_list'),
2448
2526
                        api.glance: ('image_list_detailed',)})
2449
 
    def test_select_default_keypair_if_only_one(self):
 
2527
    def test_select_default_keypair_if_only_one(self,
 
2528
                                                test_with_profile=False):
2450
2529
        keypair = self.keypairs.first()
2451
2530
 
2452
2531
        cinder.volume_list(IsA(http.HttpRequest)) \
2456
2535
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2457
2536
                                       filters={'is_public': True,
2458
2537
                                                'status': 'active'}) \
2459
 
            .AndReturn([self.images.list(), False])
 
2538
            .AndReturn([self.images.list(), False, False])
2460
2539
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2461
2540
                            filters={'property-owner_id': self.tenant.id,
2462
2541
                                     'status': 'active'}) \
2463
 
                .AndReturn([[], False])
 
2542
                .AndReturn([[], False, False])
2464
2543
        api.neutron.network_list(IsA(http.HttpRequest),
2465
2544
                                 tenant_id=self.tenant.id,
2466
2545
                                 shared=False) \
2468
2547
        api.neutron.network_list(IsA(http.HttpRequest),
2469
2548
                                 shared=True) \
2470
2549
                .AndReturn(self.networks.list()[1:])
2471
 
        # TODO(absubram): Remove if clause and create separate
2472
 
        # test stubs for when profile_support is being used.
2473
 
        # Additionally ensure those are always run even in default setting
2474
 
        if api.neutron.is_port_profiles_supported():
 
2550
        if test_with_profile:
2475
2551
            policy_profiles = self.policy_profiles.list()
2476
2552
            api.neutron.profile_list(IsA(http.HttpRequest),
2477
2553
                                     'policy').AndReturn(policy_profiles)
2504
2580
            html=True,
2505
2581
            msg_prefix="The default key pair was not selected.")
2506
2582
 
 
2583
    @test_utils.override_settings(
 
2584
        OPENSTACK_NEUTRON_NETWORK={'profile_support': 'cisco'})
 
2585
    def test_select_default_keypair_if_only_one_with_profile(self):
 
2586
        self.test_select_default_keypair_if_only_one(test_with_profile=True)
 
2587
 
2507
2588
    @test.create_stubs({api.network: ('floating_ip_target_get_by_instance',
2508
2589
                                      'tenant_floating_ip_allocate',
2509
2590
                                      'floating_ip_associate',
2522
2603
        api.network.servers_update_addresses(IsA(http.HttpRequest), servers)
2523
2604
        api.nova.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
2524
2605
        api.glance.image_list_detailed(IgnoreArg()) \
2525
 
            .AndReturn((self.images.list(), False))
 
2606
            .AndReturn((self.images.list(), False, False))
2526
2607
        api.network.floating_ip_target_get_by_instance(
2527
2608
            IsA(http.HttpRequest),
2528
2609
            server.id).AndReturn(server.id)
2557
2638
        api.network.servers_update_addresses(IsA(http.HttpRequest), servers)
2558
2639
        api.nova.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
2559
2640
        api.glance.image_list_detailed(IgnoreArg()) \
2560
 
            .AndReturn((self.images.list(), False))
 
2641
            .AndReturn((self.images.list(), False, False))
2561
2642
        api.network.floating_ip_target_list_by_instance(
2562
2643
            IsA(http.HttpRequest),
2563
2644
            server.id).AndReturn([server.id, ])
2694
2775
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2695
2776
                                       filters={'is_public': True,
2696
2777
                                                'status': 'active'}) \
2697
 
            .AndReturn([self.images.list(), False])
 
2778
            .AndReturn([self.images.list(), False, False])
2698
2779
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2699
2780
                            filters={'property-owner_id': self.tenant.id,
2700
2781
                                     'status': 'active'}) \
2701
 
            .AndReturn([[], False])
 
2782
            .AndReturn([[], False, False])
2702
2783
        api.nova.extension_supported('DiskConfig',
2703
2784
                                     IsA(http.HttpRequest)) \
2704
2785
            .AndReturn(True)
2749
2830
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2750
2831
                                       filters={'is_public': True,
2751
2832
                                                'status': 'active'}) \
2752
 
            .AndReturn([self.images.list(), False])
 
2833
            .AndReturn([self.images.list(), False, False])
2753
2834
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2754
2835
                            filters={'property-owner_id': self.tenant.id,
2755
2836
                                     'status': 'active'}) \
2756
 
            .AndReturn([[], False])
 
2837
            .AndReturn([[], False, False])
2757
2838
        api.nova.extension_supported('DiskConfig',
2758
2839
                                     IsA(http.HttpRequest)) \
2759
2840
            .AndReturn(True)
2780
2861
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2781
2862
                                       filters={'is_public': True,
2782
2863
                                                'status': 'active'}) \
2783
 
            .AndReturn([self.images.list(), False])
 
2864
            .AndReturn([self.images.list(), False, False])
2784
2865
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2785
2866
                            filters={'property-owner_id': self.tenant.id,
2786
2867
                                     'status': 'active'}) \
2787
 
            .AndReturn([[], False])
 
2868
            .AndReturn([[], False, False])
2788
2869
        api.nova.extension_supported('DiskConfig',
2789
2870
                                     IsA(http.HttpRequest)) \
2790
2871
            .AndReturn(True)
2813
2894
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2814
2895
                                       filters={'is_public': True,
2815
2896
                                                'status': 'active'}) \
2816
 
            .AndReturn([self.images.list(), False])
 
2897
            .AndReturn([self.images.list(), False, False])
2817
2898
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2818
2899
                            filters={'property-owner_id': self.tenant.id,
2819
2900
                                     'status': 'active'}) \
2820
 
            .AndReturn([[], False])
 
2901
            .AndReturn([[], False, False])
2821
2902
        api.nova.extension_supported('DiskConfig',
2822
2903
                                     IsA(http.HttpRequest)) \
2823
2904
                .AndReturn(True)
2838
2919
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2839
2920
                                       filters={'is_public': True,
2840
2921
                                                'status': 'active'}) \
2841
 
            .AndReturn([self.images.list(), False])
 
2922
            .AndReturn([self.images.list(), False, False])
2842
2923
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2843
2924
                            filters={'property-owner_id': self.tenant.id,
2844
2925
                                     'status': 'active'}) \
2845
 
            .AndReturn([[], False])
 
2926
            .AndReturn([[], False, False])
2846
2927
        api.nova.extension_supported('DiskConfig',
2847
2928
                                     IsA(http.HttpRequest)) \
2848
2929
                .AndReturn(True)
2870
2951
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2871
2952
                                       filters={'is_public': True,
2872
2953
                                                'status': 'active'}) \
2873
 
            .AndReturn([self.images.list(), False])
 
2954
            .AndReturn([self.images.list(), False, False])
2874
2955
        api.glance.image_list_detailed(IsA(http.HttpRequest),
2875
2956
                            filters={'property-owner_id': self.tenant.id,
2876
2957
                                     'status': 'active'}) \
2877
 
            .AndReturn([[], False])
 
2958
            .AndReturn([[], False, False])
2878
2959
        api.nova.extension_supported('DiskConfig',
2879
2960
                                     IsA(http.HttpRequest)) \
2880
2961
                .AndReturn(True)
2916
2997
        api.nova.flavor_list(IsA(http.HttpRequest)) \
2917
2998
            .MultipleTimes().AndReturn(self.flavors.list())
2918
2999
        api.glance.image_list_detailed(IgnoreArg()) \
2919
 
            .MultipleTimes().AndReturn((self.images.list(), False))
 
3000
            .MultipleTimes().AndReturn((self.images.list(), False, False))
2920
3001
 
2921
3002
        search_opts = {'marker': None, 'paginate': True}
2922
3003
        api.nova.server_list(IsA(http.HttpRequest), search_opts=search_opts) \
2974
3055
                                             servers[page_size:])
2975
3056
        api.nova.flavor_list(IgnoreArg()).AndReturn(self.flavors.list())
2976
3057
        api.glance.image_list_detailed(IgnoreArg()) \
2977
 
            .AndReturn((self.images.list(), False))
 
3058
            .AndReturn((self.images.list(), False, False))
2978
3059
        api.nova.server_delete(IsA(http.HttpRequest), server.id)
2979
3060
        self.mox.ReplayAll()
2980
3061