← Back to branch summary

~ubuntu-branches/ubuntu/trusty/heat/trusty-security

« back to all changes in this revision

Viewing changes to heat/tests/test_instance.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Yolanda Robla, Chuck Short
  • Date: 2013-07-22 16:22:29 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130722162229-zzvfu40id94ii0hc
Tags: 2013.2~b2-0ubuntu1
[ Yolanda Robla ]
* debian/tests: added autopkg tests

[ Chuck Short ]
* New upstream release
* debian/control:
  - Add python-pbr to build-depends.
  - Add python-d2to to build-depends.
  - Dropped python-argparse.
  - Add python-six to build-depends.
  - Dropped python-sendfile.
  - Dropped python-nose.
  - Added testrepository.
  - Added python-testtools.
* debian/rules: Run testrepository instead of nosetets.
* debian/patches/removes-lxml-version-limitation-from-pip-requires.patch: Dropped
  no longer needed.
* debian/patches/fix-package-version-detection-when-building-doc.patch: Dropped
  no longer needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
heat/tests/test_instance.py
12
12
#    License for the specific language governing permissions and limitations
13
13
#    under the License.
14
14
 
15
 
 
16
 
import os
17
15
import copy
18
16
 
19
 
import unittest
20
17
import mox
21
18
 
22
 
from nose.plugins.attrib import attr
23
 
 
 
19
from heat.engine import environment
24
20
from heat.tests.v1_1 import fakes
25
21
from heat.engine.resources import instance as instances
 
22
from heat.common import exception
26
23
from heat.common import template_format
27
24
from heat.engine import parser
 
25
from heat.engine import resource
 
26
from heat.engine import scheduler
28
27
from heat.openstack.common import uuidutils
29
 
 
30
 
 
31
 
@attr(tag=['unit', 'resource', 'instance'])
32
 
@attr(speed='fast')
33
 
class instancesTest(unittest.TestCase):
 
28
from heat.tests.common import HeatTestCase
 
29
from heat.tests import utils
 
30
from heat.tests.utils import setup_dummy_db
 
31
 
 
32
 
 
33
wp_template = '''
 
34
{
 
35
  "AWSTemplateFormatVersion" : "2010-09-09",
 
36
  "Description" : "WordPress",
 
37
  "Parameters" : {
 
38
    "KeyName" : {
 
39
      "Description" : "KeyName",
 
40
      "Type" : "String",
 
41
      "Default" : "test"
 
42
    }
 
43
  },
 
44
  "Resources" : {
 
45
    "WebServer": {
 
46
      "Type": "AWS::EC2::Instance",
 
47
      "Properties": {
 
48
        "ImageId" : "F17-x86_64-gold",
 
49
        "InstanceType"   : "m1.large",
 
50
        "KeyName"        : "test",
 
51
        "UserData"       : "wordpress"
 
52
      }
 
53
    }
 
54
  }
 
55
}
 
56
'''
 
57
 
 
58
 
 
59
class InstancesTest(HeatTestCase):
34
60
    def setUp(self):
35
 
        self.m = mox.Mox()
 
61
        super(InstancesTest, self).setUp()
36
62
        self.fc = fakes.FakeClient()
37
 
        self.path = os.path.dirname(os.path.realpath(__file__)).\
38
 
            replace('heat/tests', 'templates')
39
 
 
40
 
    def tearDown(self):
41
 
        self.m.UnsetStubs()
42
 
        print "instancesTest teardown complete"
 
63
        setup_dummy_db()
 
64
 
 
65
    def _setup_test_stack(self, stack_name):
 
66
        t = template_format.parse(wp_template)
 
67
        template = parser.Template(t)
 
68
        stack = parser.Stack(None, stack_name, template,
 
69
                             environment.Environment({'KeyName': 'test'}),
 
70
                             stack_id=uuidutils.generate_uuid())
 
71
        return (t, stack)
 
72
 
 
73
    def _setup_test_instance(self, return_server, name, image_id=None):
 
