Differential D482

Initial integration with testcloud to spawn VM instances. Fixes T414
ClosedPublic
Actions

Authored by tflink on Jul 31 2015, 8:22 PM.

Details

Reviewers
lbrabec
kparal
mkrizek
jskladan
Maniphest Tasks
T414: Sub-Feature: Virtual Machine Management for Disposable Clients
Summary

This code is most of what we need to start spawning VMs for disposable clients but there are a couple of known issues which will eventually need to be remedied.

  1. There are some conceptual mismatches between this and the recent changes to --ssh flag and config-based setting of remote/local. we'll need to figure out how to make the two concepts play nice with eachother
  2. This uses mock instead of dingus - this is intentional. dingus still doesn't support py3 and I couldn't figure out how to sanely do some of these unit tests with it.
Test Plan

Run tasks on local machine, they have worked as expected, unit tests pass

Diff Detail

Repository
rLTRN libtaskotron
Branch
feature/T414-vm-management
Lint
Lint OK
Unit
Unit Tests OK
Build Status
Buildable 68
Build 68: arc lint + arc unit
tflink retitled this revision from to Initial integration with testcloud to spawn VM instances. Fixes T414.Jul 31 2015, 8:22 PM
tflink updated this object.
tflink edited the test plan for this revision. (Show Details)
tflink added reviewers: kparal, jskladan, mkrizek, lbrabec.
tflink added a comment.Aug 6 2015, 4:48 PM

To run this, you will need testcloud and its deps installed via rpm or in a virtualenv. If your user is not an administrator, you may also need to mess with polkit.

tflink updated this revision to Diff 1289.Aug 7 2015, 2:30 PM
  • fixes to get disposable client working with current state of disposable-develop
tflink updated this revision to Diff 1290.Aug 7 2015, 2:31 PM

fixing base

tflink added a comment.Aug 7 2015, 2:32 PM

OK, that should work with --libvirt and the current state of disposable-develop.

Another thing required is a password-less ssh keypair named conf/id_taskotron(.pub)

kparal accepted this revision.Aug 7 2015, 3:08 PM

It would be great to add instructions how to create the ssh keys and configure them somewhere.

In general, this seems to work, so thumbs up here. We can fix the minor issues later.

libtaskotron/runner.py
27

For brevity, I'd call this just libtaskotron.vm. But both works.

131

Is there a need to hardcode this? It should be possibly to use --ssh-privkey cmdline option and ssh_privkey config file option, unless there is a bug somewhere.

151

We might add

# FIXME: implement --no-destroy (per T408)

here.

This revision is now accepted and ready to land.Aug 7 2015, 3:08 PM
tflink added inline comments.Aug 7 2015, 3:22 PM
libtaskotron/runner.py
27

are you suggesting a rename of the module or doing a from libtaskotron import virtualmachine as vm?

131

working around the 'no sane default' part for now, i'll see if I can get something better

tflink added inline comments.Aug 7 2015, 3:23 PM
libtaskotron/runner.py
131

nvm, was thinking backwards.

tflink closed this revision.Aug 10 2015, 12:34 PM

For some reason, this wasn't autoclosed with the ticket

kparal added a comment.Aug 10 2015, 4:26 PM
In D482#9263, @tflink wrote:

For some reason, this wasn't autoclosed with the ticket

I guess there must not be any extra leading spaces in the commit message before the Differential Revision field.

Revision Contents

PathCoverage (All)Coverage (Touched)Packages
Mdocs/source/library.rst (6 lines)--
Mlibtaskotron/runner.py (40 lines)73%5%
Mlibtaskotron/virtualmachine.py (145 lines)87%86%
AMtesting/test_virtualmachine.py (157 lines)100%100%

Diff 1290

View Options

docs/source/library.rst

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Line(s)71.. automodule:: libtaskotron.rpm_utils
72 :members: 72​ :members:
73 73​
74runner 74​runner
75====== 75​======
76 76​
77.. automodule:: libtaskotron.runner 77​.. automodule:: libtaskotron.runner
78 :members: 78​ :members:
79 79​
80​virtualmachine
81​==============
82​
83​.. automodule:: libtaskotron.virtualmachine
84​ :members:
85​
80yumrepoinfo 86​yumrepoinfo
81=========== 87​===========
82 88​
83.. automodule:: libtaskotron.yumrepoinfo 89​.. automodule:: libtaskotron.yumrepoinfo
84 :members: 90​ :members:
View Options

libtaskotron/runner.py

