def test_container_init(self):
config = mock.Mock()
instance = stubs._fake_instance()
host = mock.Mock()
with contextlib.nested(
mock.patch.object(container_client.LXDContainerClient,
'container_init'),
mock.patch.object(container_client.LXDContainerClient,
'container_wait'),
mock.patch.object(container_client.LXDContainerClient,
'container_operation_info'),
) as (
container_init,
container_wait,
container_operation_info,
):
container_init.return_value = (200, fake_api.fake_operation())
container_operation_info.return_value = (
200,
fake_api.fake_operation_info_ok())
self.assertEqual(None,
(self.container_utils.container_init(config,
instance,
host)))
self.assertTrue(container_init)
self.assertTrue(container_wait)
self.assertTrue(container_operation_info)
class SessionSnapshotTest(test.NoDBTestCase):
def setUp(self):
super(SessionSnapshotTest, self).setUp()
"""This is so we can mock out pylxd API calls."""
self.ml = stubs.lxd_mock()
lxd_patcher = mock.patch('pylxd.api.API',
mock.Mock(return_value=self.ml))
lxd_patcher.start()
self.addCleanup(lxd_patcher.stop)
self.session = session.LXDAPISession()
@stubs.annotated_data(('1,', (200, fake_api.fake_operation_info_ok())))
def test_container_snapshot(self, tag, side_effect):
snapshot = mock.Mock()
instance = stubs._fake_instance()
self.ml.container_snapshot_create.return_value = side_effect
self.assertEqual(None,
self.session.container_snapshot(snapshot, instance))
calls = [
mock.call.container_snapshot_create(instance.name, snapshot),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError(500,
'Fake'), exception.NovaException))
def test_container_snapshot_fail(self, tag, side_effect, expected):
snapshot = mock.Mock()
instance = stubs._fake_instance()
self.ml.container_snapshot_create.side_effect = side_effect
self.assertRaises(expected, self.session.container_snapshot,
instance.name, snapshot)
@stubs.annotated_data((1, (200, fake_api.fake_operation_info_ok())))
def test_container_publish(self, tag, side_effect):
image = mock.Mock()
instance = stubs._fake_instance()
self.ml.image_export.return_value = True
self.assertTrue(self.session.container_publish(image, instance))
calls = [mock.call.container_publish(image)]
self.assertEqual(calls, self.ml.method_calls)
def test_container_destroy_fail(self, tag, container_defined, test_type, side_effect, expected):
"""
container_destroy deletes a container on the LXD host.
Check whether an exeption.NovaException is raised when
there is an APIError or when the container fails to stop.
"""
instance = stubs._fake_instance()
self.ml.cotnainer_defined.return_value = container_defined
if test_type == "fail_stop":
self.ml.container_stop.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy, instance.name, instance)
if test_type == "fail_destroy":
self.ml.container_defined.return_value = container_defined
self.ml.container_stop.return_value = (200, fake_api.fake_operation_info_ok())
self.ml.container_destroy.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy, instance.name, instance)
def test_container_destroy_fail(self, tag, container_defined, test_type,
side_effect, expected):
"""
container_destroy deletes a container on the LXD host.
Check whether an exeption.NovaException is raised when
there is an APIError or when the container fails to stop.
"""
instance = stubs._fake_instance()
self.ml.cotnainer_defined.return_value = container_defined
if test_type == 'fail_stop':
self.ml.container_stop.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy,
instance.name, instance)
if test_type == 'fail_destroy':
self.ml.container_defined.return_value = container_defined
self.ml.container_stop.return_value = \
(200, fake_api.fake_operation_info_ok())
self.ml.container_destroy.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy,
instance.name, instance)
class SessionContainerTest(test.NoDBTestCase):
def setUp(self):
super(SessionContainerTest, self).setUp()
"""This is so we can mock out pylxd API calls."""
self.ml = stubs.lxd_mock()
lxd_patcher = mock.patch('pylxd.api.API',
mock.Mock(return_value=self.ml))
lxd_patcher.start()
self.addCleanup(lxd_patcher.stop)
self.session = session.LXDAPISession()
@stubs.annotated_data(
('empty', [], []),
('valid', ['test'], ['test']),
)
def test_container_list(self, tag, side_effect, expected):
"""
container_list returns a list of LXD containers
found on an LXD host.
"""
self.ml.container_list.return_value = side_effect
self.assertEqual(expected, self.session.container_list())
def test_container_list_fail(self):
"""
container_list returns an exception.NovaException,
if pylxd raises an APIError.
"""
self.ml.container_list.side_effect = (lxd_exceptions.APIError(
'Fake', 500))
self.assertRaises(exception.NovaException, self.session.container_list)
def test_container_update(self):
"""
container_update updates the LXD container configuration,
so verify that the correct pylxd calls are made.
"""
config = mock.Mock()
instance = stubs._fake_instance()
self.ml.container_update.return_value = \
(200, fake_api.fake_container_config())
self.assertEqual((200, fake_api.fake_container_config()),
self.session.container_update(config, instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_update(instance.name, config)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', True, lxd_exceptions.APIError(
'Fake', 500), exception.NovaException),
('missing_container', False, None, exception.InstanceNotFound))
def test_container_update_fail(self, tag, container_defined, side_effect,
expected):
"""
container_update will fail if the container is not found, or the
LXD raises an API error. Verify that the exceptions are raised
in both scenarios.
"""
config = mock.Mock()
instance = stubs._fake_instance()
if container_defined:
self.ml.container_defined.return_value = container_defined
self.ml.container_update.side_effect = (lxd_exceptions.APIError(
'Fake', 500))
self.assertRaises(expected, self.session.container_update, config,
instance)
if not container_defined:
self.ml.container_defined.return_value = container_defined
self.assertRaises(expected, self.session.container_update, config,
instance)
@stubs.annotated_data(
('running', True),
('idle', False),
('api_failure', lxd_exceptions.APIError('Fake', '500')),
)
def test_container_running(self, tag, side_effect):
"""
container_running determines if the container is running
or not. Verify that we are returning True if the container
is running. False if its not, raise an exception if there
is an API error.
"""
instance = stubs._fake_instance()
if side_effect:
self.ml.container_running.return_value = side_effect
self.assertTrue(self.session.container_running(instance))
if not side_effect:
self.ml.container_running.return_value = side_effect
self.assertFalse(self.session.container_running(instance))
if tag == 'api_failure':
self.ml.container_running.side_effect = side_effect
self.assertRaises(exception.NovaException,
self.session.container_running, instance)
def test_container_state(self):
"""
container_state translates LXD container status into
what nova understands. Verify that status_code sends
a power_state.RUNNING and a 108 sends a
power_state.CRASHED.
"""
calls = []
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', True, lxd_exceptions.APIError('Fake', 500), {
'state': power_state.NOSTATE,
'mem': 0,
'max_mem': 0
}))
def test_container_state_fail(self, tag, container_defined, side_effect,
expected):
"""
container_state translates LXD container status into
what nova understands. If the API sends an APIError
then raise an power_state.NOSTATE, same if the
the container goes missing.
"""
instance = stubs._fake_instance()
if container_defined:
self.ml.container_defined.return_value = container_defined
self.ml.container_state.side_effect = (lxd_exceptions.APIError(
'Fake', 500))
self.assertEqual(expected, self.session.container_state(instance))
if not container_defined:
self.ml.container_defined.return_value = container_defined
self.assertEqual(expected, self.session.container_state(instance))
def test_container_config(self):
"""
container_config returns a dictionary representation
of the LXD container. Verify that the funciton returns
a container_config
"""
instance = stubs._fake_instance()
self.ml.get_container_config.return_value = \
(200, fake_api.fake_container_config())
self.assertEqual((200, fake_api.fake_container_config()),
self.session.container_config(instance))
@stubs.annotated_data(
('api_fail', True, lxd_exceptions.APIError(
'Fake', 500), exception.NovaException), )
def test_container_config_fail(self, tag, container_defined, side_effect,
expected):
"""
container_config returns a dictionary represeation of the
LXD container. Verify that the function raises an
exception.NovaException when there is a APIError.
"""
instance = stubs._fake_instance()
if container_defined:
self.ml.container_defined.return_value = container_defined
self.ml.get_container_config.side_effect = side_effect
self.assertRaises(expected, self.session.container_config,
instance)
def test_container_info(self):
"""
container_info returns a dictonary represenation of
useful information about a container, (ip address, pid, etc).
Verify that the function returns the approiate dictionary
representation for the LXD API.
"""
instance = stubs._fake_instance()
self.ml.container_info.return_value = \
(200, fake_api.fake_container_info())
self.assertEqual((200, fake_api.fake_container_info()),
self.session.container_info(instance))
def test_container_info_fail(self):
"""
container_info returns a dictionary reprsentation of
userful information about a container (ip address, pid, etc).
Verify that the container_info returns an exception.NovaException
when there is an APIError.
"""
instance = stubs._fake_instance()
self.ml.container_info.side_effect = (lxd_exceptions.APIError(
'Fake', 500))
self.assertRaises(exception.NovaException, self.session.container_info,
instance)
@stubs.annotated_data(
('exists', True),
('missing', False),
)
def test_container_defined(self, tag, side_effect):
"""
container_defined returns True if the container
exists on an LXD host, False otherwise, verify
the apporiate return value is returned.
"""
instance = stubs._fake_instance()
self.ml.container_defined.return_value = side_effect
if side_effect:
self.assertTrue(
self.session.container_defined(instance.name, instance))
if not side_effect:
self.assertFalse(
self.session.container_defined(instance.name, instance))
@stubs.annotated_data(
('1', True, (200, fake_api.fake_operation_info_ok())))
def test_container_start(self, tag, defined, side_effect=None):
"""
containser_start starts a container on a given LXD host.
Verify that the correct pyLXD calls are made.
"""
instance = stubs._fake_instance()
self.ml.container_defined.return_value = defined
self.ml.container_start.return_value = side_effect
self.assertEqual(None,
self.session.container_start(instance.name, instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_start(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('container_missing', False, exception.InstanceNotFound),
('api_error', True, exception.NovaException,
lxd_exceptions.APIError('Fake', 500)),
)
def test_container_start_fail(self,
tag,
container_defined,
expected,
side_effect=None):
"""
container_start starts a container on a given LXD host.
Veify that an exception.InstanceNotFound when the container
is not found on an LXD host. Raises an exception.NovaException
when there is an APIError.
"""
instance = stubs._fake_instance()
if container_defined:
self.ml.container_defined.return_value = container_defined
self.ml.container_start.side_effect = side_effect
self.assertRaises(expected, self.session.container_start,
instance.name, instance)
if not container_defined:
self.ml.container_defined.return_value = container_defined
self.assertRaises(expected, self.session.container_start,
instance.name, instance)
@stubs.annotated_data(('1', (200, fake_api.fake_operation_info_ok())))
def test_container_stop(self, tag, side_effect):
"""
container_stop stops a container on a given LXD ost.
Verifty that that the apprioated pylxd calls are
made to the LXD api.
"""
instance = stubs._fake_instance()
self.ml.container_stop.return_value = side_effect
self.assertEqual(None,
self.session.container_stop(instance.name, instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_stop(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError('Fake',
500), exception.NovaException))
def test_container_stop_fail(self, tag, side_effect, expected):
"""
contianer_stop stops a container on a given LXD host.
Verifty that we raise an exception.NovaException when there is an
APIError.
"""
instance = stubs._fake_instance()
self.ml.container_stop.side_effect = side_effect
self.assertRaises(expected, self.session.container_stop, instance.name,
instance)
@stubs.annotated_data(('1,', (200, fake_api.fake_operation_info_ok())))
def test_continer_reboot(self, tag, side_effect):
""""
container_reboot reboots a container on a given LXD host.
Verify that the right pylxd calls are made to the LXD host.
"""
instance = stubs._fake_instance()
self.ml.container_reboot.return_value = side_effect
self.assertEqual(None, self.session.container_reboot(instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_reboot(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError('Fake',
500), exception.NovaException))
def test_container_reboot_fail(self, tag, side_effect, expected):
"""
container_reboot reboots a container on a given LXD host.
Check that an exception.NovaException is raised when
there is an LXD API error.
"""
instance = stubs._fake_instance()
self.ml.container_reboot.side_effect = side_effect
self.assertRaises(expected, self.session.container_reboot, instance)
@stubs.annotated_data(
('exists', True, (200, fake_api.fake_operation_info_ok())),
('missing', False, (200, fake_api.fake_operation_info_ok())))
def test_container_destroy(self, tag, container_defined, side_effect):
"""
container_destroy delete a container from the LXD Host. Check
that the approiate pylxd calls are made.
"""
instance = stubs._fake_instance()
if container_defined:
self.ml.container_defined.return_value = container_defined
self.ml.container_stop.return_value = side_effect
self.ml.container_destroy.return_value = side_effect
self.assertEqual(
None, self.session.container_destroy(instance.name, instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_defined(instance.name),
mock.call.container_stop(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200,
-1),
mock.call.container_destroy(instance.name),
mock.call.wait_container_operation('/1.0/operation/1234', 200,
-1)
]
self.assertEqual(calls, self.ml.method_calls)
if not container_defined:
self.ml.container_defined.return_value = container_defined
self.assertEqual(
None, self.session.container_destroy(instance.name, instance))
calls = [mock.call.container_defined(instance.name)]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('fail_to_stop', True, 'fail_stop',
lxd_exceptions.APIError('Fake', '500'), exception.NovaException),
('fail_to_destroy', True, 'fail_destroy',
lxd_exceptions.APIError('Fake', '500'), exception.NovaException))
def test_container_destroy_fail(self, tag, container_defined, test_type,
side_effect, expected):
"""
container_destroy deletes a container on the LXD host.
Check whether an exeption.NovaException is raised when
there is an APIError or when the container fails to stop.
"""
instance = stubs._fake_instance()
self.ml.cotnainer_defined.return_value = container_defined
if test_type == 'fail_stop':
self.ml.container_stop.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy,
instance.name, instance)
if test_type == 'fail_destroy':
self.ml.container_defined.return_value = container_defined
self.ml.container_stop.return_value = \
(200, fake_api.fake_operation_info_ok())
self.ml.container_destroy.side_effect = side_effect
self.assertRaises(expected, self.session.container_destroy,
instance.name, instance)
@stubs.annotated_data(('1', (200, fake_api.fake_operation_info_ok())))
def fake_container_pause(self, tag, side_effect):
"""
container_pause pauses a container on a given LXD host.
Verify that the appropiate pylxd API calls are made.
"""
instance = stubs._fake_instance()
self.ml.container_suspend.return_value = side_effect
self.assertEqual(None,
self.session.container_pause(instance.name, instance))
calls = [
mock.call.container_susepnd(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError(500,
'Fake'), exception.NovaException))
def test_container_pause_fail(self, tag, side_effect, expected):
"""
container_pause pauses a contianer on a LXD host. Verify
that an exception.NovaException is raised when there
is an APIError.
"""
instance = stubs._fake_instance()
instance = stubs._fake_instance()
self.ml.container_suspend.side_effect = side_effect
self.assertRaises(expected, self.session.container_pause,
instance.name, instance)
@stubs.annotated_data(('1', (200, fake_api.fake_operation_info_ok())))
def test_container_unpause(self, tag, side_effect):
"""
container_unpase unpauses a continer on a LXD host.
Check that the right pylxd calls are being sent
to the LXD API server.
"""
instance = stubs._fake_instance()
self.ml.container_resume.return_value = side_effect
self.assertEqual(
None, self.session.container_unpause(instance.name, instance))
calls = [
mock.call.container_defined(instance.name),
mock.call.container_resume(instance.name, -1),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1)
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError(500,
'Fake'), exception.NovaException))
def test_container_unpause_fail(self, tag, side_effect, expected):
"""
container_unpause resumes a previously suespended container.
Validate that an exception.NovaException is raised when a
APIError is sent by the API.
"""
instance = stubs._fake_instance()
self.ml.container_resume.side_effect = side_effect
self.assertRaises(expected, self.session.container_unpause,
instance.name, instance)
@stubs.annotated_data(('1', (200, fake_api.fake_operation_info_ok())))
def test_container_init(self, tag, side_effect):
"""
conatainer_init creates a container based on given config
for a container. Check to see if we are returning the right
pylxd calls for the LXD API.
"""
config = mock.Mock()
instance = stubs._fake_instance()
self.ml.container_init.return_value = side_effect
self.ml.operation_info.return_value = \
(200, fake_api.fake_container_state(200))
self.assertEqual(None, self.session.container_init(config, instance))
calls = [
mock.call.container_init(config),
mock.call.wait_container_operation('/1.0/operation/1234', 200, -1),
mock.call.operation_info('/1.0/operation/1234')
]
self.assertEqual(calls, self.ml.method_calls)
@stubs.annotated_data(
('api_fail', lxd_exceptions.APIError(
500, 'Fake'), exception.NovaException), )
def test_container_init_fail(self, tag, side_effect, expected):
"""
continer_init create as container on a given LXD host. Make
sure that we reaise an exception.NovaException if there is
an APIError from the LXD API.
"""
config = mock.Mock()
instance = stubs._fake_instance()
self.ml.container_init.side_effect = side_effect
self.assertRaises(expected, self.session.container_init, config,
instance)