74
        stack_name = '%s_stack' % name
 
75
        (t, stack) = self._setup_test_stack(stack_name)
 
76
 
 
77
        t['Resources']['WebServer']['Properties']['ImageId'] = \
 
78
            image_id or 'CentOS 5.2'
 
79
        t['Resources']['WebServer']['Properties']['InstanceType'] = \
 
80
            '256 MB Server'
 
81
        instance = instances.Instance('%s_name' % name,
 
82
                                      t['Resources']['WebServer'], stack)
 
83
 
 
84
        self.m.StubOutWithMock(instance, 'nova')
 
85
        instance.nova().MultipleTimes().AndReturn(self.fc)
 
86
 
 
87
        instance.t = instance.stack.resolve_runtime_data(instance.t)
 
88
 
 
89
        # need to resolve the template functions
 
90
        server_userdata = instance._build_userdata(
 
91
            instance.t['Properties']['UserData'])
 
92
        self.m.StubOutWithMock(self.fc.servers, 'create')
 
93
        self.fc.servers.create(
 
94
            image=1, flavor=1, key_name='test',
 
95
            name=utils.PhysName(stack_name, instance.name),
 
96
            security_groups=None,
 
97
            userdata=server_userdata, scheduler_hints=None,
 
98
            meta=None, nics=None, availability_zone=None).AndReturn(
 
99
                return_server)
 
100
 
 
101
        return instance
 
102
 
 
103
    def _create_test_instance(self, return_server, name):
 
104
        instance = self._setup_test_instance(return_server, name)
 
105
        self.m.ReplayAll()
 
106
        scheduler.TaskRunner(instance.create)()
 
107
        return instance
43
108
 
44
109
    def test_instance_create(self):
45
 
        f = open("%s/WordPress_Single_Instance_gold.template" % self.path)
46
 
        t = template_format.parse(f.read())
47
 
        f.close()
48
 
 
49
 
        stack_name = 'instance_create_test_stack'
50
 
        template = parser.Template(t)
51
 
        params = parser.Parameters(stack_name, template, {'KeyName': 'test'})
52
 
        stack = parser.Stack(None, stack_name, template, params,
53
 
                             stack_id=uuidutils.generate_uuid())
54
 
 
 
110
        return_server = self.fc.servers.list()[1]
 
111
        instance = self._create_test_instance(return_server,
 
112
                                              'test_instance_create')
 
113
        # this makes sure the auto increment worked on instance creation
 
114
        self.assertTrue(instance.id > 0)
 
115
 
 
116
        expected_ip = return_server.networks['public'][0]
 
117
        self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip)
 
118
        self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip)
 
119
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip)
 
120
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip)
 
121
 
 
122
        self.m.VerifyAll()
 
123
 
 
124
    def test_instance_create_with_image_id(self):
 
125
        return_server = self.fc.servers.list()[1]
 
126
        instance = self._setup_test_instance(return_server,
 
127
                                             'test_instance_create_image_id',
 
128
                                             image_id='1')
 
129
        self.m.StubOutWithMock(uuidutils, "is_uuid_like")
 
130
        uuidutils.is_uuid_like('1').AndReturn(True)
 
131
 
 
132
        self.m.ReplayAll()
 
133
        scheduler.TaskRunner(instance.create)()
 
134
 
 
135
        # this makes sure the auto increment worked on instance creation
 
136
        self.assertTrue(instance.id > 0)
 
137
 
 
138
        expected_ip = return_server.networks['public'][0]
 
139
        self.assertEqual(instance.FnGetAtt('PublicIp'), expected_ip)
 
140
        self.assertEqual(instance.FnGetAtt('PrivateIp'), expected_ip)
 
141
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip)
 
142
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), expected_ip)
 
143
 
 
144
        self.m.VerifyAll()
 
145
 
 
146
    def test_instance_create_image_name_err(self):
 
147
        stack_name = 'test_instance_create_image_name_err_stack'
 
