← Back to branch summary

~rackspace-ozone/rackspace-nova/development

« back to all changes in this revision

Viewing changes to nova/tests/test_instance_types_extra_specs.py

  • Committer: paul at openstack
  • Date: 2011-09-26 18:57:03 UTC
  • mfrom: (1098.1.519 nova)
  • Revision ID: paul@openstack.org-20110926185703-ad3bthrj309itbrw
merging Diablo

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_instance_types_extra_specs.py
45
45
 
46
46
    def tearDown(self):
47
47
        # Remove the instance type from the database
48
 
        db.api.instance_type_purge(context.get_admin_context(), "cg1.4xlarge")
 
48
        db.api.instance_type_purge(self.context, "cg1.4xlarge")
49
49
        super(InstanceTypeExtraSpecsTestCase, self).tearDown()
50
50
 
51
51
    def test_instance_type_specs_get(self):
55
55
                                 xpus="2",
56
56
                                 xpu_model="Tesla 2050")
57
57
        actual_specs = db.api.instance_type_extra_specs_get(
58
 
                              context.get_admin_context(),
 
58
                              self.context,
59
59
                              self.instance_type_id)
60
60
        self.assertEquals(expected_specs, actual_specs)
61
61
 
64
64
                                 cpu_model="Nehalem",
65
65
                                 xpu_arch="fermi",
66
66
                                 xpus="2")
67
 
        db.api.instance_type_extra_specs_delete(context.get_admin_context(),
 
67
        db.api.instance_type_extra_specs_delete(self.context,
68
68
                                      self.instance_type_id,
69
69
                                      "xpu_model")
70
70
        actual_specs = db.api.instance_type_extra_specs_get(
71
 
                              context.get_admin_context(),
 
71
                              self.context,
72
72
                              self.instance_type_id)
73
73
        self.assertEquals(expected_specs, actual_specs)
74
74
 
79
79
                                 xpus="2",
80
80
                                 xpu_model="Tesla 2050")
81
81
        db.api.instance_type_extra_specs_update_or_create(
82
 
                              context.get_admin_context(),
 
82
                              self.context,
83
83
                              self.instance_type_id,
84
84
                              dict(cpu_model="Sandy Bridge"))
85
85
        actual_specs = db.api.instance_type_extra_specs_get(
86
 
                              context.get_admin_context(),
 
86
                              self.context,
87
87
                              self.instance_type_id)
88
88
        self.assertEquals(expected_specs, actual_specs)
89
89
 
96
96
                                 net_arch="ethernet",
97
97
                                 net_mbps="10000")
98
98
        db.api.instance_type_extra_specs_update_or_create(
99
 
                              context.get_admin_context(),
 
99
                              self.context,
100
100
                              self.instance_type_id,
101
101
                              dict(net_arch="ethernet",
102
102
                                   net_mbps=10000))
103
103
        actual_specs = db.api.instance_type_extra_specs_get(
104
 
                              context.get_admin_context(),
 
104
                              self.context,
105
105
                              self.instance_type_id)
106
106
        self.assertEquals(expected_specs, actual_specs)
107
107
 
108
108
    def test_instance_type_get_with_extra_specs(self):
109
109
        instance_type = db.api.instance_type_get(
110
 
                            context.get_admin_context(),
 
110
                            self.context,
111
111
                            self.instance_type_id)
112
112
        self.assertEquals(instance_type['extra_specs'],
113
113
                          dict(cpu_arch="x86_64",
116
116
                               xpus="2",
117
117
                               xpu_model="Tesla 2050"))
118
118
        instance_type = db.api.instance_type_get(
119
 
                            context.get_admin_context(),
 
119
                            self.context,
120
120
                            5)
121
121
        self.assertEquals(instance_type['extra_specs'], {})
122
122
 
123
123
    def test_instance_type_get_by_name_with_extra_specs(self):
124
124
        instance_type = db.api.instance_type_get_by_name(
125
 
                            context.get_admin_context(),
 
125
                            self.context,
126
126
                            "cg1.4xlarge")
127
127
        self.assertEquals(instance_type['extra_specs'],
128
128
                          dict(cpu_arch="x86_64",
132
132
                               xpu_model="Tesla 2050"))
133
133
 
134
134
        instance_type = db.api.instance_type_get_by_name(
135
 
                            context.get_admin_context(),
 
135
                            self.context,
136
136
                            "m1.small")
137
137
        self.assertEquals(instance_type['extra_specs'], {})
138
138
 
139
139
    def test_instance_type_get_by_flavor_id_with_extra_specs(self):
140
140
        instance_type = db.api.instance_type_get_by_flavor_id(
141
 
                            context.get_admin_context(),
 
141
                            self.context,
142
142
                            105)
143
143
        self.assertEquals(instance_type['extra_specs'],
144
144
                          dict(cpu_arch="x86_64",
148
148
                               xpu_model="Tesla 2050"))
149
149
 
150
150
        instance_type = db.api.instance_type_get_by_flavor_id(
151
 
                            context.get_admin_context(),
 
151
                            self.context,
152
152
                            2)
153
153
        self.assertEquals(instance_type['extra_specs'], {})
154
154
 
159
159
                        xpus='2',
160
160
                        xpu_model="Tesla 2050")
161
161
 
162
 
        types = db.api.instance_type_get_all(context.get_admin_context())
163
 
 
164
 
        self.assertEquals(types['cg1.4xlarge']['extra_specs'], specs)
165
 
        self.assertEquals(types['m1.small']['extra_specs'], {})
 
162
        types = db.api.instance_type_get_all(self.context)
 
163
 
 
164
        name2specs = {}
 
165
        for instance_type in types:
 
166
            name = instance_type['name']
 
167
            name2specs[name] = instance_type['extra_specs']
 
168
 
 
169
        self.assertEquals(name2specs['cg1.4xlarge'], specs)
 
170
        self.assertEquals(name2specs['m1.small'], {})