Show All 18 Lines
19import libtaskotron 19​import libtaskotron
20from libtaskotron import taskformula 20​from libtaskotron import taskformula
21from libtaskotron import logger 21​from libtaskotron import logger
22from libtaskotron import python_utils 22​from libtaskotron import python_utils
23from libtaskotron import file_utils 23​from libtaskotron import file_utils
24from libtaskotron import config 24​from libtaskotron import config
25from libtaskotron import remote_exec 25​from libtaskotron import remote_exec
26from libtaskotron import rpm_utils 26​from libtaskotron import rpm_utils
27​from libtaskotron import virtualmachine
kparalUnsubmitted
Not Done

For brevity, I'd call this just libtaskotron.vm. But both works.

tflinkAuthorUnsubmitted
Not Done

are you suggesting a rename of the module or doing a from libtaskotron import virtualmachine as vm?

27from libtaskotron.logger import log 28​from libtaskotron.logger import log
28import libtaskotron.exceptions as exc 29​import libtaskotron.exceptions as exc
29from libtaskotron.directives import exitcode_directive 30​from libtaskotron.directives import exitcode_directive
30 31​
31 32​
32# The list of accepted item types on the command line (--type option) 33​# The list of accepted item types on the command line (--type option)
33_ITEM_TYPES = ["bodhi_id", "koji_build", "koji_tag", "compose"] 34​_ITEM_TYPES = ["bodhi_id", "koji_build", "koji_tag", "compose"]
34 35​
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Line(s)102 def _run_locally(self):
108 task_runner.prepare_task() 109​ task_runner.prepare_task()
109 task_runner.run() 110​ task_runner.run()
110 111​
111 def _run_remotely(self): 112​ def _run_remotely(self):
112 '''Init environment, instantiate RemoteRunner and run it.''' 113​ '''Init environment, instantiate RemoteRunner and run it.'''
113 114​
114 filelog_path = os.path.join(self.uuid_dir, 'taskotron-initiator.log') 115​ filelog_path = os.path.join(self.uuid_dir, 'taskotron-initiator.log')
115 logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True) 116​ logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
117​
116 stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log') 118​ stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log')
117 119​
118 if self.direct_ssh: 120​ if self.direct_ssh:
119 log.info("Running task over SSH on machine '%s'...", self.machine) 121​ log.info("Running task over SSH on machine '%s'...", self.machine)
120 else: 122​ else:
121 log.info("Running task on a disposable client using libvirt...") 123​ log.info("Running task on a disposable client using libvirt...")
122 # FIXME: create disposable client here 124​
123 raise exc.TaskotronError('libvirt execution not yet implemented') 125​ log.info("Creating VM for task")
126​ task_vm = virtualmachine.TestCloudMachine(self.arg_data['uuid'])
127​ task_vm.prepare()
128​ self.machine = task_vm.ipaddr
129​ self.port = 22
130​ self.user = task_vm.username
131​ self.ssh_privkey = 'conf/id_taskotron'
kparalUnsubmitted
Not Done

Is there a need to hardcode this? It should be possibly to use --ssh-privkey cmdline option and ssh_privkey config file option, unless there is a bug somewhere.

tflinkAuthorUnsubmitted
Not Done

working around the 'no sane default' part for now, i'll see if I can get something better

tflinkAuthorUnsubmitted
Not Done

nvm, was thinking backwards.

132​
133​ log.info("Running Task over SSH on machine %s" % task_vm.instancename)
124 134​
125 with remote_exec.RemoteExec(self.machine, self.port, self.user, 135​ with remote_exec.RemoteExec(self.machine, self.port, self.user,
126 self.ssh_privkey, stdio_filename) as ssh: 136​ self.ssh_privkey, stdio_filename) as ssh:
127 task_runner = RemoteRunner(ssh, self.task_data, self.arg_data) 137​ task_runner = RemoteRunner(ssh, self.task_data, self.arg_data)
128 try: 138​ try:
129 task_runner.prepare_task() 139​ task_runner.prepare_task()
130 task_runner.run() 140​ task_runner.run()
131 except exc.TaskotronRemoteError, e: 141​ except exc.TaskotronRemoteError, e:
132 log.exception(e) 142​ log.exception(e)
143​
133 task_runner.get_output() 144​ task_runner.get_output()
134 145​
146​ if self.direct_ssh:
147​ # don't try to run teardown in the direct ssh case
148​ return
149​
150​ # only teardown the VM when not in debug mode
151​ if self.arg_data['debug']:
kparalUnsubmitted
Not Done

