← Back to branch summary

~ubuntu-branches/ubuntu/saucy/horizon/saucy-updates

« back to all changes in this revision

Viewing changes to openstack_dashboard/test/test_data/nova_data.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/test/test_data/nova_data.py
15
15
import json
16
16
import uuid
17
17
 
 
18
from novaclient.v1_1 import aggregates
18
19
from novaclient.v1_1 import availability_zones
19
20
from novaclient.v1_1 import certs
 
21
from novaclient.v1_1 import flavor_access
20
22
from novaclient.v1_1 import flavors
21
23
from novaclient.v1_1 import floating_ips
22
24
from novaclient.v1_1 import hypervisors
25
27
from novaclient.v1_1 import security_group_rules as rules
26
28
from novaclient.v1_1 import security_groups as sec_groups
27
29
from novaclient.v1_1 import servers
 
30
from novaclient.v1_1 import services
28
31
from novaclient.v1_1 import usage
29
32
from novaclient.v1_1 import volume_snapshots as vol_snaps
30
33
from novaclient.v1_1 import volume_types
31
34
from novaclient.v1_1 import volumes
32
35
 
33
 
from openstack_dashboard.api.base import Quota
34
 
from openstack_dashboard.api.base import QuotaSet as QuotaSetWrapper
35
 
from openstack_dashboard.api.nova import FloatingIp as NetFloatingIp
36
 
from openstack_dashboard.usage.quotas import QuotaUsage
 
36
from openstack_dashboard.api import base
 
37
from openstack_dashboard.api import nova
 
38
from openstack_dashboard.usage import quotas as usage_quotas
37
39
 
38
 
from openstack_dashboard.test.test_data.utils import TestDataContainer
 
40
from openstack_dashboard.test.test_data import utils
39
41
 
40
42
 