148
        (t, stack) = self._setup_test_stack(stack_name)
 
149
 
 
150
        # create an instance with non exist image name
 
151
        t['Resources']['WebServer']['Properties']['ImageId'] = 'Slackware'
 
152
        instance = instances.Instance('instance_create_image_err',
 
153
                                      t['Resources']['WebServer'], stack)
 
154
 
 
155
        self.m.StubOutWithMock(instance, 'nova')
 
156
        instance.nova().MultipleTimes().AndReturn(self.fc)
 
157
        self.m.ReplayAll()
 
158
 
 
159
        self.assertRaises(exception.ImageNotFound, instance.handle_create)
 
160
 
 
161
        self.m.VerifyAll()
 
162
 
 
163
    def test_instance_create_duplicate_image_name_err(self):
 
164
        stack_name = 'test_instance_create_image_name_err_stack'
 
165
        (t, stack) = self._setup_test_stack(stack_name)
 
166
 
 
167
        # create an instance with a non unique image name
55
168
        t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2'
56
 
        t['Resources']['WebServer']['Properties']['InstanceType'] = \
57
 
            '256 MB Server'
58
 
        instance = instances.Instance('create_instance_name',
59
 
                                      t['Resources']['WebServer'], stack)
60
 
 
61
 
        self.m.StubOutWithMock(instance, 'nova')
62
 
        instance.nova().MultipleTimes().AndReturn(self.fc)
63
 
 
64
 
        instance.t = instance.stack.resolve_runtime_data(instance.t)
65
 
 
66
 
        # need to resolve the template functions
67
 
        server_userdata = instance._build_userdata(
68
 
            instance.t['Properties']['UserData'])
69
 
        self.m.StubOutWithMock(self.fc.servers, 'create')
70
 
        self.fc.servers.create(
71
 
            image=1, flavor=1, key_name='test',
72
 
            name='%s.%s' % (stack_name, instance.name),
73
 
            security_groups=None,
74
 
            userdata=server_userdata, scheduler_hints=None,
75
 
            meta=None, nics=None, availability_zone=None).AndReturn(
76
 
                self.fc.servers.list()[1])
77
 
        self.m.ReplayAll()
78
 
 
79
 
        self.assertEqual(instance.create(), None)
80
 
 
81
 
        # this makes sure the auto increment worked on instance creation
82
 
        self.assertTrue(instance.id > 0)
83
 
 
84
 
        self.assertEqual(instance.FnGetAtt('PublicIp'), '4.5.6.7')
85
 
        self.assertEqual(instance.FnGetAtt('PrivateIp'), '4.5.6.7')
86
 
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), '4.5.6.7')
87
 
        self.assertEqual(instance.FnGetAtt('PrivateDnsName'), '4.5.6.7')
 
169
        instance = instances.Instance('instance_create_image_err',
 
170
                                      t['Resources']['WebServer'], stack)
 
171
 
 
172
        self.m.StubOutWithMock(instance, 'nova')
 
173
        instance.nova().MultipleTimes().AndReturn(self.fc)
 
174
        self.m.StubOutWithMock(self.fc.client, "get_images_detail")
 
175
        self.fc.client.get_images_detail().AndReturn((
 
176
            200, {'images': [{'id': 1, 'name': 'CentOS 5.2'},
 
177
                             {'id': 4, 'name': 'CentOS 5.2'}]}))
 
178
        self.m.ReplayAll()
 
179
 
 
180
        self.assertRaises(exception.NoUniqueImageFound, instance.handle_create)
 
181
 
 
182
        self.m.VerifyAll()
 
183
 
 
184
    def test_instance_create_image_id_err(self):
 
185
        stack_name = 'test_instance_create_image_id_err_stack'
 
186
        (t, stack) = self._setup_test_stack(stack_name)
 
187
 
 
188
        # create an instance with non exist image Id
 
189
        t['Resources']['WebServer']['Properties']['ImageId'] = '1'
 