We might add

# FIXME: implement --no-destroy (per T408)

here.

152​ log.info("debug mode was set from command line, not tearing VM "
153​ "down for task {}".format(self.arg_data['uuid']))
154​ else:
155​ try:
156​ task_vm.teardown()
157​ except exc.TaskotronRemoteError, e:
158​ log.error("Hit problem during teardown of VM for "
159​ "task {}".format(self.arg_data['uuid']))
160​ log.error(e)
161​
135 162​
136class LocalRunner(object): 163​class LocalRunner(object):
137 def __init__(self, taskdata, argdata, workdir=None): 164​ def __init__(self, taskdata, argdata, workdir=None):
138 self.taskdata = taskdata 165​ self.taskdata = taskdata
139 self.envdata = argdata 166​ self.envdata = argdata
140 self.working_data = {} 167​ self.working_data = {}
141 self.directives = {} 168​ self.directives = {}
142 self.workdir = workdir 169​ self.workdir = workdir
Show All 25 Lines194 if not directive_dir:
168 directive_dir = os.path.join(os.path.dirname(__file__), 195​ directive_dir = os.path.join(os.path.dirname(__file__),
169 'directives') 196​ 'directives')
170 197​
171 real_name = "%s_directive" % directive_name 198​ real_name = "%s_directive" % directive_name
172 directive_file = os.path.join(directive_dir, '%s.py' % real_name) 199​ directive_file = os.path.join(directive_dir, '%s.py' % real_name)
173 200​
174 if not os.path.exists(directive_file): 201​ if not os.path.exists(directive_file):
175 raise exc.TaskotronYamlError("Directive %s not found in directory %s" % 202​ raise exc.TaskotronYamlError("Directive %s not found in directory %s" %
176 (directive_name, directive_dir)) 203​ (directive_name, directive_dir))
177 204​
178 loaded_directive = imp.load_source(real_name, directive_file) 205​ loaded_directive = imp.load_source(real_name, directive_file)
179 self.directives[directive_name] = loaded_directive 206​ self.directives[directive_name] = loaded_directive
180 207​
181 def _render_action(self, action): 208​ def _render_action(self, action):
182 '''Take an action and replace all included variables with actual values 209​ '''Take an action and replace all included variables with actual values
183 from :attr:`env_data` and :attr:`working_data`. See :meth:`do_actions` 210​ from :attr:`env_data` and :attr:`working_data`. See :meth:`do_actions`
184 to see how an action looks like. 211​ to see how an action looks like.
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Line(s)326 def __init__(self, ssh, task_data, arg_data):
303 self.taskdir = config.get_config().client_taskdir 330​ self.taskdir = config.get_config().client_taskdir
304 331​
305 def prepare_task(self): 332​ def prepare_task(self):
306 # FIXME remove this once the vm code is done 333​ # FIXME remove this once the vm code is done
307 self.ssh.install_pkgs('wget') 334​ self.ssh.install_pkgs('wget')
308 self.ssh.cmd('wget -O /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo ' 335​ self.ssh.cmd('wget -O /etc/yum.repos.d/tflink-taskotron-fedora-f21.repo '
309 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/' 336​ 'http://copr-fe.cloud.fedoraproject.org/coprs/tflink/taskotron/'
310 'repo/fedora-21/tflink-taskotron-fedora-21.repo') 337​ 'repo/fedora-21/tflink-taskotron-fedora-21.repo')
338​
311 self.ssh.install_pkgs('libtaskotron') 339​ self.ssh.install_pkgs('libtaskotron')
312 340​
313 # configure libtaskotron 341​ # configure libtaskotron
314 if config.get_config().config_filename: 342​ if config.get_config().config_filename:
315 self.ssh.put_file(config.get_config().config_filename, '/etc/taskotron/taskotron.yaml') 343​ self.ssh.put_file(config.get_config().config_filename, '/etc/taskotron/taskotron.yaml')
316 344​
345​ # create needed dirs
346​ self.ssh.mkdir(self.taskdir)
347​
317 # patch remote libtaskotron if needed (for dev, shouldn't be used in production) 348​ # patch remote libtaskotron if needed (for dev, shouldn't be used in production)
318 if self.arg_data['patch'] is not None: 349​ if self.arg_data['patch'] is not None:
319 self.ssh.put_file(os.path.abspath(self.arg_data['patch']), '%s/%s' % ( 350​ self.ssh.put_file(os.path.abspath(self.arg_data['patch']), '%s/%s' % (
320 self.taskdir, self.arg_data['patch'])) 351​ self.taskdir, self.arg_data['patch']))
321 self.ssh.install_pkgs('patch') 352​ self.ssh.install_pkgs('patch')
322 self.ssh.cmd('patch -d /usr/lib/python2.7/site-packages/ -p1 -i %s/%s' % ( 353​ self.ssh.cmd('patch -d /usr/lib/python2.7/site-packages/ -p1 -i %s/%s' % (
323 self.taskdir, self.arg_data['patch'])) 354​ self.taskdir, self.arg_data['patch']))
324 355​
325 # create needed dirs ​
326 self.ssh.mkdir(self.taskdir) ​
327 ​
328 # put files needed for execution (task, input files, etc) 356​ # put files needed for execution (task, input files, etc)
329 self.ssh.put_dir(os.path.dirname(self.arg_data['taskfile']), self.taskdir) 357​ self.ssh.put_dir(os.path.dirname(self.arg_data['taskfile']), self.taskdir)
330 358​
331 # need to have default_flow_style false to get valid yaml w/ nested dicts 359​ # need to have default_flow_style false to get valid yaml w/ nested dicts
332 self.ssh.write_file(os.path.join(self.taskdir, 360​ self.ssh.write_file(os.path.join(self.taskdir,
333 os.path.basename(self.arg_data['taskfile'])), 361​ os.path.basename(self.arg_data['taskfile'])),
334 yaml.dump(self.task_data, default_flow_style=False)) 362​ yaml.dump(self.task_data, default_flow_style=False))
335 363​
▲ Show 20 Lines • Show All 165 Lines • Show Last 20 Lines
View Options

