def test_extracts_polymorphic_lookups(self): oc = amaxa.ExtractOperation(Connection(self.connection)) oc.file_store = MockFileStore() rec = self.connection.query( "SELECT Id FROM Account WHERE Name = 'Caprica Cosmetics'" ) oc.add_dependency("Account", rec.get("records")[0]["Id"]) oc.add_step( amaxa.ExtractionStep( "Account", amaxa.ExtractionScope.SELECTED_RECORDS, ["Id", "Name", "OwnerId"], ) ) oc.add_step( amaxa.ExtractionStep( "User", amaxa.ExtractionScope.DESCENDENTS, ["Id", "Username"] ) ) oc.initialize() oc.execute() self.assertEqual(1, len(oc.get_extracted_ids("Account"))) self.assertEqual(1, len(oc.get_extracted_ids("User")))
def test_descendents_extracts_object_network(self): expected_names = {"Elosha", "Gaius"} oc = amaxa.ExtractOperation(Connection(self.connection, "48.0")) oc.file_store = MockFileStore() rec = self.connection.query( "SELECT Id FROM Account WHERE Name = 'Caprica Cosmetics'") oc.add_dependency("Account", rec.get("records")[0]["Id"]) oc.add_step( amaxa.ExtractionStep( "Account", amaxa.ExtractionScope.SELECTED_RECORDS, ["Id", "Name", "ParentId"], )) oc.add_step( amaxa.ExtractionStep( "Contact", amaxa.ExtractionScope.DESCENDENTS, ["Id", "FirstName", "LastName", "AccountId"], )) oc.initialize() oc.execute() self.assertEqual(3, len(oc.get_extracted_ids("Account"))) self.assertEqual(2, len(oc.get_extracted_ids("Contact"))) for c in oc.file_store.get_csv( "Contact", amaxa.FileType.OUTPUT).writerow.call_args_list: self.assertIn(c[0][0]["FirstName"], expected_names) expected_names.remove(c[0][0]["FirstName"]) self.assertEqual(0, len(expected_names))
def test_query_extracts_self_lookup_hierarchy(self): expected_names = { "Caprica Cosmetics", "Gemenon Gastronomy", "Aerilon Agrinomics", } oc = amaxa.ExtractOperation(Connection(self.connection)) oc.file_store = MockFileStore() rec = self.connection.query( "SELECT Id FROM Account WHERE Name = 'Caprica Cosmetics'" ) oc.add_dependency("Account", rec.get("records")[0]["Id"]) extraction = amaxa.ExtractionStep( "Account", amaxa.ExtractionScope.SELECTED_RECORDS, ["Id", "Name", "ParentId"], ) oc.add_step(extraction) extraction.initialize() extraction.execute() self.assertEqual(3, len(oc.get_extracted_ids("Account"))) for c in oc.file_store.get_csv( "Account", amaxa.FileType.OUTPUT ).writerow.call_args_list: self.assertIn(c[0][0]["Name"], expected_names) expected_names.remove(c[0][0]["Name"]) self.assertEqual(0, len(expected_names))
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_loads_and_extracts_high_data_volume(self): # This is a single unit test rather than multiple to save on execution time. records = [] for i in range(100000): records.append({ "Id": "00Q000000{:06d}".format(i), "Company": "[not provided]", "LastName": "Lead {:06d}".format(i), }) op = amaxa.LoadOperation(Connection(self.connection, "52.0")) op.file_store = MockFileStore() op.file_store.records["Lead"] = records op.add_step(amaxa.LoadStep("Lead", set(["LastName", "Company"]))) op.initialize() op.execute() self.assertEqual( 100000, self.connection.query("SELECT count() FROM Lead").get("totalSize")) oc = amaxa.ExtractOperation(Connection(self.connection, "52.0")) oc.file_store = MockFileStore() extraction = amaxa.ExtractionStep("Lead", amaxa.ExtractionScope.ALL_RECORDS, ["Id", "LastName"]) oc.add_step(extraction) extraction.initialize() extraction.execute() self.assertEqual(100000, len(oc.get_extracted_ids("Lead")))
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_get_sobject_ids_for_reference_returns_correct_ids(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store = MockFileStore() oc.get_field_map = Mock( return_value={"Lookup__c": {"referenceTo": ["Account", "Contact"]}} ) oc.store_result( "Account", {"Id": "001000000000000", "Name": "University of Caprica"} ) oc.store_result("Contact", {"Id": "003000000000000", "Name": "Gaius Baltar"}) oc.store_result( "Opportunity", {"Id": "006000000000000", "Name": "Defense Mainframe"} ) self.assertEqual( set( [ amaxa.SalesforceId("001000000000000"), amaxa.SalesforceId("003000000000000"), ] ), oc.get_sobject_ids_for_reference("Account", "Lookup__c"), )
def test_initialize_identifies_all_lookups_within_extraction(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store.set_csv("Account", amaxa.FileType.OUTPUT, Mock()) oc.file_store.set_csv("Contact", amaxa.FileType.OUTPUT, Mock()) oc.get_field_map = Mock( return_value={ "Lookup__c": { "name": "Lookup__c", "type": "reference", "referenceTo": ["Account"], }, "Other__c": { "name": "Other__c", "type": "reference", "referenceTo": ["Contact"], }, "Outside__c": { "name": "Outside__c", "type": "reference", "referenceTo": ["Opportunity"], }, }) oc.get_sobject_list = Mock(return_value=["Account", "Contact"]) step = ConcreteStep("Account", ["Lookup__c", "Other__c", "Outside__c"]) oc.add_step(step) step.initialize() self.assertEqual(set(["Other__c", "Lookup__c"]), step.all_lookups)
def test_initialize_handles_mixed_polymorphic_lookups(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store.set_csv("Account", amaxa.FileType.OUTPUT, Mock()) oc.file_store.set_csv("Contact", amaxa.FileType.OUTPUT, Mock()) oc.file_store.set_csv("Opportunity", amaxa.FileType.OUTPUT, Mock()) oc.get_field_map = Mock( return_value={ "Poly_Lookup__c": { "name": "Lookup__c", "type": "reference", "referenceTo": ["Account", "Opportunity"], }, "Other__c": { "name": "Other__c", "type": "reference", "referenceTo": ["Contact"], }, }) oc.get_sobject_list = Mock( return_value=["Account", "Contact", "Opportunity"]) step = ConcreteStep("Contact", ["Poly_Lookup__c", "Other__c"]) oc.add_step(step) step.initialize() self.assertEqual(set(["Poly_Lookup__c"]), step.dependent_lookups) self.assertEqual(set(["Poly_Lookup__c"]), step.descendent_lookups)
def test_store_result_clears_dependencies(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store = MockFileStore() oc.add_dependency("Account", amaxa.SalesforceId("001000000000000")) oc.store_result("Account", {"Id": "001000000000000", "Name": "Caprica Steel"}) self.assertEqual(set(), oc.get_dependencies("Account"))
def test_store_result_retains_ids(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store = MockFileStore() oc.store_result("Account", {"Id": "001000000000000", "Name": "Caprica Steel"}) self.assertEqual( set([amaxa.SalesforceId("001000000000000")]), oc.extracted_ids["Account"] )
def test_add_dependency_tracks_dependencies(self): connection = Mock() oc = amaxa.ExtractOperation(connection) self.assertEqual(set(), oc.get_dependencies("Account")) oc.add_dependency("Account", amaxa.SalesforceId("001000000000000")) self.assertEqual( set([amaxa.SalesforceId("001000000000000")]), oc.get_dependencies("Account") )
def test_store_result_writes_records(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store = MockFileStore() oc.store_result("Account", {"Id": "001000000000000", "Name": "Caprica Steel"}) oc.file_store.get_csv( "Account", amaxa.FileType.OUTPUT ).writerow.assert_called_once_with( {"Id": "001000000000000", "Name": "Caprica Steel"} )
def test_execute_runs_all_steps(self): connection = Mock() oc = amaxa.ExtractOperation(connection) # pylint: disable=W0612 for i in range(3): oc.add_step(Mock(sobjectname=str(i), errors=[])) oc.execute() for s in oc.steps: s.execute.assert_called_once_with() self.assertEqual(oc, s.context)
def test_all_records_extracts_accounts(self): oc = amaxa.ExtractOperation(Connection(self.connection)) oc.file_store = MockFileStore() extraction = amaxa.ExtractionStep( "Account", amaxa.ExtractionScope.ALL_RECORDS, ["Id", "Name"] ) oc.add_step(extraction) extraction.initialize() extraction.execute() self.assertEqual(5, len(oc.get_extracted_ids("Account")))
def test_store_result_handles_empty_lookup_values(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.store_result = Mock() oc.add_dependency = Mock() oc.get_extracted_ids = 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_sobject_name_for_id = Mock() 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.dependent_lookups = ["Lookup__c"] step.descendent_lookups = [] step.self_lookups = [] step.store_result({ "Id": "001000000000000", "Lookup__c": None, "Name": "Kara Thrace" }) oc.add_dependency.assert_not_called() oc.get_sobject_name_for_id.assert_not_called() oc.get_extracted_ids.assert_not_called() # Validate that the polymorphic lookup is treated properly when the content is a descendent reference step.dependent_lookups = [] step.descendent_lookups = ["Lookup__c"] step.self_lookups = [] step.store_result({ "Id": "001000000000000", "Lookup__c": None, "Name": "Kara Thrace" }) oc.add_dependency.assert_not_called() oc.get_sobject_name_for_id.assert_not_called() oc.get_extracted_ids.assert_not_called()
def test_execute_returns_on_error(self): connection = Mock() oc = amaxa.ExtractOperation(connection) # pylint: disable=W0612 for i in range(3): oc.add_step(Mock(sobjectname=str(i), errors=[])) oc.steps[1].errors = ["Bad things happened"] assert oc.execute() == -1 oc.steps[0].execute.assert_called_once_with() oc.steps[1].execute.assert_called_once_with() oc.steps[2].execute.assert_not_called()
def test_perform_bulk_api_pass_stores_results(self): retval = [{"Id": "001000000000001"}, {"Id": "001000000000002"}] connection = MockConnection(bulk_query_results=retval) oc = amaxa.ExtractOperation(connection) step = amaxa.ExtractionStep("Account", amaxa.ExtractionScope.ALL_RECORDS, ["Name"]) 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])
def test_execute_loads_all_descendents(self): connection = Mock() connection.retrieve_records_by_id.return_value = [] 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_extracts_dependencies(self): expected_account_names = { "Caprica Cosmetics", "Gemenon Gastronomy", "Aerilon Agrinomics", } expected_contact_names = {"Gaius"} oc = amaxa.ExtractOperation(Connection(self.connection)) oc.file_store = MockFileStore() rec = self.connection.query("SELECT Id FROM Contact WHERE LastName = 'Baltar'") oc.add_dependency("Contact", rec.get("records")[0]["Id"]) oc.add_step( amaxa.ExtractionStep( "Contact", amaxa.ExtractionScope.SELECTED_RECORDS, ["Id", "FirstName", "LastName", "AccountId"], ) ) oc.add_step( amaxa.ExtractionStep( "Account", amaxa.ExtractionScope.DESCENDENTS, ["Id", "Name", "ParentId"] ) ) oc.initialize() oc.execute() self.assertEqual(3, len(oc.get_extracted_ids("Account"))) self.assertEqual(1, len(oc.get_extracted_ids("Contact"))) for c in oc.file_store.get_csv( "Contact", amaxa.FileType.OUTPUT ).writerow.call_args_list: self.assertIn(c[0][0]["FirstName"], expected_contact_names) expected_contact_names.remove(c[0][0]["FirstName"]) self.assertEqual(0, len(expected_contact_names)) for c in oc.file_store.get_csv( "Account", amaxa.FileType.OUTPUT ).writerow.call_args_list: self.assertIn(c[0][0]["Name"], expected_account_names) expected_account_names.remove(c[0][0]["Name"]) self.assertEqual(0, len(expected_account_names))
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_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"]) connection.retrieve_records_by_id = Mock(return_value=[]) 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_store_result_transforms_output(self): connection = Mock() oc = amaxa.ExtractOperation(connection) oc.file_store = MockFileStore() mapper_mock = Mock() mapper_mock.transform_record = Mock( return_value={"Id": "001000000000000", "Name": "Caprica City Steel"} ) oc.mappers["Account"] = mapper_mock oc.store_result("Account", {"Id": "001000000000000", "Name": "Caprica Steel"}) mapper_mock.transform_record.assert_called_once_with( {"Id": "001000000000000", "Name": "Caprica Steel"} ) oc.file_store.get_csv( "Account", amaxa.FileType.OUTPUT ).writerow.assert_called_once_with( {"Id": "001000000000000", "Name": "Caprica City Steel"} )
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_execute_with_query_performs_bulk_api_pass(self): connection = Mock() connection.bulk_api_query.return_value = [] connection.retrieve_records_by_id.return_value = [] 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_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()
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_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 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", }, )