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()
