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