def test_spec_inheritance_for_classes(self): class Foo(object): def a(self): pass class Bar(object): def f(self): pass class_mock = create_autospec(Foo) self.assertIsNot(class_mock, class_mock()) for this_mock in class_mock, class_mock(): this_mock.a() this_mock.a.assert_called_with() self.assertRaises(TypeError, this_mock.a, 'foo') self.assertRaises(AttributeError, getattr, this_mock, 'b') instance_mock = create_autospec(Foo()) instance_mock.a() instance_mock.a.assert_called_with() self.assertRaises(TypeError, instance_mock.a, 'foo') self.assertRaises(AttributeError, getattr, instance_mock, 'b') # The return value isn't isn't callable self.assertRaises(TypeError, instance_mock) instance_mock.Bar.f() instance_mock.Bar.f.assert_called_with() self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g') instance_mock.Bar().f() instance_mock.Bar().f.assert_called_with() self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
def setUp(self): view = mock.create_autospec(PlotView) view.subplotRemovedSignal = mock.Mock() self.presenter = PlotPresenter(view) self.presenter.view.canvas = mock.Mock() self.presenter.view.canvas.draw = mock.Mock() self.view = self.presenter.view self.view.close = mock.Mock() self.view.get_subplots = mock.Mock(return_value={}) self.view.removeLine = mock.Mock() # explicitly mock pop up self.mock_selector = mock.create_autospec(dummy_popup) self.mock_selector.subplotSelectorSignal = mock.Mock() self.mock_selector.closeEventSignal = mock.Mock() self.mock_rmWindow = mock.create_autospec(dummy_popup) self.mock_rmWindow.applyRemoveSignal = mock.Mock() self.mock_rmWindow.closeEventSignal = mock.Mock() self.mock_rmWindow.subplot = mock.Mock(return_value="plot") self.mock_rmWindow.getState = mock.Mock(side_effect=[True, True]) self.mock_rmWindow.getLine = mock.Mock() # mock presenter to create mock pop ups self.presenter.createRmWindow = mock.Mock( return_value=self.mock_rmWindow) self.presenter.createSelectWindow = mock.Mock( return_value=self.mock_selector) self.mock_name = mock.Mock() self.mock_workspace = mock.Mock() self.mock_func = mock.Mock() self.mock_arbitrary_args = [mock.Mock() for i in range(3)]
def test_copy_target(): src = create_autospec(Path, spec_set=True) dest = create_autospec(Path, spec_set=True) ct = CopyTarget(src, dest) assert ct.dest == dest ct.dest.exists.return_value = False with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp: cmp.return_value = False cres1 = ct.create() cres1.is_success assert copy2.call_count == 1 assert cmp.call_count == 0 ct.dest.exists.return_value = True with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp: cmp.return_value = False cres2 = ct.create() cres2.is_success assert copy2.call_count == 1 assert cmp.call_count == 1 ct.dest.exists.return_value = True with patch("shutil.copy2") as copy2, patch("filecmp.cmp") as cmp: cmp.return_value = True cres3 = ct.create() cres3.is_success assert copy2.call_count == 0 assert cmp.call_count == 1
def test_credentials_get_token(self): creds = mock.create_autospec(InteractiveCredentials) session = mock.create_autospec(OAuth2Session) creds._setup_session.return_value = session session.fetch_token.return_value = { 'expires_at':'1', 'expires_in':'2', 'refresh_token':"test"} creds.redirect = "//my_service.com" creds.token_uri = "token_uri" creds._check_state.return_value = True creds.verify = True InteractiveCredentials.set_token(creds, "response") self.assertEqual(creds.token, session.fetch_token.return_value) session.fetch_token.assert_called_with( "token_uri", authorization_response="https://my_service.com/response", verify=True) creds._check_state.side_effect = ValueError("failed") with self.assertRaises(ValueError): InteractiveCredentials.set_token(creds, "response") creds._check_state.side_effect = None session.fetch_token.side_effect = oauthlib.oauth2.OAuth2Error with self.assertRaises(AuthenticationError): InteractiveCredentials.set_token(creds, "response")
def test_run_implementations_parallel_output_enabled_slow_implementations(self, mock_loadImplementation): """Coverage case for the display_progress option where the future is still not done after the timer expires.""" test_implementation_mapping = {"foo": "bar", "baz": "bog"} test_command = CommandUnderTest() # create dummy imps where the side_effect of calling run is to sleep. mock_imp1 = create_autospec(spec = Implementation, spec_set = True, instance = True) mock_imp1.run.side_effect = lambda args: time.sleep(4) mock_imp2 = create_autospec(spec = Implementation, spec_set = True, instance = True) mock_imp2.run.side_effect = lambda args: time.sleep(5) gen = (impl for impl in (mock_imp1, mock_imp2)) test_command.impl_list = { key: next(gen) for key in test_implementation_mapping } result = test_command.run_implementations_parallel( implementation_mapping = test_implementation_mapping, display_progress = True ) assert result == { key: namedtuple("_", ("result", "exception"))( result = None, exception = None, ) for key in test_implementation_mapping }
def setUp(self): self.load=mock.create_autospec(load_utils.LoadUtils,spec_set=True) self.load.getCurrentWS=mock.Mock(return_value=["TEST00000001",["fwd","bkwd"]]) self.load.hasDataChanged = mock.MagicMock(return_value=False) self.model=mock.create_autospec(maxent_model.MaxEntModel,spec_set=True) self.view=mock.create_autospec(maxent_view.MaxEntView,spec_set=True) #signals #needed for connect in presenter self.view.maxEntButtonSignal=mock.Mock() self.view.cancelSignal=mock.Mock() self.view.phaseSignal=mock.Mock() # functions self.view.addItems=mock.MagicMock() self.view.initMaxEntInput=mock.Mock(return_value={"InputWorkspace":"testWS","EvolChi":"out", "ReconstructedData":"out2","ReconstructedImage":"out3","EvolAngle":"out4"}) self.view.deactivateCalculateButton=mock.Mock() self.view.activateCalculateButton=mock.Mock() self.view.usePhases = mock.Mock(return_value=False) #set presenter self.presenter=maxent_presenter.MaxEntPresenter(self.view,self.model,self.load) # make thread self.thread=mock.create_autospec(thread_model.ThreadModel) self.thread.start=mock.Mock() self.thread.started=mock.Mock() self.thread.finished=mock.Mock() self.thread.setInputs=mock.Mock() self.thread.loadData=mock.Mock() self.thread.threadWrapperSetup = mock.Mock() self.thread.threadWrapperTearDown = mock.Mock()
def test_userfile_is_uploaded(self, mock_mod, mock_query, mock_ufile): """Test is_uploaded""" mock_mod.return_value = True result = mock.create_autospec(UserFile) result.name = "1" mock_ufile.return_value = result api = mock.create_autospec(batchapps.api.BatchAppsApi) ufile = UserFile(api, {'name':'1'}) resp = mock.create_autospec(Response) resp.success = False resp.result = RestCallException(None, "Boom", None) api.query_files.return_value = resp with self.assertRaises(RestCallException): ufile.is_uploaded() resp.success = True resp.result = ['1', '2', '3'] self.assertIsInstance(ufile.is_uploaded(), UserFile) self.assertTrue(api.query_files.called) self.assertTrue(mock_query.called) self.assertEqual(mock_ufile.call_count, 3) mock_ufile.assert_called_with(mock.ANY, '3') result.name = "4" self.assertIsNone(ufile.is_uploaded())
def test_engine_logger(self, mocked_application, mocked_adapter): logger = ema_logging.get_logger() mocked_logger = mock.Mock(spec=logger) mocked_logger.handlers = [] mocked_logger.manager = mock.Mock(spec=logging.Manager) mocked_logger.manager.disable = 0 ema_logging._logger = mocked_logger mocked_application.instance.return_value = mocked_application mocked_application.log = mocked_logger # no handlers ema.set_engine_logger() logger = ema_logging._logger # self.assertTrue(type(logger) == type(mocked_adapter)) mocked_logger.setLevel.assert_called_once_with(ema_logging.DEBUG) mocked_adapter.assert_called_with(mocked_logger, ema.SUBTOPIC) # with handlers mocked_logger = mock.create_autospec(logging.Logger) mock_engine_handler = mock.create_autospec(ipykernel.log.EnginePUBHandler) mocked_logger.handlers = [mock_engine_handler] mocked_application.instance.return_value = mocked_application mocked_application.log = mocked_logger ema.set_engine_logger() logger = ema_logging._logger # self.assertTrue(type(logger) == ema.EngingeLoggerAdapter) mocked_logger.setLevel.assert_called_once_with(ema_logging.DEBUG) mocked_adapter.assert_called_with(mocked_logger, ema.SUBTOPIC) mock_engine_handler.setLevel.assert_called_once_with(ema_logging.DEBUG)
def test_create_autopsec(self): mock = create_autospec(X) instance = mock() self.assertRaises(TypeError, instance) mock = create_autospec(X()) self.assertRaises(TypeError, mock)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.randomizer_mock = create_autospec(Randomizer) self.configuration = EvolutionConfiguration() self.configuration.operators = EvolutionOperatorsConfiguration() self.configuration.operators.inversion = EvolutionOperatorConfiguration() self.configuration.operators.inversion.chance = 0.5 self.configuration.operators.mutation = EvolutionOperatorConfiguration() self.configuration.operators.mutation.chance = 0.2 self.configuration.operators.crossover = EvolutionOperatorConfiguration() self.configuration.operators.crossover.chance = 0.3 self.rule_population_mock = create_autospec(RulePopulation) self.service_mock = create_autospec(EvolutionService) self.service_mock.configure_mock(randomizer=self.randomizer_mock, configuration=self.configuration) self.rule_1 = Rule(Symbol('A'), Symbol('B'), Symbol('C')) self.rule_2 = Rule(Symbol('D'), Symbol('E'), Symbol('F')) self.sut = None
def test_spec_inheritance_for_classes(self): class Foo(object): __qualname__ = 'SpecSignatureTest.test_spec_inheritance_for_classes.<locals>.Foo' def a(self): pass class Bar(object): __qualname__ = 'SpecSignatureTest.test_spec_inheritance_for_classes.<locals>.Foo.Bar' def f(self): pass class_mock = create_autospec(Foo) self.assertIsNot(class_mock, class_mock()) for this_mock in (class_mock, class_mock()): this_mock.a() this_mock.a.assert_called_with() self.assertRaises(TypeError, this_mock.a, 'foo') self.assertRaises(AttributeError, getattr, this_mock, 'b') instance_mock = create_autospec(Foo()) instance_mock.a() instance_mock.a.assert_called_with() self.assertRaises(TypeError, instance_mock.a, 'foo') self.assertRaises(AttributeError, getattr, instance_mock, 'b') self.assertRaises(TypeError, instance_mock) instance_mock.Bar.f() instance_mock.Bar.f.assert_called_with() self.assertRaises(AttributeError, getattr, instance_mock.Bar, 'g') instance_mock.Bar().f() instance_mock.Bar().f.assert_called_with() self.assertRaises(AttributeError, getattr, instance_mock.Bar(), 'g')
def build_mock_player(position, pid): player = create_autospec(Player) pose = create_autospec(Pose) pose.position = position player.pose = pose player.id = pid return player
def test_synchronization_flow(self): session = { 'id': self.session_id } queue_items = [{ 'data': { 'id': 1, }, 'meta': { 'type': 'user', 'sync': { 'event_type': 'created', 'ack_key': 'User-1234-1', 'revision': 1 } } }] client = mock.create_autospec(basecrm.Client) sync_service = mock.create_autospec(basecrm.SyncService) sync_service.start.return_value = session sync_service.fetch.side_effect = [queue_items, []] sync_service.ack.return_value = True client.sync = sync_service sync = basecrm.Sync(client, self.device_uuid) sync.fetch(lambda meta, data: basecrm.Sync.ACK) sync_service.start.assert_called_once_with(self.device_uuid) sync_service.fetch.assert_has_calls([mock.call(self.device_uuid, self.session_id), mock.call(self.device_uuid, self.session_id)]) sync_service.ack.assert_called_once_with(self.device_uuid, ['User-1234-1'])
def test_submittedjob_get_thumbnail(self, mock_prev): """Test get_thumbnail""" resp = mock.create_autospec(Response) resp.success = False resp.result = RestCallException(None, "test", None) mock_prev.return_value = resp api = mock.create_autospec(BatchAppsApi) job = SubmittedJob(api, "abc", None, None) with self.assertRaises(FileDownloadException): job.get_thumbnail() self.assertFalse(mock_prev.called) job = SubmittedJob(api, "abc", None, None, previewLink={'href':'http://'}) with self.assertRaises(RestCallException): job.get_thumbnail() self.assertTrue(mock_prev.called) resp.success = True thumb = job.get_thumbnail(filename="thumb.png") mock_prev.assert_called_with(tempfile.gettempdir(), "thumb.png", True) thumb = job.get_thumbnail(download_dir="dir", filename="thumb.png", overwrite=False) mock_prev.assert_called_with("dir", "thumb.png", False) self.assertEqual(thumb, "dir\\thumb.png")
def mock_update(url, headers=None): response = mock.create_autospec(Response) response.request = mock.create_autospec(Request) response.request.method = 'GET' if url == ASYNC_URL: response.request.url = url response.status_code = POLLING_STATUS response.content = ASYNC_BODY response.randomFieldFromPollAsyncOpHeader = None elif url == LOCATION_URL: response.request.url = url response.status_code = POLLING_STATUS response.content = LOCATION_BODY response.randomFieldFromPollLocationHeader = None elif url == ERROR: raise BadEndpointError("boom") elif url == RESOURCE_URL: response.request.url = url response.status_code = POLLING_STATUS response.content = RESOURCE_BODY else: raise Exception('URL does not match') response.json = lambda: json.loads(response.content) return response
def test_submittedjob_get_output(self, mock_final, mock_int): """Test get_output""" _callback = mock.Mock() resp = mock.create_autospec(Response) resp.success = False resp.result = RestCallException(None, "test", None) api = mock.create_autospec(BatchAppsApi) mock_final.return_value = resp mock_int.return_value = resp job = SubmittedJob(api, "abc", None, None) with self.assertRaises(FileDownloadException): job.get_output("dir") job = SubmittedJob(api, "abc", None, None, outputLink={'href':'http://'}, outputFileName="filename") with self.assertRaises(RestCallException): output = job.get_output("dir") mock_final.assert_called_with("dir", False, callback=None, block=4096) self.assertFalse(mock_int.called) resp.success = True output = job.get_output("dir") self.assertEqual(output, "dir\\filename") mock_final.called = False output = job.get_output("dir", output={'name':'test'}, overwrite=True, callback=_callback, block=1) self.assertFalse(mock_final.called) mock_int.assert_called_with({'name':'test'}, "dir", True, callback=_callback, block=1) self.assertEqual(output, "dir\\test")
def test_submittedjob_get_final_preview(self): """Test _get_final_preview""" _callback = mock.Mock() resp = mock.create_autospec(Response) api = mock.create_autospec(BatchAppsApi) api.get_output.return_value = resp job = SubmittedJob(api, None, None, None) output = job._get_final_preview("dir", "name", True) api.get_output.assert_called_with("dir", 0, "name", True, url=None, callback=None, block=4096) self.assertEqual(output, resp) job = SubmittedJob(api, None, None, None, previewLink={'href':'http://thumb'}) output = job._get_final_preview("dir", "name", False, callback=_callback, block=111) api.get_output.assert_called_with("dir", 0, "name", False, url='http://thumb', callback=_callback, block=111) self.assertEqual(output, resp)
def test_jobsubmission_job_file(self): """Test set_job_file""" jfile = mock.create_autospec(UserFile) coll = mock.create_autospec(FileCollection) api = mock.create_autospec(BatchAppsApi) jfile.name = "test" job = JobSubmission(api, "test_job") with self.assertRaises(ValueError): job.set_job_file(2) with self.assertRaises(ValueError): job.set_job_file(None) with self.assertRaises(ValueError): job.set_job_file("Something") with self.assertRaises(ValueError): job.set_job_file(jfile) job.required_files = coll job.set_job_file(jfile) self.assertEqual(job.source, "test") coll.add.assert_called_with(jfile) coll.__len__.return_value = 1 job = JobSubmission(api, "test_job") job.required_files = coll job.set_job_file(0)
def test_filecoll_remove(self, mock_api): """Test remove""" col = FileCollection(mock_api) test_file = mock.create_autospec(UserFile) test_file.name = "test" col._collection = [test_file, 1, "2", None, []] with self.assertRaises(TypeError): col.remove(None) with self.assertRaises(TypeError): col.remove(10) col.remove(1) col.remove(-1) col.remove(slice(1)) self.assertEqual(col._collection, ["2", None]) test_file2 = mock.create_autospec(UserFile) test_file2.name = "test2" test_file3 = mock.create_autospec(UserFile) test_file3.name = "test3" col._collection = [test_file, test_file2, test_file3] col.remove("test") self.assertEqual(col._collection, [test_file2, test_file3]) col.remove(["test2", "test3"]) self.assertEqual(col._collection, [])
def test_signature_callable(self): class Callable(object): def __init__(self): pass def __call__(self, a): pass mock = create_autospec(Callable) mock() mock.assert_called_once_with() self.assertRaises(TypeError, mock, 'a') instance = mock() self.assertRaises(TypeError, instance) instance(a='a') instance.assert_called_once_with(a='a') instance('a') instance.assert_called_with('a') mock = create_autospec(Callable()) mock(a='a') mock.assert_called_once_with(a='a') self.assertRaises(TypeError, mock) mock('a') mock.assert_called_with('a')
def test_filecoll_extend(self, mock_api): """Test extend""" col = FileCollection(mock_api) col2 = FileCollection(mock_api) test_file = mock.create_autospec(UserFile) test_file2 = mock.create_autospec(UserFile) col._collection = [test_file] col2._collection = [test_file2, test_file] with self.assertRaises(AttributeError): col.extend(None) with self.assertRaises(AttributeError): col.extend("test") with self.assertRaises(AttributeError): col.extend([]) col.extend(col2) self.assertEqual(len(col._collection), 2) self.assertTrue(all(i in [test_file, test_file2] for i in col._collection)) col2.extend(col) self.assertEqual(len(col._collection), 2) self.assertTrue(all(i in [test_file, test_file2] for i in col._collection))
def test_pool_update(self): """Test delete""" api = mock.create_autospec(BatchAppsApi) pool = Pool(api) api.get_pool.return_value = mock.create_autospec(Response) api.get_pool.return_value.success = True api.get_pool.return_value.result = { 'targetDedicated':'5', 'currentDedicated':'4', 'state':'active', 'allocationState':'test', } self.assertEqual(pool.target_size, 0) self.assertEqual(pool.current_size, 0) self.assertEqual(pool.state, None) self.assertEqual(pool.allocation_state, None) self.assertEqual(pool.resize_error, '') pool.update() api.get_pool.assert_called_with(pool_id=None) self.assertEqual(pool.target_size, 5) self.assertEqual(pool.current_size, 4) self.assertEqual(pool.state, 'active') self.assertEqual(pool.allocation_state, 'test') self.assertEqual(pool.resize_error, '') api.get_pool.return_value.success = False api.get_pool.return_value.result = RestCallException(None, "Test", None) with self.assertRaises(RestCallException): pool.update()
def test_step_and_run(self): """Test command execution.""" def do_nothing(): """Empty function.""" self.control_unit.fetch_and_decode = create_autospec(do_nothing) self.control_unit.load = create_autospec(do_nothing) self.control_unit.execute = create_autospec(do_nothing) self.control_unit.write_back = create_autospec(do_nothing) self.control_unit.step() self.control_unit.fetch_and_decode.assert_called_once_with() self.control_unit.load.assert_called_once_with() self.control_unit.execute.assert_called_once_with() self.control_unit.write_back.assert_called_once_with() self.control_unit.get_status = create_autospec(do_nothing) self.control_unit.get_status.return_value = HALTED self.control_unit.run() self.control_unit.get_status.assert_called_with() self.control_unit.fetch_and_decode.assert_called_once_with() self.control_unit.load.assert_called_once_with() self.control_unit.execute.assert_called_once_with() self.control_unit.write_back.assert_called_once_with()
def test_count(self): node1 = mock.create_autospec(PeerNode) node2 = mock.create_autospec(PeerNode) peer_list = PeerNodeList() peer_list.add(node1) peer_list.add(node2) self.assertEqual(2, peer_list.count())
def test_init_no_services(self): test_name = "test name" mock_address = mock.create_autospec(Address) mock_timestamp = mock.create_autospec(Timestamp) node = PeerNode(test_name, mock_address, mock_timestamp) self.assertEqual(test_name, node.name) self.assertEqual(mock_address, node.address) self.assertEqual(mock_timestamp, node.timestamp)
def timer(): histogram = mock.create_autospec(Histogram) meter = mock.create_autospec(Meter) timer = Timer('seconds') timer.meter = meter timer.histogram = histogram return timer
def test_rest_client_put(self, mock_open, mock_call): """Test put""" auth = mock.create_autospec(Credentials) u_file = mock.create_autospec(UserFile) u_file.name = "test.jpg" u_file.path = "testfile" def _callback(progress, data, total): self.assertEqual(progress, 0.0) self.assertIsInstance(progress, float) self.assertIsInstance(data, int) self.assertIsInstance(total, int) with self.assertRaises(RestCallException): rest_client.put(auth, "http://test//{0}", {"Content-Type": "application/json"}, u_file, {}) with self.assertRaises(RestCallException): rest_client.put(auth, "http://test//{0}", {"Content-Type": "application/json"}, u_file, {'timestamp':'a', 'originalFilePath':'b'}) val = rest_client.put(auth, "http://test//{name}", {"Content-Type": "application/json"}, u_file, {'timestamp':'a', 'originalFilePath':'b'}, callback=_callback, block_size=1111) mock_open.assert_called_with("testfile", 'rb') mock_call.assert_called_with(auth, 'PUT', "http://test//test.jpg", data=mock.ANY, params={'timestamp':'a', 'originalFilePath':'b'}, headers={'Content-Type': 'application/octet-stream'}) self.assertIsNotNone(val) mock_open.side_effect = OSError("test") with self.assertRaises(RestCallException): rest_client.put(auth, "http://test//{name}", {"Content-Type": "application/json"}, u_file, {'timestamp':'a', 'originalFilePath':'b'}) mock_open.side_effect = None mock_call.side_effect = RestCallException(None, "Boom!", None) with self.assertRaises(RestCallException): rest_client.put(auth, "http://test//{name}", {"Content-Type": "application/json"}, u_file, {})
def test_get(self): test_name = "hello" mock_address = mock.create_autospec(Address) mock_timestamp = mock.create_autospec(Timestamp) node = PeerNode(test_name, mock_address, mock_timestamp) peer_list = PeerNodeList() peer_list.add(node) self.assertEqual(node, peer_list.get(test_name)) self.assertRaises(PeerNodeNotFoundException, peer_list.get, "no name")
def setUp(self): self._qapp = mock_widget.mockQapp() self._view = mock.create_autospec(LoadView) self._load_model = mock.create_autospec(LoadModel) self._co_model = mock.create_autospec(CoLoadModel) self.presenter = LoadPresenter( self._view, self._load_model, self._co_model) self.view = self.presenter.view
def create_mock_teams(allies, opponents): team1 = create_autospec(Team) team1.available_players = allies GameState()._our_team = team1 print(GameState().our_team.available_players.values()) team2 = create_autospec(Team) team2.available_players = opponents GameState()._enemy_team = team2
class BehaviorsTest(behaviors.Behaviors): """Class to add dynamic values for tests""" survive_egg = mk.create_autospec(survival.Egg, spec_set=True) develop_egg = mk.create_autospec(development.Egg, spec_set=True)
def mock_games(mock_players, game_stats_service): return mock.create_autospec(GameService(mock_players, game_stats_service))
def mock_context(loop): return mock.create_autospec(ServerContext(lambda: None, loop))
def create_mock_beam_centre_tab(): view = mock.create_autospec(BeamCentre, spec_set=False) return view
def create_mock_settings_diagnostic_tab(): view = mock.create_autospec(SettingsDiagnosticTab, spec_set=False) view.get_current_row = mock.MagicMock(return_value=3) return view
def setUp(self): self.filter = JivagoBannerFilter() self.filter_chain_mock: FilterChain = mock.create_autospec(FilterChain)
def create_mock_view(user_file_path, batch_file_path=None, row_user_file_path=""): get_cell_mock_with_path = partial(get_cell_mock, user_file_path=row_user_file_path) view = mock.create_autospec(SANSDataProcessorGui, spec_set=False) view.get_user_file_path = mock.Mock(return_value=user_file_path) view.get_cell = mock.MagicMock(side_effect=get_cell_mock_with_path) view.get_batch_file_path = mock.MagicMock(return_value=batch_file_path) view.get_number_of_rows = mock.MagicMock(return_value=2) # Add the settings diagnostic mock settings_diagnostic_tab = create_mock_settings_diagnostic_tab() view.settings_diagnostic_tab = settings_diagnostic_tab # Add the masking table view masking_table = create_mock_masking_table() view.masking_table = masking_table # Add the beam centre view beam_centre = create_mock_beam_centre_tab() view.beam_centre = beam_centre # Add the data diagnostic tab diagnostic_page = create_mock_diagnostics_tab() view.diagnostic_page = diagnostic_page view.halt_process_flag = mock.MagicMock() # --------------------- # Mocking properties # --------------------- _event_slices = mock.PropertyMock(return_value="") type(view).event_slices = _event_slices _merge_scale = mock.PropertyMock(return_value=1.) type(view).merge_scale = _merge_scale _merge_shift = mock.PropertyMock(return_value=0.) type(view).merge_shift = _merge_shift _merge_q_range_start = mock.PropertyMock(return_value=None) type(view).merge_q_range_start = _merge_q_range_start _merge_q_range_stop = mock.PropertyMock(return_value=None) type(view).merge_q_range_stop = _merge_q_range_stop _merge_q_range_stop = mock.PropertyMock(return_value=None) type(view).merge_q_range_stop = _merge_q_range_stop _merge_min = mock.PropertyMock(return_value=None) type(view).merge_min = _merge_min _merge_max = mock.PropertyMock(return_value=None) type(view).merge_max = _merge_max _sample_height = mock.PropertyMock(return_value=None) type(view).sample_height = _sample_height _sample_width = mock.PropertyMock(return_value=None) type(view).sample_width = _sample_width _sample_thickness = mock.PropertyMock(return_value=None) type(view).sample_thickness = _sample_thickness _sample_shape = mock.PropertyMock(return_value=None) type(view).sample_shape = _sample_shape _pixel_adjustment_det_1 = mock.PropertyMock(return_value="") type(view).pixel_adjustment_det_1 = _pixel_adjustment_det_1 _pixel_adjustment_det_2 = mock.PropertyMock(return_value="") type(view).pixel_adjustment_det_2 = _pixel_adjustment_det_2 _wavelength_adjustment_det_1 = mock.PropertyMock(return_value="") type(view).wavelength_adjustment_det_1 = _wavelength_adjustment_det_1 _wavelength_adjustment_det_2 = mock.PropertyMock(return_value="") type(view).wavelength_adjustment_det_2 = _wavelength_adjustment_det_2 _gravity_extra_length = mock.PropertyMock(return_value=None) type(view).gravity_extra_length = _gravity_extra_length _q_resolution_source_h = mock.PropertyMock(return_value=None) type(view).q_resolution_source_h = _q_resolution_source_h _q_resolution_sample_h = mock.PropertyMock(return_value=None) type(view).q_resolution_sample_h = _q_resolution_sample_h _q_resolution_source_w = mock.PropertyMock(return_value=None) type(view).q_resolution_source_w = _q_resolution_source_w _q_resolution_sample_w = mock.PropertyMock(return_value=None) type(view).q_resolution_sample_w = _q_resolution_sample_w _phi_limit_min = mock.PropertyMock(return_value=None) type(view).phi_limit_min = _phi_limit_min _phi_limit_max = mock.PropertyMock(return_value=None) type(view).phi_limit_max = _phi_limit_max _phi_limit_max = mock.PropertyMock(return_value=None) type(view).phi_limit_max = _phi_limit_max _q_1d_step = mock.PropertyMock(return_value=.001) type(view).q_1d_step = _q_1d_step _q_1d_step_type = mock.PropertyMock(return_value=RangeStepType.Lin) type(view)._q_1d_step_type = _q_1d_step_type _output_mode = mock.PropertyMock(return_value=OutputMode.PublishToADS) type(view).output_mode = _output_mode _wavelength_range = mock.PropertyMock(return_value='') type(view).wavelength_range = _wavelength_range _instrument = mock.PropertyMock(return_value=SANSInstrument.SANS2D) type(view).instrument = _instrument return view, settings_diagnostic_tab, masking_table
def mock_logger(): return mock.create_autospec(logger)
def test_no_default_attributes_in_init(self): sm = create_autospec(SimConnect.SimConnect) pl = SimConnect.Plane(sm=sm, add_default=False) with self.assertRaises(AttributeError): pl.altitude
def mock_gcs(): m = mock.create_autospec(WebDelegatingSubject) m.check_permission.side_effect = ValueError
def test_setup(self): """test setup an initial adult""" self.simulation.behaviors = mk.create_autospec(BehaviorsTest, spec_set=True) self.simulation.behaviors.survive_adult = self.survival self.simulation.behaviors.move_adult = self.movement self.simulation.behaviors.lay = self.lay self.simulation.behaviors.mate = self.mating self.simulation.space = mk.create_autospec(space.Space, spec_set=True) self.simulation.models = mk.create_autospec(models.Models, spec_set=True) unique_id_num = mk.MagicMock(spec=int) initial_key = mk.MagicMock(spec=str) with mk.patch.object(adult.Adult, '_set_sex', autospec=True) as mkSex: # Test regular self.Adult = adult.Adult.setup(unique_id_num, initial_key, self.simulation, self.genotype, self.mate) self.assertIsInstance(self.Adult, agent.Agent) self.assertIsInstance(self.Adult, insect.Insect) self.assertIsInstance(self.Adult, adult.Adult) self.assertEqual( self.Adult.unique_id, str(initial_key) + str(unique_id_num) + keyword.adult) self.assertEqual(self.Adult.location, self.simulation.space.new_location.return_value) self.assertEqual(self.simulation.space.new_location.call_args_list, [mk.call(keyword.adult_depth)]) self.assertEqual( self.Adult.mass, self.simulation.models.__getitem__.return_value.return_value) self.assertEqual( self.simulation.models.__getitem__.return_value.call_args_list, [mk.call(self.genotype)]) self.assertEqual(self.simulation.models.__getitem__.call_args_list, [mk.call(keyword.init_mature)]) self.assertEqual(self.Adult.agent_key, '') self.assertEqual(self.Adult.alive, True) self.assertEqual(self.Adult.age, 0) self.assertEqual(self.Adult.death, keyword.alive) self.assertEqual(self.Adult.num_eggs, 0) self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)]) self.assertEqual(self.Adult.simulation, self.simulation) self.assertEqual(self.Adult.genotype, self.genotype) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.survival, self.survival) self.assertEqual(self.Adult.movement, self.movement) self.assertEqual(self.Adult.lay, self.lay) self.assertEqual(self.Adult.mating, self.mating) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._age_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._age_count), next(i_tools.count(1))) self.assertTrue(dclass.is_dataclass(self.Adult)) mkSex.reset_mock() self.simulation.space.reset_mock() self.simulation.models.reset_mock() # Test no mate self.Adult = adult.Adult.setup(unique_id_num, initial_key, self.simulation, self.genotype, self.mate) self.assertIsInstance(self.Adult, agent.Agent) self.assertIsInstance(self.Adult, insect.Insect) self.assertIsInstance(self.Adult, adult.Adult) self.assertEqual( self.Adult.unique_id, str(initial_key) + str(unique_id_num) + keyword.adult) self.assertEqual(self.Adult.location, self.simulation.space.new_location.return_value) self.assertEqual(self.simulation.space.new_location.call_args_list, [mk.call(keyword.adult_depth)]) self.assertEqual( self.Adult.mass, self.simulation.models.__getitem__.return_value.return_value) self.assertEqual( self.simulation.models.__getitem__.return_value.call_args_list, [mk.call(self.genotype)]) self.assertEqual(self.simulation.models.__getitem__.call_args_list, [mk.call(keyword.init_mature)]) self.assertEqual(self.Adult.agent_key, '') self.assertEqual(self.Adult.alive, True) self.assertEqual(self.Adult.age, 0) self.assertEqual(self.Adult.death, keyword.alive) self.assertEqual(self.Adult.num_eggs, 0) self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)]) self.assertEqual(self.Adult.simulation, self.simulation) self.assertEqual(self.Adult.genotype, self.genotype) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.survival, self.survival) self.assertEqual(self.Adult.movement, self.movement) self.assertEqual(self.Adult.lay, self.lay) self.assertEqual(self.Adult.mating, self.mating) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._age_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._age_count), next(i_tools.count(1))) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._id_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._id_count), next(i_tools.count())) self.assertTrue(dclass.is_dataclass(self.Adult))
def test_initialize(self): """test initialize the agent""" self.simulation.behaviors = mk.create_autospec(BehaviorsTest, spec_set=True) self.simulation.behaviors.survive_adult = self.survival self.simulation.behaviors.move_adult = self.movement self.simulation.behaviors.lay = self.lay self.simulation.behaviors.mate = self.mating with mk.patch.object(adult.Adult, '_set_sex', autospec=True) as mkSex: # Test regular self.Adult = adult.Adult.initialize(self.unique_id, self.simulation, self.location, self.mass, self.genotype, self.mate) self.assertIsInstance(self.Adult, agent.Agent) self.assertIsInstance(self.Adult, insect.Insect) self.assertIsInstance(self.Adult, adult.Adult) self.assertEqual(self.Adult.agent_key, '') self.assertEqual(self.Adult.alive, True) self.assertEqual(self.Adult.age, 0) self.assertEqual(self.Adult.death, keyword.alive) self.assertEqual(self.Adult.num_eggs, 0) self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)]) self.assertEqual(self.Adult.unique_id, self.unique_id) self.assertEqual(self.Adult.simulation, self.simulation) self.assertEqual(self.Adult.location, self.location) self.assertEqual(self.Adult.mass, self.mass) self.assertEqual(self.Adult.genotype, self.genotype) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.survival, self.survival) self.assertEqual(self.Adult.movement, self.movement) self.assertEqual(self.Adult.lay, self.lay) self.assertEqual(self.Adult.mating, self.mating) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._age_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._age_count), next(i_tools.count(1))) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._id_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._id_count), next(i_tools.count())) self.assertTrue(dclass.is_dataclass(self.Adult)) mkSex.reset_mock() # Test no mate self.Adult = adult.Adult.initialize(self.unique_id, self.simulation, self.location, self.mass, self.genotype) self.assertIsInstance(self.Adult, agent.Agent) self.assertIsInstance(self.Adult, insect.Insect) self.assertIsInstance(self.Adult, adult.Adult) self.assertEqual(self.Adult.agent_key, '') self.assertEqual(self.Adult.alive, True) self.assertEqual(self.Adult.age, 0) self.assertEqual(self.Adult.death, keyword.alive) self.assertEqual(self.Adult.num_eggs, 0) self.assertEqual(mkSex.call_args_list, [mk.call(self.Adult)]) self.assertEqual(self.Adult.unique_id, self.unique_id) self.assertEqual(self.Adult.simulation, self.simulation) self.assertEqual(self.Adult.location, self.location) self.assertEqual(self.Adult.mass, self.mass) self.assertEqual(self.Adult.genotype, self.genotype) self.assertEqual(self.Adult.mate, None) self.assertEqual(self.Adult.survival, self.survival) self.assertEqual(self.Adult.movement, self.movement) self.assertEqual(self.Adult.lay, self.lay) self.assertEqual(self.Adult.mating, self.mating) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._age_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._age_count), next(i_tools.count(1))) # noinspection PyTypeChecker self.assertIsInstance(self.Adult._id_count, i_tools.count) # noinspection PyTypeChecker self.assertEqual(next(self.Adult._id_count), next(i_tools.count())) self.assertTrue(dclass.is_dataclass(self.Adult))
def make_view(self): controller = mock.create_autospec(spec=FilesystemController) return GuidedFilesystemView(controller)
def test_rest_client_download(self, mock_open, mock_call, mock_path): """Test download""" def _callback(progress, data, total): self.assertEqual(progress, 0.0) self.assertIsInstance(progress, float) self.assertIsInstance(data, int) self.assertIsInstance(total, int) auth = mock.create_autospec(Credentials) mock_path.return_value = True val = rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 10, False, block_size=12345, callback=_callback) self.assertFalse(mock_call.called) self.assertTrue(val) val = rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 0, True, callback=_callback) mock_call.assert_called_with(auth, 'GET', "http://host//something//test?a=b", headers={}, stream=True) mock_path.return_value = False val = rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 500, False, ext=".jpg", callback=_callback) mock_call.assert_called_with(auth, 'GET', "http://host//something//test?a=b", headers={}, stream=True) mock_open.assert_called_with("c:\\test\\test.jpg", "wb") val = rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 500, False, ext=".jpg", f_name="another.png") mock_call.assert_called_with(auth, 'GET', "http://host//something//test?a=b", headers={}, stream=True) mock_open.assert_called_with("c:\\test\\another.png", "wb") mock_open.side_effect = IOError('oops!') with self.assertRaises(RestCallException): rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 0, True) mock_call.side_effect = RestCallException(None, "Boom!", None) with self.assertRaises(RestCallException): rest_client.download(auth, "http://host//something//test?a=b", {}, "c:\\test", 0, True)
def socket_spec(): spec = create_autospec(zmq.Socket, instance=True) spec.FD = 2 return spec
def setUp(self): super().setUp() self.naming = mock.create_autospec(naming.Naming)
def create_mock_diagnostics_tab(): view = mock.create_autospec(DiagnosticsPage, spec_set=False) return view
def model(): return create_autospec(Model)
def create_mock_masking_table(): view = mock.create_autospec(MaskingTable, spec_set=False) view.get_current_row = mock.MagicMock(return_value=3) return view
def setUp(self): self.mock_stdin = create_autospec(sys.stdin) self.mock_stdout = create_autospec(sys.stdout)
def mock_protocol(): return mock.create_autospec(QDataStreamProtocol(mock.Mock(), mock.Mock()))
def setup(self): self.mock_client = mock.create_autospec(api.Client) self.lcp_crud = crud.LCPCrud(self.mock_client)
def mock_players(mock_db_pool): return mock.create_autospec(PlayerService(mock_db_pool))
def setUp(self): self.message_dispatcher: MessageDispatcher = mock.create_autospec( MessageDispatcher) self.message_bus = SynchronousEventBus([self.message_dispatcher]) self.message_dispatcher.can_handle.return_value = True
def mock_player(): return mock.create_autospec(Player(login='******', id=42))
def setUp(self): self.view = mock.create_autospec(view.FocusView) self.model = mock.create_autospec(model.FocusModel) self.presenter = presenter.FocusPresenter(self.model, self.view) self.presenter.current_calibration.set_roi_info(None, None, None)
def setUp(self): self.site_adapter = create_autospec(SiteAdapter) self.site_agent = SiteAgent(self.site_adapter)
# Switch data to mock MAC address table SWITCH_DATA = """ Flow Link Back Mdix Port Type Duplex Speed Neg ctrl State Pressure Mode -------- ------------ ------ ----- -------- ---- ----------- -------- ------- gi1/0/1 1G-Copper -- -- -- -- Down -- -- gi1/0/2 1G-Copper Full 1000 Enabled Off Up Disabled Off gi1/0/3 1G-Copper Full 1000 Enabled Off Up Disabled On te1/0/1 10G-Fiber -- -- -- -- Down -- -- console#: """ # Intercept expectmore calls mock_expectmore = patch(target="stack.switch.x1052.ExpectMore", autospec=True).start() # Need to set the instance mock returned from calling ExpectMore() mock_expectmore.return_value = create_autospec( spec=ExpectMore, spec_set=True, instance=True, ) # Need to set the match_index to the base console prompt so that the switch thinks it is at the # correct prompt, and wont try to page through output. type(mock_expectmore.return_value).match_index = PropertyMock( return_value=SwitchDellX1052.CONSOLE_PROMPTS.index( SwitchDellX1052.CONSOLE_PROMPT)) # Return our SWITCH_DATA from ExpectMore().ask() mock_expectmore.return_value.ask.return_value = SWITCH_DATA.splitlines()
def test_reset(self): """test reset the mock""" self.simulation.models = \ mk.create_autospec(models.Models, spec_set=True) self.simulation.models.__getitem__.side_effect = [True, False] with mk.patch.object(adult.Adult, 'transition', autospec=True) as mkTransition: # Not female or mated self.assertEqual(self.Adult.reset(), []) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.num_eggs, self.num_eggs) self.assertEqual(self.lay.reset.call_args_list, []) self.assertEqual(mkTransition.call_args_list, []) self.assertEqual(self.simulation.models.__getitem__.call_args_list, []) # Is female self.Adult.agent_key = keyword.female # Female lifetime mate self.assertEqual(self.Adult.reset(), []) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.num_eggs, self.lay.reset.return_value) self.assertEqual(self.lay.reset.call_args_list, [mk.call(self.Adult)]) self.assertEqual(mkTransition.call_args_list, []) self.assertEqual(self.simulation.models.__getitem__.call_args_list, [mk.call(keyword.lifetime_female)]) # Not female lifetime mate self.Adult.num_eggs = self.num_eggs self.simulation.models.reset_mock() self.lay.reset_mock() self.assertEqual(self.Adult.reset(), []) self.assertEqual(self.Adult.mate, None) self.assertEqual(self.Adult.num_eggs, self.lay.reset.return_value) self.assertEqual(self.lay.reset.call_args_list, [mk.call(self.Adult)]) self.assertEqual(mkTransition.call_args_list, []) self.assertEqual(self.simulation.models.__getitem__.call_args_list, [mk.call(keyword.lifetime_female)]) self.Adult.num_eggs = self.num_eggs self.Adult.mate = self.mate self.simulation.models.reset_mock() self.lay.reset_mock() # Is mated and not alive self.Adult.alive = False self.Adult.agent_key = keyword.mated self.assertEqual(self.Adult.reset(), []) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.num_eggs, self.num_eggs) self.assertEqual(self.lay.reset.call_args_list, []) self.assertEqual(mkTransition.call_args_list, []) self.assertEqual(self.simulation.models.__getitem__.call_args_list, []) # Is mated and alive self.Adult.alive = True self.Adult.agent_key = keyword.mated self.assertEqual(self.Adult.reset(), []) self.assertEqual(self.Adult.mate, self.mate) self.assertEqual(self.Adult.num_eggs, self.num_eggs) self.assertEqual(self.lay.reset.call_args_list, []) self.assertEqual(mkTransition.call_args_list, [mk.call(self.Adult, keyword.male)]) self.assertEqual(self.simulation.models.__getitem__.call_args_list, [])
def annotation_delete_service(pyramid_config): service = mock.create_autospec(AnnotationDeleteService, spec_set=True, instance=True) pyramid_config.register_service(service, name="annotation_delete") return service