190
        instance = instances.Instance('instance_create_image_err',
 
191
                                      t['Resources']['WebServer'], stack)
 
192
 
 
193
        self.m.StubOutWithMock(instance, 'nova')
 
194
        instance.nova().MultipleTimes().AndReturn(self.fc)
 
195
        self.m.StubOutWithMock(uuidutils, "is_uuid_like")
 
196
        uuidutils.is_uuid_like('1').AndReturn(True)
 
197
        self.m.StubOutWithMock(self.fc.client, "get_images_1")
 
198
        self.fc.client.get_images_1().AndRaise(
 
199
            instances.clients.novaclient.exceptions.NotFound(404))
 
200
        self.m.ReplayAll()
 
201
 
 
202
        self.assertRaises(exception.ImageNotFound, instance.handle_create)
 
203
 
 
204
        self.m.VerifyAll()
 
205
 
 
206
    def test_instance_validate(self):
 
207
        stack_name = 'test_instance_validate_stack'
 
208
        (t, stack) = self._setup_test_stack(stack_name)
 
209
 
 
210
        # create an instance with non exist image Id
 
211
        t['Resources']['WebServer']['Properties']['ImageId'] = '1'
 
212
        instance = instances.Instance('instance_create_image_err',
 
213
                                      t['Resources']['WebServer'], stack)
 
214
 
 
215
        self.m.StubOutWithMock(instance, 'nova')
 
216
        instance.nova().MultipleTimes().AndReturn(self.fc)
 
217
 
 
218
        self.m.StubOutWithMock(uuidutils, "is_uuid_like")
 
219
        uuidutils.is_uuid_like('1').AndReturn(True)
 
220
        self.m.ReplayAll()
 
221
 
 
222
        self.assertEqual(instance.validate(), None)
88
223
 
89
224
        self.m.VerifyAll()
90
225
 
91
226
    def test_instance_create_delete(self):
92
 
        f = open("%s/WordPress_Single_Instance_gold.template" % self.path)
93
 
        t = template_format.parse(f.read())
94
 
        f.close()
95
 
 
96
 
        stack_name = 'instance_create_delete_test_stack'
97
 
        template = parser.Template(t)
98
 
        params = parser.Parameters(stack_name, template, {'KeyName': 'test'})
99
 
        stack = parser.Stack(None, stack_name, template, params,
100
 
                             stack_id=uuidutils.generate_uuid())
101
 
 
102
 
        t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2'
103
 
        t['Resources']['WebServer']['Properties']['InstanceType'] = \
104
 
            '256 MB Server'
105
 
        instance = instances.Instance('create_delete_instance_name',
106
 
                                      t['Resources']['WebServer'], stack)
107
 
 
108
 
        self.m.StubOutWithMock(instance, 'nova')
109
 
        instance.nova().MultipleTimes().AndReturn(self.fc)
110
 
 
111
 
        instance.t = instance.stack.resolve_runtime_data(instance.t)
112
 
 
113
 
        # need to resolve the template functions
114
 
        server_userdata = instance._build_userdata(
115
 
            instance.t['Properties']['UserData'])
116
 
        self.m.StubOutWithMock(self.fc.servers, 'create')
117
 
        self.fc.servers.create(
118
 
            image=1, flavor=1, key_name='test',
119
 
            name='%s.%s' % (stack_name, instance.name),
120
 
            security_groups=None,
121
 
            userdata=server_userdata, scheduler_hints=None,
122
 
            meta=None, nics=None, availability_zone=None).AndReturn(
123
 
                self.fc.servers.list()[1])
124
 
        self.m.ReplayAll()
125
 
 
126
 
        self.assertEqual(instance.create(), None)
 
227
        return_server = self.fc.servers.list()[1]
 
228
        instance = self._create_test_instance(return_server,
 
229
                                              'test_instance_create_delete')
127
230
        instance.resource_id = 1234
128
231
 
129
232
        # this makes sure the auto increment worked on instance creation
136
239
 
137
240
        instance.delete()
