← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nova/saucy-proposed

« back to all changes in this revision

Viewing changes to nova/tests/compute/test_compute_utils.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-09-26 12:56:25 UTC
  • mfrom: (1.1.64)
  • Revision ID: package-import@ubuntu.com-20120926125625-27eb9h4hadrjqzjm
Tags: 2012.2~rc3-0ubuntu1
New upstream relase. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/compute/test_compute_utils.py
46
46
        self.instance = {
47
47
                'uuid': 'fake',
48
48
                'root_device_name': '/dev/vda',
49
 
                'default_ephemeral_device': '/dev/vdb'
 
49
                'default_ephemeral_device': '/dev/vdb',
 
50
                'instance_type_id': 'fake',
50
51
        }
 
52
        self.data = []
 
53
 
 
54
        def fake_get(instance_type_id, ctxt=None):
 
55
            return self.instance_type
 
56
 
 
57
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
 
58
                       lambda context, instance: self.data)
51
59
 
52
60
    def _validate_device(self, device=None):
53
61
        return compute_utils.get_device_name_for_instance(self.context,
64
72
        }
65
73
 
66
74
    def test_wrap(self):
67
 
        data = []
 
75
        self.data = []
68
76
        for letter in string.ascii_lowercase[2:]:
69
 
            data.append(self._fake_bdm('/dev/vd' + letter))
70
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
71
 
                       lambda context, instance: data)
 
77
            self.data.append(self._fake_bdm('/dev/vd' + letter))
72
78
        device = self._validate_device()
73
79
        self.assertEqual(device, '/dev/vdaa')
74
80
 
75
81
    def test_wrap_plus_one(self):
76
 
        data = []
 
82
        self.data = []
77
83
        for letter in string.ascii_lowercase[2:]:
78
 
            data.append(self._fake_bdm('/dev/vd' + letter))
79
 
        data.append(self._fake_bdm('/dev/vdaa'))
80
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
81
 
                       lambda context, instance: data)
 
84
            self.data.append(self._fake_bdm('/dev/vd' + letter))
 
85
        self.data.append(self._fake_bdm('/dev/vdaa'))
82
86
        device = self._validate_device()
83
87
        self.assertEqual(device, '/dev/vdab')
84
88
 
85
89
    def test_later(self):
86
 
        data = [
 
90
        self.data = [
87
91
            self._fake_bdm('/dev/vdc'),
88
92
            self._fake_bdm('/dev/vdd'),
89
93
            self._fake_bdm('/dev/vde'),
90
94
        ]
91
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
92
 
                       lambda context, instance: data)
93
95
        device = self._validate_device()
94
96
        self.assertEqual(device, '/dev/vdf')
95
97
 
96
98
    def test_gap(self):
97
 
        data = [
 
99
        self.data = [
98
100
            self._fake_bdm('/dev/vdc'),
99
101
            self._fake_bdm('/dev/vde'),
100
102
        ]
101
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
102
 
                       lambda context, instance: data)
103
103
        device = self._validate_device()
104
104
        self.assertEqual(device, '/dev/vdd')
105
105
 
106
106
    def test_no_bdms(self):
107
 
        data = []
108
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
109
 
                       lambda context, instance: data)
 
107
        self.data = []
110
108
        device = self._validate_device()
111
109
        self.assertEqual(device, '/dev/vdc')
112
110
 
113
111
    def test_lxc_names_work(self):
114
 
        self.instance = {
115
 
                'uuid': 'fake',
116
 
                'root_device_name': '/dev/a',
117
 
                'default_ephemeral_device': '/dev/b'
118
 
        }
119
 
        data = []
120
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
121
 
                       lambda context, instance: data)
 
112
        self.instance['root_device_name'] = '/dev/a'
 
113
        self.instance['ephemeral_device_name'] = '/dev/b'
 
114
        self.data = []
122
115
        device = self._validate_device()
123
116
        self.assertEqual(device, '/dev/c')
124
117
 
125
118
    def test_name_conversion(self):
126
 
        data = []
127
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
128
 
                       lambda context, instance: data)
 
119
        self.data = []
129
120
        device = self._validate_device('/dev/c')
130
121
        self.assertEqual(device, '/dev/vdc')
131
122
        device = self._validate_device('/dev/sdc')
134
125
        self.assertEqual(device, '/dev/vdc')
135
126
 
136
127
    def test_invalid_bdms(self):
137
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
138
 
                       lambda context, instance: [])
139
128
        self.instance['root_device_name'] = "baddata"
140
129
        self.assertRaises(exception.InvalidDevicePath,
141
130
                          self._validate_device)
142
131
 
143
132
    def test_invalid_device_prefix(self):
144
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
145
 
                       lambda context, instance: [])
146
133
        self.assertRaises(exception.InvalidDevicePath,
147
134
                          self._validate_device, '/baddata/vdc')
148
135
 
149
136
    def test_device_in_use(self):
150
 
        self.stubs.Set(db, 'block_device_mapping_get_all_by_instance',
151
 
                       lambda context, instance: [])
152
137
        self.assertRaises(exception.DevicePathInUse,
153
138
                          self._validate_device, '/dev/vdb')
154
139
 
 
140
    def test_swap(self):
 
141
        self.instance['default_swap_device'] = "/dev/vdc"
 
142
        device = self._validate_device()
 
143
        self.assertEqual(device, '/dev/vdd')
 
144
 
 
145
    def test_swap_no_ephemeral(self):
 
146
        del self.instance['default_ephemeral_device']
 
147
        self.instance['default_swap_device'] = "/dev/vdb"
 
148
        device = self._validate_device()
 
149
        self.assertEqual(device, '/dev/vdc')
 
150
 
 
151
    def test_ephemeral_xenapi(self):
 
152
        self.flags(compute_driver='xenapi.XenAPIDriver')
 
153
        del self.instance['default_ephemeral_device']
 
154
        self.instance_type = {
 
155
            'ephemeral_gb': 10,
 
156
            'swap': 0,
 
157
        }
 
158
        self.stubs.Set(instance_types, 'get_instance_type',
 
159
                       lambda instance_type_id, ctxt=None: self.instance_type)
 
160
        device = self._validate_device()
 
161
        self.assertEqual(device, '/dev/xvdc')
 
162
 
 
163
    def test_swap_xenapi(self):
 
164
        self.flags(compute_driver='xenapi.XenAPIDriver')
 
165
        del self.instance['default_ephemeral_device']
 
166
        self.instance_type = {
 
167
            'ephemeral_gb': 0,
 
168
            'swap': 10,
 
169
        }
 
170
        self.stubs.Set(instance_types, 'get_instance_type',
 
171
                       lambda instance_type_id, ctxt=None: self.instance_type)
 
172
        device = self._validate_device()
 
173
        self.assertEqual(device, '/dev/xvdb')
 
174
 
 
175
    def test_swap_and_ephemeral_xenapi(self):
 
176
        self.flags(compute_driver='xenapi.XenAPIDriver')
 
177
        del self.instance['default_ephemeral_device']
 
178
        self.instance_type = {
 
179
            'ephemeral_gb': 10,
 
180
            'swap': 10,
 
181
        }
 
182
        self.stubs.Set(instance_types, 'get_instance_type',
 
183
                       lambda instance_type_id, ctxt=None: self.instance_type)
 
184
        device = self._validate_device()
 
185
        self.assertEqual(device, '/dev/xvdd')
 
186
 
155
187
 
156
188
class UsageInfoTestCase(test.TestCase):
157
189