def test_service_registration(self):
""" Verifies that the Pipeline class can correctly register services. The service registration feature allows
devices to offer services or script access to other devices in the pipeline.
"""
# Load the pipeline configuration and create a test pipeline
self.config.read_configuration(self.source_data_directory+'/hardware/pipelines/tests/data/pipeline_configuration_valid.yml')
test_pipeline = pipeline.Pipeline(self.config.get('pipelines')[0], self.device_manager, self.command_parser)
test_service_type = 'waffle'
# Create and register a mock service
test_service = MagicMock()
test_service.id = 'test_service'
test_service.type = test_service_type
test_pipeline.register_service(test_service)
self.assertTrue(test_pipeline.services[test_service_type]['test_service'] is test_service)
# Create and register a mock service with the same type but a different ID
test_service_2 = MagicMock()
test_service_2.id = 'test_service_2'
test_service_2.type = test_service_type
test_pipeline.register_service(test_service_2)
self.assertTrue(test_pipeline.services[test_service_type]['test_service_2'] is test_service_2)
# Try to register a third service with the same type and ID as an earlier service
test_service_3 = MagicMock()
test_service_3.id = 'test_service'
test_service_3.type = test_service_type
self.assertRaises(pipeline.ServiceAlreadyRegistered, test_pipeline.register_service, test_service_3)
def test_writing_device_output(self):
""" Tests that the Driver class can pass its output to its registered pipelines. The default implementation of the
Driver.write_output() method only writes to active pipelines that specify this device as its output device.
"""
# Load a device to test with
test_driver = self.device_manager.get_device_driver("test_device")
# Create some mock pipelines and register them with the device
test_pipeline = MagicMock()
test_pipeline.id = "test_pipeline"
test_pipeline.is_active = False
test_driver.register_pipeline(test_pipeline)
test_pipeline_2 = MagicMock()
test_pipeline_2.id = "test_pipeline_2"
test_pipeline_2.is_active = True
test_driver.register_pipeline(test_pipeline_2)
test_pipeline_3 = MagicMock()
test_pipeline_3.id = "test_pipeline_3"
test_pipeline_3.is_active = True
test_pipeline_3.output_device = test_driver
test_driver.register_pipeline(test_pipeline_3)
# Write some output to the associated pipelines
test_driver.write_output("waffles")
# Make sure the output never made it to the non-active pipeline
self.assertEqual(test_pipeline.write_output.call_count, 0)
# Make sure that test_pipeline_2 was never called (doesn't specify test_device as its output device)
self.assertEqual(test_pipeline_2.write_output.call_count, 0)
# Verify that test_pipeline_3 was called with the correct output
test_pipeline_3.write_output.assert_called_once_with("waffles")
def test_create_from_rest_analyte(self):
udfs = {"Some udf": 10}
api_resource = MagicMock()
api_resource.udf = udfs
api_resource.location = [None, "B:2"]
sample = MagicMock()
sample.id = "sample1"
api_resource.samples = [sample]
api_resource.id = "art1"
api_resource.name = "sample1"
container_repo = MagicMock()
container = fake_container("cont1")
container_repo.get_container.return_value = container
clarity_mapper = ClarityMapper()
analyte = clarity_mapper.analyte_create_object(
api_resource, is_input=True, container_repo=container_repo, process_type=MagicMock())
expected_analyte = fake_analyte(container_id="cont1", artifact_id="art1", sample_ids=["sample1"],
analyte_name="sample1", well_key="B:2", is_input=True,
requested_volume=10, udfs=udfs)
self.assertEqual(expected_analyte.udf_some_udf,
analyte.udf_some_udf)
self.assertEqual(expected_analyte.id, analyte.id)
self.assertEqual(expected_analyte.name, analyte.name)
self.assertEqual(expected_analyte.well.__repr__(),
analyte.well.__repr__())
self.assertEqual(expected_analyte.well.artifact.name,
analyte.well.artifact.name)
def test_pipeline_registration(self):
""" Verifies that the base driver class can correctly register pipelines
"""
# Load a driver to test with
test_driver = self.device_manager.get_device_driver("test_device")
# Create some mock pipelines to register with the device
test_pipeline = MagicMock()
test_pipeline.id = "test_pipeline"
test_pipeline.output_device = test_driver
test_pipeline_2 = MagicMock()
test_pipeline_2.id = "test_pipeline_2"
test_pipeline_2.output_device = test_driver
# Register the pipelines
test_driver.register_pipeline(test_pipeline)
test_driver.register_pipeline(test_pipeline_2)
self.assertTrue((test_driver.associated_pipelines[test_pipeline.id].id == test_pipeline.id) and
(test_driver.associated_pipelines[test_pipeline.id].output_device is test_driver))
self.assertTrue((test_driver.associated_pipelines[test_pipeline_2.id].id == test_pipeline_2.id) and
(test_driver.associated_pipelines[test_pipeline_2.id].output_device is test_driver))
# Make sure that pipelines can't be re-registered
self.assertRaises(driver.PipelineAlreadyRegistered, test_driver.register_pipeline, test_pipeline)
def test_30_updateVMInfo(self, get_driver):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.ip = '158.42.1.1' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'aws://ami-id' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{'id': 'libcloud', 'type': 'LibCloud', 'username': '******',
'password': '******', 'driver': 'EC2'}])
lib_cloud = self.get_lib_cloud()
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "1", lib_cloud.cloud, radl, radl, lib_cloud)
driver = MagicMock()
driver.name = "Amazon EC2"
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {'availability': 'use-east-1'}
node.public_ips = []
node.private_ips = ['10.0.0.1']
node.driver = driver
node.size = MagicMock()
node.size.ram = 512
node.size.price = 1
node.size.disk = 1
node.size.vcpus = 1
node.size.name = "small"
driver.list_nodes.return_value = [node]
volume = MagicMock()
volume.id = "vol1"
volume.extra = {"state": "available"}
volume.attach.return_value = True
driver.create_volume.return_value = volume
driver.ex_allocate_address.return_value = "10.0.0.1"
success, vm = lib_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_service_activation_and_lookup(self):
""" This tests that the service activation and lookup methods are working as expected. In order for a service to be
query-able, it must be active (as specified by the configuration for the session using the pipeline).
"""
# Create a test pipeline to work with
self.config.read_configuration(self.source_data_directory+'/hardware/pipelines/tests/data/pipeline_configuration_valid.yml')
test_pipeline = pipeline.Pipeline(self.config.get('pipelines')[0], self.device_manager, self.command_parser)
# Create some mock services and register them with the pipeline
test_tracker_service = MagicMock()
test_tracker_service.id = "sgp4"
test_tracker_service.type = "tracker"
test_pipeline.register_service(test_tracker_service)
test_logger_service = MagicMock()
test_logger_service.id = "basic"
test_logger_service.type = "logger"
test_pipeline.register_service(test_logger_service)
test_cornballer_service = MagicMock()
test_cornballer_service.id = "deluxe"
test_cornballer_service.type = "cornballer"
test_pipeline.register_service(test_cornballer_service)
# Define a callback to continue the test after the schedule has been loaded
def continue_test(reservation_schedule):
# Load a reservation that specifies some active services
test_reservation_config = self._load_reservation_config(reservation_schedule, 'RES.5')
# Create a new session
test_session = session.Session(test_reservation_config, test_pipeline, self.command_parser)
# Register the session with the pipeline; this will also activate the reservation's services
test_pipeline.register_session(test_session)
# Make sure the active services can be loaded
self.assertTrue(test_pipeline.load_service("tracker") is test_tracker_service)
self.assertTrue(test_pipeline.load_service("logger") is test_logger_service)
self.assertRaises(pipeline.ServiceTypeNotFound, test_pipeline.load_service, "cornballer")
# Add an unknown active service type to the reservation configuration and re-register it
test_pipeline.current_session = None
test_reservation_config['active_services']['nonexistent_type'] = "nonexistent_service"
test_session = session.Session(test_reservation_config, test_pipeline, self.command_parser)
self.assertRaises(pipeline.ServiceInvalid, test_pipeline.register_session, test_session)
# Add an unknown active service ID to the reservation configuration and re-register it
test_pipeline.current_session = None
test_reservation_config['active_services'].pop("nonexistent_type", None)
test_reservation_config['active_services']['tracker'] = "nonexistent_service"
test_session = session.Session(test_reservation_config, test_pipeline, self.command_parser)
self.assertRaises(pipeline.ServiceInvalid, test_pipeline.register_session, test_session)
# Load up a test schedule to work with
schedule_update_deferred = self._load_test_schedule()
schedule_update_deferred.addCallback(continue_test)
return schedule_update_deferred
def mock_artifact_resource(resouce_id=None, sample_name=None, well_position=None):
api_resource = MagicMock()
if well_position:
api_resource.location = [None, well_position]
sample = MagicMock()
sample.id = sample_name
api_resource.samples = [sample]
api_resource.id = resouce_id
api_resource.name = sample_name
return api_resource
def test_30_updateVMInfo(self, get_driver):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'gce://us-central1-a/centos-6' and
disk.0.os.credentials.username = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{'id': 'one', 'type': 'GCE', 'username': '******',
'password': '******', 'project': 'proj'}])
gce_cloud = self.get_gce_cloud()
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "1", gce_cloud.cloud, radl, radl, gce_cloud)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
zone = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {'flavorId': 'small'}
node.public_ips = []
node.public_ips = ['158.42.1.1']
node.private_ips = ['10.0.0.1']
node.driver = driver
zone.name = 'us-central1-a'
node.extra = {'zone': zone}
driver.ex_get_node.return_value = node
volume = MagicMock()
volume.id = "vol1"
volume.attach.return_value = True
volume.extra = {'status': 'READY'}
driver.create_volume.return_value = volume
success, vm = gce_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_session_termination(self):
""" This test checks that the session coordinator can correctly clean up sessions once they expire (as determined by
their reservation timestamp range).
"""
# Load in some valid configuration and set the defaults using validate_configuration()
self.config.read_configuration(self.source_data_directory+'/core/tests/data/test_config_basic.yml')
self.config.read_configuration(self.source_data_directory+'/hardware/pipelines/tests/data/pipeline_configuration_valid.yml')
self.config.validate_configuration()
# Setup the pipeline manager
test_pipelines = pipeline_manager.PipelineManager(self.device_manager, self.command_parser)
# Create the expected mock services
test_tracker_service = MagicMock()
test_tracker_service.id = "sgp4"
test_tracker_service.type = "tracker"
test_pipelines.pipelines['test_pipeline3'].register_service(test_tracker_service)
test_logger_service = MagicMock()
test_logger_service.id = "basic"
test_logger_service.type = "logger"
test_pipelines.pipelines['test_pipeline3'].register_service(test_logger_service)
# Setup the schedule manager
test_schedule = schedule.ScheduleManager(self.source_data_directory+'/sessions/tests/data/test_schedule_valid.json')
# Initialize the session coordinator
session_coordinator = coordinator.SessionCoordinator(test_schedule,
self.device_manager,
test_pipelines,
self.command_parser)
def continue_test(loaded_schedule):
# Activate the test reservation
session_coordinator._check_for_new_reservations()
self.assertTrue('RES.6' in session_coordinator.active_sessions)
res6 = session_coordinator.active_sessions['RES.6']
res6.kill_session = MagicMock()
# Change the expiration time on the reservation to make it expire
res6.configuration['time_end'] = 1383264000
# Kill the expired session
session_coordinator._check_for_finished_sessions()
res6.kill_session.assert_called_once_with()
self.assertTrue('RES.6' in session_coordinator.closed_sessions and
'RES.6' not in session_coordinator.active_sessions)
# Update the schedule to load in the reservations
schedule_update_deferred = test_schedule.update_schedule()
schedule_update_deferred.addCallback(continue_test)
return schedule_update_deferred
def test_session_startup_pipeline_setup_command_errors(self):
""" Tests that the Session class correctly handles fatal pipeline setup command errors when starting a new session.
"""
# First create a pipeline that contains invalid pipeline setup commands (to force an error)
test_pipeline = pipeline.Pipeline(self.config.get('pipelines')[2], self.device_manager, self.command_parser)
# Create the expected mock services
test_tracker_service = MagicMock()
test_tracker_service.id = "sgp4"
test_tracker_service.type = "tracker"
test_pipeline.register_service(test_tracker_service)
test_logger_service = MagicMock()
test_logger_service.id = "basic"
test_logger_service.type = "logger"
test_pipeline.register_service(test_logger_service)
# Define a callback to check the results of the session start procedure
def check_results(session_start_failure, test_session):
# Check if the correct error was generated (caused by a failed pipeline setup command)
self.assertTrue(isinstance(session_start_failure.value, parser.CommandFailed))
# Make sure the session is not active
self.assertTrue(not test_session.is_active)
# Make sure that the pipeline was freed after the error
self.assertTrue(not test_pipeline.is_active)
for temp_device in test_pipeline.devices:
# Try to lock the devices, if this fails then something wasn't unlocked correctly
test_pipeline.devices[temp_device].reserve_device()
# Define a callback to continue the test after the schedule has been loaded
def continue_test(reservation_schedule):
# Find the reservation that we want to test with
test_reservation_config = self._load_reservation_config(reservation_schedule, 'RES.5')
# Create a new session
test_session = session.Session(test_reservation_config, test_pipeline, self.command_parser)
# Start the session
session_start_deferred = test_session.start_session()
session_start_deferred.addErrback(check_results, test_session)
return session_start_deferred
# Now load up a test schedule to work with
schedule_update_deferred = self._load_test_schedule()
schedule_update_deferred.addCallback(continue_test)
return schedule_update_deferred
def test_60_finalize(self, get_driver):
auth = Authentication([{'id': 'libcloud', 'type': 'LibCloud', 'username': '******',
'password': '******', 'driver': 'EC2'}])
lib_cloud = self.get_lib_cloud()
radl_data = """
system test (
cpu.count>=2 and
memory.size>=2048m
)"""
radl = radl_parse.parse_radl(radl_data)
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "1", lib_cloud.cloud, radl, radl, lib_cloud)
vm.keypair = ""
driver = MagicMock()
driver.name = "Amazon EC2"
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.driver = driver
node.destroy.return_value = True
driver.list_nodes.return_value = [node]
sg = MagicMock()
sg.id = sg.name = "sg1"
driver.ex_get_node_security_groups.return_value = [sg]
keypair = MagicMock()
driver.get_key_pair.return_value = keypair
vm.keypair = keypair
volume = MagicMock()
volume.id = "id"
vm.volumes = [volume]
driver.delete_key_pair.return_value = True
driver.ex_describe_addresses_for_node.return_value = ["ip"]
driver.ex_disassociate_address.return_value = True
success, _ = lib_cloud.finalize(vm, auth)
self.assertTrue(success, msg="ERROR: finalizing VM info.")
self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_no_members_cannot_post(self, gi):
'If there are no posting members then everyone can post'
g = self.get_group_with_posting_members([])
u = MagicMock()
u.id = 'postingMember'
pm = PostingMember(u, g)
pm.check()
self.assert_can_post(pm)
u = MagicMock()
u.id = 'normalMember'
pm = PostingMember(u, g)
pm.check()
self.assert_can_post(pm)
def test_50_start(self, get_driver):
auth = Authentication([{'id': 'ost', 'type': 'OpenStack', 'username': '******',
'password': '******', 'tenant': 'tenant', 'host': 'https://server.com:5000'}])
ost_cloud = self.get_ost_cloud()
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "1", ost_cloud.cloud, "", "", ost_cloud)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {'flavorId': 'small'}
node.public_ips = ['158.42.1.1']
node.private_ips = ['10.0.0.1']
node.driver = driver
driver.list_nodes.return_value = [node]
driver.ex_start_node.return_value = True
success, _ = ost_cloud.start(vm, auth)
self.assertTrue(success, msg="ERROR: stopping VM info.")
self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_process_new_doppler_correction(self):
""" Verifies that the process_new_position() callback correctly responds to new doppler correction information. """
# Create a test pipeline
test_pipeline = MagicMock()
test_pipeline.id = "test_pipeline"
test_pipeline.current_session.user_id = "test_user"
def mock_parse_command(command_request, **keywords):
if command_request["command"] == "set_rx_freq":
self.assertEqual(command_request["parameters"]["frequency"], 5)
elif command_request["command"] == "set_tx_freq":
self.assertEqual(command_request["parameters"]["frequency"], 25)
return defer.succeed({"response": {"status": "okay"}})
# Create a test Icom driver
test_cp = MagicMock()
test_cp.parse_command = mock_parse_command
test_device = icom_910.ICOM_910(self.standard_icom_config, test_cp)
test_device._session_pipeline = test_pipeline
test_device._radio_state["set_rx_freq"] = 20
test_device._radio_state["set_tx_freq"] = 100
# Create a mock target_position and submit it
doppler_correction = {"doppler_multiplier": 0.25}
test_deferred = test_device.process_new_doppler_correction(doppler_correction)
results = yield test_deferred
# Verify result
self.assertTrue(results)
self.assertTrue(test_device._last_doppler_update > 0)
def test_50_start(self, get_driver):
auth = Authentication([{'id': 'libcloud', 'type': 'LibCloud', 'username': '******',
'password': '******', 'driver': 'EC2'}])
lib_cloud = self.get_lib_cloud()
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "1", lib_cloud.cloud, "", "", lib_cloud)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.driver = driver
driver.list_nodes.return_value = [node]
driver.ex_stop_node.return_value = True
success, _ = lib_cloud.start(vm, auth)
self.assertTrue(success, msg="ERROR: stopping VM info.")
self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_comit_no_parents(self):
mocked_repo = MagicMock()
mocked_parent = MagicMock()
mocked_parent.id = 1
mocked_repo.status.return_value = True
mocked_repo.index.write_tree.return_value = "tree"
mocked_repo.revparse_single.return_value = mocked_parent
mocked_repo.create_commit.return_value = "commit"
author = ("author_1", "author_2")
commiter = ("commiter_1", "commiter_2")
with patch('gitfs.repository.Signature') as mocked_signature:
mocked_signature.return_value = "signature"
repo = Repository(mocked_repo)
commit = repo.commit("message", author, commiter)
assert commit == "commit"
assert mocked_repo.status.call_count == 1
assert mocked_repo.index.write_tree.call_count == 1
assert mocked_repo.index.write.call_count == 1
mocked_signature.has_calls([call(*author), call(*commiter)])
mocked_repo.revparse_single.assert_called_once_with("HEAD")
mocked_repo.create_commit.assert_called_once_with("HEAD",
"signature",
"signature",
"message",
"tree", [1])
def test_on_taskrun_submit_event(self, mock_update_feed,
mock_add_user,
mock_is_task,
mock_update_task,
mock_create_result,
mock_push):
"""Test on_taskrun_submit is called."""
conn = MagicMock()
target = MagicMock()
target.id = 1
target.project_id = 1
target.task_id = 2
target.user_id = 3
tmp = Project(id=1, name='name', short_name='short_name',
info=dict(container=1, thumbnail="avatar.png"),
published=True,
webhook='http://localhost.com')
conn.execute.return_value = [tmp]
on_taskrun_submit(None, conn, target)
obj = tmp.to_public_json()
obj['action_updated'] = 'TaskCompleted'
mock_add_user.assert_called_with(conn, target.user_id, obj)
mock_update_task.assert_called_with(conn, target.task_id)
mock_update_feed.assert_called_once_with(obj)
obj_with_webhook = tmp.to_public_json()
obj_with_webhook['webhook'] = tmp.webhook
obj_with_webhook['action_updated'] = 'TaskCompleted'
mock_push.assert_called_with(obj_with_webhook, target.task_id, 1)
def test_state_changed(self):
"""Test dispatching a state changed event."""
# Pretend we're updating jobs#1234.
mock_context = Mock()
mock_context.work_status.value = u'state:CREATED'
mock_event = Mock()
mock_event.id = 1234
self.mock_unpack.return_value = ('jobs', 1234)
# Dispatch an update.
client = self.makeOne()
return_value = client.changed(mock_context, mock_event)
# The path is constructed from the context.
self.mock_unpack.assert_called_with(mock_context)
# The return value includes the status of the dispatch.
status = return_value['status']
self.assertTrue(status == u'DISPATCHED')
# And the dispatcher was called with the url and data.
torque_url = self.mock_request.registry.settings['torque.url']
call_args = self.mock_dispatcher.call_args[0]
url = call_args[0]
data = json.loads(call_args[1])
self.assertTrue(url.startswith(torque_url))
self.assertTrue(data['event_id'] == 1234)
self.assertTrue(data['state'] == u'state:CREATED')
def get_user_info(factoryName, context, userId, anonymous):
'''A utility method that allows us to easily mock calls to the createObject function'''
retval = MagicMock()
retval.id = userId
retval.name = 'Named {0}'.format(userId)
retval.anonymous = anonymous
return retval
def test_sync_record_create_noexist_noflavor(self):
""" Create a ServiceInstance with no flavor. It should automatically default to m1.small """
fakeconn = MagicMock()
with patch.object(self.step_class, "connect_openstack_admin") as fake_connect_openstack_admin:
fake_connect_openstack_admin.return_value = fakeconn
xos_instance = OpenStackServiceInstance(name="test-instance", slice=self.slice, image=self.image,
node=self.node)
step = self.step_class(model_accessor=self.model_accessor)
fakeconn.compute.servers.return_value = []
fakeconn.identity.find_project.return_value = MagicMock(id=self.slice.backend_handle)
fakeconn.identity.find_domain.return_value = MagicMock(id=self.trust_domain.backend_handle)
fakeconn.compute.find_image.return_value = MagicMock(id=self.image.backend_handle)
fakeconn.compute.find_flavor.return_value = MagicMock(id=self.flavor.backend_handle)
os_instance = MagicMock()
os_instance.id = "1234"
fakeconn.compute.create_server.return_value = os_instance
step.sync_record(xos_instance)
fakeconn.compute.create_server.assert_called_with(admin_password=ANY,
availability_zone="nova:test-node",
config_drive=True,
flavor_id=self.flavor.backend_handle,
image_id=self.image.backend_handle,
name=xos_instance.name,
networks=[],
project_domain_id=self.slice.backend_handle,
user_data=ANY)
self.assertEqual(xos_instance.backend_handle, "1234")
def test_add_helping_materials_excel_with_info(self, auto_mock, find_mock, workbook_mock):
"""Test add_helpingmaterials excel with info field works."""
auto_mock.return_value = (0, None)
project = MagicMock()
project.name = 'name'
project.short_name = 'short_name'
project.description = 'description'
project.info = dict()
project.id = 1
wb = Workbook()
ws = wb.active
headers = ['Column Name', 'foo']
ws.append(headers)
for row in range(2, 10):
ws.append(['value', 'bar'])
ws.append([None, None])
ws.append([None, None])
find_mock.return_value = project
helpingmaterials = MagicMock()
helpingmaterials.read.return_value = wb
workbook_mock.return_value = wb
pbclient = MagicMock()
self.config.pbclient = pbclient
res = _add_helpingmaterials(self.config, helpingmaterials, 'xlsx')
self.config.pbclient.create_helpingmaterial.assert_called_with(project_id=find_mock().id,
info={u'column_name': u'value',
u'foo': u'bar'})
assert res == '8 helping materials added to project: short_name', res
def test__get_relative_path(self):
repo = MagicMock()
repo.id = 'awesome_repo'
relative_path = publish._get_relative_path(repo)
self.assertEqual(relative_path, repo.id)
def test_validate_commit_path_with_more_than_one_entry(self):
mocked_repo = MagicMock()
mocked_commit = MagicMock()
mocked_entry = MagicMock()
mocked_second_entry = MagicMock()
mocked_commit.tree = "tree"
mocked_repo.revparse_single.return_value = mocked_commit
mocked_second_entry.id = 1
mocked_second_entry.name = "complex_entry"
mocked_second_entry.filemode = GIT_FILEMODE_TREE
mocked_entry.name = "simple_entry"
mocked_entry.filemode = GIT_FILEMODE_TREE
mocked_repo.__getitem__.return_value = [mocked_entry]
view = CommitView(repo=mocked_repo, commit_sha1="sha1",
mount_time="now", uid=1, gid=1)
result = view._validate_commit_path([mocked_second_entry,
mocked_entry],
["complex_entry",
"simple_entry"])
assert result is True
mocked_repo.__getitem__.assert_called_once_with(1)
def test_reap_tmp_images(self, _os_datastore_path, _uuid):
""" Test that stray images are found and deleted by the reaper """
def _fake_ds_folder(datastore, folder):
return "%s__%s" % (datastore, folder)
ds = MagicMock()
ds.id = "dsid"
ds.type = DatastoreType.EXT3
# In a random transient directory, set up a directory to act as the
# tmp images folder and to contain a stray image folder with a file.
tmpdir = file_util.mkdtemp(delete=True)
tmp_images_folder = _fake_ds_folder(ds.id, TMP_IMAGE_FOLDER_NAME)
tmp_images_dir = os.path.join(tmpdir, tmp_images_folder)
tmp_image_dir = os.path.join(tmp_images_dir, "stray_image")
os.mkdir(tmp_images_dir)
os.mkdir(tmp_image_dir)
(fd, path) = tempfile.mkstemp(prefix='strayimage_', dir=tmp_image_dir)
self.assertTrue(os.path.exists(path))
def _fake_os_datastore_path(datastore, folder):
return os.path.join(tmpdir, _fake_ds_folder(datastore, folder))
_os_datastore_path.side_effect = _fake_os_datastore_path
ds_manager = MagicMock()
ds_manager.get_datastores.return_value = [ds]
image_manager = EsxImageManager(self.vim_client, ds_manager)
image_manager.reap_tmp_images()
# verify stray image is deleted
self.assertFalse(os.path.exists(path))
def test_recursive_removal(self):
item1 = MagicMock()
item1.id = "item1"
item1._deps = ["item2"]
item2 = MagicMock()
item2.id = "item2"
item2._deps = ["item3"]
item3 = MagicMock()
item3.id = "item3"
item3._deps = []
items = [item1, item2, item3]
self.assertEqual(
deps.remove_item_dependents(items, "item3"),
([item3], [item2, item1]),
)
def test__remove_repository_protection(self, delete_protected_repo):
repo = MagicMock()
repo.id = 'reporeporeporepo'
publish.remove_repository_protection(repo)
delete_protected_repo.assert_called_once_with(publish._get_relative_path(repo))
def test_auth_package_update(self, creator_user_id, user_obj_id, user, owner_org, owner_member, authorized):
# Configure the mocks
returned_package = MagicMock()
returned_package.creator_user_id = creator_user_id
returned_package.owner_org = owner_org
auth.logic_auth.get_package_object = MagicMock(return_value=returned_package)
auth.new_authz.has_user_permission_for_group_or_org = MagicMock(return_value=owner_member)
# Prepare the context
context = {}
if user is not None:
context['user'] = user
if user_obj_id is not None:
context['auth_user_obj'] = MagicMock()
context['auth_user_obj'].id = user_obj_id
# Function to be tested
result = auth.package_update(context, {})
# Check the result
self.assertEquals(authorized, result['success'])
# Permissions for organization are checked when the user asking to update the dataset is not the creator
# and when the dataset has organization
if creator_user_id != user_obj_id and owner_org:
auth.new_authz.has_user_permission_for_group_or_org.assert_called_once_with(owner_org, user, 'update_dataset')
else:
self.assertEquals(0, auth.new_authz.has_user_permission_for_group_or_org.call_count)
def subject_mock(id, projectID):
s = MagicMock(name='subject', spec=pyxnat.core.resources.Subject)
xnat = _set_mock_intf(s)
s.id = Mock(return_value=id)
s.datatype = Mock(return_value='xnat:subjectData')
s._uri = '/subjects/' + id
attrs = {
'xnat:subjectData/project' : projectID
}
_set_mock_attrs(attrs, s)
# Resources
_add_mock_resource_files(xnat, s)
#Sessions
exp1 = session_mock(baseURI=s._uri, xnat=xnat)
sessions = { '1':exp1 }
get = Mock()
get.get = Mock(side_effect=return_collection(['1']))
s.experiments = Mock(return_value=get)
s.experiment = Mock(side_effect=lambda x: sessions.get(x))
return s
def test_get_deployment_resource_no_blueprint_resource(self):
deployment_context_mock = MagicMock()
deployment_context_mock.id = 'dep1'
self.context.deployment = deployment_context_mock
resource = self.context.get_resource(
resource_path='for_test_only_dep.txt')
self.assertEquals(resource, 'belongs to dep1')
def test__copy_to_hosted_location(self):
"""
Test the operation of _copy_to_hosted_location().
"""
repo = MagicMock(spec=Repository)
repo.id = "lebowski"
repo.working_dir = self.temp_dir
progress_report = progress.PublishProgressReport(self.publish_conduit)
config = distributor_mocks.get_basic_config(
**{constants.CONFIG_SERVE_HTTP: True, constants.CONFIG_SERVE_HTTPS: True}
)
# Let's put a dummy file and a dummy symlink in the build_dir, so we can make sure they get
# copied to the right places.
build_dir = publish._get_or_create_build_dir(repo)
with open(os.path.join(build_dir, "the_dude.txt"), "w") as the_dude:
the_dude.write("Let's go bowling.")
os.symlink("/symlink/path", os.path.join(build_dir, "symlink"))
# This should copy our dummy file to the monkey patched folders from our setUp() method.
publish._copy_to_hosted_location(repo, config, progress_report)
# Make sure that the_dude.txt got copied to the right places
expected_http_path = os.path.join(constants.ISO_HTTP_DIR, "lebowski", "the_dude.txt")
expected_https_path = os.path.join(constants.ISO_HTTPS_DIR, "lebowski", "the_dude.txt")
self.assertTrue(os.path.exists(expected_http_path))
self.assertTrue(os.path.exists(expected_https_path))
# Now make sure our symlink is also in place, and points to the correct location
expected_http_symlink_path = os.path.join(constants.ISO_HTTP_DIR, "lebowski", "symlink")
expected_https_symlink_path = os.path.join(constants.ISO_HTTPS_DIR, "lebowski", "symlink")
self.assertTrue(os.path.islink(expected_http_symlink_path))
self.assertTrue(os.path.islink(expected_https_symlink_path))
self.assertEqual(os.path.realpath(expected_http_symlink_path), "/symlink/path")
self.assertEqual(os.path.realpath(expected_https_symlink_path), "/symlink/path")
def test_score_job_exe_for_reservation(self):
"""Tests calling score_job_exe_for_reservation() successfully"""
node = MagicMock()
node.hostname = 'host_1'
node.id = 1
node.is_ready_for_new_job = MagicMock()
node.is_ready_for_new_job.return_value = True
node.is_ready_for_next_job_task = MagicMock()
node.is_ready_for_next_job_task.return_value = True
offered_resources = NodeResources([Cpus(20.0), Mem(100.0)])
watermark_resources = NodeResources([Cpus(200.0), Mem(700.0)])
resource_set = ResourceSet(offered_resources, NodeResources(),
watermark_resources)
task = HealthTask(
'1234', 'agent_1') # Resources are 0.1 CPUs and 32 MiB memory
job_exe_1 = job_test_utils.create_running_job_exe(
agent_id=self.agent_id,
resources=NodeResources([Cpus(10.0), Mem(50.0)]),
priority=1000)
job_exe_2 = job_test_utils.create_running_job_exe(
agent_id=self.agent_id,
resources=NodeResources([Cpus(56.0), Mem(15.0)]),
priority=100)
scheduling_node = SchedulingNode('agent_1', node, [task],
[job_exe_1, job_exe_2], resource_set)
queue_model_1 = queue_test_utils.create_queue(priority=100,
cpus_required=8.0,
mem_required=40.0,
disk_in_required=0.0,
disk_out_required=0.0,
disk_total_required=0.0)
job_exe_1 = QueuedJobExecution(queue_model_1)
queue_model_2 = queue_test_utils.create_queue(priority=1000,
cpus_required=8.0,
mem_required=40.0,
disk_in_required=0.0,
disk_out_required=0.0,
disk_total_required=0.0)
job_exe_2 = QueuedJobExecution(queue_model_2)
scheduling_node.accept_new_job_exe(job_exe_1)
scheduling_node.accept_new_job_exe(job_exe_2)
# We are going to try to reserve the node for a job execution with priority 120
# Calculate available resources for reservation:
# Watermark (200, 700) - System Tasks (0.1, 32) - Higher Priority Existing Job Exes (56, 15) - Higher Priority
# New Job Exes (8, 40) = 135.9 CPUs, 613 memory
# This new job should fit for reservation
queue_model = queue_test_utils.create_queue(priority=120,
cpus_required=130.0,
mem_required=600.0,
disk_in_required=0.0,
disk_out_required=0.0,
disk_total_required=0.0)
job_exe = QueuedJobExecution(queue_model)
# Expected available 5.9 CPUs and 13 MiB memory "left" on node
# (available above - new job we are scoring)
# First 2 job types should fit, next 2 are too big, so score should be 2
job_type_resource_1 = NodeResources([Cpus(2.0), Mem(10.0)])
job_type_resource_2 = NodeResources([Cpus(5.5), Mem(12.0)])
job_type_resource_3 = NodeResources([Cpus(6.0), Mem(10.0)])
job_type_resource_4 = NodeResources([Cpus(2.0), Mem(14.0)])
score = scheduling_node.score_job_exe_for_reservation(
job_exe, [
job_type_resource_1, job_type_resource_2, job_type_resource_3,
job_type_resource_4
])
self.assertEqual(score, 2)
def test_add_allocated_offers_remove_all_tasks(self):
"""Tests calling add_allocated_offers() when there are not enough resources for the job exes or node tasks"""
node = MagicMock()
node.hostname = 'host_1'
node.id = 1
health_task = HealthTask('1234', 'agent_1')
pull_task = PullTask('1234', 'agent_1')
node.is_ready_for_new_job = MagicMock()
node.is_ready_for_new_job.return_value = True
node.is_ready_for_next_job_task = MagicMock()
node.is_ready_for_next_job_task.return_value = True
node.get_next_tasks = MagicMock()
node.get_next_tasks.return_value = [health_task, pull_task]
offered_resources = NodeResources([Cpus(100.0), Mem(500.0)])
watermark_resources = NodeResources([Cpus(100.0), Mem(500.0)])
resource_set = ResourceSet(offered_resources, NodeResources(),
watermark_resources)
scheduling_node = SchedulingNode('agent_1', node, [], [], resource_set)
running_job_exe_1 = job_test_utils.create_running_job_exe(
agent_id=self.agent_id,
resources=NodeResources([Cpus(1.0), Mem(10.0)]))
running_job_exe_2 = job_test_utils.create_running_job_exe(
agent_id=self.agent_id,
resources=NodeResources([Cpus(2.0), Mem(20.0)]))
node_task_resources = NodeResources()
node_task_resources.add(health_task.get_resources())
node_task_resources.add(pull_task.get_resources())
all_required_resources = NodeResources()
all_required_resources.add(node_task_resources)
all_required_resources.add(
running_job_exe_1.next_task().get_resources())
all_required_resources.add(
running_job_exe_2.next_task().get_resources())
expected_remaining_resources = NodeResources()
expected_remaining_resources.add(offered_resources)
expected_remaining_resources.subtract(node_task_resources)
# Set up node with node tasks and job exes (there would never be queued job exes since they would be scheduled
# before add_allocated_offers() was called
scheduling_node.accept_node_tasks(now(), [])
scheduling_node.accept_job_exe_next_task(running_job_exe_1, [])
scheduling_node.accept_job_exe_next_task(running_job_exe_2, [])
self.assertEqual(len(scheduling_node.allocated_tasks), 2)
self.assertEqual(len(scheduling_node._allocated_running_job_exes), 2)
self.assertEqual(len(scheduling_node._allocated_queued_job_exes), 0)
self.assertTrue(
scheduling_node.allocated_resources.is_equal(
all_required_resources))
# Set up offers (not enough for job exes or node tasks)
offer_1 = ResourceOffer('offer_1', 'agent_1', '1234',
NodeResources([Cpus(0.1),
Mem(600.0)]), now(), None)
scheduling_node.add_allocated_offers([offer_1])
self.assertListEqual(scheduling_node.allocated_offers, [offer_1])
# All allocated tasks and job exes should be gone
self.assertEqual(len(scheduling_node.allocated_tasks), 0)
self.assertEqual(len(scheduling_node._allocated_running_job_exes), 0)
self.assertEqual(len(scheduling_node._allocated_queued_job_exes), 0)
self.assertTrue(
scheduling_node.allocated_resources.is_equal(NodeResources()))
self.assertTrue(
scheduling_node._remaining_resources.is_equal(offered_resources))
def test_auth_package_show(self, creator_user_id, user_obj_id, user,
private, state, owner_org, owner_member,
db_auth, acquire_url, request_path, authorized):
# Configure the mocks
returned_package = MagicMock()
returned_package.creator_user_id = creator_user_id
returned_package.private = private
returned_package.state = state
returned_package.owner_org = owner_org
returned_package.extras = {}
# Configure the database
db_response = []
if db_auth is True:
out = auth.db.AllowedUser()
out.package_id = 'package_id'
out.user_name = user
db_response.append(out)
auth.db.AllowedUser.get = MagicMock(return_value=db_response)
if acquire_url:
returned_package.extras['acquire_url'] = acquire_url
auth.logic_auth.get_package_object = MagicMock(
return_value=returned_package)
auth.new_authz.has_user_permission_for_group_or_org = MagicMock(
return_value=owner_member)
auth.request.path = MagicMock(return_value=request_path)
# Prepare the context
context = {'model': MagicMock()}
if user is not None:
context['user'] = user
if user_obj_id is not None:
context['auth_user_obj'] = MagicMock()
context['auth_user_obj'].id = user_obj_id
# Function to be tested
result = auth.package_show(context, {})
# Check the result
self.assertEquals(authorized, result['success'])
# Premissions for organization are checked when the dataset is private, it belongs to an organization
# and when the dataset has not been created by the user who is asking for it
if private and owner_org and state == 'active' and creator_user_id != user_obj_id:
auth.new_authz.has_user_permission_for_group_or_org.assert_called_once_with(
owner_org, user, 'read')
else:
self.assertEquals(
0,
auth.new_authz.has_user_permission_for_group_or_org.call_count)
# The databse is only initialized when:
# * the dataset is private AND
# * the dataset is active AND
# * the dataset has no organization OR the user does not belong to that organization AND
# * the dataset has not been created by the user who is asking for it OR the user is not specified
if private and state == 'active' and (
not owner_org
or not owner_member) and (creator_user_id != user_obj_id
or user_obj_id is None):
# Check that the database has been initialized properly
auth.db.init_db.assert_called_once_with(context['model'])
else:
self.assertEquals(0, auth.db.init_db.call_count)
# Conditions to buy a dataset; It should be private, active and should not belong to any organization
if not authorized and state == 'active' and not owner_org and request_path.startswith(
'/dataset/'):
auth.helpers.flash_error.assert_called_once()
else:
self.assertEquals(0, auth.helpers.flash_error.call_count)
def test_get_inf_state(self, get_inf_ids):
"""
Test GetInfrastructureState.
"""
auth0 = self.getAuth([0], [], [("Dummy", 0)])
inf = MagicMock()
get_inf_ids.return_value = ["1"]
InfrastructureList.infrastructure_list = {"1": inf}
inf.id = "1"
inf.auth = auth0
inf.deleted = False
inf.has_expired.return_value = False
vm1 = MagicMock()
vm1.im_id = 0
vm1.state = VirtualMachine.RUNNING
vm2 = MagicMock()
vm2.im_id = 1
vm2.state = VirtualMachine.RUNNING
vm3 = MagicMock()
vm3.im_id = 2
vm3.state = VirtualMachine.RUNNING
inf.get_vm_list.return_value = [vm1, vm2, vm3]
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "running")
vm1.state = VirtualMachine.FAILED
vm2.state = VirtualMachine.RUNNING
vm3.state = VirtualMachine.UNKNOWN
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "failed")
vm1.state = VirtualMachine.PENDING
vm2.state = VirtualMachine.RUNNING
vm3.state = VirtualMachine.CONFIGURED
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "pending")
vm1.state = VirtualMachine.PENDING
vm2.state = VirtualMachine.CONFIGURED
vm3.state = VirtualMachine.UNCONFIGURED
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "pending")
vm1.state = VirtualMachine.RUNNING
vm2.state = VirtualMachine.CONFIGURED
vm3.state = VirtualMachine.UNCONFIGURED
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "running")
vm1.state = VirtualMachine.RUNNING
vm2.state = VirtualMachine.CONFIGURED
vm3.state = VirtualMachine.STOPPED
state = IM.GetInfrastructureState("1", auth0)
self.assertEqual(state["state"], "running")
def test_create_vm_on_correct_resource(self):
"""Check that we create the vm on the correct datastore"""
vm = MagicMock()
vm.id = str(uuid.uuid4())
vm.networks = ["net_1", "net_2"]
vm.project_id = "p1"
vm.tenant_id = "t1"
mock_env = MagicMock()
mock_reservation = MagicMock()
mock_net_spec = MagicMock()
req = CreateVmRequest(reservation=mock_reservation,
environment=mock_env,
network_connection_spec=mock_net_spec)
image_id = stable_uuid('image_id')
handler = HostHandler(MagicMock())
pm = handler.hypervisor.placement_manager
pm.consume_vm_reservation.return_value = vm
handler._datastores_for_image = MagicMock()
handler.hypervisor.datastore_manager.datastore_type.\
return_value = DatastoreType.EXT3
handler.hypervisor.datastore_manager.image_datastores = MagicMock(
return_value=set("ds2"))
im = handler.hypervisor.image_manager
im.get_image_refcount_filename.return_value = \
os.path.join(self.agent_conf_dir, vm.id)
im.get_image_id_from_disks.return_value = image_id
# No placement descriptor
vm.placement = None
response = handler.create_vm(req)
pm.remove_vm_reservation.assert_called_once_with(mock_reservation)
assert_that(response.result,
equal_to(CreateVmResultCode.PLACEMENT_NOT_FOUND))
# If vm reservation has placement datastore info, it should
# be placed there
handler.hypervisor.vm_manager.create_vm_spec.reset_mock()
pm.remove_vm_reservation.reset_mock()
vm.placement = AgentResourcePlacement(AgentResourcePlacement.VM,
"vm_ids", "ds2")
response = handler.create_vm(req)
spec = handler.hypervisor.vm_manager.create_vm_spec.return_value
metadata = handler.hypervisor.image_manager.image_metadata.return_value
handler.hypervisor.vm_manager.create_vm_spec.assert_called_once_with(
vm.id, "ds2", vm.flavor, metadata, mock_env, image_id=image_id)
handler.hypervisor.vm_manager.create_vm.assert_called_once_with(
vm.id, spec)
handler.hypervisor.vm_manager.set_vminfo.assert_called_once_with(
spec, {
handler.VMINFO_PROJECT_KEY: 'p1',
handler.VMINFO_TENANT_KEY: 't1'
})
pm.remove_vm_reservation.assert_called_once_with(mock_reservation)
assert_that(response.result, equal_to(CreateVmResultCode.OK))
# Test create_vm honors vm.networks information
# Host has the provisioned networks required by placement_list,
# should succeed.
handler.hypervisor.network_manager.get_vm_networks.return_value = \
["net_2", "net_1"]
add_nic_mock = MagicMock()
handler.hypervisor.vm_manager.add_nic = add_nic_mock
handler.hypervisor.vm_manager.create_vm_spec.reset_mock()
pm.remove_vm_reservation.reset_mock()
spec = handler.hypervisor.vm_manager.create_vm_spec.return_value
req = CreateVmRequest(reservation=mock_reservation)
response = handler.create_vm(req)
called_networks = add_nic_mock.call_args_list
expected_networks = [call(spec, 'net_1'), call(spec, 'net_2')]
assert_that(called_networks == expected_networks, is_(True))
pm.remove_vm_reservation.assert_called_once_with(mock_reservation)
assert_that(response.result, equal_to(CreateVmResultCode.OK))
# Host does not have the provisioned networks
# required by placement_list, should fail.
handler.hypervisor.network_manager.get_vm_networks.return_value = \
["net_1", "net_7"]
handler.hypervisor.vm_manager.add_nic.reset_mock()
pm.remove_vm_reservation.reset_mock()
req = CreateVmRequest(reservation=mock_reservation)
response = handler.create_vm(req)
pm.remove_vm_reservation.assert_called_once_with(mock_reservation)
assert_that(response.result,
equal_to(CreateVmResultCode.NETWORK_NOT_FOUND))
def test_20_launch(self, get_driver):
radl_data = """
network net1 (outbound = 'yes' and provider_id = 'public' and outports = '8080,9000:9100')
network net2 ()
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'ost://server.com/ami-id' and
disk.0.os.credentials.username = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}])
ost_cloud = self.get_ost_cloud()
driver = MagicMock()
get_driver.return_value = driver
node_size = MagicMock()
node_size.ram = 512
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 1
node_size.name = "small"
driver.list_sizes.return_value = [node_size]
net = MagicMock()
net.name = "public"
driver.ex_list_networks.return_value = [net]
sg = MagicMock()
sg.name = "sg"
driver.ex_create_security_group.return_value = sg
driver.ex_list_security_groups.return_value = []
driver.ex_create_security_group_rule.return_value = True
keypair = MagicMock()
keypair.public_key = "public"
driver.create_key_pair.return_value = keypair
driver.features = {'create_node': ['ssh_key']}
node = MagicMock()
node.id = "ost1"
node.name = "ost1name"
driver.create_node.return_value = node
res = ost_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
success, _ = res[0]
self.assertTrue(success, msg="ERROR: launching a VM.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def a_project():
project = MagicMock()
project.id = a_uuid_string()
project.name = a_string()
return project
def test_20_launch(self, save_data, credentials, network_client,
compute_client, storage_client, resource_client):
radl_data = """
network net1 (outbound = 'yes' and outports = '8080,9000:9100' and sg_name = 'nsgname')
network net2 ()
system test (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
instance_tags = 'key=value,key1=value2' and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'azr://Canonical/UbuntuServer/16.04.0-LTS/latest' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path' and
disk.2.image.url='RGname/DiskName' and
disk.2.device='hdb' and
disk.2.mount_path='/mnt/path2'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'azure',
'type': 'Azure',
'subscription_id': 'subscription_id',
'username': '******',
'password': '******'
}, {
'type': 'InfrastructureManager',
'username': '******',
'password': '******'
}])
azure_cloud = self.get_azure_cloud()
cclient = MagicMock()
compute_client.return_value = cclient
nclient = MagicMock()
network_client.return_value = nclient
rclient = MagicMock()
resource_client.return_value = rclient
nclient.virtual_networks.get.side_effect = Exception()
subnet_create = MagicMock()
subnet_create_res = MagicMock()
subnet_create_res.id = "subnet-0"
subnet_create.result.return_value = subnet_create_res
nclient.subnets.create_or_update.return_value = subnet_create
public_ip_create = MagicMock()
public_ip_create_res = MagicMock()
public_ip_create_res.id = "ip-0"
public_ip_create.result.return_value = public_ip_create_res
nclient.public_ip_addresses.create_or_update.return_value = public_ip_create
instace_type = MagicMock()
instace_type.name = "instance_type1"
instace_type.number_of_cores = 1
instace_type.memory_in_mb = 1024
instace_type.resource_disk_size_in_mb = 102400
instace_types = [instace_type]
cclient.virtual_machine_sizes.list.return_value = instace_types
cclient.virtual_machines.create_or_update.side_effect = self.create_vm
disk = MagicMock()
disk.name = "dname"
disk.id = "did"
cclient.disks.get.return_value = disk
inf = InfrastructureInfo()
inf.auth = auth
inf.radl = radl
res = azure_cloud.launch_with_retry(inf, radl, radl, 3, auth, 2, 0)
self.assertEqual(len(res), 3)
self.assertTrue(res[0][0])
self.assertTrue(res[1][0])
self.assertTrue(res[2][0])
self.assertEquals(rclient.resource_groups.delete.call_count, 2)
self.assertIn("rg-userimage-",
rclient.resource_groups.delete.call_args_list[0][0][0])
self.assertIn("rg-userimage-",
rclient.resource_groups.delete.call_args_list[1][0][0])
json_vm_req = cclient.virtual_machines.create_or_update.call_args_list[
0][0][2]
self.assertEquals(
json_vm_req['storage_profile']['data_disks'][0]['disk_size_gb'], 1)
self.assertEquals(
json_vm_req['storage_profile']['data_disks'][1]['managed_disk']
['id'], "did")
image_res = {
'sku': '16.04.0-LTS',
'publisher': 'Canonical',
'version': 'latest',
'offer': 'UbuntuServer'
}
self.assertEquals(json_vm_req['storage_profile']['image_reference'],
image_res)
self.assertEquals(json_vm_req['hardware_profile']['vm_size'],
'instance_type1')
self.assertEquals(json_vm_req['os_profile']['admin_username'], 'user')
self.assertEquals(json_vm_req['os_profile']['admin_password'], 'pass')
self.assertEquals(json_vm_req['os_profile']['admin_password'], 'pass')
self.assertEquals(
nclient.subnets.create_or_update.call_args_list[0][0][3],
{'address_prefix': '10.0.1.0/24'})
self.assertEquals(
nclient.subnets.create_or_update.call_args_list[1][0][3],
{'address_prefix': '10.0.2.0/24'})
radl_data = """
network net1 (outbound = 'yes')
network net2 ()
system test (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
instance_tags = 'key=value,key1=value2' and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'azr://error/rgname/diskname' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
with self.assertRaises(Exception) as ex:
azure_cloud.launch(inf, radl, radl, 1, auth)
self.assertEquals(str(ex.exception),
"Incorrect image url: it must be snapshot or disk.")
radl_data = """
network net1 (outbound = 'yes')
network net2 (cidr = '192.168.*.0/24')
system test (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
instance_tags = 'key=value,key1=value2' and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'azr://snapshot/rgname/diskname' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
res = azure_cloud.launch(inf, radl, radl, 1, auth)
json_vm_req = cclient.virtual_machines.create_or_update.call_args_list[
5][0][2]
self.assertEquals(json_vm_req['storage_profile']['os_disk']['os_type'],
'linux')
self.assertEquals(
nclient.subnets.create_or_update.call_args_list[5][0][3],
{'address_prefix': '192.168.1.0/24'})
def test_20_launch(self, save_data, get_driver):
radl_data = """
network net1 (outbound = 'yes' and provider_id = 'public' and
outports = '8080,9000:9100' and sg_name= 'test')
network net2 (cidr='10.0.1.0/24' and dnsserver='1.1.1.1' and create = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
instance_tags='key=value,key1=value2' and
net_interface.1.connection = 'net1' and
net_interface.0.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'ost://server.com/ami-id' and
disk.0.os.credentials.username = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.2.image.url = 'ost://server.com/vol-id' and
disk.2.device='hdc'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}, {
'type': 'InfrastructureManager',
'username': '******',
'password': '******'
}])
ost_cloud = self.get_ost_cloud()
driver = MagicMock()
get_driver.return_value = driver
node_size = MagicMock()
node_size.ram = 512
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 1
node_size.name = "small"
driver.list_sizes.return_value = [node_size]
net1 = MagicMock()
net1.name = "public"
net1.id = "net1id"
net1.extra = {'router:external': True}
net2 = MagicMock()
net2.name = "private"
net2.id = "net2id"
driver.ex_list_networks.return_value = [net2, net1]
sg = MagicMock()
sg.name = "sg"
driver.ex_create_security_group.return_value = sg
driver.ex_list_security_groups.return_value = []
driver.ex_create_security_group_rule.return_value = True
driver.features = {'create_node': ['ssh_key']}
driver.create_node.side_effect = self.create_node
driver.ex_create_network.return_value = net2
subnet1 = MagicMock()
driver.ex_create_subnet.return_value = subnet1
router = MagicMock()
router.id = "id"
router.name = "name"
router.extra = {'external_gateway_info': {'network_id': net1.id}}
driver.ex_list_routers.return_value = [router]
driver.ex_add_router_subnet.return_value = True
image = MagicMock()
image.id = 'imageid'
driver.get_image.return_value = image
vol = MagicMock()
vol.id = 'volid'
driver.ex_get_volume.return_value = vol
inf = InfrastructureInfo()
inf.auth = auth
res = ost_cloud.launch_with_retry(inf, radl, radl, 1, auth, 2, 1)
success, _ = res[0]
self.assertTrue(success, msg="ERROR: launching a VM.")
self.assertEqual(driver.create_node.call_args_list[0][1]['networks'],
[net1])
mappings = [{
'source_type': 'image',
'uuid': 'imageid',
'boot_index': 0,
'delete_on_termination': False,
'device_name': 'vda'
}, {
'guest_format': 'ext3',
'boot_index': 1,
'volume_size': 1,
'device_name': 'vdb',
'source_type': 'blank',
'destination_type': 'volume',
'delete_on_termination': True
}, {
'boot_index': 2,
'delete_on_termination': False,
'destination_type': 'volume',
'device_name': 'vdc',
'source_type': 'volume',
'uuid': 'volid'
}]
self.assertEqual(
driver.create_node.call_args_list[0][1]['ex_blockdevicemappings'],
mappings)
# test with proxy auth data
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'proxy': 'proxy',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}, {
'type': 'InfrastructureManager',
'username': '******',
'password': '******'
}])
inf = InfrastructureInfo()
inf.auth = auth
res = ost_cloud.launch(inf, radl, radl, 1, auth)
success, _ = res[0]
self.assertTrue(success, msg="ERROR: launching a VM.")
def test_60_finalize(self, sleep, get_connection):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.ip = '158.42.1.1' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'one://server.com/1' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
auth = Authentication([{
'id': 'ec2',
'type': 'EC2',
'username': '******',
'password': '******'
}])
ec2_cloud = self.get_ec2_cloud()
inf = MagicMock()
inf.id = "1"
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "us-east-1;id-1", ec2_cloud.cloud, radl, radl,
ec2_cloud)
vm.keypair_name = "key"
conn = MagicMock()
get_connection.return_value = conn
reservation = MagicMock()
instance = MagicMock()
device = MagicMock()
instance.update.return_value = True
instance.terminate.return_value = True
instance.block_device_mapping = {"device": device}
device.volume_id = "volid"
reservation.instances = [instance]
conn.get_all_instances.return_value = [reservation]
conn.delete_key_pair.return_value = True
address = MagicMock()
address.public_ip = "158.42.1.1"
address.instance_id = "id-1"
address.disassociate.return_value = True
address.release.return_value = True
conn.get_all_addresses.return_value = [address]
conn.get_all_spot_instance_requests.return_value = []
volume = MagicMock()
volume.attachment_state.return_value = None
conn.get_all_volumes.return_value = [volume]
conn.delete_volume.return_value = True
sg = MagicMock()
sg.name = "im-1"
sg.instances.return_value = []
sg.revoke.return_value = True
sg.delete.return_value = True
conn.get_all_security_groups.return_value = [sg]
success, _ = ec2_cloud.finalize(vm, auth)
self.assertTrue(success, msg="ERROR: finalizing VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_30_updateVMInfo_spot(self, get_connection):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'one://server.com/1' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ec2',
'type': 'EC2',
'username': '******',
'password': '******'
}])
ec2_cloud = self.get_ec2_cloud()
inf = MagicMock()
inf.get_next_vm_id.return_value = 1
vm = VirtualMachine(inf, "us-east-1;sid-1", ec2_cloud.cloud, radl,
radl, ec2_cloud)
conn = MagicMock()
get_connection.return_value = conn
reservation = MagicMock()
instance = MagicMock()
instance.update.return_value = True
instance.tags = []
instance.virtualization_type = "vt"
instance.placement = "us-east-1"
instance.state = "running"
instance.instance_type = "t1.micro"
instance.launch_time = "2016-12-31T00:00:00"
instance.ip_address = "158.42.1.1"
instance.private_ip_address = "10.0.0.1"
instance.connection = conn
reservation.instances = [instance]
conn.get_all_instances.return_value = [reservation]
conn.get_all_addresses.return_value = []
sir = MagicMock()
sir.state = ""
sir.id = "id"
conn.get_all_spot_instance_requests.return_value = [sir]
volume = MagicMock()
volume.status = "available"
volume.id = "volid"
conn.create_volume.return_value = volume
conn.attach_volume.return_value = True
success, vm = ec2_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
def test_25_launch_spot(self, blockdevicemapping, VPCConnection,
get_region):
radl_data = """
network net1 (outbound = 'yes' and provider_id = 'vpc-id.subnet-id')
network net2 ()
system test (
spot = 'yes' and
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'aws://us-east-one/ami-id' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.private_key = 'private' and
disk.0.os.credentials.public_key = 'public' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ec2',
'type': 'EC2',
'username': '******',
'password': '******'
}])
ec2_cloud = self.get_ec2_cloud()
region = MagicMock()
get_region.return_value = region
conn = MagicMock()
VPCConnection.return_value = conn
image = MagicMock()
device = MagicMock()
reservation = MagicMock()
instance = MagicMock()
device.snapshot_id = True
device.volume_id = True
image.block_device_mapping = {"device": device}
instance.add_tag.return_value = True
instance.id = "iid"
reservation.instances = [instance]
image.run.return_value = reservation
conn.get_image.return_value = image
sg = MagicMock()
sg.id = "sgid"
sg.name = "sgname"
sg.authorize.return_value = True
conn.create_security_group.return_value = sg
conn.get_all_security_groups.return_value = []
blockdevicemapping.return_value = {'device': ''}
zone = MagicMock()
zone.name = 'us-east-1'
conn.get_all_zones.return_value = [zone]
history = MagicMock()
history.price = 0.1
conn.get_spot_price_history.return_value = [history]
request = MagicMock()
request.id = "id"
conn.request_spot_instances.return_value = [request]
res = ec2_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
success, _ = res[0]
self.assertTrue(success, msg="ERROR: launching a VM.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
self.clean_log()
from tests.helpers.patch_disco_aws import TEST_ENV_NAME
MOCK_ROUTE_FILTER = {
"vpc-id": "mock_vpc_id",
"tag:meta_network": TEST_ENV_NAME
}
MOCK_ZONE1 = MagicMock()
MOCK_ZONE1.name = "aws-zone1"
MOCK_ZONE2 = MagicMock()
MOCK_ZONE2.name = "aws-zone2"
MOCK_ZONE3 = MagicMock()
MOCK_ZONE3.name = "aws-zone3"
MOCK_ZONES = [MOCK_ZONE1, MOCK_ZONE2, MOCK_ZONE3]
MOCK_ROUTE_TABLE = MagicMock()
MOCK_ROUTE_TABLE.id = "route_table_id"
def _get_vpc_mock():
ret = MagicMock()
ret.vpc_filters.return_value = [{
"Name": "vpc-id",
"Values": [MOCK_ROUTE_FILTER["vpc-id"]]
}]
ret.get_vpc_id.return_value = MOCK_ROUTE_FILTER["vpc-id"]
return ret
def _get_vpc_conn_mock():
ret = MagicMock()
def test_55_alter(self, credentials, network_client, compute_client,
storage_client, resource_client):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'azr://image-id' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
new_radl_data = """
system test (
cpu.count>=2 and
memory.size>=2048m
)"""
new_radl = radl_parse.parse_radl(new_radl_data)
auth = Authentication([{
'id': 'azure',
'type': 'Azure',
'subscription_id': 'subscription_id',
'username': '******',
'password': '******'
}])
azure_cloud = self.get_azure_cloud()
instace_type = MagicMock()
instace_type.name = "instance_type2"
instace_type.number_of_cores = 2
instace_type.memory_in_mb = 2048
instace_type.resource_disk_size_in_mb = 102400
instace_types = [instace_type]
cclient = MagicMock()
compute_client.return_value = cclient
cclient.virtual_machine_sizes.list.return_value = instace_types
vm = MagicMock()
vm.provisioning_state = "Succeeded"
vm.hardware_profile.vm_size = "instance_type2"
vm.location = "northeurope"
ni = MagicMock()
ni.id = "/subscriptions/subscription-id/resourceGroups/rg0/providers/Microsoft.Network/networkInterfaces/ni-0"
vm.network_profile.network_interfaces = [ni]
cclient.virtual_machines.get.return_value = vm
nclient = MagicMock()
network_client.return_value = nclient
ni_res = MagicMock()
ip_conf = MagicMock()
ip_conf.private_ip_address = "10.0.0.1"
ip_conf.public_ip_address.id = (
"/subscriptions/subscription-id/resourceGroups/rg0/"
"providers/Microsoft.Network/networkInterfaces/ip-0")
ni_res.ip_configurations = [ip_conf]
nclient.network_interfaces.get.return_value = ni_res
pub_ip_res = MagicMock()
pub_ip_res.ip_address = "13.0.0.1"
nclient.public_ip_addresses.get.return_value = pub_ip_res
inf = MagicMock()
vm = VirtualMachine(inf, "rg0/vm0", azure_cloud.cloud, radl, radl,
azure_cloud, 1)
success, _ = azure_cloud.alterVM(vm, new_radl, auth)
self.assertTrue(success, msg="ERROR: modifying VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def _make_player(self, id=0, steam_id='0', name='Name'):
p = MagicMock()
p.id = id
p.steam_id = steam_id
p.name = name
return p
def test_30_updateVMInfo(self, get_driver):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'one://server.com/1' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}])
ost_cloud = self.get_ost_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "1", ost_cloud.cloud, radl, radl, ost_cloud,
1)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {
'flavorId': 'small',
'addresses': {
'os-lan': [{
'addr': '10.0.0.1',
'OS-EXT-IPS:type': 'fixed'
}]
}
}
node.public_ips = []
node.private_ips = ['10.0.0.1']
node.driver = driver
driver.list_nodes.return_value = [node]
node_size = MagicMock()
node_size.ram = 512
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 1
node_size.name = "small"
driver.ex_get_size.return_value = node_size
volume = MagicMock()
volume.id = "vol1"
volume.attach.return_value = True
driver.create_volume.return_value = volume
pool = MagicMock()
pool.name = "pool1"
pool.list_floating_ips.return_value = []
pool.create_floating_ip.return_value = True
driver.ex_list_floating_ip_pools.return_value = [pool]
success, vm = ost_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_30_updateVMInfo(self, credentials, dns_client, compute_client,
network_client):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test.domain.com' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'azr://Canonical/UbuntuServer/16.04.0-LTS/latest' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'azure',
'type': 'Azure',
'subscription_id': 'subscription_id',
'username': '******',
'password': '******'
}])
azure_cloud = self.get_azure_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "rg0/im0", azure_cloud.cloud, radl, radl,
azure_cloud, 1)
instace_type = MagicMock()
instace_type.name = "instance_type1"
instace_type.number_of_cores = 1
instace_type.memory_in_mb = 1024
instace_type.resource_disk_size_in_mb = 102400
instace_types = [instace_type]
cclient = MagicMock()
compute_client.return_value = cclient
cclient.virtual_machine_sizes.list.return_value = instace_types
avm = MagicMock()
avm.provisioning_state = "Succeeded"
avm.hardware_profile.vm_size = "instance_type1"
avm.location = "northeurope"
status1 = MagicMock()
status1.code = "ProvisioningState/succeeded"
status2 = MagicMock()
status2.code = "PowerState/running"
avm.instance_view.statuses = [status1, status2]
ni = MagicMock()
ni.id = "/subscriptions/subscription-id/resourceGroups/rg0/providers/Microsoft.Network/networkInterfaces/ni-0"
avm.network_profile.network_interfaces = [ni]
cclient.virtual_machines.get.return_value = avm
nclient = MagicMock()
network_client.return_value = nclient
ni_res = MagicMock()
ip_conf = MagicMock()
ip_conf.private_ip_address = "10.0.0.1"
ip_conf.public_ip_address.id = (
"/subscriptions/subscription-id/resourceGroups/rg0/"
"providers/Microsoft.Network/networkInterfaces/ip-0")
ni_res.ip_configurations = [ip_conf]
nclient.network_interfaces.get.return_value = ni_res
pub_ip_res = MagicMock()
pub_ip_res.ip_address = "13.0.0.1"
nclient.public_ip_addresses.get.return_value = pub_ip_res
dclient = MagicMock()
dns_client.return_value = dclient
dclient.zones.get.return_value = None
dclient.record_sets.get.return_value = None
success, vm = azure_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(dclient.zones.create_or_update.call_args_list,
[call('rg0', 'domain.com', {'location': 'global'})])
self.assertEquals(
dclient.record_sets.create_or_update.call_args_list, [
call('rg0', 'domain.com', 'test', 'A', {
'arecords': [{
'ipv4_address': '13.0.0.1'
}],
'ttl': 300
})
])
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def get_company(id):
c = MagicMock()
c.id = id
return c
def test_30_updateVMInfo(self, get_driver):
radl_data = """
network net (outbound = 'yes')
network net1 ()
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.1.connection = 'net1' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'cst://server.com/ami-id' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdc' and
disk.1.fstype='ext4' and
disk.1.mount_path='/mnt/disk1'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ost',
'type': 'CloudStack',
'username': '******',
'password': '******',
'host': 'http://server.com'
}])
osc_cloud = self.get_osc_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "1", osc_cloud.cloud, radl, radl, osc_cloud,
1)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {
'size_name': 'small',
'zone_name': 'zname',
'zone_id': 'zid'
}
node.public_ips = ['8.8.8.8']
node.private_ips = []
node.driver = driver
driver.list_nodes.return_value = [node]
node_size = MagicMock()
node_size.ram = 512
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 1
node_size.name = "small"
driver.ex_get_size.return_value = node_size
volume = MagicMock()
volume.id = "vol1"
volume.attach.return_value = True
driver.create_volume.return_value = volume
success, vm = osc_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(vm.info.systems[0].getValue("net_interface.0.ip"),
"8.8.8.8")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_answers_grouped_by_instance_id_many_answers_many_instance(self): # pylint: disable=too-many-statements
# Given
question_state = RepeatingAnswerStateQuestion('question_id',
MagicMock())
first_name_schema = Answer('first-name')
first_name_schema.widget = TextWidget('first-name')
middle_name_schema = Answer('middle-names')
middle_name_schema.widget = TextWidget('middle-names')
last_name_schema = Answer('last-name')
last_name_schema.widget = TextWidget('last-name')
question_state.schema_item.answers = [
first_name_schema, middle_name_schema, last_name_schema
]
first_name = MagicMock()
first_name.id = 'first-name'
first_name.answer_instance = 0
middle_name = MagicMock()
middle_name.id = 'middle-names'
middle_name.answer_instance = 0
last_name = MagicMock()
last_name.id = 'last-name'
last_name.answer_instance = 0
first_name1 = MagicMock()
first_name1.id = 'first-name'
first_name1.answer_instance = 1
middle_name1 = MagicMock()
middle_name1.id = 'middle-names'
middle_name1.answer_instance = 1
last_name1 = MagicMock()
last_name1.id = 'last-name'
last_name1.answer_instance = 1
first_name2 = MagicMock()
first_name2.id = 'first-name'
first_name2.answer_instance = 2
middle_name2 = MagicMock()
middle_name2.id = 'middle-names'
middle_name2.answer_instance = 2
last_name2 = MagicMock()
last_name2.id = 'last-name'
last_name2.answer_instance = 2
question_state.answers = [
first_name,
middle_name,
last_name,
first_name1,
middle_name1,
last_name1,
first_name2,
middle_name2,
last_name2,
]
# When
result = question_state.answers_grouped_by_instance()
# Then
self.assertEqual(len(result), 3)
# Instance 0
self.assertEqual(len(result[0]), 3)
self.assertEqual(result[0][0], first_name)
self.assertEqual(result[0][1], middle_name)
self.assertEqual(result[0][2], last_name)
# Instance 1
self.assertEqual(len(result[1]), 3)
self.assertEqual(result[1][0], first_name1)
self.assertEqual(result[1][1], middle_name1)
self.assertEqual(result[1][2], last_name1)
# Instance 2
self.assertEqual(len(result[2]), 3)
self.assertEqual(result[2][0], first_name2)
self.assertEqual(result[2][1], middle_name2)
self.assertEqual(result[2][2], last_name2)
def test_token_getter_setter(views_fixture, monkeypatch):
"""Test token getter setter."""
# Mock session id
monkeypatch.setattr('invenio_oauthclient._compat._create_identifier',
lambda: '1234')
monkeypatch.setattr('invenio_oauthclient.views.client._create_identifier',
lambda: '1234')
app = views_fixture
oauth = app.extensions['oauthlib.client']
# Mock user
user = MagicMock()
user.id = 1
user.get_id = MagicMock(return_value=1)
user.is_anonymous = False
with app.test_client() as c:
login_user_via_session(c, user)
# First call login to be redirected
res = c.get(url_for('invenio_oauthclient.login', remote_app='full'))
assert res.status_code == 302
assert res.location.startswith(oauth.remote_apps['full'].authorize_url)
state = parse_qs(urlparse(res.location).query)['state'][0]
# Mock resposen class
mock_response(app.extensions['oauthlib.client'], 'full')
# Imitate that the user authorized our request in the remote
# application.
c.get(
url_for(
'invenio_oauthclient.authorized',
remote_app='full',
code='test',
state=state,
))
# Assert if everything is as it should be.
from flask import session as flask_session
assert flask_session['oauth_token_full'] == \
('test_access_token', '')
t = RemoteToken.get(1, 'fullid')
assert t.remote_account.client_id == 'fullid'
assert t.access_token == 'test_access_token'
assert RemoteToken.query.count() == 1
# Mock a new authorized request
mock_response(app.extensions['oauthlib.client'],
'full',
data={
'access_token': 'new_access_token',
'scope': "",
'token_type': 'bearer'
})
c.get(
url_for('invenio_oauthclient.authorized',
remote_app='full',
code='test',
state=state))
t = RemoteToken.get(1, 'fullid')
assert t.access_token == 'new_access_token'
assert RemoteToken.query.count() == 1
val = token_getter(
app.extensions['oauthlib.client'].remote_apps['full'])
assert val == ('new_access_token', '')
# Disconnect account
res = c.get(
url_for(
'invenio_oauthclient.disconnect',
remote_app='full',
))
assert res.status_code == 302
assert res.location.endswith(
url_for('invenio_oauthclient_settings.index'))
# Assert that remote account have been removed.
t = RemoteToken.get(1, 'fullid')
assert t is None
# TODO: Figure out what is leaving session open & blocked
db.session.close()
def _get_default_repo(self):
repo = MagicMock()
repo.id = 'awesome_repo'
return repo
def test_30_updateVMInfo(self, get_driver):
radl_data = """
network net (outbound = 'yes' and provider_id = 'pool1')
network net1 (provider_id = 'os-lan' and router='10.0.0.0/16,vrouter1')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net1' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'ost://server.com/ami-id' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path' and
disk.2.image.url='ost://server.com/ami-id1' and
disk.2.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}])
ost_cloud = self.get_ost_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "1", ost_cloud.cloud, radl, radl, ost_cloud,
1)
vm2 = MagicMock()
syst = MagicMock()
syst.name = "vrouter1"
vm2.info.systems = [syst]
vm2.getIfaceIP.return_value = "10.0.0.1"
inf.vm_list = [vm2, vm]
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {
'flavorId': 'small',
'addresses': {
'os-lan': [{
'addr': '10.0.0.1',
'OS-EXT-IPS:type': 'fixed'
}]
}
}
node.public_ips = []
node.private_ips = ['10.0.0.1']
node.driver = driver
driver.ex_get_node_details.return_value = node
node_size = MagicMock()
node_size.ram = 512
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 1
node_size.name = "small"
driver.ex_get_size.return_value = node_size
volume = MagicMock()
volume.id = "vol1"
volume.attach.return_value = True
driver.create_volume.return_value = volume
pool = MagicMock()
pool.name = "pool1"
floating_ip = MagicMock()
floating_ip.ip_address = "8.8.8.8"
pool.list_floating_ips.return_value = []
pool.create_floating_ip.return_value = floating_ip
driver.ex_list_floating_ip_pools.return_value = [pool]
net1 = MagicMock()
net1.id = 'net1id'
net1.name = "os-lan"
net1.cidr = None
net1.extra = {'subnets': ["subnet1"]}
net2 = MagicMock()
net2.id = 'net2id'
net2.name = "public"
net2.cidr = None
net2.extra = {'subnets': [], 'router:external': True}
driver.ex_list_networks.return_value = [net1, net2]
port = MagicMock()
port.extra = {'device_id': net1.id}
driver.ex_list_ports.return_value = [port]
success, vm = ost_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(vm.info.systems[0].getValue("net_interface.1.ip"),
"10.0.0.1")
self.assertEquals(driver.ex_update_subnet.call_args_list[0][0][0].id,
"subnet1")
self.assertEquals(driver.ex_update_subnet.call_args_list[0][1], {
'host_routes': [{
'nexthop': '10.0.0.1',
'destination': '10.0.0.0/16'
}]
})
# In this case the Node has the float ip assigned
# node.public_ips = ['8.8.8.8']
floating_ip.node_id = node.id
pool.list_floating_ips.return_value = [floating_ip]
driver.ex_list_floating_ip_pools.return_value = [pool]
success, vm = ost_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(vm.info.systems[0].getValue("net_interface.1.ip"),
"10.0.0.1")
self.assertEquals(vm.info.systems[0].getValue("net_interface.0.ip"),
"8.8.8.8")
# In this case the Node addresses are not available and it uses the old method
node.extra = {'flavorId': 'small'}
success, vm = ost_cloud.updateVMInfo(vm, auth)
self.assertEquals(vm.info.systems[0].getValue("net_interface.1.ip"),
"10.0.0.1")
self.assertEquals(vm.info.systems[0].getValue("net_interface.0.ip"),
"8.8.8.8")
self.assertTrue(success, msg="ERROR: updating VM info.")
# the node has a IPv6 IP
node = MagicMock()
node.id = "2"
node.state = "running"
node.extra = {'flavorId': 'small'}
node.public_ips = ['8.8.8.8', '2001:630:12:581:f816:3eff:fe92:2146']
node.private_ips = ['10.0.0.1']
node.driver = driver
driver.ex_get_node_details.return_value = node
success, vm = ost_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(vm.info.systems[0].getValue("net_interface.0.ip"),
"8.8.8.8")
self.assertEquals(vm.info.systems[0].getValue("net_interface.0.ipv6"),
"2001:630:12:581:f816:3eff:fe92:2146")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_get_deployment_resource_priority_over_blueprint_resource(self):
deployment_context_mock = MagicMock()
deployment_context_mock.id = 'dep1'
self.context.deployment = deployment_context_mock
resource = self.context.get_resource(resource_path='for_test.txt')
self.assertEquals(resource, 'belongs to dep1')
def test_create_vm(self):
handler = HostHandler(MagicMock())
# test create_vm under entering-maintenance-mode and maintenance mode
state = common.services.get(ServiceName.MODE)
state.set_mode(MODE.ENTERING_MAINTENANCE)
request = MagicMock()
response = handler.create_vm(request)
assert_that(response.result,
equal_to(CreateVmResultCode.OPERATION_NOT_ALLOWED))
state.set_mode(MODE.MAINTENANCE)
response = handler.create_vm(request)
assert_that(response.result,
equal_to(CreateVmResultCode.OPERATION_NOT_ALLOWED))
# Back to NORMAL mode
state.set_mode(MODE.NORMAL)
handler.hypervisor.placement_manager = MagicMock()
handler._select_datastore_for_vm_create = MagicMock(return_value="ds1")
handler.hypervisor.datastore_manager.image_datastores = MagicMock(
return_value=set("image_ds"))
handler.hypervisor.image_manager.get_image_id_from_disks = MagicMock(
return_value="image_id")
vm = MagicMock()
vm.id = str(uuid.uuid4())
pm = handler.hypervisor.placement_manager
pm.consume_vm_reservation.return_value = vm
dm = handler.hypervisor.datastore_manager
dm.datastore_type.return_value = DatastoreType.EXT3
dm.image_datastores.return_value = set(["image_ds"])
im = handler.hypervisor.image_manager
request = MagicMock()
response = handler.create_vm(request)
assert_that(response.result, equal_to(CreateVmResultCode.OK))
pm.remove_vm_reservation.assert_called_once_with(request.reservation)
# Test lazy image copy
assert_that(im.copy_image.called, is_(False))
im.check_and_validate_image = MagicMock(side_effect=[False, True])
im.check_and_validate_image.return_value = False
pm.remove_vm_reservation.reset_mock()
response = handler.create_vm(request)
assert_that(response.result, equal_to(CreateVmResultCode.OK))
pm.remove_vm_reservation.assert_called_once_with(request.reservation)
im.copy_image.assert_called_once_with("image_ds", "image_id", "ds1",
"image_id")
# Test VM existed
im.check_image.return_value = True
im.check_and_validate_image = MagicMock(side_effect=[False, True])
pm.remove_vm_reservation.reset_mock()
handler.hypervisor.vm_manager.create_vm.side_effect = \
VmAlreadyExistException
response = handler.create_vm(request)
assert_that(response.result,
equal_to(CreateVmResultCode.VM_ALREADY_EXIST))
pm.remove_vm_reservation.assert_called_once_with(request.reservation)
# Test invalid reservation
class PlacementManagerInvalidReservation:
def consume_vm_reservation(self, reservation):
raise InvalidReservationException
handler.hypervisor.placement_manager = \
PlacementManagerInvalidReservation()
response = handler.create_vm(request)
assert_that(response.result,
equal_to(CreateVmResultCode.INVALID_RESERVATION))
def test_20_launch(self, save_data, blockdevicemapping, VPCConnection,
get_region):
radl_data = """
network net1 (outbound = 'yes' and outports='8080,9000:9100' and sg_name = 'sgname')
network net2 ()
system test (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=512m and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'aws://us-east-one/ami-id' and
disk.0.os.credentials.username = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ec2',
'type': 'EC2',
'username': '******',
'password': '******'
}])
ec2_cloud = self.get_ec2_cloud()
region = MagicMock()
get_region.return_value = region
conn = MagicMock()
VPCConnection.return_value = conn
image = MagicMock()
device = MagicMock()
reservation = MagicMock()
instance = MagicMock()
device.snapshot_id = True
device.volume_id = True
image.block_device_mapping = {"device": device}
instance.add_tag.return_value = True
instance.id = "iid"
reservation.instances = [instance]
image.run.return_value = reservation
conn.get_image.return_value = image
subnet = MagicMock()
subnet.id = "subnet-id"
conn.get_all_subnets.return_value = [subnet]
vpc = MagicMock()
vpc.id = "vpc-id"
conn.get_all_vpcs.return_value = [vpc]
sg = MagicMock()
sg.id = "sgid"
sg.name = "sgname"
sg.authorize.return_value = True
conn.create_security_group.return_value = sg
conn.get_all_security_groups.return_value = []
conn.create_key_pair.side_effect = self.create_key_pair
blockdevicemapping.return_value = {'device': ''}
res = ec2_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
success, _ = res[0]
self.assertTrue(success, msg="ERROR: launching a VM.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
# Check the case that we do not use VPC
radl_data = """
network net1 (outbound = 'yes' and outports='8080')
network net2 ()
system test (
cpu.arch='x86_64' and
cpu.count>=1 and
memory.size>=1g and
net_interface.0.connection = 'net1' and
net_interface.0.dns_name = 'test' and
net_interface.1.connection = 'net2' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'aws://us-east-one/ami-id' and
disk.0.os.credentials.username = '******' and
#disk.0.os.credentials.private_key = 'private' and
#disk.0.os.credentials.public_key = 'public' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
conn.get_all_vpcs.return_value = []
res = ec2_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
success, _ = res[0]
print(self.log.getvalue())
self.assertTrue(success, msg="ERROR: launching a VM.")
# check the instance_type selected is correct
self.assertEquals(image.run.call_args_list[1][1]["instance_type"],
"m1.small")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_55_alter(self, get_driver):
radl_data = """
network net ()
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.dns_name = 'test' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'one://server.com/1' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******'
)"""
radl = radl_parse.parse_radl(radl_data)
new_radl_data = """
system test (
cpu.count>=2 and
memory.size>=2048m
)"""
new_radl = radl_parse.parse_radl(new_radl_data)
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}])
ost_cloud = self.get_ost_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "1", ost_cloud.cloud, radl, radl, ost_cloud,
1)
driver = MagicMock()
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {'flavorId': 'small'}
node.public_ips = ['158.42.1.1']
node.private_ips = ['10.0.0.1']
node.driver = driver
driver.ex_get_node_details.return_value = node
node_size = MagicMock()
node_size.ram = 2048
node_size.price = 1
node_size.disk = 1
node_size.vcpus = 2
node_size.name = "small"
driver.list_sizes.return_value = [node_size]
driver.ex_resize.return_value = True
success, _ = ost_cloud.alterVM(vm, new_radl, auth)
self.assertTrue(success, msg="ERROR: modifying VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_30_updateVMInfo(self, record_sets, connect_to_region,
get_connection):
radl_data = """
network net (outbound = 'yes')
system test (
cpu.arch='x86_64' and
cpu.count=1 and
memory.size=512m and
net_interface.0.connection = 'net' and
net_interface.0.ip = '158.42.1.1' and
net_interface.0.dns_name = 'test.domain.com' and
disk.0.os.name = 'linux' and
disk.0.image.url = 'one://server.com/1' and
disk.0.os.credentials.username = '******' and
disk.0.os.credentials.password = '******' and
disk.1.size=1GB and
disk.1.device='hdb' and
disk.1.mount_path='/mnt/path'
)"""
radl = radl_parse.parse_radl(radl_data)
radl.check()
auth = Authentication([{
'id': 'ec2',
'type': 'EC2',
'username': '******',
'password': '******'
}])
ec2_cloud = self.get_ec2_cloud()
inf = MagicMock()
vm = VirtualMachine(inf, "us-east-1;id-1", ec2_cloud.cloud, radl, radl,
ec2_cloud, 1)
conn = MagicMock()
get_connection.return_value = conn
reservation = MagicMock()
instance = MagicMock()
instance.update.return_value = True
instance.tags = []
instance.virtualization_type = "vt"
instance.placement = "us-east-1"
instance.state = "running"
instance.instance_type = "t1.micro"
instance.launch_time = "2016-12-31T00:00:00"
instance.ip_address = "158.42.1.1"
instance.private_ip_address = "10.0.0.1"
instance.connection = conn
reservation.instances = [instance]
conn.get_all_instances.return_value = [reservation]
address = MagicMock()
address.public_ip = "158.42.1.1"
conn.get_all_addresses.return_value = [address]
volume = MagicMock()
volume.status = "available"
volume.id = "volid"
conn.create_volume.return_value = volume
conn.attach_volume.return_value = True
dns_conn = MagicMock()
connect_to_region.return_value = dns_conn
dns_conn.get_zone.return_value = None
zone = MagicMock()
zone.get_a.return_value = None
dns_conn.create_zone.return_value = zone
changes = MagicMock()
record_sets.return_value = changes
change = MagicMock()
changes.add_change.return_value = change
success, vm = ec2_cloud.updateVMInfo(vm, auth)
self.assertTrue(success, msg="ERROR: updating VM info.")
self.assertEquals(dns_conn.create_zone.call_count, 1)
self.assertEquals(dns_conn.create_zone.call_args_list[0][0][0],
"domain.com.")
self.assertEquals(changes.add_change.call_args_list,
[call('CREATE', 'test.domain.com.', 'A')])
self.assertEquals(change.add_value.call_args_list,
[call('158.42.1.1')])
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
def test_60_finalize(self, sleep, get_driver):
auth = Authentication([{
'id': 'ost',
'type': 'OpenStack',
'username': '******',
'password': '******',
'tenant': 'tenant',
'host': 'https://server.com:5000'
}])
ost_cloud = self.get_ost_cloud()
radl_data = """
network public (outboud = 'yes')
network private (create = 'yes' and provider_id = ' im-infid-private')
system test (
cpu.count>=2 and
memory.size>=2048m and
net_interface.0.connection = 'public' and
net_interface.1.connection = 'private'
)"""
radl = radl_parse.parse_radl(radl_data)
inf = MagicMock()
inf.id = "infid"
inf.radl = radl
vm = VirtualMachine(inf, "1", ost_cloud.cloud, radl, radl, ost_cloud,
1)
driver = MagicMock()
driver.name = "OpenStack"
get_driver.return_value = driver
node = MagicMock()
node.id = "1"
node.state = "running"
node.extra = {'flavorId': 'small'}
node.public_ips = ['158.42.1.1']
node.private_ips = ['10.0.0.1']
node.driver = driver
node.destroy.return_value = True
driver.ex_get_node_details.return_value = node
driver.delete_security_group.return_value = True
fip = MagicMock()
fip.node_id = node.id
fip.ip_address = '158.42.1.1'
fip.delete.return_value = True
driver.ex_list_floating_ips.return_value = [fip]
driver.ex_detach_floating_ip_from_node.return_value = True
sg1 = MagicMock()
sg1.name = "im-infid-private"
sg1.description = "Security group created by the IM"
sg2 = MagicMock()
sg2.name = "im-infid-public"
sg2.description = "Security group created by the IM"
sg3 = MagicMock()
sg3.name = "im-infid"
sg3.description = ""
driver.ex_list_security_groups.return_value = [sg1, sg2, sg3]
net1 = MagicMock()
net1.name = "im-infid-private"
net1.cidr = None
net1.extra = {'subnets': ["subnet1"]}
net2 = MagicMock()
net2.name = "public"
net2.cidr = None
net2.extra = {'subnets': [], 'router:external': True}
driver.ex_list_networks.return_value = [net1, net2]
router = MagicMock()
router.id = "id"
router.name = "name"
router.extra = {'external_gateway_info': {'network_id': net2.id}}
driver.ex_list_routers.return_value = [router]
driver.ex_add_router_subnet.return_value = True
success, _ = ost_cloud.finalize(vm, True, auth)
self.assertTrue(success, msg="ERROR: finalizing VM info.")
self.assertNotIn("ERROR",
self.log.getvalue(),
msg="ERROR found in log: %s" % self.log.getvalue())
self.assertEqual(node.destroy.call_args_list, [call()])
self.assertEqual(driver.ex_del_router_subnet.call_args_list[0][0][0],
router)
self.assertEqual(
driver.ex_del_router_subnet.call_args_list[0][0][1].id, "subnet1")
self.assertEqual(driver.ex_delete_network.call_args_list[0][0][0],
net1)
self.assertEqual(
driver.ex_delete_security_group.call_args_list[0][0][0], sg2)
self.assertEqual(
driver.ex_delete_security_group.call_args_list[1][0][0], sg1)
self.assertEqual(fip.delete.call_args_list, [call()])
self.assertEqual(
driver.ex_detach_floating_ip_from_node.call_args_list[0][0],
(node, fip))
def get_mock_stacksync_tenant(self):
tenant = MagicMock()
tenant.name = 'stacksync'
tenant.id = 'id_of_Tenant'
return tenant
