def test_resolve_categories_for_rooms(self): should_be_called = MagicMock(return_value = True) all_rooms = self.generate_rooms_with_text("Some text") with patch("__main__.DXFRoomCatsResolver._resolve_category_for_room", should_be_called): r = DXFRoomCatsResolver._resolve_categories_for_rooms( all_rooms, self.cats ) # 3 matches self.assertEqual(r, 3) for r in all_rooms: MagicMock.assert_any_call( should_be_called, r, self.cats ) self.assertEqual(should_be_called.call_count, len(all_rooms)) # Now we ensure it counts correctly the amount of rooms matched should_be_called = MagicMock(side_effect = [True, False, False]) with patch("__main__.DXFRoomCatsResolver._resolve_category_for_room", should_be_called): r = DXFRoomCatsResolver._resolve_categories_for_rooms( all_rooms, self.cats ) # 1 match self.assertEqual(r, 1)
def test_run_spark_with_store_correct_calls(): run_cell_method = MagicMock() run_cell_method.return_value = (True, "") spark_controller.run_command = run_cell_method command = "-s" name = "sessions_name" context = "-c" context_name = "spark" meth = "-m" method_name = "sample" output = "-o" output_var = "var_name" coer = "--coerce" coerce_value = "True" line = " ".join([ command, name, context, context_name, meth, method_name, output, output_var, coer, coerce_value ]) cell = "cell code" result = magic.spark(line, cell) run_cell_method.assert_any_call(Command(cell), name) run_cell_method.assert_any_call( SparkStoreCommand(output_var, samplemethod=method_name, coerce=True), name)
def test_handle_request_happy_path_no_failures( self, mock_store_validation_results: MagicMock, mock_fetch_validations: MagicMock, mock_run_job: MagicMock, mock_emit_failures: MagicMock, mock_rematerialize_views: MagicMock, ) -> None: mock_fetch_validations.return_value = self._TEST_VALIDATIONS mock_run_job.return_value = DataValidationJobResult( validation_job=self._TEST_VALIDATIONS[0], result_details=FakeValidationResultDetails(passed=True), ) headers = {"X-Appengine-Cron": "test-cron"} response = self.client.get("/validate", headers=headers) self.assertEqual(200, response.status_code) self.assertEqual(_API_RESPONSE_IF_NO_FAILURES, response.get_data().decode()) self.assertEqual(4, mock_run_job.call_count) for job in self._TEST_VALIDATIONS: mock_run_job.assert_any_call(job) mock_rematerialize_views.assert_called() mock_emit_failures.assert_not_called() mock_store_validation_results.assert_called_once() ((results,), _kwargs) = mock_store_validation_results.call_args self.assertEqual(4, len(results))
def test_allowed_user_convert(self, users, previous_users, expected_users): key_str = 'allowed_users_str' key = 'allowed_users' # Configure mock name_validator = MagicMock() conv_val.toolkit.get_validator = MagicMock(return_value=name_validator) # Fullfill the data dictionary # * list should be included in the allowed_users filed # * strings should be included in the allowed_users_str field if isinstance(users, basestring): data_key = key_str else: data_key = key data = {(data_key,): users} for i in range(0, previous_users): data[(key, i)] = i # Call the function context = {'user': '******', 'auth_obj_id': {'id': 1}} conv_val.allowed_users_convert((key,), data, {}, context) # Check that the users are set properly for i in range(previous_users, previous_users + len(expected_users)): name_validator.assert_any_call(expected_users[i - previous_users], context) self.assertEquals(expected_users[i - previous_users], data[(key, i)])
def test_run_spark_command_exception_while_storing(): run_cell_method = MagicMock() exception = LivyUnexpectedStatusException('WOW') run_cell_method.side_effect = [(True, ""), exception] spark_controller.run_command = run_cell_method command = "-s" name = "sessions_name" context = "-c" context_name = "spark" meth = "-m" method_name = "sample" output = "-o" output_var = "var_name" line = " ".join([ command, name, context, context_name, meth, method_name, output, output_var ]) cell = "cell code" result = magic.spark(line, cell) run_cell_method.assert_any_call(Command(cell), name) run_cell_method.assert_any_call( SparkStoreCommand(output_var, samplemethod=method_name), name) ipython_display.write.assert_called_once_with("") ipython_display.send_error.assert_called_once_with( EXPECTED_ERROR_MSG.format(exception))
def test_allowed_user_convert(self, users, previous_users, expected_users): key_str = 'allowed_users_str' key = 'allowed_users' # Configure mock name_validator = MagicMock() conv_val.toolkit.get_validator = MagicMock(return_value=name_validator) # Fullfill the data dictionary # * list should be included in the allowed_users filed # * strings should be included in the allowed_users_str field if isinstance(users, basestring): data_key = key_str else: data_key = key data = {(data_key, ): users} for i in range(0, previous_users): data[(key, i)] = i # Call the function context = {'user': '******', 'auth_obj_id': {'id': 1}} conv_val.allowed_users_convert((key, ), data, {}, context) # Check that the users are set properly for i in range(previous_users, previous_users + len(expected_users)): name_validator.assert_any_call(expected_users[i - previous_users], context) self.assertEquals(expected_users[i - previous_users], data[(key, i)])
def test_serialize_returns_expected(self): obj_with_ser = MagicMock(spec=object) mock_serialize = MagicMock(return_value={'a': 'b'}) obj_with_ser.attach_mock(mock_serialize, 'serialize') obj_without_ser = MagicMock(spec=object) class ICanSerialize(mixins.SerializableMixin): def __init__(self): self.attr1 = obj_with_ser self.attr2 = obj_without_ser serialize_me = ICanSerialize() actual = serialize_me.serialize() expected = { 'attr1': { 'a': 'b', }, 'attr2': obj_without_ser, } self.assertEqual(actual, expected) mock_serialize.assert_any_call()
def test_resolve_room_categories(self): a_floor = MagicMock() should_be_called = MagicMock(return_value = True) cats = MagicMock(return_value = "cats_result") class_ns = "__main__.DXFRoomCatsResolver" with patch(class_ns+".get_room_categories_dict", cats): with patch(class_ns+"._resolve_room_categories_for_floor", should_be_called): # Chiamata 1 - un solo floor, passato come parametro r = DXFRoomCatsResolver.resolve_room_categories(MagicMock(), a_floor) self.assertEqual(r, 1) MagicMock.assert_called_once_with(cats) MagicMock.assert_called_once_with( should_be_called, a_floor, "cats_result", ) MagicMock.reset_mock(should_be_called) b = { "dxf": { "floors": ["firstfloor", "secondfloor", "thirdfloor"] } } r = DXFRoomCatsResolver.resolve_room_categories(b) for f in b["dxf"]["floors"]: MagicMock.assert_any_call( should_be_called, f, "cats_result" ) self.assertEqual(r, 3)
def test_check_if_command_exits_when_fixture_path_does_not_exist( self, os_path_exists_mock: MagicMock) -> None: os_path_exists_mock.return_value = False with self.assertRaises(SystemExit): call_command(self.COMMAND_NAME, fixture=self.fixture_path, url=self.url) os_path_exists_mock.assert_any_call(os.path.join(settings.DEPLOY_ROOT, self.fixture_path))
def test_read_from_file(self): read_csv = MagicMock(return_value=pandas.DataFrame()) with patch('pandas.read_csv', read_csv): allocator = HouseholdAllocator.from_csvs('households_file', 'persons_file') assert type(allocator) == HouseholdAllocator read_csv.assert_any_call('households_file') read_csv.assert_any_call('persons_file')
def test_read_from_file(self): read_csv = MagicMock(return_value=pandas.DataFrame()) with patch('pandas.read_csv', read_csv): population = Population.from_csvs('persons_file', 'households_file') assert type(population) == Population read_csv.assert_any_call('households_file') read_csv.assert_any_call('persons_file')
def test_scan(self, connect_mock, tpl_mock): self.maxDiff = None now = '2013-09-20 11:48:33' tpl_mock.return_value = { 'status': 'unknown', 'date': now, 'plugin': 'ssh_cisco_asa', 'messages': [], } ip = '10.10.10.10' asa_ssh_mock = MagicMock() command_mock = MagicMock() asa_ssh_mock.asa_command = command_mock command_mock.side_effect = cisco_asa_ssh_mock connect_mock.return_value = asa_ssh_mock correct_ret = { 'status': 'success', 'plugin': 'ssh_cisco_asa', 'messages': [], 'device': { 'model_name': 'Cisco SOME_ASA_MODEL', 'type': 'firewall', 'serial_number': 'SOME-SN', 'mac_addresses': [ u'AB12BC235556', u'AB12BC235558', u'DEF113DE4567', u'DEF113DE4566', u'DEF113DE5677', u'DEF113DE5676', u'DEF113DE6785', u'DEF113DE6784', ], 'boot_firmware': 'SOME-BOOT-FIRMWARE', 'management_ip_addresses': [ ip, ], 'memory': [{ 'size': 12288, }], 'processors': [{ 'family': 'AMD Opteron', 'model_name': 'AMD Opteron', 'speed': 2600, }], }, } ret = ssh_cisco_asa.scan_address(ip, snmp_name='Cisco Software:UCOS') correct_ret['date'] = ret['date'] # assuming datetime is working. self.assertEqual(ret, correct_ret) command_mock.assert_any_call( "show version | grep (^Hardware|Boot microcode|^Serial|address is)", ) self.assertEqual(command_mock.call_count, 1)
def test_local_import_source_corrupted_full_progress( self, is_cancelled_mock, cancel_mock, path_mock, isfile_mock, annotation_mock, files_to_transfer_mock, channel_list_status_mock, ): """ Ensure that when a file is imported that does not match the file size in the database that the overall progress tracking for the content import process is properly updated to reflect the size of the file in the database, not the file on disk. This is important, as the total progress for the overall process is measured against the total file size recorded in the database for all files, not for the the transferred file size. """ local_src_path = tempfile.mkstemp()[1] with open(local_src_path, "w") as f: f.write("This is just a test") src_file_size = os.path.getsize(local_src_path) expected_file_size = 10000 local_dest_path = tempfile.mkstemp()[1] os.remove(local_dest_path) # Delete all but one file associated with ContentNode to reduce need for mocking files = ContentNode.objects.get( id="32a941fb77c2576e8f6b294cde4c3b0c").files.all() first_file = files.first() files.exclude(id=first_file.id).delete() LocalFile.objects.filter( files__contentnode="32a941fb77c2576e8f6b294cde4c3b0c").update( file_size=expected_file_size) files_to_transfer_mock.return_value = ( LocalFile.objects.filter( files__contentnode="32a941fb77c2576e8f6b294cde4c3b0c"), 10, ) path_mock.side_effect = [local_dest_path, local_src_path] mock_overall_progress = MagicMock() mock_file_progress = MagicMock() with patch( "kolibri.core.tasks.management.commands.base.ProgressTracker" ) as progress_mock: progress_mock.return_value.__enter__.side_effect = [ mock_overall_progress, mock_file_progress, ] call_command( "importcontent", "disk", self.the_channel_id, "destination", node_ids=["32a941fb77c2576e8f6b294cde4c3b0c"], ) mock_overall_progress.assert_any_call(expected_file_size - src_file_size)
def test_tuners(self, tuner: MagicMock): main = Main(self.config) g1 = Geo() g2 = Geo() main.geos = [g1, g2] main._init_tuners() self.assertEqual(len(main.tuners), 2) tuner.assert_any_call(g1, main.config, main.ssdp, port=6077) tuner.assert_any_call(g1, main.config, main.ssdp, port=6078)
def test_tuners_multiplex(self, tuner: MagicMock): self.config.multiplex = True main = Main(self.config) g1 = Geo() g2 = Geo() main.geos = [g1, g2] main._init_tuners() self.assertEqual(len(main.tuners), 2) tuner.assert_any_call(g1, main.config, main.ssdp, port=None) tuner.assert_any_call(g2, main.config, main.ssdp, port=None)
def test_parallel_execution_without_arguments(self): # Fixture func = MagicMock() # Test self.sut.parallel(func) # Assert for uri, mock in self.factory.mocks.items(): func.assert_any_call(mock)
def test_calcErrors(self): diffMock = MagicMock(return_value=1) with patch('miscFuncs.calcDiffErrors', diffMock): an = AnalysisNodeData('node', ['K1', 'K2'], 'areas') an.results = {'K1': ['1r1', '1r2'], 'K2': ['2r1', '2r2']} an.anSol = {'K1': ['1a1', '1a2'], 'K2': ['2a1', '2a2']} an.calcErrors() diffMock.assert_any_call(['1a1', '1a2'], ['1r1', '1r2']) diffMock.assert_any_call(['2a1', '2a2'], ['2r1', '2r2']) self.assertEqual(2, diffMock.call_count) expected = {'difference': {'K1': 1, 'K2': 1}, 'normedDiff': {}}
def file_import_test(self): """ Test the actual import of real song files and check that the imported data is correct. """ # GIVEN: Test files with a mocked out SongImport class, a mocked out "manager", a mocked out "import_wizard", # and mocked out "author", "add_copyright", "add_verse", "finish" methods. with patch('openlp.plugins.songs.lib.ewimport.SongImport'), \ patch('openlp.plugins.songs.lib.ewimport.retrieve_windows_encoding') as mocked_retrieve_windows_encoding: mocked_retrieve_windows_encoding.return_value = 'cp1252' mocked_manager = MagicMock() mocked_import_wizard = MagicMock() mocked_add_author = MagicMock() mocked_add_verse = MagicMock() mocked_finish = MagicMock() mocked_title = MagicMock() mocked_finish.return_value = True importer = EasyWorshipSongImportLogger(mocked_manager) importer.import_wizard = mocked_import_wizard importer.stop_import_flag = False importer.addAuthor = mocked_add_author importer.addVerse = mocked_add_verse importer.title = mocked_title importer.finish = mocked_finish importer.topics = [] # WHEN: Importing each file importer.import_source = os.path.join(TEST_PATH, 'Songs.DB') # THEN: doImport should return none, the song data should be as expected, and finish should have been # called. self.assertIsNone(importer.doImport(), 'doImport should return None when it has completed') for song_data in SONG_TEST_DATA: print mocked_title.mocked_calls() title = song_data['title'] author_calls = song_data['authors'] song_copyright = song_data['copyright'] ccli_number = song_data['ccli_number'] add_verse_calls = song_data['verses'] verse_order_list = song_data['verse_order_list'] self.assertIn(title, importer._title_assignment_list, 'title for %s should be "%s"' % (title, title)) for author in author_calls: mocked_add_author.assert_any_call(author) if song_copyright: self.assertEqual(importer.copyright, song_copyright) if ccli_number: self.assertEquals(importer.ccliNumber, ccli_number, 'ccliNumber for %s should be %s' % (title, ccli_number)) for verse_text, verse_tag in add_verse_calls: mocked_add_verse.assert_any_call(verse_text, verse_tag) if verse_order_list: self.assertEquals(importer.verseOrderList, verse_order_list, 'verseOrderList for %s should be %s' % (title, verse_order_list)) mocked_finish.assert_called_with()
def add_file_test(isfile, getdest): """ Checks that the add_file() method behaves correctly under various circumstances. """ @command() @argument('src') @argument('dest') @option('--force', '-f', is_flag=True) def click_mock(src, dest, force): scr.add_file(method, src, dest, scr.cur_notebook, force) def side_effect1(*args): if not args[3]: raise OSError else: pass method = MagicMock() scr.add_file(method, 'src', 'dest', scr.cur_notebook, True) method.assert_called_with(scr.cur_notebook, 'src', 'dest', True) method = MagicMock(side_effect=side_effect1) runner = CliRunner() result = runner.invoke(click_mock, ['src', 'dest'], input='y\n') method.assert_any_call(scr.cur_notebook, 'src', 'dest', False) method.assert_called_with(scr.cur_notebook, 'src', 'dest', True) method = MagicMock(side_effect=(OSError('1'), None)) isfile.side_effect = [True, False] getdest.return_value = 'dest' result = runner.invoke(click_mock, ['src', 'dest'], input='\n-\n') assert 'Placing this file in the notebook would' in result.output assert 'Provide a new filename' in result.output method.assert_called_with(scr.cur_notebook, 'src', 'dest', False) assert method.call_count == 1 method = MagicMock(side_effect=(OSError('1'), None)) getdest.return_value = 'dest.txt' isfile.side_effect = [True, False] result = runner.invoke(click_mock, ['src', 'dest.txt'], input='\n\n') method.assert_called_with(scr.cur_notebook, 'src', 'dest-1.txt', False) method = MagicMock(side_effect=(OSError('1'), None)) getdest.return_value = 'dest.txt' isfile.side_effect = [True, False, False] result = runner.invoke(click_mock, ['src', 'dest.txt'], input='\nthingy.txt\n') method.assert_called_with(scr.cur_notebook, 'src', 'thingy.txt', False) method = MagicMock(side_effect=(OSError('1'), None)) getdest.return_value = 'out/dest.txt' isfile.side_effect = [True, False] result = runner.invoke(click_mock, ['src', 'out/dest.txt'], input='\n\n') method.assert_called_with(scr.cur_notebook, 'src', 'out/dest-1.txt', False)
def test_scan(self, connect_mock, tpl_mock): self.maxDiff = None now = '2013-09-20 11:48:33' tpl_mock.return_value = { 'status': 'unknown', 'date': now, 'plugin': 'ssh_cisco_asa', 'messages': [], } ip = '10.10.10.10' asa_ssh_mock = MagicMock() command_mock = MagicMock() asa_ssh_mock.asa_command = command_mock command_mock.side_effect = cisco_asa_ssh_mock connect_mock.return_value = asa_ssh_mock correct_ret = { 'status': 'success', 'plugin': 'ssh_cisco_asa', 'messages': [], 'device': { 'model_name': 'Cisco SOME_ASA_MODEL', 'type': 'firewall', 'serial_number': 'SOME-SN', 'mac_addresses': [ u'AB12BC235556', u'AB12BC235558', u'DEF113DE4567', u'DEF113DE4566', u'DEF113DE5677', u'DEF113DE5676', u'DEF113DE6785', u'DEF113DE6784', ], 'boot_firmware': 'SOME-BOOT-FIRMWARE', 'management_ip_addresses': [ip, ], 'memory': [{ 'size': 12288, }], 'processors': [{ 'family': 'AMD Opteron', 'model_name': 'AMD Opteron', 'speed': 2600, }], }, } ret = ssh_cisco_asa.scan_address(ip, snmp_name='Cisco Software:UCOS') correct_ret['date'] = ret['date'] # assuming datetime is working. self.assertEqual(ret, correct_ret) command_mock.assert_any_call( "show version | grep (^Hardware|Boot microcode|^Serial|address is)", ) self.assertEqual(command_mock.call_count, 1)
def test_delAttr(self): """ You can delete attributes. """ ev = MagicMock() world = World(ev) obj = world.create('foo') world.setAttr(obj['id'], 'foo', 'bar') ev.reset_mock() world.delAttr(obj['id'], 'foo') ev.assert_any_call(AttrDel(obj['id'], 'foo')) self.assertNotIn('foo', world.get(obj['id']))
def test_snapshot(self): pvc_driver = self._driver pvc_driver._service.snapshot = MagicMock() context = MagicMock() instance = 1 image_id = 1 update_task_state = MagicMock() pvc_driver.snapshot(context, instance, image_id, update_task_state) update_task_state.assert_any_call( task_state=task_states.IMAGE_PENDING_UPLOAD) update_task_state.assert_any_call( task_state=task_states.IMAGE_UPLOADING, expected_state=task_states.IMAGE_PENDING_UPLOAD)
def test_removeItem(self): """ You can remove items from a list """ ev = MagicMock() world = World(ev) obj = world.create('foo') world.addItem(obj['id'], 'foo', 'bar') ev.reset_mock() world.removeItem(obj['id'], 'foo', 'bar') ev.assert_any_call(ItemRemoved(obj['id'], 'foo', 'bar')) self.assertEqual(world.get(obj['id'])['foo'], [])
def test_setAttr(self): """ You can set the value of an attribute. """ ev = MagicMock() world = World(ev) obj = world.create('foo') ev.reset_mock() world.setAttr(obj['id'], 'foo', 'bar') ev.assert_any_call(AttrSet(obj['id'], 'foo', 'bar')) obj = world.get(obj['id']) self.assertEqual(obj['foo'], 'bar')
def test_filter_trace(self): mock_filter = MagicMock() self.mf.filter = mock_filter mock_filter.side_effect = cycle([[sentinel.filtered_even] * 2, [sentinel.filtered_odd] * 2, [sentinel.filtered_recombined]]) trace_segment = [sentinel.trace_even, sentinel.trace_odd] filtered_trace = self.mf.filter_trace(trace_segment * 4) self.assertEqual(filtered_trace, [sentinel.filtered_recombined]) mock_filter.assert_any_call([sentinel.trace_even] * 4) mock_filter.assert_any_call([sentinel.trace_odd] * 4) mock_filter.assert_called_with([sentinel.filtered_even, sentinel.filtered_odd] * 2)
def test_log_call_accepts_callable(self, logging): """flog.flog.log_sensitive_call: Accepts a callable and calls it as if it were a logger function""" my_logger = MagicMock() randoa = random.randint(0, 500) randob = random.randint(0, 500) randoc = random.randint(0, 500) # SUT flog.log_sensitive_call(my_logger)(my_fun)(randoa, randob, randoc, random_frippery_scale=32) my_logger.assert_any_call("test_log_call.my_fun: args: *XXXXXX, kwargs: **XXXXXXX") my_logger.assert_any_call("test_log_call.my_fun: returns: XXXXXXXXXX")
def test_handle_request_happy_path_some_failures( self, mock_store_validation_results: MagicMock, mock_fetch_validations: MagicMock, mock_run_job: MagicMock, mock_emit_failures: MagicMock, mock_rematerialize_views: MagicMock, ) -> None: mock_fetch_validations.return_value = self._TEST_VALIDATIONS first_failure = DataValidationJobResult( validation_job=self._TEST_VALIDATIONS[1], result_details=FakeValidationResultDetails(passed=False), ) second_failure = DataValidationJobResult( validation_job=self._TEST_VALIDATIONS[2], result_details=FakeValidationResultDetails(passed=False), ) mock_run_job.side_effect = [ DataValidationJobResult( validation_job=self._TEST_VALIDATIONS[0], result_details=FakeValidationResultDetails(passed=True), ), first_failure, second_failure, DataValidationJobResult( validation_job=self._TEST_VALIDATIONS[3], result_details=FakeValidationResultDetails(passed=True), ), ] headers = {"X-Appengine-Cron": "test-cron"} response = self.client.get("/validate", headers=headers) self.assertEqual(200, response.status_code) self.assertNotEqual(_API_RESPONSE_IF_NO_FAILURES, response.get_data().decode()) self.assertEqual(4, mock_run_job.call_count) for job in self._TEST_VALIDATIONS: mock_run_job.assert_any_call(job) mock_rematerialize_views.assert_called() mock_emit_failures.assert_called_with( [], UnorderedCollection([first_failure, second_failure]) ) mock_store_validation_results.assert_called_once() self.assertEqual(1, len(mock_store_validation_results.call_args[0])) ((results,), _kwargs) = mock_store_validation_results.call_args self.assertEqual(4, len(results))
def test_create(self): """ You can create objects. """ ev = MagicMock() world = World(ev) obj = world.create('foo') self.assertIn('id', obj) self.assertEqual(obj['kind'], 'foo') self.assertEqual(obj, world.objects[obj['id']], "Should be in the " "objects list") ev.assert_any_call(Created(obj['id'])) ev.assert_any_call(AttrSet(obj['id'], 'kind', 'foo'))
def test_addItem(self): """ You can add items to a list """ ev = MagicMock() world = World(ev) obj = world.create('foo') ev.reset_mock() world.addItem(obj['id'], 'foo', 'bar') ev.assert_any_call(ItemAdded(obj['id'], 'foo', 'bar')) obj = world.get(obj['id']) self.assertEqual(obj['foo'], ['bar'])
def test_filter_trace(self): mock_filter = MagicMock() self.mf.filter = mock_filter mock_filter.side_effect = cycle([[sentinel.filtered_even] * 2, [sentinel.filtered_odd] * 2, [sentinel.filtered_recombined]]) trace_segment = [sentinel.trace_even, sentinel.trace_odd] filtered_trace = self.mf.filter_trace(trace_segment * 4) self.assertEqual(filtered_trace, [sentinel.filtered_recombined]) mock_filter.assert_any_call([sentinel.trace_even] * 4) mock_filter.assert_any_call([sentinel.trace_odd] * 4) mock_filter.assert_called_with( [sentinel.filtered_even, sentinel.filtered_odd] * 2)
def test_validator_call(self): validator = MagicMock() attr_val = { 'attr1': validator, 'attr2': validator, } with patch('bundlewrap.items.symlinks.ATTRIBUTE_VALIDATORS', new=attr_val): symlinks.Symlink.validate_attributes( MagicMock(), "symlink:/foo", {'attr1': 1, 'attr2': 2}, ) validator.assert_any_call("symlink:/foo", 1) validator.assert_any_call("symlink:/foo", 2) self.assertEqual(validator.call_count, 2)
def test_load_plugins(self): dir_name = os.path.realpath(os.path.join(__file__, '../../monitorrent')) walk_result = [ (dir_name, ['plugins'], ['__init__.py']), (os.path.join(dir_name, 'plugins'), [], ['__init__.py', 'plugin1.py', 'plugin2.py']), ] os_walk_mock = MagicMock(return_value=walk_result) import_mock = MagicMock() with patch('monitorrent.plugin_managers.os.walk', os_walk_mock), \ patch('monitorrent.plugin_managers.__import__', import_mock, create=True): load_plugins('plugins') self.assertTrue(os_walk_mock.call_count, 1) self.assertTrue(import_mock.call_count, 2) import_mock.assert_any_call('monitorrent.plugins.plugin1') import_mock.assert_any_call('monitorrent.plugins.plugin2')
def test_wait(self, waitpid_mock): exit_cb = MagicMock() waitpid_mock.side_effect = [('testpid1', 0), OSError(errno.ESRCH, 'No such pid'), OSError(99, 'Something else')] worker1 = MagicMock(queues=None, pid='testpid1') worker2 = MagicMock(queues=None, pid='testpid2') worker3 = MagicMock(queues=None, pid='testpid3') master = WorkerMaster('testapp', exit_callback=exit_cb) master.workers = [worker1, worker2, worker3] self.assertRaises(OSError, master.wait) waitpid_mock.assert_any_call('testpid1', 0) waitpid_mock.assert_any_call('testpid2', 0) waitpid_mock.assert_any_call('testpid3', 0) exit_cb.assert_any_call(None, 'testpid1', 0) exit_cb.assert_any_call(None, 'testpid2', None)
def test_main(): mock = MagicMock() with patch('builtins.print', new=mock): main() mock.assert_any_call(1) mock.assert_any_call("Fizz") mock.assert_any_call("Buzz") mock.assert_any_call("FizzBuzz") mock.assert_any_call(16)
def song_import_test(self): """ Test that a simulated WorshipCenter Pro recordset is imported correctly """ # GIVEN: A mocked out SongImport class, a mocked out pyodbc module with a simulated recordset, a mocked out # translate method, a mocked "manager", addVerse method & mocked_finish method. with patch('openlp.plugins.songs.lib.worshipcenterproimport.SongImport'), \ patch('openlp.plugins.songs.lib.worshipcenterproimport.pyodbc') as mocked_pyodbc, \ patch('openlp.plugins.songs.lib.worshipcenterproimport.translate') as mocked_translate: mocked_manager = MagicMock() mocked_import_wizard = MagicMock() mocked_add_verse = MagicMock() mocked_finish = MagicMock() mocked_pyodbc.connect().cursor().fetchall.return_value = RECORDSET_TEST_DATA mocked_translate.return_value = 'Translated Text' importer = WorshipCenterProImportLogger(mocked_manager) importer.import_source = 'import_source' importer.import_wizard = mocked_import_wizard importer.addVerse = mocked_add_verse importer.stop_import_flag = False importer.finish = mocked_finish # WHEN: Calling the doImport method return_value = importer.doImport() # THEN: doImport should return None, and pyodbc, import_wizard, importer.title and addVerse are called with # known calls self.assertIsNone(return_value, 'doImport should return None when pyodbc raises an exception.') mocked_pyodbc.connect.assert_called_with('DRIVER={Microsoft Access Driver (*.mdb)};DBQ=import_source') mocked_pyodbc.connect().cursor.assert_any_call() mocked_pyodbc.connect().cursor().execute.assert_called_with('SELECT ID, Field, Value FROM __SONGDATA') mocked_pyodbc.connect().cursor().fetchall.assert_any_call() mocked_import_wizard.progress_bar.setMaximum.assert_called_with(2) add_verse_call_count = 0 for song_data in SONG_TEST_DATA: title_value = song_data['title'] self.assertIn(title_value, importer._title_assignment_list, 'title should have been set to %s' % title_value) verse_calls = song_data['verses'] add_verse_call_count += len(verse_calls) for call in verse_calls: mocked_add_verse.assert_any_call(call) self.assertEqual(mocked_add_verse.call_count, add_verse_call_count, 'Incorrect number of calls made to addVerse')
def test_validator_call(self): validator = MagicMock() attr_val = { 'attr1': validator, 'attr2': validator, } with patch('bundlewrap.items.files.ATTRIBUTE_VALIDATORS', new=attr_val): files.File.validate_attributes( MagicMock(), "item:id", { 'attr1': 1, 'attr2': 2, }, ) validator.assert_any_call("item:id", 1) validator.assert_any_call("item:id", 2) self.assertEqual(validator.call_count, 2)
def test_destroy(self): """ You can destroy an object, and be notified about it. """ ev = MagicMock() world = World(ev) obj = world.create('foo') ev.reset_mock() called = [] world.receiveFor(obj['id'], called.append) world.destroy(obj['id']) ev.assert_any_call(Destroyed(obj['id'])) self.assertEqual(called, [Destroyed(obj['id'])], "Should notify things" " receiving events for the object") self.assertNotIn(obj['id'], world.objects)
def test_load_plugins(self): dir_name = os.path.dirname( os.path.realpath(os.path.join(__file__, '..'))) walk_result = [ (dir_name, ['plugins'], ['__init__.py']), (os.path.join(dir_name, 'plugins'), [], ['__init__.py', 'plugin1.py', 'plugin2.py']), ] os_walk_mock = MagicMock(return_value=walk_result) import_mock = MagicMock() with patch('monitorrent.plugin_managers.os.walk', os_walk_mock), \ patch('monitorrent.plugin_managers.__import__', import_mock, create=True): load_plugins('plugins') self.assertTrue(os_walk_mock.call_count, 1) self.assertTrue(import_mock.call_count, 2) import_mock.assert_any_call('monitorrent.plugins.plugin1') import_mock.assert_any_call('monitorrent.plugins.plugin2')
def test_destroy(self): """ You can destroy an object, and be notified about it. """ ev = MagicMock() world = World(ev) obj = world.create('foo') ev.reset_mock() called = [] world.receiveFor(obj['id'], called.append) world.destroy(obj['id']) ev.assert_any_call(Destroyed(obj['id'])) self.assertEqual( called, [Destroyed(obj['id'])], "Should notify things" " receiving events for the object") self.assertNotIn(obj['id'], world.objects)
def test_destroy_callbacks_are_called(self): ODMModel.set_pm(MagicMock()) dic = {"_id" : "2323", "pippo" : "pluto"} odm = ODMModel(dic) pippo = MagicMock() pluto = MagicMock() sempronio = MagicMock() ODMModel.listen("before_destroy", pippo) ODMModel.listen("before_destroy", sempronio) ODMModel.listen("after_destroy", sempronio) ODMModel.listen("after_destroy", pluto) odm.destroy() MagicMock.assert_called_once_with(pippo, odm) MagicMock.assert_called_once_with(pluto, odm) MagicMock.assert_any_call(sempronio, odm)
def test_destroy_callbacks_are_called(self): ODMModel.set_pm(MagicMock()) dic = {"_id": "2323", "pippo": "pluto"} odm = ODMModel(dic) pippo = MagicMock() pluto = MagicMock() sempronio = MagicMock() ODMModel.listen("before_destroy", pippo) ODMModel.listen("before_destroy", sempronio) ODMModel.listen("after_destroy", sempronio) ODMModel.listen("after_destroy", pluto) odm.destroy() MagicMock.assert_called_once_with(pippo, odm) MagicMock.assert_called_once_with(pluto, odm) MagicMock.assert_any_call(sempronio, odm)
def test_scan(self, connect_mock, network_mock): cata_ssh_mock = MagicMock() command_mock = MagicMock() cata_ssh_mock.cisco_command = command_mock command_mock.side_effect = ssh_catalyst_mock connect_mock.return_value = cata_ssh_mock ip = '11.11.11.11' network_mock.return_value = 'cata1' correct_ret = { 'status': 'success', 'plugin': 'ssh_cisco_catalyst', 'messages': [], 'device': { 'hostname': 'cata1', 'model_name': 'Cisco Catalyst SOME_CATA_MODEL', 'type': u'switch', 'serial_number': 'SOME-SN', 'mac_adresses': ['AB12BC235556', ], 'management_ip_addresses': [ip, ], 'parts': [ { 'serial_number': 'eth-sn1', 'name': 'GigabitEthernet0/45', 'label': '1000BaseSX SFP', }, { 'serial_number': 'eth-sn2', 'name': 'GigabitEthernet0/46', 'label': '1000BaseSX SFP', }, ], }, } ret = ssh_cisco_catalyst.scan_address(ip) correct_ret['date'] = ret['date'] # assuming datetime is working. self.assertEqual(ret, correct_ret) network_mock.assertCalledWith(ip) command_mock.assert_any_call( "show version | include Base ethernet MAC Address", ) command_mock.assert_any_call("show inventory") self.assertEqual(command_mock.call_count, 2)
def test_parallel_execution(self): # Fixture func = MagicMock() args_dict = { self.URI1: ['cf1-arg1'], self.URI2: ['cf2-arg1'], self.URI3: ['cf3-arg1'], } cf1 = self.factory.mocks[self.URI1] cf2 = self.factory.mocks[self.URI2] cf3 = self.factory.mocks[self.URI3] # Test self.sut.parallel(func, args_dict=args_dict) # Assert func.assert_any_call(cf1, 'cf1-arg1') func.assert_any_call(cf2, 'cf2-arg1') func.assert_any_call(cf3, 'cf3-arg1')
def test_ensure_webhook_remove(self): testee = BridgeProviderBitbucket({ 'username': '******', 'password': '******', 'incoming_token': 'glig', }) dest=MagicMock() def replacement_api(*args, **kwargs): if args[1].endswith('hooks/'): return [ { 'uuid': 1, 'url': 'http://me.com/bla', 'description': 'Greg2', 'skip_cert_verification': False, 'active': True, 'events': [u'pullrequest:comment_created', u'repo:push'], }, { 'uuid': 2, 'url': 'http://me.com/', 'description': 'Grog2', 'skip_cert_verification': False, 'active': True, 'events': [u'pullrequest:comment_created', u'repo:push'], } ] else: return dest(*args, **kwargs) testee.api = replacement_api testee.ensure_webhook('on','aboat','http://me.com') dest.assert_any_call('2.0','repositories/on/aboat/hooks/1',method='DELETE') dest.assert_any_call('2.0','repositories/on/aboat/hooks/2',method='DELETE') dest.assert_any_call('2.0','repositories/on/aboat/hooks',form_data={ 'url': 'http://me.com', 'description': 'Greg2', 'skip_cert_verification': False, 'active': True, 'events': [u'pullrequest:comment_created', u'repo:push'], },method='POST',request_type='json') self.assertEquals(dest.call_count,3)
def test_scan(self, connect_mock, tpl_mock): self.maxDiff = None now = "2013-09-20 11:48:33" tpl_mock.return_value = {"status": "unknown", "date": now, "plugin": "ssh_cisco_asa", "messages": []} ip = "10.10.10.10" asa_ssh_mock = MagicMock() command_mock = MagicMock() asa_ssh_mock.asa_command = command_mock command_mock.side_effect = cisco_asa_ssh_mock connect_mock.return_value = asa_ssh_mock correct_ret = { "status": "success", "plugin": "ssh_cisco_asa", "messages": [], "device": { "model_name": "Cisco SOME_ASA_MODEL", "type": "firewall", "serial_number": "SOME-SN", "mac_adresses": [ "AB12BC235556", "AB12BC235558", "DEF113DE4567", "DEF113DE4566", "DEF113DE5677", "DEF113DE5676", "DEF113DE6785", "DEF113DE6784", ], "boot_firmware": "SOME-BOOT-FIRMWARE", "management_ip_addresses": [ip], "memory": [{"size": 12288}], "processors": [{"model_name": "AMD Opteron", "speed": 2600}], }, } ret = ssh_cisco_asa.scan_address(ip) correct_ret["date"] = ret["date"] # assuming datetime is working. self.assertEqual(ret, correct_ret) command_mock.assert_any_call("show version | grep (^Hardware|Boot microcode|^Serial|address is)") command_mock.assert_any_call("show inventory") self.assertEqual(command_mock.call_count, 2)
def test_log_call_accepts_callable(self, logging): """flog.flog.log_call: Accepts a callable and calls it as if it were a logger function""" my_logger = MagicMock() randoa = random.randint(0, 500) randob = random.randint(0, 500) randoc = random.randint(0, 500) flog.log_call(my_logger)(self.instance_method)(randoa, randob, randoc, random_frippery_scale=32) # SUT my_logger.assert_any_call( "test_log_call.TestLogCall.instance_method: args: ({}, {}, {}), kwargs: {rfs}".format( randoa, randob, randoc, rfs="{'random_frippery_scale': 32}" ) ) my_logger.assert_any_call( "test_log_call.TestLogCall.instance_method: returns: {}".format(randoa + randob + randoc) )
def test_serialize_returns_expected(self): obj_with_ser = MagicMock(spec=object) mock_serialize = MagicMock(return_value={'a': 'b'}) obj_with_ser.attach_mock(mock_serialize, 'serialize') obj_without_ser = MagicMock(spec=object) class ICanSerialize(mixins.SerializableMixin): def __init__(self): self.attr1 = obj_with_ser self.attr2 = obj_without_ser serialize_me = ICanSerialize() actual = serialize_me.serialize() expected = {'attr1': {'a': 'b', }, 'attr2': obj_without_ser, } self.assertEqual(actual, expected) mock_serialize.assert_any_call()
def testFailoverToFirstRouteWhenIndexIsLastRoute(self, mockCreateRoute): mockOnTearDown = MagicMock() mockOnSetup = MagicMock() mockOnConnectionFailed = MagicMock() mockOnConnected = MagicMock() self.failoverRoute.onTearDown = mockOnTearDown self.defaultRoute.onSetup = mockOnSetup self.failoverRoute.onConnectionFailed = mockOnConnectionFailed self.defaultRoute.onConnected = mockOnConnected assert 0 == ifacefailover.failoverToNextRoute(self.routes, 1) mockCreateRoute.assert_called_once_with(self.defaultRoute) mockOnTearDown.assert_any_call() mockOnSetup.assert_any_call() mockOnConnectionFailed.assert_any_call() mockOnConnected.assert_any_call()