def test_wait_for_delete(self): _ctx = self._gen_decorators_context('test_wait_for_delete') @decorators.wait_for_delete(status_deleted=['deleted'], status_pending=['pending']) def test_delete(*agrs, **kwargs): pass # deleted mock_interface = MagicMock() mock_interface.status = 'deleted' test_delete(ctx=_ctx, iface=mock_interface) self.assertEqual(_ctx.instance.runtime_properties, { '__deleted': True, }) # pending mock_interface = MagicMock() mock_interface.status = 'pending' with self.assertRaises(OperationRetry): test_delete(ctx=_ctx, iface=mock_interface) # unknow mock_interface = MagicMock() mock_interface.status = 'unknow' with self.assertRaises(NonRecoverableError): test_delete(ctx=_ctx, iface=mock_interface)
def test_wait_for_status(self): _ctx = self._gen_decorators_context( 'test_wait_for_status', op_name='cloudify.interfaces.lifecycle.create') @decorators.wait_for_status(status_good=['ok'], status_pending=['pending']) def test_ok(*agrs, **kwargs): pass # ok mock_interface = MagicMock() mock_interface.status = 'ok' mock_interface.properties = {'status': 'ok'} test_ok(ctx=_ctx, iface=mock_interface) self.assertEqual(_ctx.instance.runtime_properties, { 'resource_config': {}, 'create_response': {'status': 'ok'}, }) # pending mock_interface = MagicMock() mock_interface.status = 'pending' mock_interface.properties = {'status': 'pending'} with self.assertRaises(OperationRetry): test_ok(ctx=_ctx, iface=mock_interface) # unknow mock_interface = MagicMock() mock_interface.status = 'unknown' mock_interface.properties = {'status': 'unknown'} with self.assertRaises(NonRecoverableError): test_ok(ctx=_ctx, iface=mock_interface) # empty status mock_interface = MagicMock() mock_interface.status = None mock_interface.properties = {'status': None} with self.assertRaises(NonRecoverableError): test_ok(ctx=_ctx, iface=mock_interface) # empty status but ignore mock_interface = MagicMock() mock_interface.status = None mock_interface.properties = {'status': None} @decorators.wait_for_status(status_pending=['pending'], fail_on_missing=False) def test_ignore(*agrs, **kwargs): pass test_ignore(ctx=_ctx, iface=mock_interface)
def test_command_succeeded(self): response = MagicMock() result = json.loads('{"status": "Failure", "kind": "Status", "code": 409, "apiVersion": "v1", "reason": "AlreadyExists", "details": {"kind": "node", "name": "10.200.147.200"}, "message": "node \\"10.200.147.200\\" already exists", "creationTimestamp": null}') # noqa response.status = 200 self.r.command_succeeded(response, result) response.status = 409 self.r.command_succeeded(response, result) response.status = 500 with pytest.raises(RuntimeError): self.r.command_succeeded(response, result)
def get_response(self): method, url = self.__class__.last_op resp = MagicMock() if method == "GET": if url == "/-/": resp.status = 200 resp.read.return_value = read_file_as_string("files/occi.txt") elif url == "/compute/1": resp.status = 200 resp.read.return_value = read_file_as_string("files/occi_vm_info.txt") elif url.startswith("/storage"): resp.status = 200 resp.read.return_value = 'X-OCCI-Attribute: occi.storage.state="online"' elif method == "POST": if url == "/compute/": resp.status = 201 resp.read.return_value = 'https://server.com/compute/1' elif url.endswith("action=suspend"): resp.status = 200 elif url.endswith("action=start"): resp.status = 200 elif url == "/link/storagelink": resp.status = 200 elif method == "DELETE": if url.endswith("/compute/1"): resp.status = 200 elif url.endswith("/storage/1"): resp.status = 200 return resp
def get_response(self): method, url = self.__class__.last_op resp = MagicMock() if method == "GET": if "/deployments/" in url: resp.status = 200 resp.read.return_value = ("<Deployment><Status>Running</Status><RoleInstanceList><RoleInstance>" "<InstanceSize>RoleSizeName</InstanceSize><PowerState>Started</PowerState>" "<IpAddress>10.0.0.1</IpAddress><InstanceEndpoints><InstanceEndpoint>" "<Vip>158.42.1.1</Vip></InstanceEndpoint></InstanceEndpoints></RoleInstance>" "</RoleInstanceList></Deployment>") if "/operations/" in url: resp.status = 200 resp.read.return_value = ("<Operation><Status>Succeeded" "</Status></Operation>") elif "/storageservices/" in url: resp.status = 200 resp.read.return_value = ("<StorageService><StorageServiceProperties><GeoPrimaryRegion>North Europe" "</GeoPrimaryRegion></StorageServiceProperties></StorageService>") elif url.endswith("/rolesizes"): resp.status = 200 resp.read.return_value = ("<RoleSizes><RoleSize><SupportedByVirtualMachines>true" "</SupportedByVirtualMachines><Name>RoleSizeName</Name>" "<MemoryInMb>512</MemoryInMb><Cores>1</Cores>" "<VirtualMachineResourceDiskSizeInMb>2014" "</VirtualMachineResourceDiskSizeInMb>" "</RoleSize>" "<RoleSize><SupportedByVirtualMachines>true" "</SupportedByVirtualMachines><Name>RoleSizeName</Name>" "<MemoryInMb>2048</MemoryInMb><Cores>2</Cores>" "<VirtualMachineResourceDiskSizeInMb>2014" "</VirtualMachineResourceDiskSizeInMb>" "</RoleSize>" "</RoleSizes>") elif method == "POST": if url.endswith("/Operations"): resp.status = 202 resp.getheader.return_value = "id" elif url.endswith("/services/hostedservices"): resp.status = 201 resp.read.return_value = "" elif url.endswith("/deployments"): resp.status = 202 resp.getheader.return_value = "id" elif method == "DELETE": if url.endswith("comp=media"): resp.status = 202 resp.getheader.return_value = "id" elif method == "PUT": if "roles" in url: resp.status = 202 resp.getheader.return_value = "id" return resp
def test_SchedulerAdmin_status_renderer(self): scheduler = MagicMock() schedulerAdmin = SchedulerAdmin(Scheduler, MagicMock()) scheduler.status = 'S' self.assertEqual('<font color="green">Success</font>', schedulerAdmin.status_renderer(scheduler)) scheduler.status = 'I' self.assertEqual('<font color="yellow">Invalid</font>', schedulerAdmin.status_renderer(scheduler)) scheduler.status = 'F' self.assertEqual('<font color="red">Fail</font>', schedulerAdmin.status_renderer(scheduler)) scheduler.status = 'R' self.assertEqual('<font color="orange">Running</font>', schedulerAdmin.status_renderer(scheduler))
def test034_launch_asynchronous_ftp_error(self, m_session_transaction, m_Scan, m_ftp_ctrl, m_add_empty_result): m_scan, m_session = MagicMock(), MagicMock() fw1, fw2 = MagicMock(), MagicMock() file1, file2 = MagicMock(), MagicMock() pathf1, pathf2 = 'path-file1', 'path-file2' file1.path = pathf1 file2.path = pathf2 fw1.file.sha256 = "sha256file1" fw1.file.mimetype = "mimetypefile1" fw2.file.sha256 = "sha256file2" fw2.file.mimetype = "mimetypefile2" m_scan.files_web = [fw1, fw2] m_scan.files = [file1, file2] probe1, probe2 = "Probe1", "Probe2" probelist = [probe1, probe2] m_scan.get_probe_list.return_value = probelist m_add_empty_result.return_value = probelist m_session_transaction().__enter__.return_value = m_session m_scan.status = IrmaScanStatus.ready m_scan.mimetype_filtering = False m_Scan.load_from_ext_id.return_value = m_scan scanid = "scanid" m_ftp_ctrl.upload_scan.side_effect = IrmaFtpError() module.launch_asynchronous(scanid) expected = IrmaScanStatus.error_ftp_upload m_scan.set_status.assert_called_once_with(expected)
def test_read_from(self): instance = MagicMock() instance.status = 1 instance.scores = { 'left': [5, 10, 15, 20], 'right': [10, 15, 20, 25], } self.object().read_from(instance) assert self.object().get_data_dict(True) == { 'csrf_token': self.mget_csrf_token().return_value, 'status': 1, 'left_quart_1': 5, 'left_quart_2': 10, 'left_quart_3': 15, 'left_quart_4': 20, 'right_quart_1': 10, 'right_quart_2': 15, 'right_quart_3': 20, 'right_quart_4': 25, } assert self.object().instance is instance
def test_backup_info_corner_cases(self, command_mock): # BackupManager mock backup_manager = self.build_backup_manager('test_server', 'test_file') backup_manager.config.post_test_hook = 'not_existent_script' backup_manager.get_previous_backup.return_value = None # BackupInfo mock backup_info = MagicMock(name='backup_info') backup_info.get_basebackup_directory.return_value = 'backup_directory' backup_info.backup_id = '123456789XYZ' backup_info.error = 'Test error' backup_info.status = 'FAILED' # the actual test script = HookScriptRunner(backup_manager, 'test_hook', 'post') script.env_from_backup_info(backup_info) expected_env = { 'BARMAN_PHASE': 'post', 'BARMAN_VERSION': version, 'BARMAN_SERVER': 'test_server', 'BARMAN_CONFIGURATION': 'test_file', 'BARMAN_HOOK': 'test_hook', 'BARMAN_BACKUP_DIR': 'backup_directory', 'BARMAN_BACKUP_ID': '123456789XYZ', 'BARMAN_ERROR': 'Test error', 'BARMAN_STATUS': 'FAILED', 'BARMAN_PREVIOUS_ID': '', } script.run() assert command_mock.call_count == 1 assert command_mock.call_args[1]['env_append'] == expected_env
def test_backup_info_exception(self, command_mock): # BackupManager mock backup_manager = build_backup_manager(name='test_server') backup_manager.config.pre_test_hook = 'not_existent_script' backup_manager.get_previous_backup = MagicMock() backup_manager.get_previous_backup.side_effect = \ UnknownBackupIdException() # BackupInfo mock backup_info = MagicMock(name='backup_info') backup_info.get_basebackup_directory.return_value = 'backup_directory' backup_info.backup_id = '123456789XYZ' backup_info.error = None backup_info.status = 'OK' # the actual test script = HookScriptRunner(backup_manager, 'test_hook', 'pre') script.env_from_backup_info(backup_info) expected_env = { 'BARMAN_PHASE': 'pre', 'BARMAN_VERSION': version, 'BARMAN_SERVER': 'test_server', 'BARMAN_CONFIGURATION': 'build_config_from_dicts', 'BARMAN_HOOK': 'test_hook', 'BARMAN_BACKUP_DIR': 'backup_directory', 'BARMAN_BACKUP_ID': '123456789XYZ', 'BARMAN_ERROR': '', 'BARMAN_STATUS': 'OK', 'BARMAN_PREVIOUS_ID': '', 'BARMAN_RETRY': '0', } script.run() assert command_mock.call_count == 1 assert command_mock.call_args[1]['env_append'] == expected_env
def make_response_mock(response_status): """ Constructs HTTP Response mock object. """ response_mock = MagicMock() response_mock.status = response_status return response_mock
def test_backup_info_exception(self, command_mock): # BackupManager mock backup_manager = build_backup_manager(name="test_server") backup_manager.config.pre_test_hook = "not_existent_script" backup_manager.get_previous_backup = MagicMock() backup_manager.get_previous_backup.side_effect = UnknownBackupIdException() # BackupInfo mock backup_info = MagicMock(name="backup_info") backup_info.get_basebackup_directory.return_value = "backup_directory" backup_info.backup_id = "123456789XYZ" backup_info.error = None backup_info.status = "OK" # the actual test script = HookScriptRunner(backup_manager, "test_hook", "pre") script.env_from_backup_info(backup_info) expected_env = { "BARMAN_PHASE": "pre", "BARMAN_VERSION": version, "BARMAN_SERVER": "test_server", "BARMAN_CONFIGURATION": "build_config_from_dicts", "BARMAN_HOOK": "test_hook", "BARMAN_BACKUP_DIR": "backup_directory", "BARMAN_BACKUP_ID": "123456789XYZ", "BARMAN_ERROR": "", "BARMAN_STATUS": "OK", "BARMAN_PREVIOUS_ID": "", } script.run() assert command_mock.call_count == 1 assert command_mock.call_args[1]["env_append"] == expected_env
def test012_cancel_status_cancelled(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.cancelled label = IrmaScanStatus.label[scan.status] expected = "can not cancel scan in {} status".format(label) with self.assertRaises(IrmaValueError) as context: module.cancel(scan, session) self.assertEqual(str(context.exception), expected)
def test_format_int_status(self): req = MagicMock() resp = MagicMock() resp.status = 200 hook_format(req, resp) self.assertEquals(resp.status, '200 OK')
def test_hook_finished(self, m_log): self.scan.date = "scan_date" self.fw.scan = self.scan self.fw.file.sha256 = "sha256" self.fw.name = "filename" self.fw.file.timestamp_first_scan = "ts_first_scan" self.fw.file.timestamp_last_scan = "ts_last_scan" self.fw.file.size = "size" pr1, pr2 = MagicMock(), MagicMock() self.fw.probe_results = [pr1, pr2] pr1.name = "probe1" pr1.type = "antivirus" pr1.status = "status1" pr1.duration = "duration1" pr1.results = "results1" pr2.name = "probe2" pr2.type = "metadata" pr2.status = "status2" pr2.duration = None pr2.results = "results2" pr1.get_details.return_value = pr1 pr2.get_details.return_value = pr2 self.fw.hook_finished() expected1 = "[files_results] date: %s file_id: %s scan_id: %s " expected1 += "status: %s probes: %s submitter: %s submitter_id: %s" call1 = call(expected1, 'scan_date', self.fw.external_id, self.fw.scan.external_id, 'Clean', 'probe1, probe2', 'unknown', 'undefined') expected2 = '[av_results] date: %s av_name: "%s" ' expected2 += "status: %d virus_name: \"%s\" file_id: %s " expected2 += "file_sha256: %s scan_id: %s duration: %f " expected2 += "submitter: %s submitter_id: %s" call2 = call(expected2, 'scan_date', 'probe1', 'status1', 'results1', self.fw.external_id, 'sha256', self.fw.scan.external_id, 'duration1', 'unknown', 'undefined') expected3 = '[probe_results] date: %s name: "%s" ' expected3 += "status: %d file_sha256: %s file_id: %s " expected3 += "duration: %f submitter: %s submitter_id: %s" call3 = call(expected3, 'scan_date', 'probe2', 'status2', self.fw.external_id, 'sha256', 0, 'unknown', 'undefined') m_log.info.assert_has_calls([call1]) m_log.info.assert_has_calls([call2]) m_log.info.assert_has_calls([call3])
def test008_cancel_status_launched_ok(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.launched retcode = IrmaReturnCode.success cancel_res = {'cancel_details': "details"} self.celery_brain.scan_cancel.return_value = (retcode, cancel_res) res = module.cancel(scan, session) self.assertEqual(res, cancel_res['cancel_details']) scan.set_status.assert_called_once_with(IrmaScanStatus.cancelled)
def test003_check_probe_None(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.ready probelist = None all_probelist = ['probe1', 'probe2', 'probe3'] scan.set_probelist.return_value = None self.celery_brain.probe_list.return_value = all_probelist module.check_probe(scan, probelist, session) self.assertTrue(scan.set_probelist.called) scan.set_probelist.assert_called_once_with(all_probelist)
def get_response(self): method, url = self.__class__.last_op resp = MagicMock() if method == "GET": if "/api/credential/somecred" == url: resp.status = 200 resp.read.return_value = ('[{"name": "Username", "type": "text", "value": "username"},' '{"name": "Password", "type": "text", "value": "password"}]') if "/api/service" == url: resp.status = 200 resp.read.return_value = ('{"service_list": [{"id":"sid", "type":"stype", "host": "shost"}]}') elif method == "POST": if url == "/api/credential/": resp.status = 303 resp.msg = {'location': "/api/credential/somecred"} return resp
def request(self, method, path, data=None, stream=False, **kwargs): self._reason = self.REASONS[self.counter % len(self.REASONS)] self._status = self.STATI[self.counter % len(self.STATI)] print(self.counter, self._status) self.counter += 1 mock_response = MagicMock() mock_response.status = self._status mock_response.reason = self._reason mock_response.headers = {"content-type": self.content_type} return mock_response
def test_put_observation(self, mock_conn, caps_mock): caps_mock.get_service_host.return_value = 'some.host.com' caps_mock.return_value.get_access_url.return_value =\ 'http://serviceurl/caom2repo/pub' collection = 'cfht' observation_id = '7000000o' service = 'caom2repo' service_url = 'www.cadc.nrc.ca' obs = SimpleObservation(collection, observation_id) subject = auth.Subject(certificate='somefile.pem') level = logging.DEBUG visitor = CAOM2RepoClient(subject, level, host=service_url) response = MagicMock() response.status = 200 mock_conn.return_value = response iobuffer = BytesIO() ObservationWriter().write(obs, iobuffer) obsxml = iobuffer.getvalue() response.content = obsxml visitor.put_observation(obs) self.assertEqual('PUT', mock_conn.call_args[0][0].method) self.assertEqual( '/{}/pub/{}/{}'.format(service, collection, observation_id), mock_conn.call_args[0][0].path_url) self.assertEqual('application/xml', mock_conn.call_args[0][0].headers['Content-Type']) self.assertEqual(obsxml, mock_conn.call_args[0][0].body) # signal problems http_error = requests.HTTPError() response.status_code = 500 http_error.response = response response.raise_for_status.side_effect = [http_error] with self.assertRaises(exceptions.InternalServerException): visitor.create(obs) # temporary transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response response.raise_for_status.side_effect = [http_error, None] visitor.put_observation(obs) # permanent transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response def raise_error(): raise http_error response.raise_for_status.side_effect = raise_error with self.assertRaises(exceptions.HttpException): visitor.put_observation(obs)
def test_should_remove_proxy_returns_true_when_response_status_code_is_within_not_allowed_ones( read_proxies_mock): middleware = ProxyMiddleware(MagicMock()) middleware.remove_proxy_for_status_codes = [504] response = MagicMock() response.status = 504 remove_proxy = middleware.should_remove_proxy(response) assert_that(remove_proxy, is_(True))
def test_modify_vpc_attribute(self): ctx = self.get_mock_ctx("Vpc") iface = MagicMock() iface.status = 0 self.vpc.resource_id = 'test_name' try: vpc.modify_vpc_attribute( ctx, iface, {VPC_ID: self.vpc.resource_id}) except OperationRetry: pass self.assertTrue(iface.modify_vpc_attribute.called)
def test_modify_subnet_attribute(self): ctx = self.get_mock_ctx("Subnet") iface = MagicMock() iface.status = 0 self.subnet.resource_id = 'test_name' try: subnet.modify_subnet_attribute( ctx, iface, {SUBNET_ID: self.subnet.resource_id}) except OperationRetry: pass self.assertTrue(iface.modify_subnet_attribute.called)
def test004_check_probe_unknown_probe(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.ready probelist = ['probe1', 'probe2', 'probe6'] all_probelist = ['probe1', 'probe2', 'probe3'] scan.set_probelist.return_value = None self.celery_brain.probe_list.return_value = all_probelist with self.assertRaises(IrmaValueError) as context: module.check_probe(scan, probelist, session) self.assertFalse(scan.set_probelist.called) self.assertEquals(str(context.exception), "probe probe6 unknown")
def test008_cancel_status_launched_brain_error(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.launched retcode = IrmaReturnCode.error ret_val = "reason" self.celery_brain.scan_cancel.return_value = (retcode, ret_val) with self.assertRaises(IrmaTaskError) as context: module.cancel(scan, session) self.assertEqual(str(context.exception), ret_val) scan.set_status.assert_not_called()
def _prepare_dynamic(self, packages, config_content='MockContent', device_path='/dev/vdb', is_db_installed=True, backup_id=None, is_root_enabled=False, overrides=None): # covering all outcomes is starting to cause trouble here if not backup_id: backup_info = {'id': backup_id, 'location': 'fake-location', 'type': 'InnoBackupEx', 'checksum': 'fake-checksum', } mock_status = MagicMock() mock_app = MagicMock() mock_app.status = mock_status self.manager._app = mock_app mock_status.begin_install = MagicMock(return_value=None) mock_app.install_if_needed = MagicMock(return_value=None) mock_app.init_storage_structure = MagicMock(return_value=None) mock_app.write_config = MagicMock(return_value=None) mock_app.apply_initial_guestagent_configuration = MagicMock( return_value=None) mock_app.restart = MagicMock(return_value=None) mock_app.start_db = MagicMock(return_value=None) mock_app.stop_db = MagicMock(return_value=None) os.path.exists = MagicMock(return_value=True) volume.VolumeDevice.format = MagicMock(return_value=None) volume.VolumeDevice.migrate_data = MagicMock(return_value=None) volume.VolumeDevice.mount = MagicMock(return_value=None) volume.VolumeDevice.mount_points = MagicMock(return_value=[]) with patch.object(pkg.Package, 'pkg_is_installed', return_value=is_db_installed): # invocation self.manager.prepare(context=self.context, packages=packages, config_contents=config_content, databases=None, memory_mb='2048', users=None, device_path=device_path, mount_point="/var/lib/cassandra", backup_info=backup_info, overrides=None, cluster_config=None) # verification/assertion mock_status.begin_install.assert_any_call() mock_app.install_if_needed.assert_any_call(packages) mock_app.init_storage_structure.assert_any_call('/var/lib/cassandra') mock_app.apply_initial_guestagent_configuration.assert_any_call() mock_app.start_db.assert_any_call(update_db=False) mock_app.stop_db.assert_any_call()
def test008_cancel_status_launched_status_processed(self): scan, session = MagicMock(), MagicMock() scan.status = IrmaScanStatus.launched retcode = IrmaReturnCode.success status = IrmaScanStatus.label[IrmaScanStatus.processed] cancel_res = {'status': status} self.celery_brain.scan_cancel.return_value = (retcode, cancel_res) with self.assertRaises(IrmaValueError) as context: module.cancel(scan, session) self.assertEqual(str(context.exception), "can not cancel scan in {0} status".format(status)) scan.set_status.assert_called_once_with(IrmaScanStatus.processed)
def test_api_task_status(self, get_result): async_result = MagicMock() async_result.status = "running" async_result.ready.return_value = False get_result.return_value = async_result output = self.app.get("/api/0/task/123abc/status/") self.assertEqual(output.status_code, 200) data = json.loads(output.get_data(as_text=True)) self.assertEqual(data, {"ready": False, "status": "running"}) async_result = MagicMock() async_result.status = "finished" async_result.ready.return_value = True async_result.successful.return_value = True get_result.return_value = async_result output = self.app.get("/api/0/task/123abc/status/") self.assertEqual(output.status_code, 200) data = json.loads(output.get_data(as_text=True)) self.assertEqual( data, {"ready": True, "status": "finished", "successful": True} )
def test_get_probe_results_as_dict(self): pr1, pr2 = MagicMock(), MagicMock() pr3 = MagicMock() pr1.doc = "whatever" pr2.doc = "something" pr3.status = None self.fw.probe_results = [pr1, pr2, pr3] self.assertIsInstance(self.fw.get_probe_results(results_as="dict"), dict) pr1.get_details.assert_called_with(True) pr2.get_details.assert_called_with(True) pr3.get_details.assert_not_called()
def get_response(self): method, url = self.__class__.last_op resp = MagicMock() if method == "GET": if url == "/api/": resp.status = 200 resp.read.return_value = '{"versions": "v1"}' if url == "/containers/1/json": resp.status = 200 resp.read.return_value = '{"State": {"Running": 1}, "NetworkSettings": {"IPAddress": "10.0.0.1"}}' elif method == "POST": if url == "/containers/create": resp.status = 201 resp.read.return_value = '{"Id": "id"}' elif url.endswith("/start"): resp.status = 204 elif url.endswith("/stop"): resp.status = 204 elif method == "DELETE": if url.endswith("/containers/1"): resp.status = 204 return resp
def test_print_endpoint_info(): magic = SparkMagicBase(None) magic.ipython_display = MagicMock() current_session_id = 1 session1 = MagicMock() session1.id = 1 session1.get_app_id.return_value = 'app1234' session1.kind = SESSION_KIND_PYSPARK session1.status = IDLE_SESSION_STATUS session1.get_spark_ui_url.return_value = 'https://microsoft.com/sparkui' session1.get_driver_log_url.return_value = 'https://microsoft.com/driverlog' session2 = MagicMock() session2.id = 3 session2.get_app_id.return_value = 'app5069' session2.kind = SESSION_KIND_SPARK session2.status = BUSY_SESSION_STATUS session2.get_spark_ui_url.return_value = None session2.get_driver_log_url.return_value = None magic._print_endpoint_info([session2, session1], current_session_id) magic.ipython_display.html.assert_called_once_with(u"""<table> <tr><th>ID</th><th>YARN Application ID</th><th>Kind</th><th>State</th><th>Spark UI</th><th>Driver log</th><th>Current session?</th></tr>\ <tr><td>1</td><td>app1234</td><td>pyspark</td><td>idle</td><td><a target="_blank" href="https://microsoft.com/sparkui">Link</a></td><td><a target="_blank" href="https://microsoft.com/driverlog">Link</a></td><td>\u2714</td></tr>\ <tr><td>3</td><td>app5069</td><td>spark</td><td>busy</td><td></td><td></td><td></td></tr>\ </table>""")
def test_run_spider(self): """Test running the spider.""" def status_result(): """Return value of the status property.""" if status.call_count > 2: return '100' return '50' class_mock = MagicMock() class_mock.scan.return_value = '1' status = Mock(side_effect=status_result) class_mock.status = status self.zap_helper.zap.spider = class_mock self.zap_helper.run_spider('http://localhost', status_check_sleep=0)
def test_run_active_scan(self): """Test running an active scan.""" def status_result(): """Return value of the status property.""" if status.call_count > 2: return '100' return '50' class_mock = MagicMock() class_mock.scan.return_value = '1' status = Mock(side_effect=status_result) class_mock.status = status self.zap_helper.zap.ascan = class_mock self.zap_helper.run_active_scan('http://localhost')
def test_modify_instance_attribute(self): ctx = self.get_mock_ctx( "EC2Instances", test_properties={'os_family': 'linux'}, type_hierarchy=['cloudify.nodes.Root', 'cloudify.nodes.Compute']) current_ctx.set(ctx=ctx) iface = MagicMock() iface.status = 0 self.instances.resource_id = 'test_name' try: instances.modify_instance_attribute( ctx, iface, {INSTANCE_ID: self.instances.resource_id}) except OperationRetry: pass self.assertTrue(iface.modify_instance_attribute.called)
def test_monitor_trail_with_custom_arguments(self): mock_trail_client = MagicMock() mock_trail_client.status = MagicMock( return_value='mock_trail_client_result') mock_status_filter_handler_pairs = MagicMock() monitor_patcher = patch('autotrail.helpers.trail.monitor') mock_monitor = monitor_patcher.start() diff_lists_patcher = patch('autotrail.helpers.trail.diff_lists') mock_diff_lists = diff_lists_patcher.start() monitor_trail(mock_trail_client, mock_status_filter_handler_pairs, status_kwargs=dict(foo='bar'), delay=55, max_tries=1) kwargs = mock_monitor.call_args[1] function = kwargs['function'] result_predicate = kwargs['result_predicate'] filter_handler_pairs = kwargs['filter_handler_pairs'] pre_processor = kwargs['pre_processor'] delay = kwargs['delay'] history_limit = kwargs['history_limit'] self.assertEqual(delay, 55) self.assertEqual(history_limit, 2) # History will be max_tries + 1 self.assertEqual(filter_handler_pairs, mock_status_filter_handler_pairs) result = function() self.assertEqual(result, 'mock_trail_client_result') mock_trail_client.status.assert_called_once_with(foo='bar') self.assertTrue(result_predicate([None, 'result'])) self.assertTrue(result_predicate(['result'])) self.assertFalse(result_predicate(['result', None])) self.assertFalse(result_predicate([None, None, None])) pre_processor([1, 2, 3]) mock_diff_lists.assert_called_once_with([2, 3]) pre_processor([2, 3]) mock_diff_lists.assert_called_with([2, 3]) pre_processor([3]) mock_diff_lists.assert_called_with([3]) pre_processor([None]) mock_diff_lists.assert_called_with([None]) diff_lists_patcher.stop() monitor_patcher.stop()
def test_retrieve_page_basic_auth(self, mock_make_request): """ Test that a basic auth request generates the correct header """ path = "http://google.com" username, password = "******", "pass" auth_str = base64.b64encode(":".join((username, password))) expected_uri = path expected_headers = {"Authorization": "Basic %s" % auth_str} mock_http_response = MagicMock() mock_http_response.status = 200 mock_make_request.return_value = mock_http_response fw = Framework() fw.retrieve_page("GET", path, username=username, password=password) mock_make_request.asserted_called_with(expected_uri, method="GET", body=None, headers=expected_headers)
def getTestMock( self, nameID=0): """create a JobInfo object with mocks""" from ILCDIRAC.ILCTransformationSystem.Utilities.JobInfo import JobInfo testJob = Mock ( name = "jobInfoMock_%s" % nameID, spec=JobInfo ) testJob.jobID = 1234567 testJob.tType = "testType" testJob.otherTasks = None testJob.inputFileExists = True testJob.status = "Done" testJob.fileStatus = "Assigned" testJob.outputFiles = ["/my/stupid/file.lfn", "/my/stupid/file2.lfn"] testJob.outputFileStatus = ["Exists", "Exists"] testJob.inputFile = "inputfile.lfn" testJob.pendingRequest = False testJob.getTaskInfo = Mock() return testJob
def test_transition_issue_to_proper_status_mapping_error(self): self.handler.update_status_mappings = MagicMock() self.handler.transition_issue = MagicMock() ticket = MagicMock() status = "status" ticket.status = status jira_issue = MagicMock() self.handler.status_mappings = {} self.handler.update_status_mappings.side_effect = JIRAError() self.handler.transition_issue_to_proper_status(jira_issue, ticket) self.handler.update_status_mappings.assert_called_once() self.handler.transition_issue.assert_not_called()
def test_update_status_mappings_not_exists_in_mappings(self, input_mock): self.handler.transitions = MagicMock() ticket = MagicMock() status = "status" ticket.status = status jira_issue = MagicMock() jira_status = "To Do" transition = {"to": {"name": jira_status}} input_mock.side_effect = ["Error", jira_status] self.handler.transitions.return_value = [transition] self.handler.status_mappings = {} self.handler.update_status_mappings(ticket, jira_issue) self.assertEqual(input_mock.call_count, 2)
def test_run_active_scan_as_user(self): """Test running an active scan as a given user.""" def status_result(): """Return value of the status property.""" if status.call_count > 2: return '100' return '50' class_mock = MagicMock() class_mock.scan_as_user.return_value = '1' status = Mock(side_effect=status_result) class_mock.status = status self.zap_helper.zap.ascan = class_mock self.zap_helper.zap.context.context = Mock(return_value={'id': '1'}) self.zap_helper.zap.users.users_list = Mock(return_value=[{'name': 'Test', 'id': '1'}]) self.zap_helper.run_active_scan('http://localhost', False, 'Test', 'Test')
def test_transport(mock_sleep): mock_status = MagicMock() mock_status.status = 502 client, _ = get_client_and_http() client.setup_retry(3, 2, 2, 10) client.transport._http.request = MagicMock(side_effect=TransportException(mock_status, None)) try: client.Contact.get_contacts() except TransportException: pass else: raise AssertionError() assert client.transport._http.request.call_count == 3 assert mock_sleep.call_count == 2
def test_url_format(self, mock_manager): response_mock = MagicMock() response_mock.status = 200 response_mock.data = None mock_connection = MagicMock() mock_connection.request.return_value = response_mock mock_manager.return_value = mock_connection host = 'http://test.com/' url = '/path/to/we/' expected_url = 'http://test.com/path/to/we/' utils.make_request('GET', host, url, 'a_user', 'a_pass') mock_connection.request.assert_called_once_with('GET', expected_url, fields=Any(), headers=Any())
def test_transition_issue_to_proper_status(self): self.handler.update_status_mappings = MagicMock() self.handler.transition_issue = MagicMock() ticket = MagicMock() status = "status" ticket.status = status jira_issue = MagicMock() self.handler.status_mappings[status] = status self.handler.transition_issue_to_proper_status(jira_issue, ticket) self.handler.update_status_mappings.assert_not_called() self.handler.transition_issue.assert_called_once_with( jira_issue, status )
def setUp(self): self.resource = MagicMock( OneTouch(test_helper.API_URL, test_helper.API_KEY)) self.response = MagicMock() otr = MagicMock(OneTouchResponse(self.resource, self.response)) otr.errors = MagicMock(return_value={}) otr.ok = MagicMock(return_value=True) otr.get_uuid = MagicMock( return_value="1836762c-e4b7-4c99-a0e4-d8e7518b4e78") otr.status = MagicMock(return_value=True) self.resource.send_request = MagicMock(return_value=otr) self.resource.get_approval_status = MagicMock(return_value=otr) self.resource.clean_logos = OneTouch.clean_logos self.resource.__make_http_query = OneTouch._OneTouch__make_http_query self.resource.validate_one_touch_signature = OneTouch.validate_one_touch_signature self.resource.api_key = 'foobar123'
def getTestMock(self, nameID=0, jobID=1234567): """create a JobInfo object with mocks""" from DIRAC.TransformationSystem.Utilities.JobInfo import JobInfo testJob = Mock(name="jobInfoMock_%s" % nameID, spec=JobInfo) testJob.jobID = jobID testJob.tType = "testType" testJob.otherTasks = [] testJob.errorCounts = [] testJob.status = "Done" testJob.transFileStatus = ['Assigned', 'Assigned'] testJob.inputFileStatus = ['Exists', 'Exists'] testJob.outputFiles = ["/my/stupid/file.lfn", "/my/stupid/file2.lfn"] testJob.outputFileStatus = ["Exists", "Exists"] testJob.inputFiles = ['inputfile.lfn', 'inputfile2.lfn'] testJob.pendingRequest = False testJob.getTaskInfo = Mock() return testJob
def test_run_spider_as_user_error(self): """Test running the spider as a given user when an error occurs.""" def status_result(): """Return value of the status property.""" if status.call_count > 2: return '100' return '50' class_mock = MagicMock() class_mock.scan_as_user.return_value = '1' status = Mock(side_effect=status_result) class_mock.status = status self.zap_helper.zap.spider = class_mock self.zap_helper.zap.context.context = Mock(return_value={'id': '1'}) self.zap_helper.zap.users.users_list = Mock(return_value=[]) with self.assertRaises(ZAPError): self.zap_helper.run_spider('http://localhost', 'Test', 'Test')
def test_prepare_for_export_zip_task(self, ExportRun, isfile, join, mock_generate_qgs_style): from eventkit_cloud.tasks.export_tasks import prepare_for_export_zip_task # This doesn't need to be valid with ExportRun mocked mock_run_uid = str(uuid.uuid4()) style_file = "style.qgs" mock_generate_qgs_style.return_value = style_file expected_file_list = ['e1', 'e2', 'e3', style_file] missing_file_list = ['e4'] all_file_list = expected_file_list + missing_file_list def fake_isfile(fname): if fname in expected_file_list: return True else: return False isfile.side_effect = fake_isfile # Fill out the behavior for mocked ExportRun by adding a provider task with # subtasks for each file in all_file_list mocked_provider_subtasks = [] for fname in all_file_list: mps = MagicMock() mps.result.filename = fname mocked_provider_subtasks.append(mps) mocked_provider_task = MagicMock() mocked_provider_task.status = TaskStates.COMPLETED.value mocked_provider_task.tasks.all.return_value = mocked_provider_subtasks mocked_run = MagicMock() mocked_run.job.include_zipfile = True mocked_run.provider_tasks.all.return_value = [mocked_provider_task] ExportRun.objects.get.return_value = mocked_run include_files = prepare_for_export_zip_task.run(run_uid=mock_run_uid) mock_generate_qgs_style.assert_called_once_with(run_uid=mock_run_uid) self.assertEqual(include_files, set(expected_file_list))
def test_delete_observation(self, mock_conn, caps_mock): caps_mock.get_service_host.return_value = 'some.host.com' caps_mock.return_value.get_access_url.return_value =\ 'http://serviceurl/caom2repo/pub' collection = 'cfht' observation_id = '7000000o' service_url = 'www.cadc.nrc.ca' level = logging.DEBUG visitor = CAOM2RepoClient(auth.Subject(), level, host=service_url) response = MagicMock() response.status = 200 mock_conn.return_value = response visitor.delete_observation(collection, observation_id) self.assertEqual('DELETE', mock_conn.call_args[0][0].method) # signal problems http_error = requests.HTTPError() response.status_code = 500 http_error.response = response response.raise_for_status.side_effect = [http_error] with self.assertRaises(exceptions.InternalServerException): visitor.delete(collection, observation_id) # temporary transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response response.raise_for_status.side_effect = [http_error, None] visitor.delete_observation(collection, observation_id) # permanent transient errors http_error = requests.HTTPError() response.status_code = 503 http_error.response = response def raise_error(): raise http_error response.raise_for_status.side_effect = raise_error with self.assertRaises(exceptions.HttpException): visitor.delete_observation(collection, observation_id)
def request(self, method, path, data=None, stream=False, **kwargs): mock_response = MagicMock() mock_response.status = 400 mock_response.reason = "Bad Request" mock_response.headers = {"content-type": self.content_type} mock_response.data = json.dumps({ "results": [{ "rowcount": 1 }, { "error_message": "an error occured" }, { "error_message": "another error" }, { "error_message": "" }, { "error_message": None }] }).encode() return mock_response
def test_makes_request_403(self, mock_connection_from_url): response_mock = MagicMock() response_mock.status = 403 response_mock.data = 'test_data' mock_connection = MagicMock() mock_connection.request.return_value = response_mock mock_connection_from_url.return_value = mock_connection host = 'http://whynotestsforthisstuff.com' url = '/my_test_url/' self.assertRaises( Exception, utils.make_request, 'GET', host, url, 'a_user', 'a_pass' )
def test_makes_request_None(self, mock_connection_from_url): response_mock = MagicMock() response_mock.status = 200 response_mock.data = None mock_connection = MagicMock() mock_connection.request.return_value = response_mock mock_connection_from_url.return_value = mock_connection host = 'http://whynotestsforthisstuff.com' url = '/my_test_url/' utils.make_request( 'GET', host, url, 'a_user', 'a_pass' ) mock_connection_from_url.assert_called_once_with(host) mock_connection.request.assert_called_once()
def test_makes_request_skip_decode(self, mock_conn, mock_determine): response_mock = MagicMock() response_mock.status = 200 response_mock.data = 'test_data' mock_connection = MagicMock() mock_connection.request.return_value = response_mock mock_conn.return_value = mock_connection host = 'http://whynotestsforthisstuff.com' url = '/my_test_url/' utils.make_request('GET', host, url, 'a_user', 'a_pass', skip_decode=True) mock_conn.assert_called_once_with(num_pools=1) mock_connection.request.assert_called_once() mock_determine.assert_not_called()
def testDistributeKeyHandler(self, mock_get_all, mock_request, mock_make_key_string): """Test the distribute handler calls to put the keys on each proxy.""" fake_proxy_server = GetFakeProxyServer() fake_proxy_servers = [fake_proxy_server] mock_get_all.return_value = fake_proxy_servers mock_response = MagicMock() mock_response.status = 200 fake_content = '' mock_request.return_value = mock_response, fake_content fake_key_string = 'ssh-rsa public_key email' mock_make_key_string.return_value = fake_key_string self.testapp.get(PATHS['cron_proxy_server_distribute_key']) mock_request.assert_called_once_with( 'http://%s/key' % fake_proxy_server.ip_address, headers={'content-type': 'text/plain'}, method='PUT', body=fake_key_string)
def test_diff_stack_validationerror_template_too_large( self, caplog: LogCaptureFixture, cfngin_context: MockCFNginContext, monkeypatch: MonkeyPatch, ) -> None: """Test _diff_stack ValidationError - template too large.""" caplog.set_level(logging.ERROR) cfngin_context.add_stubber("cloudformation") cfngin_context.config.cfngin_bucket = "" expected = SkippedStatus("cfngin_bucket: existing bucket required") provider = Provider(cfngin_context.get_session()) # type: ignore mock_get_stack_changes = MagicMock( side_effect=ClientError( { "Error": { "Code": "ValidationError", "Message": "length less than or equal to", } }, "create_change_set", ) ) monkeypatch.setattr(provider, "get_stack_changes", mock_get_stack_changes) stack = MagicMock() stack.region = cfngin_context.env.aws_region stack.name = "test-stack" stack.fqn = "test-stack" stack.blueprint.rendered = "{}" stack.locked = False stack.status = None result = Action( context=cfngin_context, provider_builder=MockProviderBuilder(provider=provider), cancel=MockThreadingEvent(), # type: ignore )._diff_stack(stack) mock_get_stack_changes.assert_called_once() assert result == expected
def test_generate_qgs_style(self,ExportRun, mock_open): run_uid = 1234 stage_dir = os.path.join(settings.EXPORT_STAGING_ROOT, str(run_uid)) # Fill out the behavior for mocked ExportRun by adding a provider task with # subtasks for each file in all_file_list mocked_provider_subtasks = [] for fname in [ 'F1']: mps = MagicMock() mps.result.filename = fname mocked_provider_subtasks.append(mps) mocked_provider_task = MagicMock() mocked_provider_task.status = TaskStates.COMPLETED.value mocked_provider_task.slug = 'mocked_slug' mocked_provider_task.tasks.all.return_value = mocked_provider_subtasks mocked_run = MagicMock() mocked_run.job.include_zipfile = True mocked_run.job.name = 'mocked_job_name' mocked_run.provider_tasks.all.return_value = [mocked_provider_task] ExportRun.objects.get.return_value = mocked_run # test 1 - with a provider task returnvalue = generate_qgs_style(run_uid, mocked_provider_task) now = datetime.datetime.now() datestamp = "%s%02d%02d" % (now.year,now.month,now.day) style_file = os.path.join(stage_dir,mocked_run.job.name+"-"+datestamp+".qgs") mock_open.assert_called_once_with(style_file, 'w') self.assertEquals(returnvalue,style_file) # test 2 - without a provider task returnvalue = generate_qgs_style(run_uid, None) self.assertEquals(returnvalue,style_file)
def test_backup_info_exception(self, command_mock): # BackupManager mock backup_manager = build_backup_manager(name='test_server') backup_manager.config.pre_test_hook = 'not_existent_script' backup_manager.get_previous_backup = MagicMock() backup_manager.get_previous_backup.side_effect = \ UnknownBackupIdException() backup_manager.get_next_backup = MagicMock() backup_manager.get_next_backup.side_effect = \ UnknownBackupIdException() # BackupInfo mock backup_info = MagicMock(name='backup_info') backup_info.get_basebackup_directory.return_value = 'backup_directory' backup_info.backup_id = '123456789XYZ' backup_info.error = None backup_info.status = 'OK' # the actual test script = HookScriptRunner(backup_manager, 'test_hook', 'pre') script.env_from_backup_info(backup_info) expected_env = { 'BARMAN_PHASE': 'pre', 'BARMAN_VERSION': version, 'BARMAN_SERVER': 'test_server', 'BARMAN_CONFIGURATION': 'build_config_from_dicts', 'BARMAN_HOOK': 'test_hook', 'BARMAN_BACKUP_DIR': 'backup_directory', 'BARMAN_BACKUP_ID': '123456789XYZ', 'BARMAN_ERROR': '', 'BARMAN_STATUS': 'OK', 'BARMAN_PREVIOUS_ID': '', 'BARMAN_NEXT_ID': '', 'BARMAN_RETRY': '0', } script.run() assert command_mock.call_count == 1 assert command_mock.call_args[1]['env_append'] == expected_env
def setup_method(self): BraintreeTriggered._has_been_setup = True BraintreeTriggeredRecurring._has_been_setup = True transaction = MagicMock() transaction.amount = 1000 transaction.status = BraintreeTransaction.Status.Settled transaction.id = 'beertrain' transaction.processor_response_code = 2000 transaction.payment_instrument_type = 'paypal_account' transaction.paypal_details = MagicMock() transaction.paypal_details.image_url = 'image_url' transaction.paypal_details.payer_email = 'payer_email' transaction.paypal_details.token = 'kento' transaction.credit_card_details = MagicMock() transaction.credit_card_details.image_url = 'image_url' transaction.credit_card_details.last_4 = '1234' transaction.credit_card_details.card_type = 'card_type' transaction.credit_card_details.token = 'kento' transaction.customer_details = MagicMock() transaction.customer_details.id = 'braintree_id' self.transaction = transaction result = MagicMock() result.is_success = True result.transaction = transaction result.errors = MagicMock() result.errors.deep_errors = [ MagicMock(code=2001), MagicMock(code=2042) ] self.result = result self.search_result = MagicMock(items=[self.transaction])
def test_backup_info_exception(self, command_mock): # BackupManager mock backup_manager = build_backup_manager(name="test_server") backup_manager.config.pre_test_hook = "not_existent_script" backup_manager.get_previous_backup = MagicMock() backup_manager.get_previous_backup.side_effect = UnknownBackupIdException( ) backup_manager.get_next_backup = MagicMock() backup_manager.get_next_backup.side_effect = UnknownBackupIdException() # BackupInfo mock backup_info = MagicMock(name="backup_info") backup_info.get_basebackup_directory.return_value = "backup_directory" backup_info.backup_id = "123456789XYZ" backup_info.error = None backup_info.status = "OK" # the actual test script = HookScriptRunner(backup_manager, "test_hook", "pre") script.env_from_backup_info(backup_info) expected_env = { "BARMAN_PHASE": "pre", "BARMAN_VERSION": version, "BARMAN_SERVER": "test_server", "BARMAN_CONFIGURATION": "build_config_from_dicts", "BARMAN_HOOK": "test_hook", "BARMAN_BACKUP_DIR": "backup_directory", "BARMAN_BACKUP_ID": "123456789XYZ", "BARMAN_ERROR": "", "BARMAN_STATUS": "OK", "BARMAN_PREVIOUS_ID": "", "BARMAN_NEXT_ID": "", "BARMAN_RETRY": "0", } script.run() assert command_mock.call_count == 1 assert command_mock.call_args[1]["env_append"] == expected_env
def retry_helper(tries, delay, backoff, cap, mock_sleep): """ Helper function that calls a function with the retry decorator. This helper returns mock_request and mock_sleep. mock_request is called from inside the decorated function, and mock_sleep is the mocked `time.sleep`. """ mock_request = MagicMock() mock_status = MagicMock() mock_status.status = 502 @_retry(tries, delay, backoff, cap) def func(): mock_request() raise TransportException(mock_status, None) # The function should eventually raise the exception try: func() except TransportException: pass else: raise AssertionError() return mock_request, mock_sleep