def test_notification_message(self): self.notif.setText("Hello world! It's so nice here") QApplication.sendPostedEvents(self.notif, QEvent.LayoutRequest) self.assertTrue(self.notif.geometry().isValid()) button_ok = self.notif.button(NotificationWidget.Ok) button_close = self.notif.button(NotificationWidget.Close) self.assertTrue(all([button_ok, button_close])) self.assertIs(self.notif.button(NotificationWidget.Ok), button_ok) self.assertIs(self.notif.button(NotificationWidget.Close), button_close) button = self.notif.button(NotificationWidget.Ok) self.assertIsNot(button, None) self.assertTrue(self.notif.buttonRole(button), NotificationWidget.AcceptRole) mock = unittest.mock.MagicMock() self.notif.accepted.connect(mock) NotificationOverlay.registerNotification(self.notif) cloned = NotificationOverlay.overlayInstances[0].currentWidget() self.assertTrue(cloned.isVisible()) button = cloned._msgwidget.button(NotificationWidget.Ok) QTest.mouseClick(button, Qt.LeftButton) self.assertFalse(cloned.isVisible()) mock.assert_called_once()
def test_events_analyzer(self): start_events_analyzer(_registry=self.events_processes_registry) events_analyzer = get_events_process( name=EVENTS_ANALYZER_ID, _registry=self.events_processes_registry) time.sleep(EVENTS_SUBSCRIBERS_START_DELAY) try: self.assertIsInstance(events_analyzer, EventsAnalyzer) self.assertTrue(events_analyzer.is_alive()) self.assertEqual(events_analyzer._registry, self.events_main_device._registry) self.assertEqual(events_analyzer._registry, self.events_processes_registry) event1 = InfoEvent(message="m1") event2 = SpotTerminationEvent(node="n1", message="m2") with unittest.mock.patch( "sdcm.sct_events.events_analyzer.EventsAnalyzer.kill_test" ) as mock: with self.wait_for_n_events(events_analyzer, count=2, timeout=1): self.events_main_device.publish_event(event1) self.events_main_device.publish_event(event2) self.assertEqual(self.events_main_device.events_counter, events_analyzer.events_counter) mock.assert_called_once() finally: events_analyzer.stop(timeout=1)
def test_success_goes_to_view(self, mock: MagicMock) -> None: path = ( "recap/dev.gov.uscourts.txnd.28766/gov.uscourts.txnd.28766.1.0.pdf" ) r = self.client.get(self.url, {"file_path": path}) self.assertEqual(r.status_code, HTTP_200_OK) mock.assert_called_once()
def test_energy_graph_show(self, mock): """Test used to check that plt.show is called within the energy_graph method Uses mocking """ Animation.energy_graph_comparisson(100) mock.assert_called_once()
def test_extract_find_dups_once_only_with_many_files(self, mock): with test_utils.capture('stdout', 'stderr') as (stdout, stderr): test_utils.run_with_args(extract_main, [self.config_filename, path.join(self.tempdir, 'Downloads')], extract.__file__) output = stdout.getvalue() mock.assert_called_once()
def test_scatterplot_show(self, mock): """Test used to prove that plt.show() is called once in scatter_plot method uses mocking """ self.system_probe = SolarSystem(3600, 10000, Options.PROBE_RUN, "CelestialObjects") animate = Animation(self.system_probe) animate.scatter_plot(100) mock.assert_called_once()
def test_gsheets_periodically_process_pending_rows_workbook_space_needed(gsheets_handler_no_thread): def side_effect(): gsheets_handler_no_thread.close() raise WorkbookSpaceNeededError with unittest.mock.patch.object(gsheets_handler_no_thread, 'process_pending_rows', side_effect=side_effect): with unittest.mock.patch.object(gsheets_handler_no_thread, '_handle_workbook_space_needed_error') as mock: gsheets_handler_no_thread._periodically_process_pending_rows() mock.assert_called_once()
def test_gsheets_periodically_process_pending_rows_resource_exhausted(gsheets_handler_no_thread): def side_effect(): gsheets_handler_no_thread.close() raise ResourceExhaustedError with unittest.mock.patch.object(gsheets_handler_no_thread, 'process_pending_rows', side_effect=side_effect): with unittest.mock.patch.object(google_sheets_handler, '_handle_resource_exhausted_error') as mock: gsheets_handler_no_thread._periodically_process_pending_rows() mock.assert_called_once()
def test_edit(self, mock: mock.Mock): # test 1 mock.return_value = file_to_json("edit") self.assertTrue( self.wiki.edit("User:Fastily", "Text foobar", "example summary")) mock.assert_called_once() # test 2 with self.assertRaises(ValueError): self.wiki.edit("Foo")
def test_gsheets_periodically_process_pending_rotate_on_too_many_rows(gsheets_handler_no_thread): def side_effect(): gsheets_handler_no_thread.close() gsheets_handler_no_thread.rows_in_active_sheet = 9999999999999 with unittest.mock.patch.object(gsheets_handler_no_thread, 'process_pending_rows', side_effect=side_effect): with unittest.mock.patch.object(gsheets_handler_no_thread, '_rotate_to_new_sheet_in_workbook') as mock: gsheets_handler_no_thread._periodically_process_pending_rows() mock.assert_called_once()
def test_execute_inits_build_report_with_completed_order(self): o = self.o.assign('bob') t = time.localtime() with unittest.mock.patch.object(build_report, 'BuildReport') as mock, \ unittest.mock.patch('time.localtime', new=lambda: t): self.bs.execute(order=o, source_oid=None, cwd='.') mock.assert_called_once(order=o.complete()) args, kwargs = mock.call_args self.assertIn('order', kwargs) self.assertEqual(kwargs['order'], o.complete())
def test_handler_called(): class TestEventsProcessor(EventsProcessor): @handler() def handler_with_no_predicate(self, _: Event) -> None: mock() mock = unittest.mock.Mock() processor = TestEventsProcessor() asyncio.get_event_loop().run_until_complete(processor.process_event( {})) mock.assert_called_once()
def test_extract_archive_defer_to_decompress(self): filename = "foo" for ext, remove_finished in itertools.product((".gz", ".xz"), (True, False)): with self.subTest(ext=ext, remove_finished=remove_finished): with unittest.mock.patch("torchvision.datasets.utils._decompress") as mock: file = f"{filename}{ext}" utils.extract_archive(file, remove_finished=remove_finished) mock.assert_called_once() self.assertEqual( call_args_to_kwargs_only(mock.call_args, utils._decompress), dict(from_path=file, to_path=filename, remove_finished=remove_finished), )
def assert_mock_called_once(self, mock): """assert that the mock was called only once. The `mock.assert_called_once()` method was added in PY36. TODO: Remove this when PY35 support is dropped. """ try: mock.assert_called_once() except AttributeError: if not mock.call_count == 1: msg = ("Expected '%s' to have been called once. Called %s times." % (mock._mock_name or 'mock', self.call_count)) raise AssertionError(msg)
def start_rpc(self, filters, ws, RPC): RPC.register(ws) for ft in filters: RPC.filter_manager.register(ft, NOPMessage, backoff=ft.backoff) yield RPC RPC.unregister(ws) for mock in [ RPC.poll, RPC.register, RPC.unregister, RPC.filter_manager.setup_event_filters ]: mock.assert_called_once() assert len(RPC.filter_manager.pool) == 0 assert len(RPC.websockets) == 0
def test_gsheets_handle_workbook_space_needed(gsheets_handler_no_thread): class FakeWorksheet: def __init__(self, title): self.title = title def __eq__(self, other): return self.title == other.title worksheets = [FakeWorksheet('log2'), FakeWorksheet('log0'), FakeWorksheet('log1')] with unittest.mock.patch.object(gsheets_handler_no_thread.workbook, 'worksheets', return_value=worksheets) as mock: with unittest.mock.patch.object(gsheets_handler_no_thread.workbook, 'del_worksheet') as del_wks_mock: gsheets_handler_no_thread._handle_workbook_space_needed_error() mock.assert_called_once() del_wks_mock.assert_called_once_with(FakeWorksheet('log2'))
def test_gsheets_periodically_process_pending_top_level_error_leads_to_resource_exhaustion_handling(gsheets_handler_no_thread): def side_effect(): gsheets_handler_no_thread.close() # force rotation logic to hit gsheets_handler_no_thread.rows_in_active_sheet = 9999999999999 with unittest.mock.patch.object(gsheets_handler_no_thread, 'process_pending_rows', side_effect=side_effect): with unittest.mock.patch.object(google_sheets_handler, '_handle_resource_exhausted_error') as mock: with unittest.mock.patch.object(gsheets_handler_no_thread, '_rotate_to_new_sheet_in_workbook', side_effect=EnvironmentError) as mock2: gsheets_handler_no_thread._periodically_process_pending_rows() mock.assert_called_once() mock2.assert_called_once()
def test_set_globalplaceholderfile(self): """ Should store file in _globalplaceholderfile Should call _initialize_global_placeholders() :return: """ from businesslogic.placeholders import Placeholder expected_file = "dummy" mock = MagicMock(return_value=None) with patch('businesslogic.placeholders.path.exists', MagicMock(return_value=True)): with patch('businesslogic.placeholders.Placeholder._initialize_global_placeholders', mock): Placeholder.set_globalplaceholderfile(expected_file) mock.assert_called_once() self.assertEqual(expected_file, Placeholder._globalplaceholderfile)
def test_approve_order_anymail_error( superuser_api_client, payment_provider, notification_template_orders_approved, order: Order, ): order.status = OrderStatus.DRAFTED order.save(update_fields=["status"]) order_id = to_global_id(OrderNode, order.id) previous_order_status = order.status previous_lease_status = order.lease.status previous_application_status = order.lease.application.status variables = { "orders": [{ "orderId": order_id, "email": "*****@*****.**" }], } with patch( "customers.services.profile.requests.post", side_effect=mocked_response_profile(count=1, data=None, use_edges=False), ): with patch( "payments.utils.send_notification", side_effect=AnymailError("Anymail error"), ) as mock: executed = superuser_api_client.execute(APPROVE_ORDER_MUTATION, input=variables) mock.assert_called_once() assert len(executed["data"]["approveOrders"]["failedOrders"]) == 1 assert executed["data"]["approveOrders"]["failedOrders"][0] == { "id": order_id, "error": "Anymail error", } order = Order.objects.get(id=order.id) assert order.status == previous_order_status assert order.lease.status == previous_lease_status.value assert order.lease.application.status == previous_application_status
def test_training_instance_norm( preprocessor_mocks, optimizer_mocks, style_transforms_mocks, transformer_mocks, perceptual_loss_mocks, default_transformer_optim_loop_patch, training, impl_params, instance_norm, ): mock, _ = transformer_mocks training(impl_params=impl_params, instance_norm=instance_norm) mock.assert_called_once() _, kwargs = mock.call_args if instance_norm is None: assert kwargs["instance_norm"] is impl_params else: assert kwargs["instance_norm"] is instance_norm
def test_login_and_get_gspread(): google_sheets_handler._GSPREAD = 45 assert _login_and_get_gspread(None) == 45 google_sheets_handler._GSPREAD = None with pytest.raises(FileNotFoundError): _login_and_get_gspread('/asdasd/asdffasfd/fgasfdfa/fdasfadsf/dsafadsfasdf/afds/cvx') google_sheets_handler._GSPREAD = None with unittest.mock.patch.object(gspread, 'service_account') as mock: ret = _login_and_get_gspread(__file__) assert isinstance(ret, unittest.mock.Mock) assert ret._login_type == 'service_account' google_sheets_handler._GSPREAD = None with unittest.mock.patch.object(gspread, 'service_account', side_effect=ValueError()): with unittest.mock.patch.object(gspread, 'oauth') as mock: ret = _login_and_get_gspread(__file__) mock.assert_called_once() assert isinstance(ret, unittest.mock.Mock) assert ret._login_type == 'user_oauth' google_sheets_handler._GSPREAD = None
def test_gsheets_add_rows_to_active_sheet_set_coerce_to_correct_exceptions(gsheets_handler_no_thread): with unittest.mock.patch.object(gsheets_handler_no_thread.sheet, 'append_rows', side_effect=Exception("RESOURCE_EXHAUSTED uh-oh")) as mock: with pytest.raises(ResourceExhaustedError): gsheets_handler_no_thread._add_rows_to_active_sheet([]) mock.assert_called_once() with unittest.mock.patch.object(gsheets_handler_no_thread.sheet, 'append_rows', side_effect=Exception("UNAVAILABLE uh-oh")) as mock: with pytest.raises(ResourceExhaustedError): gsheets_handler_no_thread._add_rows_to_active_sheet([]) mock.assert_called_once() with unittest.mock.patch.object(gsheets_handler_no_thread.sheet, 'append_rows', side_effect=Exception("INVALID_ARGUMENT YOU ARE ABOVE THE LIMIT")) as mock: with pytest.raises(WorkbookSpaceNeededError): gsheets_handler_no_thread._add_rows_to_active_sheet([]) mock.assert_called_once() e = EnvironmentError("other thing") with unittest.mock.patch.object(gsheets_handler_no_thread.sheet, 'append_rows', side_effect=e) as mock: with pytest.raises(EnvironmentError): gsheets_handler_no_thread._add_rows_to_active_sheet([]) mock.assert_called_once()
def test_extract_find_dups_once_only_with_many_files(self, mock): result = self.ingest('extract', path.join(self.tempdir, 'Downloads')) mock.assert_called_once()
def test_skipping_s3_storage_decorator_with_s3_storage(self): mock = MagicMock() skip_if_s3_storage_not_used(mock)() mock.assert_called_once()
def test_gsheets_init_calls_make_owner_if_not_already_if_email_given(gsheets_handler_no_thread): with unittest.mock.patch.object(gsheets_handler_no_thread, '_make_owner_if_not_already') as mock: gsheets_handler_no_thread.__init__('test') mock.assert_not_called() gsheets_handler_no_thread.__init__('test', share_email='*****@*****.**') mock.assert_called_once()
def test_undelete(self, mock: mock.Mock): mock.return_value = file_to_json("undelete") self.assertTrue( self.wiki.undelete("User:Fastily", "testing undeletion")) mock.assert_called_once()
def test_delete(self, mock: mock.Mock): mock.return_value = file_to_json("delete") self.assertTrue(self.wiki.delete("User:Fastily", "foobar")) mock.assert_called_once()
def test__union_sub_type_to_protobuf_variable_name_tuple(self, mock): """Test _union_sub_type_to_protobuf_variable_name method tuple.""" pytest.skip() _union_sub_type_to_protobuf_variable_name("content_name", "Tuple[str, ...]") mock.assert_called_once()