138
241
        self.assertTrue(instance.resource_id is None)
139
 
        self.assertEqual(instance.state, instance.DELETE_COMPLETE)
 
242
        self.assertEqual(instance.state, (instance.DELETE, instance.COMPLETE))
140
243
        self.m.VerifyAll()
141
244
 
142
245
    def test_instance_update_metadata(self):
143
 
        f = open("%s/WordPress_Single_Instance_gold.template" % self.path)
144
 
        t = template_format.parse(f.read())
145
 
        f.close()
146
 
 
147
 
        stack_name = 'instance_update_test_stack'
148
 
        template = parser.Template(t)
149
 
        params = parser.Parameters(stack_name, template, {'KeyName': 'test'})
150
 
        stack = parser.Stack(None, stack_name, template, params,
151
 
                             stack_id=uuidutils.generate_uuid())
152
 
 
153
 
        t['Resources']['WebServer']['Properties']['ImageId'] = 'CentOS 5.2'
154
 
        t['Resources']['WebServer']['Properties']['InstanceType'] = \
155
 
            '256 MB Server'
156
 
        instance = instances.Instance('create_instance_name',
157
 
                                      t['Resources']['WebServer'], stack)
158
 
 
159
 
        self.m.StubOutWithMock(instance, 'nova')
160
 
        instance.nova().MultipleTimes().AndReturn(self.fc)
161
 
 
162
 
        instance.t = instance.stack.resolve_runtime_data(instance.t)
163
 
 
164
 
        # need to resolve the template functions
165
 
        server_userdata = instance._build_userdata(
166
 
            instance.t['Properties']['UserData'])
167
 
        self.m.StubOutWithMock(self.fc.servers, 'create')
168
 
        self.fc.servers.create(
169
 
            image=1, flavor=1, key_name='test',
170
 
            name='%s.%s' % (stack_name, instance.name),
171
 
            security_groups=None,
172
 
            userdata=server_userdata, scheduler_hints=None,
173
 
            meta=None, nics=None, availability_zone=None).AndReturn(
174
 
                self.fc.servers.list()[1])
175
 
        self.m.ReplayAll()
176
 
 
177
 
        self.assertEqual(instance.create(), None)
 
246
        return_server = self.fc.servers.list()[1]
 
247
        instance = self._create_test_instance(return_server,
 
248
                                              'test_instance_update')
178
249
 
179
250
        update_template = copy.deepcopy(instance.t)
180
251
        update_template['Metadata'] = {'test': 123}
181
 
        self.assertEqual(instance.update(update_template),
182
 
                         instance.UPDATE_COMPLETE)
 
252
        self.assertEqual(None, instance.update(update_template))
183
253
        self.assertEqual(instance.metadata, {'test': 123})
184
254
 
 
255
    def test_instance_update_replace(self):
 
256
        return_server = self.fc.servers.list()[1]
 
257
        instance = self._create_test_instance(return_server,
 
258
                                              'test_instance_update')
 
259
 
 
260
        update_template = copy.deepcopy(instance.t)
 
261
        update_template['Notallowed'] = {'test': 123}
 
262
        self.assertRaises(resource.UpdateReplace,
 
263
                          instance.update, update_template)
 
264
 
 
265
    def test_instance_update_properties(self):
 
266
        return_server = self.fc.servers.list()[1]
 
267
        instance = self._create_test_instance(return_server,
 
268
                                              'test_instance_update')
 
269
 
 
270
        update_template = copy.deepcopy(instance.t)
 
271
        update_template['Properties']['KeyName'] = 'mustreplace'
 
272
        self.assertRaises(resource.UpdateReplace,
 
273
                          instance.update, update_template)
 
274
 
 
275
    def test_instance_status_build(self):
 
276
        return_server = self.fc.servers.list()[0]
 
277
        instance = self._setup_test_instance(return_server,
 
278
                                             'test_instance_status_build')
 
279
        instance.resource_id = 1234
 
280
 
 
281
        # Bind fake get method which Instance.check_create_complete will call
 