libtaskotron/virtualmachine.py

1# -*- coding: utf-8 -*- 1​# -*- coding: utf-8 -*-
2# Copyright 2009-2015, Red Hat, Inc. 2​# Copyright 2009-2015, Red Hat, Inc.
3# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> 3​# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
4# See the LICENSE file for more details on Licensing 4​# See the LICENSE file for more details on Licensing
5 5​
6 6​
7"""Interface to locally spawned virtual machines that are used as disposable 7​"""Interface to locally spawned virtual machines that are used as disposable
8clients for executing Taskotron tasks.""" 8​clients for executing Taskotron tasks."""
9 9​
10​from time import sleep
11​
12​from libtaskotron.logger import log
13​import libtaskotron.exceptions as exc
14​
15​from testcloud import instance, image, cli
16​from testcloud.exceptions import TestcloudInstanceError, TestcloudImageError
17​
18​
10class TestCloudMachine(object): 19​class TestCloudMachine(object):
11 """Launch virtual machines with TestCloud and prepare them for executing 20​ '''Launch virtual machines with TestCloud and prepare them for executing
12 tasks (install packages etc.) 21​ tasks (install packages etc.)'''
13 """ 22​
14 # need to add paramiko methods for ssh/scp 23​ def __init__(self, uuid):
15 pass 24​ ''':param uuid: unicode string uuid for the task being executed'''
25​
26​ # this should be temporary and go away once we have better image
27​ # finding and discovery.
28​ self.imageurl = 'http://dl.fedoraproject.org/pub/fedora/linux/releases/22/Cloud/x86_64/\
29​Images/Fedora-Cloud-Base-22-20150521.x86_64.qcow2'
30​
31​ #: name of the testcloud instance spawned for this task
32​ self.instancename = 'taskotron-{}'.format(uuid)
33​
34​ #: username to use when connecting to the virtual machine
35​ self.username = 'root'
36​
37​ #: password for user on the remote machine
38​ self.password = 'passw0rd'
39​
40​ #: ip address of the remote machine (only set after prepared and spawned successfully)
41​ self.ipaddr = None
42​
43​ #: uuid of the task which spawned this instance
44​ self.uuid = uuid
45​
46​ def _prepare_image(self):
47​ '''Use testcloud to prepare an image for local booting
48​ :raises TaskotronRemoteError: for errors in preparing the image with testcloud'''
49​
50​ log.debug("preparing image {} for task {}".format(self.imageurl, self.uuid))
51​ tc_image = None
52​
53​ try:
54​ tc_image = image.Image(self.imageurl)
55​ tc_image.prepare()
56​ except TestcloudImageError, e:
57​ log.error(e)
58​ raise exc.TaskotronRemoteError("There was an error while preparing the "
59​ "testcloud image", e)
60​
61​ return tc_image
62​
63​ def _prepare_instance(self, tc_image):
64​ '''Prepare an instance for booting and boot it with testcloud'''
65​ log.debug("preparing testcloud instance {}".format(self.instancename))
66​ tc_instance = instance.Instance(self.instancename, tc_image)
67​ tc_instance.prepare()
68​
69​ log.debug("spawning testcloud instance {}".format(self.instancename))
70​ tc_instance.spawn_vm()
71​
72​ def _check_existing_instance(self, should_exist=False):
73​ '''Check whether an instance with the same name already exists, raise errors if the result
74​ was not as expected.
75​
76​ :param should_exist: sets expectation on whether the instance should
77​ exist already or not
78​ :raises TaskotronRemoteError: if the preset expectation is not met
79​ '''
80​ existing_instance = instance.find_instance(self.instancename)
81​
82​ if existing_instance is None:
83​ if should_exist:
84​ raise exc.TaskotronRemoteError("Was expecting to find instance {} but it does not"
85​ " already exist".format(self.instancename))
86​ else:
87​ if not should_exist:
88​ raise exc.TaskotronRemoteError("Expected to NOT find instance {} but it is "
89​ "already defined".format(self.instancename))
90​ return existing_instance
91​
92​ def prepare(self):
93​ '''Prepare a virtual machine for running tasks.
94​
95​ :raises TaskotronRemoteError: if there are any errors while preparing
96​ the virtual machine.
97​ '''
98​
99​ tc_image = self._prepare_image()
100​
101​ self._check_existing_instance(should_exist=False)
102​
103​ self._prepare_instance(tc_image)
104​
105​ self.ipaddr = cli.find_vm_ip(self.instancename)
106​
107​ def _stop_instance(self, tc_instance):
108​ '''Stop (shut down) a virtual machine instance
109​
110​ :raises TaskotronRemoteError: if stopping the instance fails'''
111​
112​ log.debug("Stopping instance {}".format(self.instancename))
113​ try:
114​ tc_instance.stop()
115​ except TestcloudInstanceError, e:
116​ log.error("Hit error while stopping instance {}".format(self.instancename), e)
117​ raise exc.TaskotronRemoteError(e)
118​
119​ def _destroy_instance(self, tc_instance):
120​ '''Destroy (delete) the virtual machine instance.
121​
122​ :raises TaskotronRemoteError: if destroying the instance fails'''
123​
124​ log.debug("destroying instance {}".format(self.instancename))
125​ try:
126​ tc_instance.destroy()
127​ except TestcloudInstanceError, e:
128​ log.error("Hit error while destroying instance {}".format(self.instancename), e)
129​ raise exc.TaskotronRemoteError(e)
130​
131​ def teardown(self):
132​ '''Tear down the virtual machine by shutting it down and removing any
133​ trace of it from the host machine.
134​
135​ :raises TaskotronRemoteError: if there is a failure while stopping or
136​ removing the virtual machine instance
137​ '''
138​
139​ tc_instance = self._check_existing_instance(should_exist=True)
140​
141​ self._stop_instance(tc_instance)
142​
143​ # wait for testcloud to actually stop the instance, currently
144​ # instance.stop() returns before the instance is actually stopped
145​ sleep(2)
146​
147​ self._destroy_instance(tc_instance)
148​
16 149​
17class Image(object): 150​class Image(object):
18 """Retrieve images from either local or remote sources""" 151​ '''Retrieve images from either local or remote sources'''
19 pass 152​ pass
View Options

