def test_create_default_values(self):
"""
test server create with default value and error in request
"""
fake_ctx = self.generate_node_context(
properties={
'management_network': '_management_network',
'vcloud_config': {
'vdc': 'vdc_name'
},
'server': {
'template': 'template',
'catalog': 'catalog'
}
})
fake_client = self.generate_client()
with mock.patch('vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)):
self.run_with_statuses(fake_client, fake_ctx)
fake_ctx.instance._relationships = None
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
fake_client.create_vapp.assert_called_with('vdc_name',
'test',
'template',
'catalog',
vm_name='test')
def test_get_state(self):
num_tries = 5
verified = False
server.create()
self._run_with_retry(server.start, self.ctx)
for _ in range(num_tries):
result = server._get_state(self.vca_client)
if result is True:
self.assertTrue('ip' in self.ctx.instance.runtime_properties)
self.assertTrue('networks'
in self.ctx.instance.runtime_properties)
self.assertEqual(1,
len(self.ctx.instance.
runtime_properties['networks'].keys()))
self.assertEqual(self.network_name,
self.ctx.instance.
runtime_properties['networks'].keys()[0])
ip_valid = True
try:
socket.inet_aton(
self.ctx.instance.runtime_properties['ip'])
except socket.error:
ip_valid = False
self.assertTrue(ip_valid)
verified = True
break
time.sleep(2)
self.assertTrue(verified)
def test_get_state(self):
num_tries = 5
verified = False
server.create()
self._run_with_retry(server.start, self.ctx)
for _ in range(num_tries):
result = server._get_state(self.vca_client)
if result is True:
self.assertTrue('ip' in self.ctx.instance.runtime_properties)
self.assertTrue(
'networks' in self.ctx.instance.runtime_properties)
self.assertEqual(
1,
len(self.ctx.instance.runtime_properties['networks'].keys(
)))
self.assertEqual(
self.network_name,
self.ctx.instance.runtime_properties['networks'].keys()[0])
ip_valid = True
try:
socket.inet_aton(
self.ctx.instance.runtime_properties['ip'])
except socket.error:
ip_valid = False
self.assertTrue(ip_valid)
verified = True
break
time.sleep(2)
self.assertTrue(verified)
def test_server_stop_start(self):
server.create()
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
self.assertFalse(server._vapp_is_on(vapp))
self._run_with_retry(server.start, self.ctx)
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertTrue(server._vapp_is_on(vapp))
server.stop()
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertFalse(server._vapp_is_on(vapp))
self._run_with_retry(server.start, self.ctx)
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertTrue(server._vapp_is_on(vapp))
def test_create_cpu_mem_values(self):
"""
check custom cpu/memmory with error in task
"""
fake_ctx = self.generate_node_context(properties={
'management_network': '_management_network',
'vcloud_config': {
'vdc': 'vdc_name'
},
'server': {
'template': 'ubuntu',
'catalog': 'public',
'hardware': {
'cpu': 1,
'memory': 512
}
}
})
fake_client = self.generate_client()
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_ERROR
)
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
fake_client.create_vapp.assert_called_with(
'vdc_name', 'test', 'ubuntu', 'public',
vm_name='test', vm_memory=512, vm_cpus=1
)
def test_create_default_values(self):
"""
test server create with default value and error in request
"""
fake_ctx = self.generate_node_context(properties={
'management_network': '_management_network',
'vcloud_config': {
'vdc': 'vdc_name'
},
'server': {
'template': 'template',
'catalog': 'catalog'
}
})
fake_client = self.generate_client()
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
self.run_with_statuses(
fake_client, fake_ctx
)
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
fake_client.create_vapp.assert_called_with(
'vdc_name', 'test', 'template', 'catalog',
vm_name='test', vm_memory=None, vm_cpus=None
)
def test_create_cpu_mem_values(self):
"""
check custom cpu/memmory with error in task
"""
fake_ctx = self.generate_node_context(
properties={
'management_network': '_management_network',
'vcloud_config': {
'vdc': 'vdc_name'
},
'server': {
'template': 'ubuntu',
'catalog': 'public',
'hardware': {
'cpu': 1,
'memory': 512
}
}
},
relation_node_properties={
"not_test": "not_test"
}
)
fake_client = self.generate_client()
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
# can't customize memory
with self.assertRaises(cfy_exc.NonRecoverableError):
server.configure(ctx=fake_ctx)
fake_client._vapp.modify_vm_memory.assert_called_with(
'test', 512
)
fake_client._vapp.modify_vm_memory = mock.MagicMock(
return_value=self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
)
# can't customize cpu
with self.assertRaises(cfy_exc.NonRecoverableError):
server.configure(ctx=fake_ctx)
fake_client._vapp.modify_vm_cpu.assert_called_with(
'test', 1
)
fake_client._vapp.modify_vm_cpu = mock.MagicMock(
return_value=self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
)
# everything fine
server.create(ctx=fake_ctx)
def _create_test(self):
server.create()
self._run_with_retry(server.start, self.ctx)
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
networks = server._get_vm_network_connections(vapp)
self.assertEqual(1, len(networks))
self.assertEqual(self.network_name, networks[0]['network_name'])
def _create_test(self):
server.create()
self._run_with_retry(server.start, self.ctx)
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
networks = server._get_vm_network_connections(vapp)
self.assertEqual(1, len(networks))
self.assertEqual(self.network_name, networks[0]['network_name'])
def test_server_create_delete(self):
server.create()
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
self.assertFalse(server._vapp_is_on(vapp))
self.check_hardware(vapp)
server.delete()
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertTrue(vapp is None)
def test_server_create_delete(self):
server.create()
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
self.assertFalse(server._vapp_is_on(vapp))
self.check_hardware(vapp)
server.delete()
vapp = self.vca_client.get_vapp(
vdc,
self.ctx.node.properties['server']['name'])
self.assertTrue(vapp is None)
def test_create_link_success(self):
"""
test server create with default value and success in link
"""
fake_ctx = self.generate_context_for_create()
fake_client = self.generate_client()
self.run_with_statuses(fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS)
with mock.patch('vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_create_connection_empty_task(self):
"""
test server create with default value and empty task
from connection
"""
fake_ctx = self.generate_context_for_create()
fake_client = self.generate_client()
self.run_with_statuses(fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS)
with mock.patch('vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)):
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_create_external_resource(self):
"""
must run without any errors
"""
fake_ctx = self.generate_node_context(properties={
'use_external_resource': True,
'resource_id': 'ServerName'
})
with mock.patch('vcloud_plugin_common.VcloudAirClient',
self.generate_vca()):
server.create(ctx=fake_ctx)
self.assertTrue(
server.VCLOUD_VAPP_NAME in fake_ctx.instance.runtime_properties)
self.assertTrue(
fake_ctx.instance.runtime_properties[server.VCLOUD_VAPP_NAME],
'ServerName')
def test_create_connection_empty_task(self):
"""
test server create with default value and empty task
from connection
"""
fake_ctx = self.generate_context_for_create()
fake_client = self.generate_client()
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_create_link_success(self):
"""
test server create with default value and success in link
"""
fake_ctx = self.generate_context_for_create()
fake_client = self.generate_client()
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_create_cpu_mem_values(self):
"""
check custom cpu/memmory with error in task
"""
fake_ctx = self.generate_node_context(
properties={
'management_network': '_management_network',
'vcloud_config': {
'vdc': 'vdc_name'
},
'server': {
'template': 'ubuntu',
'catalog': 'public',
'hardware': {
'cpu': 1,
'memory': 512
}
}
},
relation_node_properties={"not_test": "not_test"})
fake_client = self.generate_client()
self.run_with_statuses(fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS)
with mock.patch('vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)):
# can't customize memory
with self.assertRaises(cfy_exc.NonRecoverableError):
server.configure(ctx=fake_ctx)
fake_client._vapp.modify_vm_memory.assert_called_with('test', 512)
fake_client._vapp.modify_vm_memory = mock.MagicMock(
return_value=self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS))
# can't customize cpu
with self.assertRaises(cfy_exc.NonRecoverableError):
server.configure(ctx=fake_ctx)
fake_client._vapp.modify_vm_cpu.assert_called_with('test', 1)
fake_client._vapp.modify_vm_cpu = mock.MagicMock(
return_value=self.generate_task(
vcloud_plugin_common.TASK_STATUS_SUCCESS))
# everything fine
server.create(ctx=fake_ctx)
def test_create_customization(self):
"""
test customization - task None
"""
fake_ctx = self.generate_context_for_customization()
fake_client = self.generate_client()
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_create_customization(self):
"""
test customization - task None
"""
fake_ctx = self.generate_context_for_customization()
fake_client = self.generate_client()
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
with self.assertRaises(cfy_exc.NonRecoverableError):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
def test_server_stop_start(self):
server.create()
vdc = self.vca_client.get_vdc(self.vcloud_config['org'])
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertFalse(vapp is None)
self.assertFalse(server._vapp_is_on(vapp))
self._run_with_retry(server.start, self.ctx)
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertTrue(server._vapp_is_on(vapp))
server.stop()
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertFalse(server._vapp_is_on(vapp))
self._run_with_retry(server.start, self.ctx)
vapp = self.vca_client.get_vapp(
vdc, self.ctx.node.properties['server']['name'])
self.assertTrue(server._vapp_is_on(vapp))
def test_create_customization_customized(self):
"""
test customization - success customization
"""
fake_ctx = self.generate_context_for_customization()
fake_client = self.generate_client()
fake_client._vapp.customize_on_next_poweron = mock.MagicMock(
return_value=True
)
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
self.check_get_vapp(fake_client, 'test')
def test_create_external_resource(self):
"""
must run without any errors
"""
fake_ctx = self.generate_node_context(
properties={
'use_external_resource': True,
'resource_id': 'ServerName'
}
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient',
self.generate_vca()
):
server.create(ctx=fake_ctx)
self.assertTrue(
server.VCLOUD_VAPP_NAME in fake_ctx.instance.runtime_properties
)
self.assertTrue(
fake_ctx.instance.runtime_properties[server.VCLOUD_VAPP_NAME],
'ServerName'
)
def test_create_customization_customized(self):
"""
test customization - success customization
"""
fake_ctx = self.generate_context_for_customization()
fake_client = self.generate_client()
fake_client._vapp.customize_on_next_poweron = mock.MagicMock(
return_value=True
)
self.run_with_statuses(
fake_client, fake_ctx,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS,
vcloud_plugin_common.TASK_STATUS_SUCCESS
)
with mock.patch(
'vcloud_plugin_common.VcloudAirClient.get',
mock.MagicMock(return_value=fake_client)
):
server.create(ctx=fake_ctx)
self.check_create_call(fake_client, fake_ctx)
self.check_get_vapp(fake_client, 'test')
def _create_server(self):
with contextlib.nested(
mock.patch('server_plugin.server.ctx', self.server_ctx),
mock.patch('vcloud_plugin_common.ctx', self.server_ctx)):
server.create()
self._run_with_retry(server.start, self.server_ctx)
def _create_server(self):
with contextlib.nested(
mock.patch('server_plugin.server.ctx', self.server_ctx),
mock.patch('vcloud_plugin_common.ctx', self.server_ctx)):
server.create()
self._run_with_retry(server.start, self.server_ctx)