282
        def activate_status(server):
 
283
            server.status = 'ACTIVE'
 
284
        return_server.get = activate_status.__get__(return_server)
 
285
        self.m.ReplayAll()
 
286
 
 
287
        scheduler.TaskRunner(instance.create)()
 
288
        self.assertEqual(instance.state, (instance.CREATE, instance.COMPLETE))
 
289
 
 
290
    def test_instance_status_suspend_immediate(self):
 
291
        return_server = self.fc.servers.list()[1]
 
292
        instance = self._create_test_instance(return_server,
 
293
                                              'test_instance_suspend')
 
294
 
 
295
        instance.resource_id = 1234
 
296
        self.m.ReplayAll()
 
297
 
 
298
        # Override the get_servers_1234 handler status to SUSPENDED
 
299
        d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
300
        d['server']['status'] = 'SUSPENDED'
 
301
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
302
        get = self.fc.client.get_servers_1234
 
303
        get().AndReturn((200, d))
 
304
        mox.Replay(get)
 
305
 
 
306
        scheduler.TaskRunner(instance.suspend)()
 
307
        self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE))
 
308
 
 
309
        self.m.VerifyAll()
 
310
 
 
311
    def test_instance_status_resume_immediate(self):
 
312
        return_server = self.fc.servers.list()[1]
 
313
        instance = self._create_test_instance(return_server,
 
314
                                              'test_instance_resume')
 
315
 
 
316
        instance.resource_id = 1234
 
317
        self.m.ReplayAll()
 
318
 
 
319
        # Override the get_servers_1234 handler status to SUSPENDED
 
320
        d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
321
        d['server']['status'] = 'ACTIVE'
 
322
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
323
        get = self.fc.client.get_servers_1234
 
324
        get().AndReturn((200, d))
 
325
        mox.Replay(get)
 
326
        instance.state_set(instance.SUSPEND, instance.COMPLETE)
 
327
 
 
328
        scheduler.TaskRunner(instance.resume)()
 
329
        self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE))
 
330
 
 
331
        self.m.VerifyAll()
 
332
 
 
333
    def test_instance_status_suspend_wait(self):
 
334
        return_server = self.fc.servers.list()[1]
 
335
        instance = self._create_test_instance(return_server,
 
336
                                              'test_instance_suspend')
 
337
 
 
338
        instance.resource_id = 1234
 
339
        self.m.ReplayAll()
 
340
 
 
341
        # Override the get_servers_1234 handler status to SUSPENDED, but
 
342
        # return the ACTIVE state first (twice, so we sleep)
 
343
        d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
344
        d2 = copy.deepcopy(d1)
 
345
        d1['server']['status'] = 'ACTIVE'
 
346
        d2['server']['status'] = 'SUSPENDED'
 
347
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
348
        get = self.fc.client.get_servers_1234
 
349
        get().AndReturn((200, d1))
 
350
        get().AndReturn((200, d1))
 
351
        get().AndReturn((200, d2))
 
352
        self.m.ReplayAll()
 
353
 
 
354
        scheduler.TaskRunner(instance.suspend)()
 
355
        self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE))
 
356
 
 
357
        self.m.VerifyAll()
 
358
 
 
359
    def test_instance_status_resume_wait(self):
 
360
        return_server = self.fc.servers.list()[1]
 
361
        instance = self._create_test_instance(return_server,
 
362
                                              'test_instance_resume')
 
363
 
 
364
        instance.resource_id = 1234
 
365
        self.m.ReplayAll()
 
366
 
 
367
        # Override the get_servers_1234 handler status to ACTIVE, but
 
368
        # return the SUSPENDED state first (twice, so we sleep)
 
369
        d1 = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
370
        d2 = copy.deepcopy(d1)
 
371
        d1['server']['status'] = 'SUSPENDED'
 
372
        d2['server']['status'] = 'ACTIVE'
 
373
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
374
        get = self.fc.client.get_servers_1234
 
