def test_binary_reel_header_delegation(self, delegatee): p = PropertyMock(return_value=BinaryReelHeader()) type(delegatee).binary_reel_header = p dd = DelegatingDataset(delegatee) brh = dd.binary_reel_header p.assert_called_once_with() assert are_equal(brh, BinaryReelHeader())
def test_extended_textual_header_delegation(self, delegatee): p = PropertyMock(return_value=['Hello', 'World!']) type(delegatee).extended_textual_header = p dd = DelegatingDataset(delegatee) eth = dd.extended_textual_header p.assert_called_once_with() assert eth == ['Hello', 'World!']
def test_dimensionality_header_delegation(self, delegatee): p = PropertyMock(return_value=3) type(delegatee).dimensionality = p dd = DelegatingDataset(delegatee) d = dd.dimensionality p.assert_called_once_with() assert d == 3
def test_endian_delegation(self, delegatee): p = PropertyMock(return_value='<') type(delegatee).endian = p dd = DelegatingDataset(delegatee) e = dd.endian p.assert_called_once_with() assert e == '<'
def test_encoding_delegation(self, delegatee): p = PropertyMock(return_value='ascii') type(delegatee).encoding = p dd = DelegatingDataset(delegatee) e = dd.encoding p.assert_called_once_with() assert e == 'ascii'
def testRead(self, mockWorksheet, mockObservedMatrix, mockExpectedMatrix): mockBases = Mock() testTitle = "Test Title" mockWorksheetTitle = PropertyMock(return_value = testTitle) type(mockWorksheet).title = mockWorksheetTitle testResult = (mockObservedMatrix, mockExpectedMatrix) testReader = ObservedExpectedMatricesReader(mockBases) testReader._validateHeaders = MagicMock(return_value = True) testReader._readAndValidateSubstitutionValues = \ MagicMock(return_value = testResult) testReader.read(mockWorksheet) self.assertEquals(testReader.matricesDictionary[testTitle], testResult, "Matrices dictionary value must be equal to the" + "test result.") testReader._validateHeaders \ .assert_any_call(18, 1, mockWorksheet) testReader._validateHeaders \ .assert_any_call(18, 7, mockWorksheet) self.assertEquals(testReader._validateHeaders.call_count, 2, "Header validation must have been called exactly twice.") testReader._readAndValidateSubstitutionValues \ .assert_called_once_with(mockWorksheet) mockWorksheetTitle.assert_called_once_with()
def test_ValidateHeaders(self, mockWorksheet): testStartRowIndex = 0 testStartColIndex = 0 testHeaders = self.validHeaders mockKeys = MagicMock() mockKeys.__iter__.return_value = testHeaders mockMembers = Mock() mockMembers.keys.return_value = mockKeys mockBase = Mock() pMockMembers = PropertyMock(return_value = mockMembers) type(mockBase).__members__ = pMockMembers mockWorksheet.cell = MagicMock(side_effect = self.getValidHeaderValue) testReader = ObservedExpectedMatricesReader(mockBase) testReader._validateHeaders(testStartRowIndex, testStartColIndex, mockWorksheet) mockKeys.__iter__.assert_called_once_with() mockMembers.keys.assert_called_once_with() pMockMembers.assert_called_once_with() mockMembers.keys.assert_called_once_with() testFullHeaders = [" "] testFullHeaders.append(self.validHeaders) for index in range(len(testFullHeaders)): mockWorksheet.cell.assert_any_call(row = testStartRowIndex + index, column = testStartColIndex) mockWorksheet.cell.assert_any_call(row = testStartRowIndex, column = testStartColIndex + index)
def test_writeHeaders(self, mockWorksheet, mockSubstitutionMatrix): mockBase = MagicMock() mockWorksheet.cell = MagicMock(spec=openpyxl.cell.cell) pValueMock = PropertyMock() type(mockWorksheet.cell(row = ANY, column = ANY)) \ .value = pValueMock testSubjectHeader = "Test Header" testSubject = "Subject" testInvalidSubject = "Invalid Subject" testValidSubjects = {testSubject: mockSubstitutionMatrix} testInvalidSubjects = [testInvalidSubject] mockBase.__iter__.return_value = [1, 2,] testWriter = SubstitutionMatrixDataWriter(testSubjectHeader, testValidSubjects, testInvalidSubjects, mockBase) testWriter._writeHeaders(mockWorksheet) self.assertEquals(mockBase.__iter__.call_count, 3, "Nucleobase iterator must be called three times.") mockWorksheet.cell.assert_any_call(row = 1, column = 1) mockWorksheet.cell.assert_any_call(row = 1, column = 2) pValueMock.assert_any_call("Virus") pValueMock.assert_any_call("1 -> 2") pValueMock.assert_any_call("2 -> 1")
def test_textual_reel_header_delegation(self, delegatee): p = PropertyMock(return_value=['foo']) type(delegatee).textual_reel_header = p dd = DelegatingDataset(delegatee) trh = dd.textual_reel_header p.assert_called_once_with() assert trh == ['foo']
def test_propertymock_returnvalue(self): m = MagicMock() p = PropertyMock() type(m).foo = p returned = m.foo p.assert_called_once_with() self.assertIsInstance(returned, MagicMock) self.assertNotIsInstance(returned, PropertyMock)
def test_step_visibility(self, _step: PropertyMock): """Should return values from the internal _step object.""" _step.return_value = MagicMock(is_visible=True) es = exposed.ExposedStep() self.assertTrue(es.visible) es.visible = False self.assertFalse(es.visible)
def test_step_stop_aborted(self, _step: PropertyMock): """ Should abort stopping and not raise an error when no internal step is available to stop. """ _step.return_value = None es = exposed.ExposedStep() es.stop()
def test_write_to_console_fail(self, _step: PropertyMock): """ Should raise a ValueError when there is no current step to operate upon by the write function call. """ _step.return_value = None step = exposed.ExposedStep() with self.assertRaises(ValueError): step.write_to_console('hello')
def test_get_internal_project( self, sleep: MagicMock, internal_project: PropertyMock ): """Should get internal project on the third attempt""" project = exposed.ExposedProject() internal_project.side_effect = [None, None, 'test'] result = project.get_internal_project() self.assertEqual('test', result) self.assertEqual(2, sleep.call_count)
def test_step_properties(self, _step: PropertyMock): """Should return values from the internal _step object.""" now = datetime.utcnow() _step.return_value = MagicMock( start_time=now, end_time=now, elapsed_time=0, is_visible=True ) es = exposed.ExposedStep() self.assertEqual(now, es.start_time) self.assertEqual(now, es.end_time) self.assertEqual(0, es.elapsed_time)
def test_writeSubject(self, mockSubstitutionMatrix, mockWorksheet): testSubjectHeader = "Test Header" testSubject = "Subject" testInvalidSubject = "Invalid Subject" testValidSubjects = {testSubject: mockSubstitutionMatrix} testInvalidSubjects = [testInvalidSubject] testSubjectName = "Test Subject Name" mockBase = MagicMock() mockBase.__iter__.return_value = [0, 1] mockSubstitutionMatrix.getCopy.return_value = [[1, 2], [3, 4]] pValueMock = PropertyMock() type(mockWorksheet.cell(row = ANY, column = ANY)).value \ = pValueMock testWriter = SubstitutionMatrixDataWriter(testSubjectHeader, testValidSubjects, testInvalidSubjects, mockBase) testWriter._writeSubject(testSubjectName, mockSubstitutionMatrix, mockWorksheet) pValueMock.assert_any_call(testSubjectName) pValueMock.assert_any_call(2) pValueMock.assert_any_call(3)
def test_render_to_console(self, _step: PropertyMock): """ Should render to the console using a write_source function call on the internal step report's stdout_interceptor. """ message = ' {{ a }} is not {{ b }}.' _step_mock = MagicMock() write_source = MagicMock() _step_mock.report.stdout_interceptor.write_source = write_source _step.return_value = _step_mock step = exposed.ExposedStep() step.render_to_console(message, a=7, b='happy') args, kwargs = write_source.call_args self.assertEqual('7 is not happy.', args[0])
def test_get_internal_project_fail( self, sleep: MagicMock, time_time: MagicMock, internal_project: PropertyMock ): """ Should fail to get internal project and return None after eventually timing out. """ project = exposed.ExposedProject() time_time.side_effect = range(20) internal_project.return_value = None result = project.get_internal_project() self.assertIsNone(result) self.assertEqual(10, sleep.call_count)
def test_write_to_console(self, _step: PropertyMock): """ Should write to the console using a write_source function call on the internal step report's stdout_interceptor. """ trials = [2, True, None, 'This is a test', b'hello'] for message in trials: _step_mock = MagicMock() write_source = MagicMock() _step_mock.report.stdout_interceptor.write_source = write_source _step.return_value = _step_mock step = exposed.ExposedStep() step.write_to_console(message) args, kwargs = write_source.call_args self.assertEqual('{}'.format(message), args[0])
class TestMediator(TestCase): def setUp(self): super(TestCase, self).setUp() self.logger = logging.getLogger("test-mediator") self.mediator = MockMediator(user={"name": "Example"}, age=30, logger=self.logger) def test_must_implement_call(self): del MockMediator.call with self.assertRaises(NotImplementedError): MockMediator.run(user={"name": "Example"}) def test_validate_params(self): with self.assertRaises(TypeError): MockMediator.run(user=False) def test_param_access(self): assert self.mediator.user == {"name": "Example"} assert self.mediator.age == 30 def test_param_default_access(self): assert self.mediator.name == "Example" def test_missing_params(self): with self.assertRaises(AttributeError): MockMediator.run(name="Pete", age=30) def test_log(self): with patch.object(self.logger, "info") as mock: self.mediator.log(at="test") mock.assert_called_with(None, extra={"at": "test"}) @patch( "sentry.app.env", new_callable=PropertyMock( return_value=Double( request=Double(resolver_match=Double(kwargs={"organization_slug": "beep"})) ) ), ) def test_log_with_request_org(self, _): with patch.object(self.logger, "info") as log: self.mediator.log(at="test") assert faux(log).kwarg_equals("extra.org", "beep") @patch( "sentry.app.env", new_callable=PropertyMock( return_value=Double(request=Double(resolver_match=Double(kwargs={"team_slug": "foo"}))) ), ) def test_log_with_request_team(self, _): with patch.object(self.logger, "info") as log: self.mediator.log(at="test") assert faux(log).kwarg_equals("extra.team", "foo") @patch( "sentry.app.env", new_callable=PropertyMock( return_value=Double( request=Double(resolver_match=Double(kwargs={"project_slug": "bar"})) ) ), ) def test_log_with_request_project(self, _): with patch.object(self.logger, "info") as log: self.mediator.log(at="test") assert faux(log).kwarg_equals("extra.project", "bar") def test_log_start(self): with patch.object(self.logger, "info") as mock: self.mediator.call() assert faux(mock, 0).args_equals(None) assert faux(mock, 0).kwarg_equals("extra.at", "start") def test_log_finish(self): with patch.object(self.logger, "info") as mock: self.mediator.call() assert faux(mock).kwarg_equals("extra.at", "finish") def test_log_exception(self): def call(self): with self.log(): raise TypeError setattr(self.mediator, "call", types.MethodType(call, self.mediator)) with patch.object(self.logger, "info") as mock: try: self.mediator.call() except Exception: pass assert faux(mock).kwarg_equals("extra.at", "exception") assert faux(mock).kwargs_contain("extra.elapsed") def test_automatic_transaction(self): class TransactionMediator(Mediator): def call(self): User.objects.create(username="******") raise RuntimeError() with self.assertRaises(RuntimeError): TransactionMediator.run() assert not User.objects.filter(username="******").exists() @patch.object(MockMediator, "post_commit") @patch.object(MockMediator, "call") def test_post_commit(self, mock_call, mock_post_commit): mediator = MockMediator(user={"name": "Example"}, age=30) mediator.run(user={"name": "Example"}, age=30) mock_post_commit.assert_called_once_with() mock_call.assert_called_once_with()
def test_run_calls_submit_task_with_report_data(self, psubmit_task, prun, report_data, hb): mocked_sensors = PropertyMock() type(self.simple_instance).sensors = mocked_sensors self.simple_instance.run() psubmit_task.assert_has_calls([call(self.simple_instance.report_data)])
async def test_alarm_control_panel(hass, canary) -> None: """Test the creation and values of the alarm_control_panel for Canary.""" await async_setup_component(hass, "persistent_notification", {}) registry = mock_registry(hass) online_device_at_home = mock_device(20, "Dining Room", True, "Canary Pro") mocked_location = mock_location( location_id=100, name="Home", is_celsius=True, is_private=False, mode=mock_mode(7, "standby"), devices=[online_device_at_home], ) instance = canary.return_value instance.get_locations.return_value = [mocked_location] config = { DOMAIN: { "username": "******", "password": "******" } } with patch("homeassistant.components.canary.PLATFORMS", ["alarm_control_panel"]): assert await async_setup_component(hass, DOMAIN, config) await hass.async_block_till_done() entity_id = "alarm_control_panel.home" entity_entry = registry.async_get(entity_id) assert entity_entry assert entity_entry.unique_id == "100" state = hass.states.get(entity_id) assert state assert state.state == STATE_UNKNOWN assert not state.attributes["private"] # test private system type(mocked_location).is_private = PropertyMock(return_value=True) await hass.helpers.entity_component.async_update_entity(entity_id) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state assert state.state == STATE_ALARM_DISARMED assert state.attributes["private"] type(mocked_location).is_private = PropertyMock(return_value=False) # test armed home type(mocked_location).mode = PropertyMock( return_value=mock_mode(4, LOCATION_MODE_HOME)) await hass.helpers.entity_component.async_update_entity(entity_id) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state assert state.state == STATE_ALARM_ARMED_HOME # test armed away type(mocked_location).mode = PropertyMock( return_value=mock_mode(5, LOCATION_MODE_AWAY)) await hass.helpers.entity_component.async_update_entity(entity_id) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state assert state.state == STATE_ALARM_ARMED_AWAY # test armed night type(mocked_location).mode = PropertyMock( return_value=mock_mode(6, LOCATION_MODE_NIGHT)) await hass.helpers.entity_component.async_update_entity(entity_id) await hass.async_block_till_done() state = hass.states.get(entity_id) assert state assert state.state == STATE_ALARM_ARMED_NIGHT
def test_get_attribute(self): type(self.obj)._config = PropertyMock(return_value=self.config_example) response = self.obj.get_attribute('spring.cloud.consul.host') self.assertIsNotNone(response) self.assertEqual(response, "discovery")
from core.tests.helpers import create_response from casestudy import casestudies from directory_constants.constants import cms def test_interstitial_page_exopps(client): url = reverse('export-opportunities') response = client.get(url) assert response.status_code == 302 assert response.url == settings.SERVICES_EXOPPS_ACTUAL @patch('core.helpers.GeoLocationRedirector.should_redirect', PropertyMock(return_value=True)) @patch('core.helpers.GeoLocationRedirector.country_language', PropertyMock(return_value='fr')) def test_landing_page_redirect(client): url = reverse('landing-page') response = client.get(url) assert response.status_code == 302 assert response.url == (reverse('landing-page-international') + '?lang=' + 'fr') assert response.cookies[helpers.GeoLocationRedirector.COOKIE_NAME].value @patch('directory_cms_client.client.cms_api_client.lookup_by_slug') def test_landing_page(mock_get_page, client, settings):
def testObservationsFromDataAbandoned(self): truth = { 0.5: { "arm_name": "0_0", "parameters": { "x": 0, "y": "a", "z": 1 }, "mean": 2.0, "sem": 2.0, "trial_index": 0, "metric_name": "a", "updated_parameters": { "x": 0, "y": "a", "z": 0.5 }, "mean_t": np.array([2.0]), "covariance_t": np.array([[4.0]]), "z": 0.5, "timestamp": 50, }, 1: { "arm_name": "1_0", "parameters": { "x": 0, "y": "a", "z": 1 }, "mean": 4.0, "sem": 4.0, "trial_index": 1, "metric_name": "b", "updated_parameters": { "x": 0, "y": "a", "z": 1 }, "mean_t": np.array([4.0]), "covariance_t": np.array([[16.0]]), "z": 1, "timestamp": 100, }, 0.25: { "arm_name": "2_0", "parameters": { "x": 1, "y": "a", "z": 0.5 }, "mean": 3.0, "sem": 3.0, "trial_index": 2, "metric_name": "a", "updated_parameters": { "x": 1, "y": "b", "z": 0.25 }, "mean_t": np.array([3.0]), "covariance_t": np.array([[9.0]]), "z": 0.25, "timestamp": 25, }, 0.75: { "arm_name": "2_1", "parameters": { "x": 1, "y": "b", "z": 0.75 }, "mean": 3.0, "sem": 3.0, "trial_index": 2, "metric_name": "a", "updated_parameters": { "x": 1, "y": "b", "z": 0.75 }, "mean_t": np.array([3.0]), "covariance_t": np.array([[9.0]]), "z": 0.75, "timestamp": 25, }, } arms = { obs["arm_name"]: Arm(name=obs["arm_name"], parameters=obs["parameters"]) for _, obs in truth.items() } experiment = Mock() experiment._trial_indices_by_status = { status: set() for status in TrialStatus } trials = { obs["trial_index"]: (Trial(experiment, GeneratorRun(arms=[arms[obs["arm_name"]]]))) for _, obs in list(truth.items())[:-1] if not obs["arm_name"].startswith("2") } batch = BatchTrial(experiment, GeneratorRun(arms=[arms["2_0"], arms["2_1"]])) trials.update({2: batch}) trials.get(1).mark_abandoned() trials.get(2).mark_arm_abandoned(arm_name="2_1") type(experiment).arms_by_name = PropertyMock(return_value=arms) type(experiment).trials = PropertyMock(return_value=trials) df = pd.DataFrame(list(truth.values()))[[ "arm_name", "trial_index", "mean", "sem", "metric_name" ]] data = Data(df=df) # 1 arm is abandoned and 1 trial is abandoned, so only 2 observations should be # included. obs_no_abandoned = observations_from_data(experiment, data) self.assertEqual(len(obs_no_abandoned), 2) # 1 arm is abandoned and 1 trial is abandoned, so only 2 observations should be # included. obs_with_abandoned = observations_from_data(experiment, data, include_abandoned=True) self.assertEqual(len(obs_with_abandoned), 4)
def setUp(self): self.metadata = Mock(spec=MetaData) self.phage = Mock(spec=Table) self.gene = Mock(spec=Table) self.trna = Mock(spec=Table) type(self.phage).name = PropertyMock(return_value="phage") type(self.gene).name = PropertyMock(return_value="gene") type(self.trna).name = PropertyMock(return_value="trna") tables = {"phage": self.phage, "gene": self.gene, "trna": self.trna} self.PhageID = Mock(spec=Column) self.GeneID = Mock(spec=Column) type(self.phage).columns = {"PhageID": self.PhageID} type(self.gene).columns = { "PhageID": self.PhageID, "GeneID": self.GeneID } type(self.trna).columns = {"PhageID": self.PhageID} type(self.PhageID).table = PropertyMock(return_value=self.phage) type(self.GeneID).table = PropertyMock(return_value=self.gene) self.PhageGeneKey = Mock(spec=ForeignKey) self.PhageTrnaKey = Mock(spec=ForeignKey) type( self.PhageGeneKey).column = PropertyMock(return_value=self.PhageID) type( self.PhageGeneKey).parent = PropertyMock(return_value=self.PhageID) type( self.PhageTrnaKey).column = PropertyMock(return_value=self.PhageID) type( self.PhageTrnaKey).parent = PropertyMock(return_value=self.PhageID) type(self.phage).foreign_keys = PropertyMock(return_value=set()) type(self.gene).foreign_keys = PropertyMock( return_value=set([self.PhageGeneKey])) type(self.trna).foreign_keys = PropertyMock( return_value=set([self.PhageTrnaKey])) type(self.metadata).tables = PropertyMock(return_value=tables)
def service(): schedule.clear() AppScheduler.RUNNING = PropertyMock(side_effect=[1, 0]) yield AppScheduler()
def setUp(self): self.graph = Mock() self.metadata = Mock() self.graph_properties = {"metadata": self.metadata} type(self.graph).graph = PropertyMock( return_value=self.graph_properties) self.phage = Mock(spec=Table) self.gene = Mock(spec=Table) self.trna = Mock(spec=Table) self.tables = [self.phage, self.gene, self.trna] type(self.phage).name = PropertyMock(return_value="phage") type(self.gene).name = PropertyMock(return_value="gene") type(self.trna).name = PropertyMock(return_value="trna") self.table_names = ["phage", "gene", "trna"] nodes_dict = { "phage": { "table": self.phage }, "gene": { "table": self.gene }, "trna": { "table": self.trna } } tables_dict = { "phage": self.phage, "gene": self.gene, "trna": self.trna } mock_nodes = PropertyMock(return_value=nodes_dict) mock_tables = PropertyMock(return_value=tables_dict) type(self.graph).nodes = mock_nodes type(self.metadata).tables = mock_tables self.pathing = [self.phage, [["phage", "gene"], ["phage", "trna"]]] self.Cluster = Mock(spec=Column) self.PhamID = Mock(spec=Column) self.Notes = Mock(spec=Column) self.columns = [self.Cluster, self.PhamID, self.Notes] type(self.Cluster).name = PropertyMock(return_value="Cluster") type(self.PhamID).name = PropertyMock(return_value="PhamID") type(self.Notes).name = PropertyMock(return_value="Notes") self.Cluster_type = Mock() self.PhamID_type = Mock() self.Notes_type = Mock() type(self.Cluster_type).python_type = PropertyMock(return_value=str) type(self.PhamID_type).python_type = PropertyMock(return_value=int) type(self.Notes_type).python_type = PropertyMock(return_value=bytes) type(self.Cluster).type = PropertyMock(return_value=self.Cluster_type) type(self.PhamID).type = PropertyMock(return_value=self.PhamID_type) type(self.Notes).type = PropertyMock(return_value=self.Notes_type) self.phage_columns = {"Cluster": self.Cluster} self.gene_columns = {"PhamID": self.PhamID} self.trna_columns = {"Notes": self.Notes} type( self.phage).columns = PropertyMock(return_value=self.phage_columns) type(self.gene).columns = PropertyMock(return_value=self.gene_columns) type(self.trna).columns = PropertyMock(return_value=self.trna_columns) self.not_column = Mock() self.count_column = Mock() self.whereclause_1 = Mock(spec=BinaryExpression) self.whereclause_2 = Mock(spec=BinaryExpression) self.whereclause_3 = Mock(spec=BinaryExpression) self.not_whereclause = Mock() self.whereclauses = [ self.whereclause_1, self.whereclause_2, self.whereclause_3 ] self.session_mock = Mock() self.query_mock = Mock() self.select_from_mock = Mock() self.filter_mock = Mock() self.session_mock.query.return_value = self.query_mock self.query_mock.select_from_mock.return_value = self.select_from_mock self.select_from_mock.filter_mock.return_value = self.filter_mock
class TestImageProcessingFace: """Test class for face image processing.""" def setup_method(self): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() config = { ip.DOMAIN: { "platform": "demo" }, "camera": { "platform": "demo" } } with patch( "homeassistant.components.demo.image_processing." "DemoImageProcessingFace.should_poll", new_callable=PropertyMock(return_value=False), ): setup_component(self.hass, ip.DOMAIN, config) state = self.hass.states.get("camera.demo_camera") self.url = "{0}{1}".format(self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE)) self.face_events = [] @callback def mock_face_event(event): """Mock event.""" self.face_events.append(event) self.hass.bus.listen("image_processing.detect_face", mock_face_event) def teardown_method(self): """Stop everything that was started.""" self.hass.stop() def test_face_event_call(self, aioclient_mock): """Set up and scan a picture and test faces from event.""" aioclient_mock.get(self.url, content=b"image") common.scan(self.hass, entity_id="image_processing.demo_face") self.hass.block_till_done() state = self.hass.states.get("image_processing.demo_face") assert len(self.face_events) == 2 assert state.state == "Hans" assert state.attributes["total_faces"] == 4 event_data = [ event.data for event in self.face_events if event.data.get("name") == "Hans" ] assert len(event_data) == 1 assert event_data[0]["name"] == "Hans" assert event_data[0]["confidence"] == 98.34 assert event_data[0]["gender"] == "male" assert event_data[0]["entity_id"] == "image_processing.demo_face" @patch( "homeassistant.components.demo.image_processing." "DemoImageProcessingFace.confidence", new_callable=PropertyMock(return_value=None), ) def test_face_event_call_no_confidence(self, mock_config, aioclient_mock): """Set up and scan a picture and test faces from event.""" aioclient_mock.get(self.url, content=b"image") common.scan(self.hass, entity_id="image_processing.demo_face") self.hass.block_till_done() state = self.hass.states.get("image_processing.demo_face") assert len(self.face_events) == 3 assert state.state == "4" assert state.attributes["total_faces"] == 4 event_data = [ event.data for event in self.face_events if event.data.get("name") == "Hans" ] assert len(event_data) == 1 assert event_data[0]["name"] == "Hans" assert event_data[0]["confidence"] == 98.34 assert event_data[0]["gender"] == "male" assert event_data[0]["entity_id"] == "image_processing.demo_face"
def test_fill_leverage_tiers_binance(default_conf, mocker): api_mock = MagicMock() api_mock.fetch_leverage_tiers = MagicMock(return_value={ 'ADA/BUSD': [ { "tier": 1, "minNotional": 0, "maxNotional": 100000, "maintenanceMarginRate": 0.025, "maxLeverage": 20, "info": { "bracket": "1", "initialLeverage": "20", "maxNotional": "100000", "minNotional": "0", "maintMarginRatio": "0.025", "cum": "0.0" } }, { "tier": 2, "minNotional": 100000, "maxNotional": 500000, "maintenanceMarginRate": 0.05, "maxLeverage": 10, "info": { "bracket": "2", "initialLeverage": "10", "maxNotional": "500000", "minNotional": "100000", "maintMarginRatio": "0.05", "cum": "2500.0" } }, { "tier": 3, "minNotional": 500000, "maxNotional": 1000000, "maintenanceMarginRate": 0.1, "maxLeverage": 5, "info": { "bracket": "3", "initialLeverage": "5", "maxNotional": "1000000", "minNotional": "500000", "maintMarginRatio": "0.1", "cum": "27500.0" } }, { "tier": 4, "minNotional": 1000000, "maxNotional": 2000000, "maintenanceMarginRate": 0.15, "maxLeverage": 3, "info": { "bracket": "4", "initialLeverage": "3", "maxNotional": "2000000", "minNotional": "1000000", "maintMarginRatio": "0.15", "cum": "77500.0" } }, { "tier": 5, "minNotional": 2000000, "maxNotional": 5000000, "maintenanceMarginRate": 0.25, "maxLeverage": 2, "info": { "bracket": "5", "initialLeverage": "2", "maxNotional": "5000000", "minNotional": "2000000", "maintMarginRatio": "0.25", "cum": "277500.0" } }, { "tier": 6, "minNotional": 5000000, "maxNotional": 30000000, "maintenanceMarginRate": 0.5, "maxLeverage": 1, "info": { "bracket": "6", "initialLeverage": "1", "maxNotional": "30000000", "minNotional": "5000000", "maintMarginRatio": "0.5", "cum": "1527500.0" } } ], "ZEC/USDT": [ { "tier": 1, "minNotional": 0, "maxNotional": 50000, "maintenanceMarginRate": 0.01, "maxLeverage": 50, "info": { "bracket": "1", "initialLeverage": "50", "maxNotional": "50000", "minNotional": "0", "maintMarginRatio": "0.01", "cum": "0.0" } }, { "tier": 2, "minNotional": 50000, "maxNotional": 150000, "maintenanceMarginRate": 0.025, "maxLeverage": 20, "info": { "bracket": "2", "initialLeverage": "20", "maxNotional": "150000", "minNotional": "50000", "maintMarginRatio": "0.025", "cum": "750.0" } }, { "tier": 3, "minNotional": 150000, "maxNotional": 250000, "maintenanceMarginRate": 0.05, "maxLeverage": 10, "info": { "bracket": "3", "initialLeverage": "10", "maxNotional": "250000", "minNotional": "150000", "maintMarginRatio": "0.05", "cum": "4500.0" } }, { "tier": 4, "minNotional": 250000, "maxNotional": 500000, "maintenanceMarginRate": 0.1, "maxLeverage": 5, "info": { "bracket": "4", "initialLeverage": "5", "maxNotional": "500000", "minNotional": "250000", "maintMarginRatio": "0.1", "cum": "17000.0" } }, { "tier": 5, "minNotional": 500000, "maxNotional": 1000000, "maintenanceMarginRate": 0.125, "maxLeverage": 4, "info": { "bracket": "5", "initialLeverage": "4", "maxNotional": "1000000", "minNotional": "500000", "maintMarginRatio": "0.125", "cum": "29500.0" } }, { "tier": 6, "minNotional": 1000000, "maxNotional": 2000000, "maintenanceMarginRate": 0.25, "maxLeverage": 2, "info": { "bracket": "6", "initialLeverage": "2", "maxNotional": "2000000", "minNotional": "1000000", "maintMarginRatio": "0.25", "cum": "154500.0" } }, { "tier": 7, "minNotional": 2000000, "maxNotional": 30000000, "maintenanceMarginRate": 0.5, "maxLeverage": 1, "info": { "bracket": "7", "initialLeverage": "1", "maxNotional": "30000000", "minNotional": "2000000", "maintMarginRatio": "0.5", "cum": "654500.0" } } ], }) default_conf['dry_run'] = False default_conf['trading_mode'] = TradingMode.FUTURES default_conf['margin_mode'] = MarginMode.ISOLATED exchange = get_patched_exchange(mocker, default_conf, api_mock, id="binance") exchange.fill_leverage_tiers() assert exchange._leverage_tiers == { 'ADA/BUSD': [ { "min": 0, "max": 100000, "mmr": 0.025, "lev": 20, "maintAmt": 0.0 }, { "min": 100000, "max": 500000, "mmr": 0.05, "lev": 10, "maintAmt": 2500.0 }, { "min": 500000, "max": 1000000, "mmr": 0.1, "lev": 5, "maintAmt": 27500.0 }, { "min": 1000000, "max": 2000000, "mmr": 0.15, "lev": 3, "maintAmt": 77500.0 }, { "min": 2000000, "max": 5000000, "mmr": 0.25, "lev": 2, "maintAmt": 277500.0 }, { "min": 5000000, "max": 30000000, "mmr": 0.5, "lev": 1, "maintAmt": 1527500.0 } ], "ZEC/USDT": [ { 'min': 0, 'max': 50000, 'mmr': 0.01, 'lev': 50, 'maintAmt': 0.0 }, { 'min': 50000, 'max': 150000, 'mmr': 0.025, 'lev': 20, 'maintAmt': 750.0 }, { 'min': 150000, 'max': 250000, 'mmr': 0.05, 'lev': 10, 'maintAmt': 4500.0 }, { 'min': 250000, 'max': 500000, 'mmr': 0.1, 'lev': 5, 'maintAmt': 17000.0 }, { 'min': 500000, 'max': 1000000, 'mmr': 0.125, 'lev': 4, 'maintAmt': 29500.0 }, { 'min': 1000000, 'max': 2000000, 'mmr': 0.25, 'lev': 2, 'maintAmt': 154500.0 }, { 'min': 2000000, 'max': 30000000, 'mmr': 0.5, 'lev': 1, 'maintAmt': 654500.0 }, ] } api_mock = MagicMock() api_mock.load_leverage_tiers = MagicMock() type(api_mock).has = PropertyMock(return_value={'fetchLeverageTiers': True}) ccxt_exceptionhandlers( mocker, default_conf, api_mock, "binance", "fill_leverage_tiers", "fetch_leverage_tiers", )
class TestDatasetDetailViews(DatasetViewTestCase): def setUp(self): super().setUp() self.url = reverse('datasets:dataset-detail', args=['id']) @patch('mlplaygrounds.datasets.views.datasets.DatasetDetail.get_object', return_value=MagicMock()) @patch('mlplaygrounds.datasets.views.datasets.DatasetSerializer.data', new_callable=PropertyMock) def test_get(self, mock_get_object, mock_serializer_data): mock_get_object.return_value = {} mock_serializer_data.return_value = {} response = self.client.get(self.url) self.assertEqual(response.status_code, status.HTTP_200_OK) @patch('mlplaygrounds.datasets.views.datasets.DatasetDetail.get_object', return_value=MagicMock()) def test_update_valid_data(self, mock_get_object): mock_get_object.return_value = Dataset() response = self.client.get(self.url) self.assertEqual(response.status_code, status.HTTP_200_OK) @patch('mlplaygrounds.datasets.views.datasets.DatasetDetail.get_object', return_value=MagicMock()) @patch('mlplaygrounds.datasets.views.datasets.DatasetSerializer.is_valid', return_value=False) @patch('mlplaygrounds.datasets.views.datasets.DatasetSerializer.errors', new_callable=PropertyMock(return_value=['Invalid'])) def test_update_invalid_data(self, mock_get_obj, mock_is_valid, mock_err): response = self.client.put(self.url) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) @patch( 'mlplaygrounds.datasets.views.datasets.Dataset.objects.delete', return_value=MagicMock() ) def test_delete(self, mock_delete): mock_delete.return_value = 1 response = self.client.delete(self.url) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) @patch( 'mlplaygrounds.datasets.views.datasets.Dataset.objects.delete', return_value=MagicMock() ) def test_delete_non_existant_dataset(self, mock_delete): mock_delete.return_value = 0 response = self.client.delete(self.url) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) @patch( 'mlplaygrounds.datasets.views.datasets.Dataset.objects.get', return_value=MagicMock() ) def test_get_document(self, mock_get): mock_get.return_value = {'name': 'test'} view = DatasetDetail() document = view.get_document('id', 'user_id') self.assertEqual(document, {'name': 'test'}) @patch( 'mlplaygrounds.datasets.views.datasets.Dataset.objects.get', return_value=MagicMock() ) def test_get_non_existant_document(self, mock_get): mock_get.side_effect = Http404 view = DatasetDetail() with self.assertRaises(Http404): view.get_document('id', 'user_id') @patch('mlplaygrounds.datasets.views.datasets.DatasetDetail.get_document') def test_get_object(self, mock_get_document): document = {'name': 'test', 'user_id': 'user', 'data': {'foo': 'bar'}} mock_get_document.return_value = document view = DatasetDetail() dataset = view.get_object(str(self.dummy_data[0]['_id']), self.dummy_data[0]['user_id']) object_data = { 'name': dataset.name, 'user_id': dataset.user_id, 'data': dataset.data } self.assertDictEqual(document, object_data)
class TestMicrosoftFaceIdentify: """Test class for image processing.""" def setup_method(self): """Set up things to be run when tests are started.""" self.hass = get_test_home_assistant() self.config = { ip.DOMAIN: { "platform": "microsoft_face_identify", "source": { "entity_id": "camera.demo_camera", "name": "test local" }, "group": "Test Group1", }, "camera": { "platform": "demo" }, mf.DOMAIN: { "api_key": "12345678abcdef6" }, } self.endpoint_url = "https://westus.{0}".format(mf.FACE_API_URL) def teardown_method(self): """Stop everything that was started.""" self.hass.stop() @patch( "homeassistant.components.microsoft_face_identify.image_processing." "MicrosoftFaceIdentifyEntity.should_poll", new_callable=PropertyMock(return_value=False), ) def test_ms_identify_process_image(self, poll_mock, aioclient_mock): """Set up and scan a picture and test plates from event.""" aioclient_mock.get( self.endpoint_url.format("persongroups"), text=load_fixture("microsoft_face_persongroups.json"), ) aioclient_mock.get( self.endpoint_url.format("persongroups/test_group1/persons"), text=load_fixture("microsoft_face_persons.json"), ) aioclient_mock.get( self.endpoint_url.format("persongroups/test_group2/persons"), text=load_fixture("microsoft_face_persons.json"), ) setup_component(self.hass, ip.DOMAIN, self.config) state = self.hass.states.get("camera.demo_camera") url = "{0}{1}".format(self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE)) face_events = [] @callback def mock_face_event(event): """Mock event.""" face_events.append(event) self.hass.bus.listen("image_processing.detect_face", mock_face_event) aioclient_mock.get(url, content=b"image") aioclient_mock.post( self.endpoint_url.format("detect"), text=load_fixture("microsoft_face_detect.json"), ) aioclient_mock.post( self.endpoint_url.format("identify"), text=load_fixture("microsoft_face_identify.json"), ) common.scan(self.hass, entity_id="image_processing.test_local") self.hass.block_till_done() state = self.hass.states.get("image_processing.test_local") assert len(face_events) == 1 assert state.attributes.get("total_faces") == 2 assert state.state == "David" assert face_events[0].data["name"] == "David" assert face_events[0].data["confidence"] == float(92) assert face_events[0].data[ "entity_id"] == "image_processing.test_local" # Test that later, if a request is made that results in no face # being detected, that this is reflected in the state object aioclient_mock.clear_requests() aioclient_mock.post(self.endpoint_url.format("detect"), text="[]") common.scan(self.hass, entity_id="image_processing.test_local") self.hass.block_till_done() state = self.hass.states.get("image_processing.test_local") # No more face events were fired assert len(face_events) == 1 # Total faces and actual qualified number of faces reset to zero assert state.attributes.get("total_faces") == 0 assert state.state == STATE_UNKNOWN
def thermocycler(): t = asyncio.get_event_loop().run_until_complete( utils.build( port='/dev/ot_module_thermocycler1', which='thermocycler', simulating=True, interrupt_callback=lambda x: None, execution_manager=ExecutionManager(loop=asyncio.get_event_loop()), loop=asyncio.get_event_loop())) Thermocycler.lid_status = PropertyMock(return_value="open") Thermocycler.lid_target = PropertyMock(return_value=1.2) Thermocycler.lid_temp = PropertyMock(return_value=22.0) Thermocycler.temperature = PropertyMock(return_value=100.0) Thermocycler.target = PropertyMock(return_value=200.0) Thermocycler.hold_time = PropertyMock(return_value=1) Thermocycler.ramp_rate = PropertyMock(return_value=3) Thermocycler.current_cycle_index = PropertyMock(return_value=1) Thermocycler.total_cycle_count = PropertyMock(return_value=3) Thermocycler.current_step_index = PropertyMock(return_value=5) Thermocycler.total_step_count = PropertyMock(return_value=2) return t
def testObservationsWithCandidateMetadata(self): SOME_METADATA_KEY = "metadatum" truth = [ { "arm_name": "0_0", "parameters": { "x": 0, "y": "a" }, "mean": 2.0, "sem": 2.0, "trial_index": 0, "metric_name": "a", }, { "arm_name": "1_0", "parameters": { "x": 1, "y": "b" }, "mean": 3.0, "sem": 3.0, "trial_index": 1, "metric_name": "a", }, ] arms = { obs["arm_name"]: Arm(name=obs["arm_name"], parameters=obs["parameters"]) for obs in truth } experiment = Mock() experiment._trial_indices_by_status = { status: set() for status in TrialStatus } trials = { obs["trial_index"]: Trial( experiment, GeneratorRun( arms=[arms[obs["arm_name"]]], candidate_metadata_by_arm_signature={ arms[obs["arm_name"]].signature: { SOME_METADATA_KEY: f"value_{obs['trial_index']}" } }, ), ) for obs in truth } type(experiment).arms_by_name = PropertyMock(return_value=arms) type(experiment).trials = PropertyMock(return_value=trials) df = pd.DataFrame(truth)[[ "arm_name", "trial_index", "mean", "sem", "metric_name" ]] data = Data(df=df) observations = observations_from_data(experiment, data) for observation in observations: self.assertEqual( observation.features.metadata.get(SOME_METADATA_KEY), f"value_{observation.features.trial_index}", )
def setUp(self): self.graph = Mock() self.center = Mock() self.table_object = Mock() self.table_1 = Mock() self.table_2 = Mock() self.table_3 = Mock() self.table_4 = Mock() type(self.center).name = PropertyMock(return_value="center") type(self.table_1).name = PropertyMock(return_value="table_1") type(self.table_2).name = PropertyMock(return_value="table_2") type(self.table_3).name = PropertyMock(return_value="table_3") type(self.table_4).name = PropertyMock(return_value="table_4") self.table_list_1 = [ self.center, self.table_1, self.table_2, self.table_3, self.table_4 ] self.table_names_1 = ["table_1", "table_2", "table_3", "table_4"] self.table_list_2 = [ self.table_1, self.table_3, self.table_4, self.center, self.table_2 ] self.table_names_2 = ["table_1", "table_3", "table_4", "table_2"] nodes_dict = { "table_1": { "table": self.table_1 }, "table_2": { "table": self.table_2 }, "table_3": { "table": self.table_3 }, "table_4": { "table": self.table_4 } } mock_nodes = PropertyMock(return_value=nodes_dict) type(self.graph).nodes = mock_nodes type(self.center).name = PropertyMock(return_value="center") self.table_path_1 = ["center", "table_1"] self.table_path_2 = ["center", "table_2"] self.table_path_3 = ["center", "table_2", "table_3"] self.table_path_4 = ["center", "table_1", "table_4"] self.table_paths_1 = [ self.table_path_1, self.table_path_2, self.table_path_3, self.table_path_4 ] self.table_paths_2 = [ self.table_path_1, self.table_path_3, self.table_path_4, self.table_path_2 ] self.table_pathing_1 = [ self.center, [ self.table_path_1, self.table_path_2, self.table_path_3, self.table_path_4 ] ] self.table_pathing_2 = [self.center, []]
def testObservationsFromDataWithSomeMissingTimes(self): truth = [ { "arm_name": "0_0", "parameters": { "x": 0, "y": "a" }, "mean": 2.0, "sem": 2.0, "trial_index": 1, "metric_name": "a", "start_time": 0, }, { "arm_name": "0_1", "parameters": { "x": 1, "y": "b" }, "mean": 3.0, "sem": 3.0, "trial_index": 2, "metric_name": "a", "start_time": 0, }, { "arm_name": "0_0", "parameters": { "x": 0, "y": "a" }, "mean": 4.0, "sem": 4.0, "trial_index": 1, "metric_name": "b", "start_time": None, }, { "arm_name": "0_1", "parameters": { "x": 1, "y": "b" }, "mean": 5.0, "sem": 5.0, "trial_index": 2, "metric_name": "b", "start_time": None, }, ] arms = { obs["arm_name"]: Arm(name=obs["arm_name"], parameters=obs["parameters"]) for obs in truth } experiment = Mock() experiment._trial_indices_by_status = { status: set() for status in TrialStatus } trials = { obs["trial_index"]: Trial(experiment, GeneratorRun(arms=[arms[obs["arm_name"]]])) for obs in truth } type(experiment).arms_by_name = PropertyMock(return_value=arms) type(experiment).trials = PropertyMock(return_value=trials) df = pd.DataFrame(truth)[[ "arm_name", "trial_index", "mean", "sem", "metric_name", "start_time" ]] data = Data(df=df) observations = observations_from_data(experiment, data) self.assertEqual(len(observations), 2) # Get them in the order we want for tests below if observations[0].features.parameters["x"] == 1: observations.reverse() obsd_truth = { "metric_names": [["a", "b"], ["a", "b"]], "means": [np.array([2.0, 4.0]), np.array([3.0, 5.0])], "covariance": [np.diag([4.0, 16.0]), np.diag([9.0, 25.0])], } cname_truth = ["0_0", "0_1"] for i, obs in enumerate(observations): self.assertEqual(obs.features.parameters, truth[i]["parameters"]) self.assertEqual(obs.features.trial_index, truth[i]["trial_index"]) self.assertEqual(obs.data.metric_names, obsd_truth["metric_names"][i]) self.assertTrue( np.array_equal(obs.data.means, obsd_truth["means"][i])) self.assertTrue( np.array_equal(obs.data.covariance, obsd_truth["covariance"][i])) self.assertEqual(obs.arm_name, cname_truth[i])
class TestFeatureObservationsReportView(TestCase): def setUp(self): self.factory = RequestFactory() feature_class = FeatureClassFactory(www=True) self.feature = FeatureFactory( feature_class=feature_class, protection_level=PROTECTION_LEVELS["PUBLIC"], ) self.observation_admin = ObservationFactory( protection_level=PROTECTION_LEVELS["ADMIN"], feature=self.feature, ) self.observation_office = ObservationFactory( protection_level=PROTECTION_LEVELS["OFFICE"], feature=self.feature, ) self.observation_www = ObservationFactory( protection_level=PROTECTION_LEVELS["PUBLIC"], feature=self.feature, ) @patch( "nature.views.HMACAuth.user_role", new_callable=PropertyMock(return_value=UserRole.ADMIN), ) def test_get_context_data_for_admin(self, *args): view = FeatureObservationsReportView() view_kwargs = {"pk": self.feature.pk} request = self.factory.get( reverse("nature:feature-observations-report", kwargs=view_kwargs)) request.user = AnonymousUser() view.request = request view.object = self.feature context = view.get_context_data() self.assertQuerysetEqual( context["observations"], [ repr(self.observation_admin), repr(self.observation_office), repr(self.observation_www), ], ordered=False, ) self.assertEqual(context["secret_observation_count"], 0) @patch( "nature.views.HMACAuth.user_role", new_callable=PropertyMock(return_value=UserRole.OFFICE_HKI), ) def test_get_context_data_for_office_hki(self, *args): view = FeatureObservationsReportView() view_kwargs = {"pk": self.feature.pk} request = self.factory.get( reverse("nature:feature-observations-report", kwargs=view_kwargs)) request.user = AnonymousUser() view.request = request view.object = self.feature context = view.get_context_data() self.assertQuerysetEqual( context["observations"], [repr(self.observation_office), repr(self.observation_www)], ordered=False, ) self.assertEqual(context["secret_observation_count"], 1) @patch( "nature.views.HMACAuth.user_role", new_callable=PropertyMock(return_value=UserRole.OFFICE), ) def test_get_context_data_for_office(self, *args): view = FeatureObservationsReportView() view_kwargs = {"pk": self.feature.pk} request = self.factory.get( reverse("nature:feature-observations-report", kwargs=view_kwargs)) request.user = AnonymousUser() view.request = request view.object = self.feature context = view.get_context_data() self.assertQuerysetEqual( context["observations"], [repr(self.observation_office), repr(self.observation_www)], ordered=False, ) self.assertEqual(context["secret_observation_count"], 1) @patch( "nature.views.HMACAuth.user_role", new_callable=PropertyMock(return_value=UserRole.PUBLIC), ) def test_get_context_data_for_public_www(self, *args): view = FeatureObservationsReportView() view_kwargs = {"pk": self.feature.pk} request = self.factory.get( reverse("nature:feature-observations-report", kwargs=view_kwargs)) request.user = AnonymousUser() view.request = request view.object = self.feature context = view.get_context_data() self.assertQuerysetEqual( context["observations"], [repr(self.observation_www)], ordered=False, ) self.assertEqual(context["secret_observation_count"], 0)
def testObservationsFromMapData(self): truth = { 0.5: { "arm_name": "0_0", "parameters": { "x": 0, "y": "a", "z": 1 }, "mean": 2.0, "sem": 2.0, "trial_index": 1, "metric_name": "a", "updated_parameters": { "x": 0, "y": "a", "z": 0.5 }, "mean_t": np.array([2.0]), "covariance_t": np.array([[4.0]]), "z": 0.5, "timestamp": 50, }, 0.25: { "arm_name": "0_1", "parameters": { "x": 1, "y": "b", "z": 0.5 }, "mean": 3.0, "sem": 3.0, "trial_index": 2, "metric_name": "a", "updated_parameters": { "x": 1, "y": "b", "z": 0.25 }, "mean_t": np.array([3.0]), "covariance_t": np.array([[9.0]]), "z": 0.25, "timestamp": 25, }, 1: { "arm_name": "0_0", "parameters": { "x": 0, "y": "a", "z": 1 }, "mean": 4.0, "sem": 4.0, "trial_index": 1, "metric_name": "b", "updated_parameters": { "x": 0, "y": "a", "z": 1 }, "mean_t": np.array([4.0]), "covariance_t": np.array([[16.0]]), "z": 1, "timestamp": 100, }, } arms = { obs["arm_name"]: Arm(name=obs["arm_name"], parameters=obs["parameters"]) for _, obs in truth.items() } experiment = Mock() experiment._trial_indices_by_status = { status: set() for status in TrialStatus } trials = { obs["trial_index"]: Trial(experiment, GeneratorRun(arms=[arms[obs["arm_name"]]])) for _, obs in truth.items() } type(experiment).arms_by_name = PropertyMock(return_value=arms) type(experiment).trials = PropertyMock(return_value=trials) df = pd.DataFrame(list(truth.values()))[[ "arm_name", "trial_index", "mean", "sem", "metric_name", "z", "timestamp" ]] data = MapData(df=df, map_keys=["z", "timestamp"]) observations = observations_from_data(experiment, data) self.assertEqual(len(observations), 3) for obs in observations: t = truth[obs.features.parameters["z"]] self.assertEqual(obs.features.parameters, t["updated_parameters"]) self.assertEqual(obs.features.trial_index, t["trial_index"]) self.assertEqual(obs.data.metric_names, [t["metric_name"]]) self.assertTrue(np.array_equal(obs.data.means, t["mean_t"])) self.assertTrue( np.array_equal(obs.data.covariance, t["covariance_t"])) self.assertEqual(obs.arm_name, t["arm_name"]) self.assertEqual(obs.features.metadata, {"timestamp": t["timestamp"]})
def test_sensors_is_property(self): sensors = MagicMock() mocked_sensors = PropertyMock(return_value=sensors) type(self.simple_instance).sensors = mocked_sensors self.simple_instance.sensors mocked_sensors.assert_called_once_with()
def test_get_keys(self): type(self.obj)._config = PropertyMock(return_value=self.config_example) self.assertEqual(self.obj.get_keys(), self.config_example.keys())
def test_run_calls_fructosad_run(self, psubmit_task, prun): mocked_sensors = PropertyMock() type(self.simple_instance).sensors = mocked_sensors self.simple_instance.run() prun.assert_called_once_with()
class TestMicrosoftFaceIdentify(object): """Test class for image processing.""" def setup_method(self): """Setup things to be run when tests are started.""" self.hass = get_test_home_assistant() self.config = { ip.DOMAIN: { 'platform': 'microsoft_face_identify', 'source': { 'entity_id': 'camera.demo_camera', 'name': 'test local' }, 'group': 'Test Group1', }, 'camera': { 'platform': 'demo' }, mf.DOMAIN: { 'api_key': '12345678abcdef6', } } def teardown_method(self): """Stop everything that was started.""" self.hass.stop() @patch('homeassistant.components.image_processing.microsoft_face_identify.' 'MicrosoftFaceIdentifyEntity.should_poll', new_callable=PropertyMock(return_value=False)) def test_ms_identify_process_image(self, poll_mock, aioclient_mock): """Setup and scan a picture and test plates from event.""" aioclient_mock.get( mf.FACE_API_URL.format("persongroups"), text=load_fixture('microsoft_face_persongroups.json')) aioclient_mock.get( mf.FACE_API_URL.format("persongroups/test_group1/persons"), text=load_fixture('microsoft_face_persons.json')) aioclient_mock.get( mf.FACE_API_URL.format("persongroups/test_group2/persons"), text=load_fixture('microsoft_face_persons.json')) setup_component(self.hass, ip.DOMAIN, self.config) state = self.hass.states.get('camera.demo_camera') url = "{0}{1}".format(self.hass.config.api.base_url, state.attributes.get(ATTR_ENTITY_PICTURE)) face_events = [] @callback def mock_face_event(event): """Mock event.""" face_events.append(event) self.hass.bus.listen('image_processing.detect_face', mock_face_event) aioclient_mock.get(url, content=b'image') aioclient_mock.post(mf.FACE_API_URL.format("detect"), text=load_fixture('microsoft_face_detect.json')) aioclient_mock.post(mf.FACE_API_URL.format("identify"), text=load_fixture('microsoft_face_identify.json')) ip.scan(self.hass, entity_id='image_processing.test_local') self.hass.block_till_done() state = self.hass.states.get('image_processing.test_local') assert len(face_events) == 1 assert state.attributes.get('total_faces') == 2 assert state.state == 'David' assert face_events[0].data['name'] == 'David' assert face_events[0].data['confidence'] == float(92) assert face_events[0].data['entity_id'] == \ 'image_processing.test_local'
def test_finish_authentication( self, _, saml_response, current_time, filter_expression, expected_value, mock_validation=False, ): # Arrange identity_provider_entity_id = "http://idp.hilbertteam.net/idp/shibboleth" service_provider_host_name = "opds.hilbertteam.net" identity_providers = [ copy(identity_provider) for identity_provider in IDENTITY_PROVIDERS ] identity_providers[0].entity_id = identity_provider_entity_id if mock_validation: validate_mock = MagicMock(return_value=True) else: real_validate_sign = OneLogin_Saml2_Utils.validate_sign validate_mock = MagicMock(side_effect=lambda *args, **kwargs: real_validate_sign(*args, **kwargs)) filter_expression_mock = PropertyMock(return_value=filter_expression) service_provider_debug_mode_mock = PropertyMock(return_value=False) service_provider_strict_mode = PropertyMock(return_value=False) configuration = create_autospec(spec=SAMLConfiguration) type(configuration).filter_expression = filter_expression_mock type(configuration ).service_provider_debug_mode = service_provider_debug_mode_mock type(configuration ).service_provider_strict_mode = service_provider_strict_mode configuration.get_service_provider = MagicMock( return_value=SERVICE_PROVIDER_WITH_UNSIGNED_REQUESTS) configuration.get_identity_providers = MagicMock( return_value=identity_providers) onelogin_configuration = SAMLOneLoginConfiguration(configuration) subject_parser = SAMLSubjectParser() parser = DSLParser() visitor = DSLEvaluationVisitor() evaluator = DSLEvaluator(parser, visitor) subject_filter = SAMLSubjectFilter(evaluator) authentication_manager = SAMLAuthenticationManager( onelogin_configuration, subject_parser, subject_filter) saml_response = base64.b64encode(saml_response) # Act with freeze_time(current_time): with patch( "onelogin.saml2.response.OneLogin_Saml2_Utils.validate_sign", validate_mock, ): self.app.config["SERVER_NAME"] = service_provider_host_name with self.app.test_request_context( "/SAML2/POST", data={"SAMLResponse": saml_response}): result = authentication_manager.finish_authentication( self._db, identity_provider_entity_id) # Assert assert expected_value == result
def test_api_profit(botclient, mocker, ticker, fee, markets, limit_buy_order, limit_sell_order): ftbot, client = botclient patch_get_signal(ftbot, (True, False)) mocker.patch.multiple( 'freqtrade.exchange.Exchange', get_balances=MagicMock(return_value=ticker), fetch_ticker=ticker, get_fee=fee, markets=PropertyMock(return_value=markets) ) rc = client_get(client, f"{BASE_URI}/profit") assert_response(rc, 200) assert rc.json()['trade_count'] == 0 ftbot.enter_positions() trade = Trade.query.first() # Simulate fulfilled LIMIT_BUY order for trade trade.update(limit_buy_order) rc = client_get(client, f"{BASE_URI}/profit") assert_response(rc, 200) # One open trade assert rc.json()['trade_count'] == 1 assert rc.json()['best_pair'] == '' assert rc.json()['best_rate'] == 0 trade = Trade.query.first() trade.update(limit_sell_order) trade.close_date = datetime.utcnow() trade.is_open = False rc = client_get(client, f"{BASE_URI}/profit") assert_response(rc) assert rc.json() == {'avg_duration': ANY, 'best_pair': 'ETH/BTC', 'best_rate': 6.2, 'first_trade_date': 'just now', 'first_trade_timestamp': ANY, 'latest_trade_date': 'just now', 'latest_trade_timestamp': ANY, 'profit_all_coin': 6.217e-05, 'profit_all_fiat': 0.76748865, 'profit_all_percent': 6.2, 'profit_all_percent_mean': 6.2, 'profit_all_ratio_mean': 0.06201058, 'profit_all_percent_sum': 6.2, 'profit_all_ratio_sum': 0.06201058, 'profit_closed_coin': 6.217e-05, 'profit_closed_fiat': 0.76748865, 'profit_closed_percent': 6.2, 'profit_closed_ratio_mean': 0.06201058, 'profit_closed_percent_mean': 6.2, 'profit_closed_ratio_sum': 0.06201058, 'profit_closed_percent_sum': 6.2, 'trade_count': 1, 'closed_trade_count': 1, 'winning_trades': 1, 'losing_trades': 0, }
def test_api_status(botclient, mocker, ticker, fee, markets): ftbot, client = botclient patch_get_signal(ftbot, (True, False)) mocker.patch.multiple('freqtrade.exchange.Exchange', get_balances=MagicMock(return_value=ticker), fetch_ticker=ticker, get_fee=fee, markets=PropertyMock(return_value=markets)) rc = client_get(client, f"{BASE_URI}/status") assert_response(rc, 200) assert rc.json() == [] ftbot.enter_positions() trades = Trade.get_open_trades() trades[0].open_order_id = None ftbot.exit_positions(trades) Trade.query.session.flush() rc = client_get(client, f"{BASE_URI}/status") assert_response(rc) assert len(rc.json()) == 1 assert rc.json() == [{ 'amount': 91.07468123, 'amount_requested': 91.07468123, 'base_currency': 'BTC', 'close_date': None, 'close_date_hum': None, 'close_timestamp': None, 'close_profit': None, 'close_profit_pct': None, 'close_profit_abs': None, 'close_rate': None, 'current_profit': -0.00408133, 'current_profit_pct': -0.41, 'current_profit_abs': -4.09e-06, 'profit_ratio': -0.00408133, 'profit_pct': -0.41, 'profit_abs': -4.09e-06, 'profit_fiat': ANY, 'current_rate': 1.099e-05, 'open_date': ANY, 'open_date_hum': 'just now', 'open_timestamp': ANY, 'open_order': None, 'open_rate': 1.098e-05, 'pair': 'ETH/BTC', 'stake_amount': 0.001, 'stop_loss_abs': 9.882e-06, 'stop_loss_pct': -10.0, 'stop_loss_ratio': -0.1, 'stoploss_order_id': None, 'stoploss_last_update': ANY, 'stoploss_last_update_timestamp': ANY, 'initial_stop_loss_abs': 9.882e-06, 'initial_stop_loss_pct': -10.0, 'initial_stop_loss_ratio': -0.1, 'stoploss_current_dist': -1.1080000000000002e-06, 'stoploss_current_dist_ratio': -0.10081893, 'stoploss_current_dist_pct': -10.08, 'stoploss_entry_dist': -0.00010475, 'stoploss_entry_dist_ratio': -0.10448878, 'trade_id': 1, 'close_rate_requested': None, 'fee_close': 0.0025, 'fee_close_cost': None, 'fee_close_currency': None, 'fee_open': 0.0025, 'fee_open_cost': None, 'fee_open_currency': None, 'is_open': True, 'max_rate': 1.099e-05, 'min_rate': 1.098e-05, 'open_order_id': None, 'open_rate_requested': 1.098e-05, 'open_trade_value': 0.0010025, 'sell_reason': None, 'sell_order_status': None, 'strategy': 'DefaultStrategy', 'timeframe': 5, 'exchange': 'bittrex', }] mocker.patch( 'freqtrade.freqtradebot.FreqtradeBot.get_sell_rate', MagicMock(side_effect=ExchangeError("Pair 'ETH/BTC' not available"))) rc = client_get(client, f"{BASE_URI}/status") assert_response(rc) resp_values = rc.json() assert len(resp_values) == 1 assert isnan(resp_values[0]['profit_abs'])
from unittest.mock import patch, create_autospec, PropertyMock from stack.expectmore import ExpectMore from stack.switch.x1052 import SwitchDellX1052 # 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)) # Throw an exception when we try to get the switch mac address infromation mock_expectmore.return_value.ask.side_effect = ValueError("Test error")
request.user = AnonymousUser() view.request = request view.object = self.feature context = view.get_context_data() self.assertQuerysetEqual( context["observations"], [repr(self.observation_www)], ordered=False, ) self.assertEqual(context["secret_observation_count"], 0) @patch( "nature.views.HMACAuth.user_role", new_callable=PropertyMock(return_value=UserRole.ADMIN), ) class TestReportViews(TestCase): """ TestCase that verifies that report views can be rendered correctly """ def setUp(self): self.client = Client() def test_feature_report(self, *args): feature = FeatureFactory() url = reverse("nature:feature-report", kwargs={"pk": feature.id}) response = self.client.get(url) self.assertEqual(response.status_code, 200) def test_observationseries_report(self, *args):
def test_convert_for_internal(self): min_return = 10 amount_to_convert = 5 convert_result_amount = 10 for_address = Address.from_string("hx" + "a" * 40) icx_token_score_interface = \ self.network_score.create_interface_score(self.icx_token, ProxyScore(ABCIcxToken)) icx_token_score_interface.withdrawTo = PropertyMock() irc_token_score_interface = \ self.network_score.create_interface_score(self.connector_token_list[0], ProxyScore(ABCIRCToken)) irc_token_score_interface.transfer = PropertyMock() # success case: finally converted token is Icx token ( Icx token SCORE's 'withdrawTo' method should be called ) converted_path = [ self.connector_token_list[0], self.flexible_token_address_list[0], self.icx_token ] # '_convert_by_path' method returns 'to' token Address, and converted amount with MultiPatch([ patch_property(IconScoreBase, 'msg', Message(self.network_owner)), patch.object(Network, '_convert_by_path', return_value=(self.icx_token, convert_result_amount)), patch.object(Network, 'create_interface_score', return_value=icx_token_score_interface) ]): # register icx_token self.network_score._icx_tokens[self.icx_token] = True self.network_score._convert_for_internal(converted_path, amount_to_convert, min_return, for_address) icx_token_score_interface.withdrawTo.assert_called_with( convert_result_amount, for_address) # success case: finally converted token is irc token ( token SCORE's 'transfer' method should be called ) converted_path = [ self.icx_token, self.flexible_token_address_list[0], self.connector_token_list[1] ] # '_convert_by_path' method returns 'to' token Address, and converted amount with MultiPatch([ patch_property(IconScoreBase, 'msg', Message(self.network_owner)), patch.object(Network, '_convert_by_path', return_value=(self.connector_token_list[1], convert_result_amount)), patch.object(Network, 'create_interface_score', return_value=irc_token_score_interface) ]): self.network_score._convert_for_internal(converted_path, amount_to_convert, min_return, for_address) irc_token_score_interface.transfer.assert_called_with( for_address, convert_result_amount, b'None')
class test_ExtractionStep(unittest.TestCase): def test_retains_lookup_behavior_for_fields(self): step = amaxa.ExtractionStep( 'Account', amaxa.ExtractionScope.ALL_RECORDS, ['Self_Lookup__c', 'Other__c'], '', amaxa.SelfLookupBehavior.TRACE_NONE, amaxa.OutsideLookupBehavior.INCLUDE ) self.assertEqual(amaxa.SelfLookupBehavior.TRACE_NONE, step.get_self_lookup_behavior_for_field('Self_Lookup__c')) step.set_lookup_behavior_for_field('Self_Lookup__c', amaxa.SelfLookupBehavior.TRACE_ALL) self.assertEqual(amaxa.SelfLookupBehavior.TRACE_ALL, step.get_self_lookup_behavior_for_field('Self_Lookup__c')) self.assertEqual(amaxa.OutsideLookupBehavior.INCLUDE, step.get_outside_lookup_behavior_for_field('Other__c')) step.set_lookup_behavior_for_field('Other__c', amaxa.OutsideLookupBehavior.DROP_FIELD) self.assertEqual(amaxa.OutsideLookupBehavior.DROP_FIELD, step.get_outside_lookup_behavior_for_field('Other__c')) def test_store_result_calls_context(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_sobject_list = Mock(return_value=['Account']) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, []) oc.add_step(step) step.initialize() step.store_result({ 'Id': '001000000000000', 'Name': 'Picon Fleet Headquarters' }) oc.store_result.assert_called_once_with('Account', { 'Id': '001000000000000', 'Name': 'Picon Fleet Headquarters' }) oc.add_dependency.assert_not_called() def test_store_result_registers_self_lookup_dependencies(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_sobject_list = Mock(return_value=['Account']) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) oc.add_step(step) step.initialize() step.store_result({ 'Id': '001000000000000', 'Lookup__c': '001000000000001', 'Name': 'Picon Fleet Headquarters' }) oc.add_dependency.assert_called_once_with('Account', amaxa.SalesforceId('001000000000001')) def test_store_result_respects_self_lookup_options(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_sobject_list = Mock(return_value=['Account']) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c'], None, amaxa.SelfLookupBehavior.TRACE_NONE) oc.add_step(step) step.initialize() step.store_result({ 'Id': '001000000000000', 'Lookup__c': '001000000000001', 'Name': 'Picon Fleet Headquarters' }) oc.add_dependency.assert_not_called() def test_store_result_registers_dependent_lookup_dependencies(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Opportunity'] } }) oc.get_sobject_list = Mock(return_value=['Account', 'Opportunity']) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) oc.add_step(step) step.initialize() step.store_result({ 'Id': '001000000000000', 'Lookup__c': '006000000000001', 'Name': 'Picon Fleet Headquarters' }) oc.add_dependency.assert_called_once_with('Opportunity', amaxa.SalesforceId('006000000000001')) def test_store_result_handles_polymorphic_lookups(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Opportunity', 'Account', 'Task'] } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact', 'Opportunity']) oc.get_extracted_ids = Mock(return_value=['001000000000001']) oc.get_sobject_name_for_id = Mock(side_effect=lambda id: {'001': 'Account', '006': 'Opportunity', '00T': 'Task'}[id[:3]]) step = amaxa.ExtractionStep('Contact', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) oc.add_step(step) step.initialize() # Validate that the polymorphic lookup is treated properly when the content is a dependent reference step.store_result({ 'Id': '001000000000000', 'Lookup__c': '006000000000001', 'Name': 'Kara Thrace' }) oc.add_dependency.assert_called_once_with('Opportunity', amaxa.SalesforceId('006000000000001')) oc.store_result.assert_called_once_with('Contact', { 'Id': '001000000000000', 'Lookup__c': '006000000000001', 'Name': 'Kara Thrace' }) oc.add_dependency.reset_mock() oc.store_result.reset_mock() # Validate that the polymorphic lookup is treated properly when the content is a descendent reference step.store_result({ 'Id': '001000000000000', 'Lookup__c': '001000000000001', 'Name': 'Kara Thrace' }) oc.add_dependency.assert_not_called() oc.store_result.assert_called_once_with('Contact', { 'Id': '001000000000000', 'Lookup__c': '001000000000001', 'Name': 'Kara Thrace' }) oc.add_dependency.reset_mock() oc.store_result.reset_mock() # Validate that the polymorphic lookup is treated properly when the id is None step.store_result({ 'Id': '001000000000000', 'Lookup__c': None, 'Name': 'Kara Thrace' }) oc.add_dependency.assert_not_called() oc.store_result.assert_called_once_with('Contact', { 'Id': '001000000000000', 'Lookup__c': None, 'Name': 'Kara Thrace' }) oc.add_dependency.reset_mock() oc.store_result.reset_mock() # Validate that the polymorphic lookup is treated properly when the content is a off-extraction reference step.store_result({ 'Id': '001000000000000', 'Lookup__c': '00T000000000001', 'Name': 'Kara Thrace' }) oc.add_dependency.assert_not_called() oc.store_result.assert_called_once_with('Contact', { 'Id': '001000000000000', 'Lookup__c': '00T000000000001', 'Name': 'Kara Thrace' }) def test_store_result_respects_outside_lookup_behavior_drop_field(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'AccountId': { 'name': 'AccountId', 'type': 'reference', 'referenceTo': ['Account'] }, 'LastName': { 'name': 'Name', 'type': 'string' } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact']) oc.get_extracted_ids = Mock(return_value=set()) step = amaxa.ExtractionStep( 'Contact', amaxa.ExtractionScope.DESCENDENTS, ['AccountId'], outside_lookup_behavior=amaxa.OutsideLookupBehavior.DROP_FIELD ) oc.add_step(step) step.initialize() step.store_result({'Id': '003000000000001', 'AccountId': '001000000000001'}) oc.store_result.assert_called_once_with('Contact', {'Id': '003000000000001'}) def test_store_result_respects_outside_lookup_behavior_error(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'AccountId': { 'name': 'AccountId', 'type': 'reference', 'referenceTo': ['Account'] }, 'LastName': { 'name': 'Name', 'type': 'string' } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact']) oc.get_extracted_ids = Mock(return_value=set()) step = amaxa.ExtractionStep( 'Contact', amaxa.ExtractionScope.DESCENDENTS, ['AccountId'], outside_lookup_behavior=amaxa.OutsideLookupBehavior.ERROR ) oc.add_step(step) step.initialize() step.store_result({'Id': '003000000000001', 'AccountId': '001000000000001'}) self.assertEqual( [ '{} {} has an outside reference in field {} ({}), which is not allowed by the extraction configuration.'.format( 'Contact', '003000000000001', 'AccountId', '001000000000001' ) ], step.errors ) def test_store_result_respects_outside_lookup_behavior_include(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'AccountId': { 'name': 'AccountId', 'type': 'reference', 'referenceTo': ['Account'] }, 'LastName': { 'name': 'Name', 'type': 'string' } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact']) oc.get_extracted_ids = Mock(return_value=set()) step = amaxa.ExtractionStep( 'Contact', amaxa.ExtractionScope.DESCENDENTS, ['AccountId'], outside_lookup_behavior=amaxa.OutsideLookupBehavior.INCLUDE ) oc.add_step(step) step.initialize() step.store_result({'Id': '003000000000001', 'AccountId': '001000000000001'}) oc.store_result.assert_called_once_with('Contact', {'Id': '003000000000001', 'AccountId': '001000000000001'}) def test_store_result_discriminates_polymorphic_lookup_type(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_field_map = Mock(return_value={ 'AccountId': { 'name': 'AccountId', 'type': 'reference', 'referenceTo': ['Account'] }, 'WhoId': { 'name': 'Name', 'type': 'string' } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact', 'Task']) oc.get_extracted_ids = Mock(return_value=set()) step = amaxa.ExtractionStep( 'Contact', amaxa.ExtractionScope.DESCENDENTS, ['AccountId'], outside_lookup_behavior=amaxa.OutsideLookupBehavior.DROP_FIELD ) oc.add_step(step) step.initialize() step.store_result({'Id': '003000000000001', 'AccountId': '001000000000001'}) oc.store_result.assert_called_once_with('Contact', {'Id': '003000000000001'}) def test_perform_lookup_pass_executes_correct_query(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_sobject_ids_for_reference = Mock(return_value=set([amaxa.SalesforceId('001000000000000')])) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) oc.add_step(step) step.initialize() step.perform_id_field_pass = Mock() step.perform_lookup_pass('Lookup__c') oc.get_sobject_ids_for_reference.assert_called_once_with('Account', 'Lookup__c') step.perform_id_field_pass.assert_called_once_with('Lookup__c', set([amaxa.SalesforceId('001000000000000')])) def test_perform_id_field_pass_queries_all_records(self): connection = Mock() connection.query_all = Mock(side_effect=lambda x: { 'records': [{ 'Id': '001000000000001'}] }) oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.store_result = Mock() oc.add_step(step) step.initialize() id_set = set() # Generate enough fake Ids to require two queries. for i in range(400): new_id = amaxa.SalesforceId('001000000000' + str(i + 1).zfill(3)) id_set.add(new_id) self.assertEqual(400, len(id_set)) step.perform_id_field_pass('Lookup__c', id_set) self.assertLess(1, len(connection.query_all.call_args_list)) total = 0 for call in connection.query_all.call_args_list: self.assertLess(len(call[0][0]) - call[0][0].find('WHERE'), 4000) total += call[0][0].count('\'001') self.assertEqual(400, total) def test_perform_id_field_pass_stores_results(self): connection = Mock() connection.query_all = Mock(side_effect=lambda x: { 'records': [{ 'Id': '001000000000001'}, { 'Id': '001000000000002'}] }) oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.store_result = Mock() oc.add_step(step) step.initialize() step.perform_id_field_pass('Lookup__c', set([amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002')])) step.store_result.assert_any_call(connection.query_all('Account')['records'][0]) step.store_result.assert_any_call(connection.query_all('Account')['records'][1]) def test_perform_id_field_pass_ignores_empty_set(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) oc.add_step(step) step.initialize() step.perform_id_field_pass('Lookup__c', set()) connection.query_all.assert_not_called() @patch('amaxa.ExtractOperation.bulk', new_callable=PropertyMock()) def test_perform_bulk_api_pass_calls_query(self, bulk_proxy): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) retval = [{ 'Id': '001000000000001'}, { 'Id': '001000000000002'}] bulk_proxy.is_batch_done = Mock(side_effect=[False, True]) bulk_proxy.create_query_job = Mock(return_value = '075000000000000AAA') bulk_proxy.get_all_results_for_query_batch = Mock( return_value = [IteratorBytesIO([json.dumps(retval).encode('utf-8')])] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.QUERY, ['Lookup__c']) step.store_result = Mock() oc.add_step(step) step.initialize() step.perform_bulk_api_pass('SELECT Id FROM Account') bulk_proxy.query.assert_called_once_with('075000000000000AAA', 'SELECT Id FROM Account') @patch('amaxa.ExtractOperation.bulk', new_callable=PropertyMock()) def test_perform_bulk_api_pass_stores_results(self, bulk_proxy): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) retval = [{ 'Id': '001000000000001'}, { 'Id': '001000000000002'}] bulk_proxy.is_batch_done = Mock(side_effect=[False, True]) bulk_proxy.create_query_job = Mock(return_value = '075000000000000AAA') bulk_proxy.get_all_results_for_query_batch = Mock( return_value = [IteratorBytesIO([json.dumps(retval).encode('utf-8')])] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.store_result = Mock() oc.add_step(step) step.initialize() step.perform_bulk_api_pass('SELECT Id FROM Account') step.store_result.assert_any_call(retval[0]) step.store_result.assert_any_call(retval[1]) @patch('amaxa.ExtractOperation.bulk', new_callable=PropertyMock()) def test_perform_bulk_api_pass_stores_high_volume_results(self, bulk_proxy): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) retval = [] for i in range(5): retval.append([ {'Id': '00100000{:d}{:06d}'.format(i, j), 'Name': 'Account {:d}{:06d}'.format(i, j)} for j in range(100000) ]) bulk_proxy.is_batch_done = Mock(side_effect=[False, True]) bulk_proxy.create_query_job = Mock(return_value = '075000000000000AAA') bulk_proxy.get_all_results_for_query_batch = Mock( return_value = [IteratorBytesIO([json.dumps(chunk).encode('utf-8')]) for chunk in retval] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.store_result = Mock() oc.add_step(step) step.initialize() step.perform_bulk_api_pass('SELECT Id FROM Account') self.assertEqual(500000, step.store_result.call_count) @patch('amaxa.ExtractOperation.bulk', new_callable=PropertyMock()) def test_perform_bulk_api_pass_converts_datetimes(self, bulk_proxy): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'CreatedDate': { 'name': 'CreatedDate', 'type': 'datetime' } }) retval = [{ 'Id': '001000000000001', 'CreatedDate': 1546659665000}] bulk_proxy.is_batch_done = Mock(side_effect=[False, True]) bulk_proxy.create_query_job = Mock(return_value = '075000000000000AAA') bulk_proxy.get_all_results_for_query_batch = Mock( return_value = [IteratorBytesIO([json.dumps(retval).encode('utf-8')])] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.QUERY, ['CreatedDate']) step.store_result = Mock() oc.add_step(step) step.initialize() step.perform_bulk_api_pass('SELECT Id, CreatedDate FROM Account') step.store_result.assert_called_once_with( { 'Id': '001000000000001', 'CreatedDate': '2019-01-05T03:41:05.000+0000' } ) def test_resolve_registered_dependencies_loads_records(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_dependencies = Mock( side_effect=[ set([ amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002') ]), set() ] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.perform_id_field_pass = Mock() oc.add_step(step) step.initialize() step.resolve_registered_dependencies() oc.get_dependencies.assert_has_calls([unittest.mock.call('Account'), unittest.mock.call('Account')]) step.perform_id_field_pass.assert_called_once_with('Id', set([amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002')])) def test_resolve_registered_dependencies_registers_error_for_missing_ids(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Lookup__c': { 'name': 'Lookup__c', 'type': 'reference', 'referenceTo': ['Account'] } }) oc.get_dependencies = Mock( side_effect=[ set([ amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002') ]), set([ amaxa.SalesforceId('001000000000002') ]) ] ) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Lookup__c']) step.perform_id_field_pass = Mock() oc.add_step(step) step.initialize() step.resolve_registered_dependencies() self.assertEqual( [ 'Unable to resolve dependencies for sObject {}. The following Ids could not be found: {}'.format( step.sobjectname, ', '.join([str(i) for i in [amaxa.SalesforceId('001000000000002')]]) ) ], step.errors ) def test_execute_with_all_records_performs_bulk_api_pass(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Name': { 'name': 'Name', 'type': 'text' } }) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.ALL_RECORDS, ['Name']) step.perform_bulk_api_pass = Mock() oc.add_step(step) step.initialize() step.execute() step.perform_bulk_api_pass.assert_called_once_with('SELECT Name FROM Account') def test_execute_with_query_performs_bulk_api_pass(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Name': { 'name': 'Name', 'type': 'text' } }) step = amaxa.ExtractionStep('Account', amaxa.ExtractionScope.QUERY, ['Name'], 'Name != null') step.perform_bulk_api_pass = Mock() oc.add_step(step) step.initialize() step.execute() step.perform_bulk_api_pass.assert_called_once_with('SELECT Name FROM Account WHERE Name != null') def test_execute_loads_all_descendents(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Name': { 'name': 'Name', 'type': 'text' }, 'AccountId': { 'name': 'AccountId', 'type': 'reference', 'referenceTo': ['Account'] }, 'Household__c': { 'name': 'Household__c', 'type': 'reference', 'referenceTo': ['Account'] }, 'Event__c': { 'name': 'Event__c', 'type': 'reference', 'referenceTo': ['Event__c'] } }) oc.get_sobject_list = Mock(return_value=['Account', 'Contact']) step = amaxa.ExtractionStep('Contact', amaxa.ExtractionScope.DESCENDENTS, ['Name', 'AccountId', 'Household__c']) step.perform_lookup_pass = Mock() oc.add_step(step) step.initialize() step.execute() step.perform_lookup_pass.assert_has_calls( [ unittest.mock.call('AccountId'), unittest.mock.call('Household__c') ], any_order=True ) def test_execute_resolves_self_lookups(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Name': { 'name': 'Name', 'type': 'text' }, 'ParentId': { 'name': 'ParentId', 'type': 'reference', 'referenceTo': [ 'Account' ] } }) oc.get_extracted_ids = Mock( side_effect=[ set([amaxa.SalesforceId('001000000000001')]), set([amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002')]), set([amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002')]), set([amaxa.SalesforceId('001000000000001'), amaxa.SalesforceId('001000000000002')]) ] ) step = amaxa.ExtractionStep( 'Account', amaxa.ExtractionScope.QUERY, ['Name', 'ParentId'], 'Name = \'ACME\'' ) step.perform_bulk_api_pass = Mock() step.perform_lookup_pass = Mock() step.resolve_registered_dependencies = Mock() oc.add_step(step) step.initialize() self.assertEqual(set(['ParentId']), step.self_lookups) step.execute() step.perform_bulk_api_pass.assert_called_once_with('SELECT Name, ParentId FROM Account WHERE Name = \'ACME\'') oc.get_extracted_ids.assert_has_calls( [ unittest.mock.call('Account'), unittest.mock.call('Account'), unittest.mock.call('Account'), unittest.mock.call('Account') ] ) step.perform_lookup_pass.assert_has_calls( [ unittest.mock.call('ParentId'), unittest.mock.call('ParentId') ] ) step.resolve_registered_dependencies.assert_has_calls( [ unittest.mock.call(), unittest.mock.call() ] ) def test_execute_does_not_trace_self_lookups_without_trace_all(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.get_field_map = Mock(return_value={ 'Name': { 'name': 'Name', 'type': 'text' }, 'ParentId': { 'name': 'ParentId', 'type': 'reference', 'referenceTo': [ 'Account' ] } }) oc.get_extracted_ids = Mock() step = amaxa.ExtractionStep( 'Account', amaxa.ExtractionScope.QUERY, ['Name', 'ParentId'], 'Name = \'ACME\'', amaxa.SelfLookupBehavior.TRACE_NONE ) step.perform_bulk_api_pass = Mock() step.perform_lookup_pass = Mock() step.resolve_registered_dependencies = Mock() oc.add_step(step) step.initialize() step.execute() self.assertEqual(set(['ParentId']), step.self_lookups) step.resolve_registered_dependencies.assert_called_once_with() oc.get_extracted_ids.assert_not_called()