41
43
SERVER_DATA = """
146
148
 
147
149
 
148
150
def data(TEST):
149
 
    TEST.servers = TestDataContainer()
150
 
    TEST.flavors = TestDataContainer()
151
 
    TEST.keypairs = TestDataContainer()
152
 
    TEST.security_groups = TestDataContainer()
153
 
    TEST.security_groups_uuid = TestDataContainer()
154
 
    TEST.security_group_rules = TestDataContainer()
155
 
    TEST.security_group_rules_uuid = TestDataContainer()
156
 
    TEST.volumes = TestDataContainer()
157
 
    TEST.quotas = TestDataContainer()
158
 
    TEST.quota_usages = TestDataContainer()
159
 
    TEST.floating_ips = TestDataContainer()
160
 
    TEST.floating_ips_uuid = TestDataContainer()
161
 
    TEST.usages = TestDataContainer()
162
 
    TEST.certs = TestDataContainer()
163
 
    TEST.volume_snapshots = TestDataContainer()
164
 
    TEST.volume_types = TestDataContainer()
165
 
    TEST.availability_zones = TestDataContainer()
166
 
    TEST.hypervisors = TestDataContainer()
 
151
    TEST.servers = utils.TestDataContainer()
 
152
    TEST.flavors = utils.TestDataContainer()
 
153
    TEST.flavor_access = utils.TestDataContainer()
 
154
    TEST.keypairs = utils.TestDataContainer()
 
155
    TEST.security_groups = utils.TestDataContainer()
 
156
    TEST.security_groups_uuid = utils.TestDataContainer()
 
157
    TEST.security_group_rules = utils.TestDataContainer()
 
158
    TEST.security_group_rules_uuid = utils.TestDataContainer()
 
159
    TEST.volumes = utils.TestDataContainer()
 
160
    TEST.quotas = utils.TestDataContainer()
 
161
    TEST.quota_usages = utils.TestDataContainer()
 
162
    TEST.floating_ips = utils.TestDataContainer()
 
163
    TEST.floating_ips_uuid = utils.TestDataContainer()
 
164
    TEST.usages = utils.TestDataContainer()
 
165
    TEST.certs = utils.TestDataContainer()
 
166
    TEST.volume_snapshots = utils.TestDataContainer()
 
167
    TEST.volume_types = utils.TestDataContainer()
 
168
    TEST.availability_zones = utils.TestDataContainer()
 
169
    TEST.hypervisors = utils.TestDataContainer()
 
170
    TEST.services = utils.TestDataContainer()
 
171
    TEST.aggregates = utils.TestDataContainer()
167
172
 
168
173
    # Data return by novaclient.
169
174
    # It is used if API layer does data conversion.
170
 
    TEST.api_floating_ips = TestDataContainer()
171
 
    TEST.api_floating_ips_uuid = TestDataContainer()
 
175
    TEST.api_floating_ips = utils.TestDataContainer()
 
176
    TEST.api_floating_ips_uuid = utils.TestDataContainer()
172
177
 
173
178
    # Volumes
174
179
    volume = volumes.Volume(volumes.VolumeManager(None),
225
230
                               'ram': 512,
226
231
                               'swap': 0,
227
232
                               'extra_specs': {},
 
233
                               'os-flavor-access:is_public': True,
228
234
                               'OS-FLV-EXT-DATA:ephemeral': 0})
229
235
    flavor_2 = flavors.Flavor(flavors.FlavorManager(None),
230
236
                              {'id': "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb",
234
240
                               'ram': 10000,
235
241
                               'swap': 0,
236
242
                               'extra_specs': {'Trusted': True, 'foo': 'bar'},
237
 
                               'OS-FLV-EXT-DATA:ephemeral': 2048})
238
 
    TEST.flavors.add(flavor_1, flavor_2)
 
243
                               'os-flavor-access:is_public': True,
 
244
                               'OS-FLV-EXT-DATA:ephemeral': 2048})
 
245
    flavor_3 = flavors.Flavor(flavors.FlavorManager(None),
 
246
                              {'id': "dddddddd-dddd-dddd-dddd-dddddddddddd",
 
247
                               'name': 'm1.secret',
 
248
                               'vcpus': 1000,
 
249
                               'disk': 1024,
 
250
                               'ram': 10000,
 
251
                               'swap': 0,
 
252
                               'extra_specs': {},
 
253
                               'os-flavor-access:is_public': False,
 
254
                               'OS-FLV-EXT-DATA:ephemeral': 2048})
 
255
    TEST.flavors.add(flavor_1, flavor_2, flavor_3)
 
256
 
 
257
    flavor_access_manager = flavor_access.FlavorAccessManager(None)
 
258
    flavor_access_1 = flavor_access.FlavorAccess(flavor_access_manager,
 
259
            {"tenant_id": "1",
 
260
             "flavor_id": "dddddddd-dddd-dddd-dddd-dddddddddddd"})
 
261
    flavor_access_2 = flavor_access.FlavorAccess(flavor_access_manager,
 
262
            {"tenant_id": "2",
 
263
             "flavor_id": "dddddddd-dddd-dddd-dddd-dddddddddddd"})
 
264
    TEST.flavor_access.add(flavor_access_1, flavor_access_2)
239
265
 
240
266
    # Keypairs
241
267
    keypair = keypairs.Keypair(keypairs.KeypairManager(None),
333
359
                      security_groups='10',
334
360
                      security_group_rules='20')
335
361
    quota = quotas.QuotaSet(quotas.QuotaSetManager(None), quota_data)
336
 
    TEST.quotas.nova = QuotaSetWrapper(quota)
337
 
    TEST.quotas.add(QuotaSetWrapper(quota))
 
362
    TEST.quotas.nova = base.QuotaSet(quota)
 
363
    TEST.quotas.add(base.QuotaSet(quota))
338
364
 
339
365
    # Quota Usages
340
366
    quota_usage_data = {'gigabytes': {'used': 0,
344
370
                        'ram': {'used': 0,
345
371
                                'quota': 10000},
346
372
                        'cores': {'used': 0,
347
 
                                  'quota': 20}}
348
 
    quota_usage = QuotaUsage()
 
373
                                  'quota': 20},
 
374
                        'floating_ips': {'used': 0,
 
375
                                         'quota': 10},
 
376
                        'volumes': {'used': 0,
 
377
                                    'quota': 10}}
 
378
    quota_usage = usage_quotas.QuotaUsage()
349
379
    for k, v in quota_usage_data.items():
350
 
        quota_usage.add_quota(Quota(k, v['quota']))
 
380
        quota_usage.add_quota(base.Quota(k, v['quota']))
351
381
        quota_usage.tally(k, v['used'])
352
382
 
353
383
    TEST.quota_usages.add(quota_usage)
424
454
             'pool': 'pool2'}
425
455
    TEST.api_floating_ips.add(generate_fip(fip_1), generate_fip(fip_2))
426
456
 
427
 
    TEST.floating_ips.add(NetFloatingIp(generate_fip(fip_1)),
428
 
                          NetFloatingIp(generate_fip(fip_2)))
 
457
    TEST.floating_ips.add(nova.FloatingIp(generate_fip(fip_1)),
 
458
                          nova.FloatingIp(generate_fip(fip_2)))
429
459
 
430
460
    # Floating IP with UUID id (for Floating IP with Neutron Proxy)
431
461
    fip_3 = {'id': str(uuid.uuid4()),
440
470
             'pool': 'pool2'}
441
471
    TEST.api_floating_ips_uuid.add(generate_fip(fip_3), generate_fip(fip_4))
442
472
 
443
 
    TEST.floating_ips_uuid.add(NetFloatingIp(generate_fip(fip_3)),
444
 
                               NetFloatingIp(generate_fip(fip_4)))
 
473
    TEST.floating_ips_uuid.add(nova.FloatingIp(generate_fip(fip_3)),
 
474
                               nova.FloatingIp(generate_fip(fip_4)))
445
475
 
446
476
    # Usage
447
477
    usage_vals = {"tenant_id": TEST.tenant.id,
482
512
    TEST.availability_zones.add(
483
513
        availability_zones.AvailabilityZone(
484
514
            availability_zones.AvailabilityZoneManager(None),
485
 
            {'zoneName': 'nova', 'zoneState': {'available': True}}
 
515
            {
 
516
                'zoneName': 'nova',
 
517
                'zoneState': {'available': True},
 
518
                'hosts': {
 
519
                    "host001": {
 
520
                        "nova-network": {
 
521
                            "active": True,
 
522
                            "available": True
 
523
                        }
 
524
                    }
 
525
                }
 
526
            }
486
527
        )
487
528
    )
488
529
 
512
553
        }
513
554
    )
514
555
    TEST.hypervisors.add(hypervisor_1)
 
556
 
 
557
    TEST.hypervisors.stats = {
 
558
        "hypervisor_statistics": {
 
559
            "count": 5,
 
560
            "vcpus_used": 3,
 
561
            "local_gb_used": 15,
 
562
            "memory_mb": 483310,
 
563
            "current_workload": 0,
 
564
            "vcpus": 160,
 
565
            "running_vms": 3,
 
566
            "free_disk_gb": 12548,
 
567
            "disk_available_least": 12556,
 
568
            "local_gb": 12563,
 
569
            "free_ram_mb": 428014,
 
570
            "memory_mb_used": 55296
 
571
        }
 
572
    }
 
573
 
 
574
    # Services
 
575
    service_1 = services.Service(services.ServiceManager(None),
 
576
        {
 
577
            "status": "enabled",
 
578
            "binary": "nova-conductor",
 
579
            "zone": "internal",
 
580
            "state": "up",
 
581
            "updated_at": "2013-07-08T05:21:00.000000",
 
582
            "host": "devstack001",
 
583
            "disabled_reason": None
 
584
        }
 
585
    )
 
586
 
 
587
    service_2 = services.Service(services.ServiceManager(None),
 
588
        {
 
589
            "status": "enabled",
 
590
            "binary": "nova-compute",
 
591
            "zone": "nova",
 
592
            "state": "up",
 
593
            "updated_at": "2013-07-08T05:20:51.000000",
 
594
            "host": "devstack001",
 
595
            "disabled_reason": None
 
596
        }
 
597
    )
 
598
    TEST.services.add(service_1)
 
599
    TEST.services.add(service_2)
 
600
 
 
601
    # Aggregates
 
602
    aggregate_1 = aggregates.Aggregate(aggregates.AggregateManager(None),
 
603
        {
 
604
            "name": "foo",
 
605
            "availability_zone": None,
 
606
            "deleted": 0,
 
607
            "created_at": "2013-07-04T13:34:38.000000",
 
608
            "updated_at": None,
 
609
            "hosts": ["foo", "bar"],
 
610
            "deleted_at": None,
 
611
            "id": 1,
 
612
            "metadata": {
 
613
                "foo": "testing",
 
614
                "bar": "testing"
 
615
            }
 
616
        }
 
617
    )
 
618
 
 
619
    aggregate_2 = aggregates.Aggregate(aggregates.AggregateManager(None),
 
620
        {
 
621
            "name": "bar",
 
622
            "availability_zone": "testing",
 
623
            "deleted": 0,
 
624
            "created_at": "2013-07-04T13:34:38.000000",
 
625
            "updated_at": None,
 
626
            "hosts": ["foo", "bar"],
 
627
            "deleted_at": None,
 
628
            "id": 2,
 
629
            "metadata": {
 
630
                "foo": "testing",
 
631
                "bar": "testing"
 
632
            }
 
633
        }
 
634
    )
 
635
 
 
636
    TEST.aggregates.add(aggregate_1)
 
637
    TEST.aggregates.add(aggregate_2)