375
        get().AndReturn((200, d1))
 
376
        get().AndReturn((200, d1))
 
377
        get().AndReturn((200, d2))
 
378
        self.m.ReplayAll()
 
379
 
 
380
        instance.state_set(instance.SUSPEND, instance.COMPLETE)
 
381
 
 
382
        scheduler.TaskRunner(instance.resume)()
 
383
        self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE))
 
384
 
 
385
        self.m.VerifyAll()
 
386
 
 
387
    def test_instance_suspend_volumes_step(self):
 
388
        return_server = self.fc.servers.list()[1]
 
389
        instance = self._create_test_instance(return_server,
 
390
                                              'test_instance_suspend')
 
391
 
 
392
        instance.resource_id = 1234
 
393
        self.m.ReplayAll()
 
394
 
 
395
        # Override the get_servers_1234 handler status to SUSPENDED
 
396
        d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
397
        d['server']['status'] = 'SUSPENDED'
 
398
 
 
399
        # Return a dummy PollingTaskGroup to make check_suspend_complete step
 
400
        def dummy_detach():
 
401
            yield
 
402
        dummy_tg = scheduler.PollingTaskGroup([dummy_detach, dummy_detach])
 
403
        self.m.StubOutWithMock(instance, '_detach_volumes_task')
 
404
        instance._detach_volumes_task().AndReturn(dummy_tg)
 
405
 
 
406
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
407
        get = self.fc.client.get_servers_1234
 
408
        get().AndReturn((200, d))
 
409
        self.m.ReplayAll()
 
410
 
 
411
        scheduler.TaskRunner(instance.suspend)()
 
412
        self.assertEqual(instance.state, (instance.SUSPEND, instance.COMPLETE))
 
413
 
 
414
        self.m.VerifyAll()
 
415
 
 
416
    def test_instance_resume_volumes_step(self):
 
417
        return_server = self.fc.servers.list()[1]
 
418
        instance = self._create_test_instance(return_server,
 
419
                                              'test_instance_resume')
 
420
 
 
421
        instance.resource_id = 1234
 
422
        self.m.ReplayAll()
 
423
 
 
424
        # Override the get_servers_1234 handler status to ACTIVE
 
425
        d = {'server': self.fc.client.get_servers_detail()[1]['servers'][0]}
 
426
        d['server']['status'] = 'ACTIVE'
 
427
 
 
428
        # Return a dummy PollingTaskGroup to make check_resume_complete step
 
429
        def dummy_attach():
 
430
            yield
 
431
        dummy_tg = scheduler.PollingTaskGroup([dummy_attach, dummy_attach])
 
432
        self.m.StubOutWithMock(instance, '_attach_volumes_task')
 
433
        instance._attach_volumes_task().AndReturn(dummy_tg)
 
434
 
 
435
        self.m.StubOutWithMock(self.fc.client, 'get_servers_1234')
 
436
        get = self.fc.client.get_servers_1234
 
437
        get().AndReturn((200, d))
 
438
 
 
439
        self.m.ReplayAll()
 
440
 
 
441
        instance.state_set(instance.SUSPEND, instance.COMPLETE)
 
442
 
 
443
        scheduler.TaskRunner(instance.resume)()
 
444
        self.assertEqual(instance.state, (instance.RESUME, instance.COMPLETE))
 
445
 
 
446
        self.m.VerifyAll()
 
447
 
 
448
    def test_instance_status_build_spawning(self):
 
449
        self._test_instance_status_not_build_active('BUILD(SPAWNING)')
 
450
 
 
451
    def test_instance_status_hard_reboot(self):
 
452
        self._test_instance_status_not_build_active('HARD_REBOOT')
 
453
 
 
454
    def test_instance_status_password(self):
 
455
        self._test_instance_status_not_build_active('PASSWORD')
 
456
 
 
457
    def test_instance_status_reboot(self):
 
458
        self._test_instance_status_not_build_active('REBOOT')
 
459
 
 
460
    def test_instance_status_rescue(self):
 
