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