def setUp(self): AddPatch(self, patch.dict('os.environ', {'NACL_SDK_ROOT': '/sdk/root'})) AddPatch( self, patch('webports.util.GetPlatform', Mock(return_value='linux'))) AddPatch( self, patch('webports.util.GetInstallRoot', Mock(return_value='/package/install/path'))) AddPatch( self, patch('webports.util.GetSDKRoot', Mock(return_value='/sdk/root'))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) AddPatch( self, patch('webports.util.InstallLock', Mock(return_value=mock_lock))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) AddPatch( self, patch('webports.util.BuildLock', Mock(return_value=mock_lock)))
def test_load(self, _open, listdir): files = ['a.conf', 'b.conf', 'c.other'] fp0 = Mock() fp0.buffer = StringIO(self.FILE % tuple(range(0, 4))) fp0.readline.side_effect = fp0.buffer.readline fp0.__enter__ = Mock(return_value=fp0) fp0.__exit__ = Mock() fp1 = Mock() fp1.buffer = StringIO(self.FILE % tuple(range(4, 8))) fp1.readline.side_effect = fp1.buffer.readline fp1.__enter__ = Mock(return_value=fp1) fp1.__exit__ = Mock() _open.side_effect = [fp0, fp1] listdir.return_value = files # test table = AliasTable() table.load() # validation for fp in (fp0, fp1): fp.__enter__.assert_called_once_with() fp.__exit__.assert_called_once_with(None, None, None) self.assertEqual( _open.call_args_list, [call('/etc/httpd/conf.d/{n}'.format(n=n)) for n in files[:-1]]) self.assertEqual(table.table, {'0': '1', '2': '3', '4': '5', '6': '7'})
def test_get_api_pod_parse_error(self, m_json_load, m_session): # Set up driver. self.driver.pod_name = 'pod-1' self.driver.namespace = 'a' pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}' api_root = "http://kubernetesapi:8080/api/v1/" self.driver.api_root = api_root # Set up mock objects self.driver.auth_token = 'TOKEN' m_json_load.side_effect = TypeError get_obj = Mock() get_obj.status_code = 200 get_obj.text = pod1 m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.return_value = get_obj m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test assert_raises(ApplyProfileError, self.driver._get_api_pod)
def test_inject_parent_settings(self, _pulp_conf, _read_config, _open): host = 'test-host' cert_path = '/path/cert' _pulp_conf.get.return_value = host _read_config.return_value.main = Mock(node_certificate=cert_path) fp = Mock() fp.__enter__ = Mock(return_value=fp) fp.__exit__ = Mock() _open.return_value = fp # test options = {} NodeProfiler._inject_parent_settings(options) # validation _pulp_conf.get.assert_called_once_with('server', 'server_name') _read_config.assert_called_once_with() _open.assert_called_once_with(cert_path) settings = options[constants.PARENT_SETTINGS] self.assertEqual(settings[constants.HOST], host) self.assertEqual(settings[constants.PORT], 443) self.assertEqual(settings[constants.NODE_CERTIFICATE], _open.return_value.read.return_value)
def vcenter_api_client(): vcenter_client = Mock() vcenter_client.__enter__ = Mock() vcenter_client.__exit__ = Mock() vcenter_client.get_ip_pool_for_dpg.return_value = None vcenter_client.set_vlan_id.return_value = 'success', 'success message' return vcenter_client
def setUp(self): self.context = ResourceCommandContext() self.context.resource = ResourceContextDetails() self.context.resource.name = 'resource' self.context.reservation = Mock() self.context.reservation.reservation_id = 'e34aa58a-468e-49a1-8a1d-0da1d2cc5b41' self.file_system = Mock() self.file_system.create_file = Mock( return_value=mock_enter_exit(Mock())) self.downloader = Mock() self.executor = Mock() self.executor.execute_playbook = Mock(return_value=['', '']) self.logger = mock_enter_exit(Mock()) session = Mock() session_context = Mock() session_context.__enter__ = Mock(return_value=session) session_context.__exit__ = Mock() self.session_provider = Mock() self.session_provider.get = Mock(return_value=session_context) self.conf = AnsibleConfiguration() self.conf.timeout_minutes = "0.0" self.shell = AnsibleShell(self.file_system, self.downloader, self.executor) self.shell.connection_service.check_connection = Mock() self.ansible_result_patcher = patch( 'cloudshell.cm.ansible.ansible_shell.AnsibleResult') self.ansible_result = Mock() self.ansible_result.success = True self.ansible_result.ctor = self.ansible_result_patcher.start() self.ansible_result.ctor.return_value = self.ansible_result
def test_inject_parent_settings(self, _pulp_conf, _read_config, _open): host = 'test-host' cert_path = '/path/cert' _pulp_conf.get.return_value = host _read_config.return_value.main = Mock(node_certificate=cert_path) fp = Mock() fp.__enter__ = Mock(return_value=fp) fp.__exit__ = Mock() _open.return_value = fp # test options = {} NodeProfiler._inject_parent_settings(options) # validation _pulp_conf.get.assert_called_once_with('server', 'server_name') _read_config.assert_called_once_with() _open.assert_called_once_with(cert_path) settings = options[constants.PARENT_SETTINGS] self.assertEqual(settings[constants.HOST], host) self.assertEqual(settings[constants.PORT], 443) self.assertEqual( settings[constants.NODE_CERTIFICATE], _open.return_value.read.return_value)
def test_get_api_pod(self, m_json_load, m_session): # Set up driver. self.driver.pod_name = 'pod-1' self.driver.namespace = 'a' pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}' api_root = "http://kubernetesapi:8080/api/v1/" self.driver.api_root = api_root # Set up mock objects self.driver.auth_token = 'TOKEN' get_obj = Mock() get_obj.status_code = 200 get_obj.text = pod1 m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.return_value = get_obj m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test self.driver._get_api_pod() # Assert correct data in calls. m_session_obj.headers.update.assert_called_once_with( {'Authorization': 'Bearer ' + 'TOKEN'}) m_session_obj.get.assert_called_once_with(api_root + 'namespaces/a/pods/pod-1', verify=False) m_json_load.assert_called_once_with(pod1)
def test_get_api_pod_with_client_certs(self, m_json_load, m_session): # Set up driver. self.driver.pod_name = 'pod-1' self.driver.namespace = 'a' pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}' api_root = "http://kubernetesapi:8080/api/v1/" self.driver.api_root = api_root self.driver.client_certificate = "cert.pem" self.driver.client_key = "key.pem" self.driver.certificate_authority = "ca.pem" get_obj = Mock() get_obj.status_code = 200 get_obj.text = pod1 m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.return_value = get_obj m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test self.driver._get_api_pod() # Assert correct data in calls. m_session_obj.get.assert_called_once_with(api_root + 'namespaces/a/pods/pod-1', verify="ca.pem", cert=("cert.pem", "key.pem")) m_json_load.assert_called_once_with(pod1)
def setUp(self) -> None: data_obj = MagicMock(key="foo", filename="foo.yml", data={"name": "foo"}) runtime = MagicMock() runtime.group_config.urls.cgit = "http://distgit.example.com/cgit" runtime.group_config.scan_freshness.threshold_hours = 6 runtime.logger = Mock() koji_mock = Mock() koji_mock.__enter__ = Mock() koji_mock.__enter__.return_value = koji_mock koji_mock.__exit__ = Mock() runtime.pooled_koji_client_session = Mock() runtime.pooled_koji_client_session.return_value = koji_mock self.package_id = 5 koji_mock.getPackage = Mock(return_value={'name': 'foo-container', 'id': self.package_id}) koji_mock.listTags = Mock(return_value=[{'name': 'rhaos-4.7-rhel-8-candidate'}]) runtime.assembly = 'hotfix_a' image_meta = Metadata("image", runtime, data_obj) image_meta.logger = Mock() image_meta.get_component_name = Mock(return_value='foo-container') image_meta.branch_major_minor = Mock(return_value='4.7') image_meta.branch = Mock(return_value='rhaos-4.7-rhel-8') image_meta.candidate_brew_tags = Mock(return_value=['rhaos-4.7-rhel-8-candidate', 'rhaos-4.7-rhel-7-candidate']) self.runtime = runtime self.meta = image_meta self.koji_mock = koji_mock
def test_run_interactive(capfd): """Ensure the calls to run a command on a list of hosts interactively.""" runner = Bladerunner({"threads": 14}) fake_result = Mock() fake_result.result = Mock(return_value="fake results") mock_con = Mock() runner.interactive_hosts = {"fake host": mock_con} fake_thread = Mock() fake_thread.__enter__ = fake_context fake_thread.__exit__ = fake_context fake_thread.submit = Mock(return_value=fake_result) threadpool_mock = patch.object( base, "ThreadPoolExecutor", return_value=fake_thread, ) with patch.object(runner, "setup_interactive") as mock_setup: with threadpool_mock as mock_threadpool: runner.run_interactive("fake cmd", "fake host") mock_setup.assert_called_once_with("fake host") mock_threadpool.assert_called_once_with(max_workers=14) stdout, stderr = capfd.readouterr() assert stdout == "fake host: fake results\n" assert stderr == ""
def test_run_interactive_returns(): """Confirm the dict return when print_results is False.""" runner = Bladerunner({"threads": 17}) fake_result = Mock() fake_result.result = Mock(return_value="some result") mock_con = Mock() runner.interactive_hosts = {"host": mock_con} fake_thread = Mock() fake_thread.__enter__ = fake_context fake_thread.__exit__ = fake_context fake_thread.submit = Mock(return_value=fake_result) threadpool_mock = patch.object( base, "ThreadPoolExecutor", return_value=fake_thread, ) with patch.object(runner, "setup_interactive") as mock_setup: with threadpool_mock as mock_threadpool: results = runner.run_interactive("ok", "host", print_results=False) mock_setup.assert_called_once_with("host") mock_threadpool.assert_called_once_with(max_workers=17) assert results == {"host": "some result"}
def test_get_api_pod_with_client_certs(self, m_json_load, m_session): # Set up driver. self.driver.pod_name = 'pod-1' self.driver.namespace = 'a' pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}' api_root = "http://kubernetesapi:8080/api/v1/" self.driver.api_root = api_root self.driver.client_certificate = "cert.pem" self.driver.client_key = "key.pem" self.driver.certificate_authority = "ca.pem" get_obj = Mock() get_obj.status_code = 200 get_obj.text = pod1 m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.return_value = get_obj m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test self.driver._get_api_pod() # Assert correct data in calls. m_session_obj.get.assert_called_once_with( api_root + 'namespaces/a/pods/pod-1', verify="ca.pem", cert=("cert.pem", "key.pem")) m_json_load.assert_called_once_with(pod1)
def test_DBExporter(): path = u'apa/movie' xt = u'tree:tiger:ASDASDSADASDASDSADASDASDSADASDASDSADASD' db = DB(':memory:') db.update(Object(u"dir:apa", { u'directory': ValueSet(u"dir:/apa"), })) db.update(Object('some_file', { u'directory': ValueSet(u"dir:apa/movie"), u'xt': ValueSet(xt), })) asset = Mock() asset.__enter__ = Mock(return_value=asset) asset.__exit__ = Mock(return_value=False) asset.status = Mock( return_value=proto.AssetStatus(status=proto.SUCCESS)) bithorde = Mock() bithorde.open = Mock(return_value=asset) bithorde.pool = Mock(return_value=itertools) writer = Mock() magnet = u'magnet:?xt=urn:' + xt exp = links.DBExporter(db, bithorde, writer) exp.export(False) writer.assert_called_once_with(path, magnet) writer.reset_mock() exp.export(False) writer.assert_not_called() exp.export(True) writer.assert_called_once_with(path, magnet)
def test_get_api_pod(self, m_json_load, m_session): # Set up driver. self.driver.pod_name = 'pod-1' self.driver.namespace = 'a' pod1 = '{"metadata": {"namespace": "a", "name": "pod-1"}}' api_root = "http://kubernetesapi:8080/api/v1/" self.driver.api_root = api_root # Set up mock objects self.driver.auth_token = 'TOKEN' get_obj = Mock() get_obj.status_code = 200 get_obj.text = pod1 m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.return_value = get_obj m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test self.driver._get_api_pod() # Assert correct data in calls. m_session_obj.headers.update.assert_called_once_with( {'Authorization': 'Bearer ' + 'TOKEN'}) m_session_obj.get.assert_called_once_with( api_root + 'namespaces/a/pods/pod-1', verify=False) m_json_load.assert_called_once_with(pod1)
def test_delete_security_rules(self): # Arrange self.network_security_group = MagicMock() network_client = MagicMock() private_ip_address = Mock() resource_group_name = "group_name" vm_name = "vm_name" security_group = NetworkSecurityGroup() security_group.name = "security_group_name" security_rule = Mock() security_rule.name = "rule_name" security_rule.destination_address_prefix = private_ip_address security_rules = [security_rule] security_group.security_rules = security_rules self.security_group_service.get_network_security_group = MagicMock() self.security_group_service.get_network_security_group.return_value = security_group self.network_service.get_private_ip = Mock( return_value=private_ip_address) contex_enter_mock = Mock() locker = Mock() locker.__enter__ = contex_enter_mock locker.__exit__ = Mock() # Act self.security_group_service.delete_security_rules( network_client, resource_group_name, vm_name, locker, Mock()) # Verify network_client.security_rules.delete.assert_called_once_with( resource_group_name=resource_group_name, network_security_group_name=security_group.name, security_rule_name=security_rule.name) contex_enter_mock.assert_called_once()
def test_catter(): fs = Filesystem(DB(':memory:')) fs.root().add_file('zeroes', [test_asset_ids], 130) asset = Mock() asset.__enter__ = Mock(return_value=asset) asset.__exit__ = Mock(return_value=False) asset.status = Mock(return_value=proto.AssetStatus(size=1024 * 1024, status=proto.SUCCESS)) asset.__iter__ = Mock(return_value=('\x00' * (128 * 1024) for _ in range(8))) bithorde = Mock() bithorde.open = Mock(return_value=asset) cat = Cat(fs, bithorde) sha = sha1() for chunk in cat(P('zeroes')): sha.update(chunk) assert_equals(sha.hexdigest(), '3b71f43ff30f4b15b5cd85dd9e95ebc7e84eb5a3') with assert_raises(FNotFound): for chunk in cat(P('NON-EXISTING')): pass asset.status = Mock(return_value=proto.AssetStatus(status=proto.NOTFOUND)) with assert_raises(NotFoundError): for chunk in cat(P('zeroes')): pass
def testErrorResultAndActiveModelInScrubInferernceResults( self, repoMock, *_args): """Calling _scrubInferenceResultsAndInitMetricData with a failed inference result and ACTIVE model should set the model to ERROR state and raise RejectedInferenceResultBatch. """ class MetricRowSpec(object): uid = None status = None parameters = None server = None metricRowMock = Mock(spec_set=MetricRowSpec, status=MetricStatus.ACTIVE, parameters=None, uid=0) class MetricDataRowSpec(object): uid = None rowid = None metric_value = None timestamp = None raw_anomaly_score = None metricRowDataMock = Mock(spec_set=MetricDataRowSpec, uid=0, rowid=0, timestamp=None, metric_value=0, raw_anomaly_score=None) engineMock = Mock(spec_set=sqlalchemy.engine.Engine) cmMock = Mock() engineMock.connect.return_value = cmMock cmMock.__enter__ = cmMock cmMock.__exit__ = cmMock connMock = Mock(spec_set=sqlalchemy.engine.Connection) cmMock.return_value = connMock runner = anomaly_service.AnomalyService() with self.assertRaises( anomaly_service.RejectedInferenceResultBatch) as cm: runner._scrubInferenceResultsAndInitMetricData( engine=engineMock, inferenceResults=[ ModelInferenceResult(rowID=0, status=MetricStatus.ERROR, errorMessage="bad inference") ], metricDataRows=[metricRowDataMock], metricObj=metricRowMock) repoMock.setMetricStatus.assert_called_with(connMock, 0, MetricStatus.ERROR, "bad inference") self.assertIn("promoted to ERROR state", cm.exception.args[0])
def test_write_data(self, m_open): mock_fp = Mock() mock_fp.__enter__ = lambda x: mock_fp mock_fp.__exit__ = lambda w, x, y, z: None m_open.return_value = mock_fp c.write_to_file('data', 'outfile') m_open.assert_called_once_with('outfile', 'w') mock_fp.write.assert_called_once_with('data')
def create_file_context_manager(*args, **kwargs): path = args[0] file_mock = Mock() file_mock.read = Mock(return_value=file_map[path]) cm = Mock() cm.__enter__ = Mock(return_value=file_mock) cm.__exit__ = Mock() return cm
def test_execute_jobs(): context = Mock() context.args = Mock() context.args.event_handlers = None task_context = Mock() task_context.pkg = Mock() task_context.pkg.name = 'name' jobs = { 'one': Job(identifier='id', dependencies=set(), task=None, task_context=task_context) } event_reactor = Mock() event_reactor.__enter__ = lambda self: self event_reactor.__exit__ = lambda self, *args: None with patch('colcon_core.executor.create_event_reactor', return_value=event_reactor): with EntryPointContext(extension1=Extension1, extension2=Extension2): # no extension selected with pytest.raises(AssertionError): execute_jobs(context, jobs) # execute method not implemented and sending skipped job event context.args.executor = 'extension2' with patch('colcon_core.executor.logger.error') as error: rc = execute_jobs(context, jobs) assert rc == 1 assert error.call_count == 1 assert len(error.call_args[0]) == 1 assert error.call_args[0][0].startswith( "Exception in executor extension 'extension2': \n") assert event_reactor.get_queue().put.call_count == 2 assert isinstance( event_reactor.get_queue().put.call_args_list[0][0][0][0], JobQueued) assert isinstance( event_reactor.get_queue().put.call_args_list[1][0][0][0], JobSkipped) # successful execution event_reactor.get_queue().put.reset_mock() jobs['one'].returncode = 0 extensions = get_executor_extensions() extensions[110]['extension2'].execute = \ lambda args, jobs, on_error: 0 callback = Mock() rc = execute_jobs(context, jobs, on_error=OnError.interrupt, pre_execution_callback=callback) assert rc == 0 assert event_reactor.get_queue().put.call_count == 1 assert isinstance(event_reactor.get_queue().put.call_args[0][0][0], JobQueued) assert callback.call_count == 1
def test_update(self): value_function = Mock() value_function.__enter__ = Mock(return_value=(Mock(), None)) value_function.__exit__ = Mock(return_value=None) advantage_function = Gae(value_function=value_function, gamma=1, lambduh=1) episodes = generate_episodes([[0, 0, 0], [0, 1, 2], [2, 1, 0], [1, 1, 1]]) advantage_function.update(episodes)
def global_reader_bis(path=''): reader = Mock(spec=RasterReader) reader.shape = (361, 720) reader.affine = Affine(-180., 0.5, 0.0, 90., 0.0, -0.5) context = Mock() context.__enter__ = Mock(return_value=reader) context.__exit__ = Mock(return_value=False) return context
def _get_context_mock(self, **kwargs): """ Mock the get_receipt_emails context manager """ inner_mock = Mock() inner_mock.__enter__ = Mock(**kwargs) inner_mock.__exit__ = Mock(return_value=False) return inner_mock
def global_reader_invalid_bounds(path=''): reader = Mock(spec=RasterReader) reader.shape = (360, 720) reader.affine = Affine(-180., 0.5, 0.0, 90., 0.0, -0.5) reader.bounds = BoundingBox(-180., 90., 0.5, 0.) context = Mock() context.__enter__ = Mock(return_value=reader) context.__exit__ = Mock(return_value=False) return context
def testContextManagerMocking(self): mock = Mock() mock.__enter__ = Mock() mock.__exit__ = Mock() mock.__exit__.return_value = False with mock as m: self.assertEqual(m, mock.__enter__.return_value) mock.__enter__.assert_called_with() mock.__exit__.assert_called_with(None, None, None)
def test_update_unlocked(self): ''' til; How to mock a context generator ''' job = {'app_id': 6380} self.master.apphandlerlocks = {6380: None} nblc = Mock() nblc.__enter__ = Mock(return_value=False) nblc.__exit__ = Mock() nblc_mock = Mock(return_value=nblc) with patch('master.NBLockContext', nblc_mock, create=True): self.assertFalse(self.master.api_update(job, Mock()))
def testErrorResultAndActiveModelInScrubInferernceResults( self, repoMock, *_args): """Calling _scrubInferenceResultsAndInitMetricData with a failed inference result and ACTIVE model should set the model to ERROR state and raise RejectedInferenceResultBatch. """ class MetricRowSpec(object): uid = None status = None parameters = None server = None metricRowMock = Mock( spec_set=MetricRowSpec, status=MetricStatus.ACTIVE, parameters=None, uid=0) class MetricDataRowSpec(object): uid = None rowid = None metric_value = None timestamp = None raw_anomaly_score = None metricRowDataMock = Mock( spec_set=MetricDataRowSpec, uid=0, rowid=0, timestamp=None, metric_value=0, raw_anomaly_score=None) engineMock = Mock(spec_set=sqlalchemy.engine.Engine) cmMock = Mock() engineMock.connect.return_value = cmMock cmMock.__enter__ = cmMock cmMock.__exit__ = cmMock connMock = Mock(spec_set=sqlalchemy.engine.Connection) cmMock.return_value = connMock runner = anomaly_service.AnomalyService() with self.assertRaises(anomaly_service.RejectedInferenceResultBatch) as cm: runner._scrubInferenceResultsAndInitMetricData( engine=engineMock, inferenceResults=[ModelInferenceResult(rowID=0, status=MetricStatus.ERROR, errorMessage="bad inference")], metricDataRows=[metricRowDataMock], metricObj=metricRowMock) repoMock.setMetricStatus.assert_called_with( connMock, 0, MetricStatus.ERROR, "bad inference") self.assertIn("promoted to ERROR state", cm.exception.args[0])
def test_setup_application_logging_from_file(self, yaml_mock, open_mock): fake_file = Mock() fake_file.__exit__ = Mock() fake_file.__enter__ = Mock(return_value=fake_file) open_mock.return_value = fake_file fake_config = {"level": "DEBUG", "handlers": {}, "formatters": {}} yaml_mock.safe_load.return_value = fake_config config = self.loader.load(filename="fake_file", level="INFO", default_config=None) self.assertEqual(config.level, "DEBUG")
def setUp(self): AddPatch(self, patch.dict('os.environ', {'NACL_SDK_ROOT': '/sdk/root'})) AddPatch(self, patch('naclports.util.GetPlatform', Mock(return_value='linux'))) AddPatch(self, patch('naclports.util.GetInstallRoot', Mock(return_value='/package/install/path'))) AddPatch(self, patch('naclports.util.GetSDKRoot', Mock(return_value='/sdk/root'))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) AddPatch(self, patch('naclports.util.InstallLock', Mock(return_value=mock_lock))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) AddPatch(self, patch('naclports.util.BuildLock', Mock(return_value=mock_lock)))
def setUp(self): add_patch(self, patch.dict('os.environ', {'NACL_SDK_ROOT': '/sdk/root'})) add_patch(self, patch('webports.util.get_platform', Mock(return_value='linux'))) add_patch(self, patch('webports.util.get_install_root', Mock(return_value='/package/install/path'))) add_patch(self, patch('webports.util.get_sdk_root', Mock(return_value='/sdk/root'))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) add_patch(self, patch('webports.util.InstallLock', Mock(return_value=mock_lock))) mock_lock = Mock() mock_lock.__enter__ = lambda s: s mock_lock.__exit__ = Mock(return_value=False) add_patch(self, patch('webports.util.BuildLock', Mock(return_value=mock_lock)))
def test_setup_application_logging_from_file(self, config_mock, json_mock, open_mock): fake_file = Mock() fake_file.__exit__ = Mock() fake_file.__enter__ = Mock(return_value=fake_file) open_mock.return_value = fake_file fake_config = {"foo": "bar"} json_mock.return_value = fake_config app_config = Mock(log_config="/path/to/log/config") bg_utils.setup_application_logging(app_config, {}) config_mock.assert_called_with({"foo": "bar"})
def _setup_mocks(self, stats_extension): pipeline_mock = Mock() pipeline_contextmanager_mock = Mock() pipeline_contextmanager_mock.__enter__ = Mock( return_value=pipeline_mock) pipeline_contextmanager_mock.__exit__ = Mock(return_value=False) stats_extension.pipeline = Mock() stats_extension.pipeline.return_value = pipeline_contextmanager_mock return pipeline_mock
def test_lock_is_used_if_supplied(self): mock_lock = Mock() mock_lock.__enter__ = Mock() mock_lock.__exit__ = Mock() obj = DummyObject() exposed_object = ExposedObject(obj, ["a"], lock=mock_lock) self.assertEqual(exposed_object["a:get"](), obj.a) mock_lock.__enter__.assert_called_once() mock_lock.__exit__.assert_called_once()
def _setup_mocks(self, stats_extension): pipeline_mock = Mock() pipeline_contextmanager_mock = Mock() pipeline_contextmanager_mock.__enter__ = Mock( return_value=pipeline_mock ) pipeline_contextmanager_mock.__exit__ = Mock(return_value=False) stats_extension.pipeline = Mock() stats_extension.pipeline.return_value = pipeline_contextmanager_mock return pipeline_mock
def test_generate_logging_config(self, open_mock, spec): fake_file = Mock() fake_file.__exit__ = Mock() fake_file.__enter__ = Mock(return_value=fake_file) open_mock.return_value = fake_file generated_config = {"foo": "bar"} config_generator = Mock(return_value=generated_config) logging_config = bg_utils.generate_logging_config_file( spec, config_generator, ["--log-config-file", "/path/to/log/config"]) assert logging_config == generated_config assert open_mock.called is True
def reader_context(**attrs): reader = Mock( spec=DatasetReader, shape=(360, 720), transform=Affine(-180., 0.5, 0.0, -90., 0.0, 0.5), bounds=BoundingBox(-180., -90., 0., 0.), crs={"init": "epsg:4326"}, ) reader.configure_mock(**attrs) context = Mock() context.__enter__ = Mock(return_value=reader) context.__exit__ = Mock(return_value=False) return context
def test_load(self, _open, listdir): files = [ 'a.conf', 'b.conf', 'c.other' ] fp0 = Mock() fp0.buffer = StringIO(self.FILE % tuple(range(0, 4))) fp0.readline.side_effect = fp0.buffer.readline fp0.__enter__ = Mock(return_value=fp0) fp0.__exit__ = Mock() fp1 = Mock() fp1.buffer = StringIO(self.FILE % tuple(range(4, 8))) fp1.readline.side_effect = fp1.buffer.readline fp1.__enter__ = Mock(return_value=fp1) fp1.__exit__ = Mock() _open.side_effect = [ fp0, fp1 ] listdir.return_value = files # test table = AliasTable() table.load() # validation for fp in (fp0, fp1): fp.__enter__.assert_called_once_with() fp.__exit__.assert_called_once_with(None, None, None) self.assertEqual( _open.call_args_list, [call('/etc/httpd/conf.d/{n}'.format(n=n)) for n in files[:-1]]) self.assertEqual(table.table, {'0': '1', '2': '3', '4': '5', '6': '7'})
def test_works(self, gamma, lambduh, rewards, expected_advantages): value_function = Mock() value_function.__enter__ = Mock(return_value=(Mock(), None)) value_function.__exit__ = Mock(return_value=None) value_function.get_values = Mock() value_function.get_values.side_effect = np.asarray(rewards) advantage_function = Gae(value_function=value_function, gamma=gamma, lambduh=lambduh) episodes = generate_episodes(rewards) advantages = advantage_function.get_advantages(episodes) assert advantages == expected_advantages
def test_execute_playbook_fail(self): self.mocks['mkdtemp'].return_value = '/inventory/dir' task = self.klass(self.ctx, self.task_config) task.setup() with patch.object(ansible.pexpect, 'run') as m_run: with patch('teuthology.task.ansible.open') as m_open: fake_failure_log = Mock() fake_failure_log.__enter__ = Mock() fake_failure_log.__exit__ = Mock() m_open.return_value = fake_failure_log m_run.return_value = ('', 1) with raises(CommandFailedError): task.execute_playbook() assert task.ctx.summary.get('status') == 'dead'
def test_should_report_failed_tests_to_ci_server(self, proxy): project = Project("basedir") mock_proxy = Mock() proxy.return_value = mock_proxy mock_proxy.and_test_name.return_value = mock_proxy mock_proxy.__enter__ = Mock(return_value=mock_proxy) mock_proxy.__exit__ = Mock(return_value=False) result = Mock() result.test_names = ["test1", "test2", "test3"] result.failed_test_names_and_reasons = {"test2": "Something went very wrong"} report_to_ci_server(project, result) mock_proxy.fails.assert_called_with("Something went very wrong")
def test_should_report_passed_tests_to_ci_server(self, proxy): project = Project('basedir') mock_proxy = Mock() proxy.return_value = mock_proxy mock_proxy.and_test_name.return_value = mock_proxy mock_proxy.__enter__ = Mock(return_value=mock_proxy) mock_proxy.__exit__ = Mock(return_value=False) result = Mock() result.test_names = ['test1', 'test2', 'test3'] result.failed_test_names_and_reasons = {} report_to_ci_server(project, result) mock_proxy.fails.assert_not_called()
def test_execute_playbook_fail(self): self.task_config.update(dict(playbook=[])) task = self.klass(self.ctx, self.task_config) task.setup() with patch.object(ansible.pexpect, "run") as m_run: with patch("teuthology.task.ansible.open") as m_open: fake_failure_log = Mock() fake_failure_log.__enter__ = Mock() fake_failure_log.__exit__ = Mock() m_open.return_value = fake_failure_log m_run.return_value = ("", 1) with raises(CommandFailedError): task.execute_playbook() assert task.ctx.summary.get("status") is None
def mock_get_recording(p_url, timeout=0, stream=False): result = Mock() result.__enter__ = Mock(return_value=result) result.__exit__ = Mock() result.iter_content = Mock(return_value='0') result.status_code = 200 result.headers = {'content-length': fetchtv.MAX_OCTET} response_dir = os.path.dirname( __file__) + os.path.sep + 'responses' + os.path.sep if p_url.endswith('cds.xml'): result.text = get_file(response_dir + 'fetch_cds.xml') else: result.text = get_file(response_dir + 'fetch_info.xml') return result
def test_execute_playbook_fail(self): self.task_config.update(dict( playbook=[], )) task = self.klass(self.ctx, self.task_config) task.setup() with patch.object(ansible.pexpect, 'run') as m_run: with patch('teuthology.task.ansible.open') as m_open: fake_failure_log = Mock() fake_failure_log.__enter__ = Mock() fake_failure_log.__exit__ = Mock() m_open.return_value = fake_failure_log m_run.return_value = ('', 1) with raises(CommandFailedError): task.execute_playbook()
def test_load(self, mock_open): mock_fp = Mock() mock_fp.read = Mock(return_value=RSA_KEY) mock_fp.__enter__ = Mock(return_value=mock_fp) mock_fp.__exit__ = Mock() mock_open.return_value = mock_fp # test authenticator = Authenticator() authenticator.load() # validation self.assertTrue(mock_fp.__exit__.called) self.assertTrue(isinstance(authenticator.rsa_key, RSA.RSA))
def setUp(self): self.pcmd = taskqueue.daemonlib.parse_cmdline opts = Mock() opts.foreground = True taskqueue.daemonlib.parse_cmdline = Mock(return_value=opts) self.config = ConfigParser() taskqueue.daemonlib.pika = Mock() fake_ctx = Mock() fake_ctx.__exit__ = Mock() fake_ctx.__enter__ = Mock() taskqueue.daemonlib.daemon.DaemonContext = Mock(return_value=fake_ctx) taskqueue.daemonlib.logging.config = Mock() config = Mock() config.items = Mock(return_value=[]) taskqueue.daemonlib.ConfigParser = Mock(return_value=config) self.daemon = taskqueue.daemonlib.Daemon(self.config)
def test_read(self, _open): path = '/tmp/xx' fp = Mock() fp.__enter__ = Mock(return_value=fp) fp.__exit__ = Mock() _open.return_value = fp # test content = cudl.read(path) # validation _open.assert_called_once_with(path) fp.__enter__.assert_called_once_with() fp.__exit__.assert_called_once_with(None, None, None) fp.read.assert_called_once_with() self.assertEqual(content, fp.read.return_value)
def _create_zmq_execution_mocks(self, patch, side=None, valid=True, response=ZMQ_ERROR_RESPONSE): socket = Mock() context = Mock() context.__enter__ = Mock() context.__enter__.return_value = socket context.__exit__ = Mock() context.__exit__.return_value = valid patch.return_value = context if valid: socket.recv.return_value = ZMQ_RESPONSE else: socket.recv.return_value = response if side: socket.recv.side_effect = side return socket, context
def test_default_paths(self, mock_config, mock_validate, mock_open, *unused): mock_config.return_value = INIConfig() mock_fp = Mock() mock_fp.__enter__ = Mock(return_value=mock_fp) mock_fp.__exit__ = Mock() mock_open.return_value = mock_fp # test read_config(validate=False) # validation paths = ["/etc/pulp/consumer/consumer.conf", os.path.expanduser("~/.pulp/consumer.conf")] mock_open.assert_any(paths[0]) mock_open.assert_any(paths[1]) self.assertFalse(mock_validate.called)
def test_storage_dir(self, storage): url = "url-123" repo = Mock(id="id-123") config = {importer_constants.KEY_FEED: url} st = Mock() st.__enter__ = Mock(return_value=st) st.__exit__ = Mock() storage.return_value = st # test step = Main(repo=repo, config=config) path = step.storage_dir storage.assert_called_once_with(constants.STORAGE_PROVIDER, step.remote_id) st.__enter__.assert_called_once_with() st.__exit__.assert_called_once_with(None, None, None) self.assertEqual(path, st.content_dir)
def test_get_pod_config_error(self, m_json_load, m_session): """Test _get_api_path with API Access Error """ # Set up mock objects self.driver.auth_token = 'TOKEN' m_session_obj = Mock() m_session_obj.headers = Mock() m_session_obj.get.side_effect = BaseException m_session.return_value = m_session_obj m_session_obj.__enter__ = Mock(return_value=m_session_obj) m_session_obj.__exit__ = Mock(return_value=False) # Call method under test assert_raises(ApplyProfileError, self.driver._get_api_pod)