461
        self._test_instance_status_not_build_active('RESCUE')
 
462
 
 
463
    def test_instance_status_resize(self):
 
464
        self._test_instance_status_not_build_active('RESIZE')
 
465
 
 
466
    def test_instance_status_revert_resize(self):
 
467
        self._test_instance_status_not_build_active('REVERT_RESIZE')
 
468
 
 
469
    def test_instance_status_shutoff(self):
 
470
        self._test_instance_status_not_build_active('SHUTOFF')
 
471
 
 
472
    def test_instance_status_suspended(self):
 
473
        self._test_instance_status_not_build_active('SUSPENDED')
 
474
 
 
475
    def test_instance_status_verify_resize(self):
 
476
        self._test_instance_status_not_build_active('VERIFY_RESIZE')
 
477
 
 
478
    def _test_instance_status_not_build_active(self, uncommon_status):
 
479
        return_server = self.fc.servers.list()[0]
 
480
        instance = self._setup_test_instance(return_server,
 
481
                                             'test_instance_status_build')
 
482
        instance.resource_id = 1234
 
483
 
 
484
        # Bind fake get method which Instance.check_create_complete will call
 
485
        def activate_status(server):
 
486
            if hasattr(server, '_test_check_iterations'):
 
487
                server._test_check_iterations += 1
 
488
            else:
 
489
                server._test_check_iterations = 1
 
490
            if server._test_check_iterations == 1:
 
491
                server.status = uncommon_status
 
492
            if server._test_check_iterations > 2:
 
493
                server.status = 'ACTIVE'
 
494
        return_server.get = activate_status.__get__(return_server)
 
495
        self.m.ReplayAll()
 
496
 
 
497
        scheduler.TaskRunner(instance.create)()
 
498
        self.assertEqual(instance.state, (instance.CREATE, instance.COMPLETE))
 
499
 
 
500
        self.m.VerifyAll()
 
501
 
185
502
    def test_build_nics(self):
186
 
        self.assertEqual(None, instances.Instance._build_nics([]))
187
 
        self.assertEqual(None, instances.Instance._build_nics(None))
 
503
        return_server = self.fc.servers.list()[1]
 
504
        instance = self._create_test_instance(return_server,
 
505
                                              'test_build_nics')
 
506
 
 
507
        self.assertEqual(None, instance._build_nics([]))
 
508
        self.assertEqual(None, instance._build_nics(None))
188
509
        self.assertEqual([
189
510
            {'port-id': 'id3'}, {'port-id': 'id1'}, {'port-id': 'id2'}],
190
 
            instances.Instance._build_nics([
 
511
            instance._build_nics([
191
512
                'id3', 'id1', 'id2']))
192
513
        self.assertEqual([
193
514
            {'port-id': 'id1'},
194
515
            {'port-id': 'id2'},
195
 
            {'port-id': 'id3'}], instances.Instance._build_nics([
 
516
            {'port-id': 'id3'}], instance._build_nics([
196
517
                {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'},
197
518
                {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'},
198
519
                {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2},
203
524
            {'port-id': 'id3'},
204
525
            {'port-id': 'id4'},
205
526
            {'port-id': 'id5'}
206
 
        ], instances.Instance._build_nics([
 
527
        ], instance._build_nics([
207
528
            {'NetworkInterfaceId': 'id3', 'DeviceIndex': '3'},
208
529
            {'NetworkInterfaceId': 'id1', 'DeviceIndex': '1'},
209
530
            {'NetworkInterfaceId': 'id2', 'DeviceIndex': 2},
210
531
            'id4',
211
532
            'id5'
212
533
        ]))
 
534
 
 
535
    def test_instance_without_ip_address(self):
 
536
        return_server = self.fc.servers.list()[3]
 
537
        instance = self._create_test_instance(return_server,
 
538
                                              'test_without_ip_address')
 
539
 
 
540
        self.assertEqual(instance.FnGetAtt('PrivateIp'), '0.0.0.0')