testing/test_virtualmachine.py

  • This file was added.
1​# -*- coding: utf-8 -*-
2​# Copyright 2009-2015, Red Hat, Inc.
3​# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
4​# See the LICENSE file for more details on Licensing
5​
6​import pytest
7​from mock import Mock, MagicMock
8​
9​from libtaskotron import virtualmachine
10​from libtaskotron import exceptions as exc
11​
12​from testcloud import image, instance
13​from testcloud.exceptions import TestcloudImageError, TestcloudInstanceError
14​
15​
16​class TestVirtualMachineImagePrepare(object):
17​ '''Test libtaskotron.virtualmachine._prepare_image'''
18​
19​ def setup_method(self, method):
20​ self.ref_uuid = '1234-5678-9012'
21​
22​ def should_raise_on_failure(self, monkeypatch):
23​ stub_image = Mock(side_effect=TestcloudImageError())
24​
25​ monkeypatch.setattr(image, 'Image', stub_image)
26​
27​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
28​
29​ with pytest.raises(exc.TaskotronRemoteError):
30​ test_vm._prepare_image()
31​
32​ def should_behave_on_success(self, monkeypatch):
33​ stub_image = MagicMock()
34​
35​ monkeypatch.setattr(image, 'Image', stub_image)
36​
37​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
38​
39​ test_vm._prepare_image()
40​
41​
42​class TestVirtualMachineInstancePrepare(object):
43​ '''Test libtaskotron.virtualmachine._prepare_instance'''
44​
45​ def setup_method(self, method):
46​ self.ref_uuid = '1234-5678-9012'
47​
48​ def should_make_proper_calls(self, monkeypatch):
49​ stub_image = Mock()
50​ stub_instance = MagicMock()
51​ stub_instanceclass = Mock(return_value=stub_instance)
52​
53​ monkeypatch.setattr(instance, 'Instance', stub_instanceclass)
54​
55​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
56​
57​ test_vm._prepare_instance(stub_image)
58​
59​ assert stub_instance.method_calls == [('prepare',), ('spawn_vm',)]
60​
61​
62​class TestVirtualMachineStop(object):
63​ '''Test libtaskotron.virtualmachine._stop_instance'''
64​
65​ def setup_method(self, method):
66​ self.ref_uuid = '1234-5678-9012'
67​
68​ def should_bequiet_on_success(self):
69​ stub_instance = Mock()
70​
71​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
72​
73​ test_vm._stop_instance(stub_instance)
74​
75​ def should_raise_on_failure(self):
76​ stub_instance = Mock()
77​ stub_instance.stop.side_effect = TestcloudInstanceError()
78​
79​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
80​
81​ with pytest.raises(exc.TaskotronRemoteError):
82​ test_vm._stop_instance(stub_instance)
83​
84​
85​class TestVirtualMachineDestroy(object):
86​ '''Tests for the libtaskotron.virtualmachine.destroy() method'''
87​
88​ def setup_method(self, method):
89​ self.ref_uuid = '1234-5678-9012'
90​
91​ def should_bequiet_on_success(self):
92​ stub_instance = Mock()
93​
94​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
95​
96​ test_vm._destroy_instance(stub_instance)
97​
98​ def should_raise_on_failure(self):
99​ stub_instance = Mock()
100​ stub_instance.destroy.side_effect = TestcloudInstanceError()
101​
102​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
103​
104​ with pytest.raises(exc.TaskotronRemoteError):
105​ test_vm._destroy_instance(stub_instance)
106​
107​
108​class TestVirtualMachineExistingInstances(object):
109​ '''Test the possible outcomes of checking for existing instances. Exception
110​ should be thrown if the should_exist arg doesn't match "reality".'''
111​
112​ def setup_method(self, method):
113​ self.ref_uuid = '1234-5678-9012'
114​
115​ def should_raise_existing_expecting_novm(self, monkeypatch):
116​ stub_instance = Mock(return_value=None)
117​
118​ monkeypatch.setattr(instance, 'find_instance', stub_instance)
119​
120​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
121​
122​ with pytest.raises(exc.TaskotronRemoteError):
123​ test_vm._check_existing_instance(True)
124​
125​ def should_return_none_expecting_novm(self, monkeypatch):
126​ stub_instance = Mock(return_value=None)
127​
128​ monkeypatch.setattr(instance, 'find_instance', stub_instance)
129​
130​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
131​
132​ test_instance = test_vm._check_existing_instance(False)
133​
134​ assert test_instance is None
135​
136​ def should_return_instance_found_expecting_vm(self, monkeypatch):
137​ stub_found_instance = Mock()
138​ stub_instance = Mock(return_value=stub_found_instance)
139​
140​ monkeypatch.setattr(instance, 'find_instance', stub_instance)
141​
142​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
143​
144​ test_instance = test_vm._check_existing_instance(True)
145​
146​ assert test_instance == stub_found_instance
147​
148​ def should_raise_noexisting_expecting_vm(self, monkeypatch):
149​ stub_found_instance = Mock()
150​ stub_instance = Mock(return_value=stub_found_instance)
151​
152​ monkeypatch.setattr(instance, 'find_instance', stub_instance)
153​
154​ test_vm = virtualmachine.TestCloudMachine(self.ref_uuid)
155​
156​ with pytest.raises(exc.TaskotronRemoteError):
157​ test_vm._check_existing_instance(False)