async def test_host_game_session(mock_execute_dialog: AsyncMock, skip_qtbot, default_online_interactions, mocker): # Setup mock_create_and_update: AsyncMock = mocker.patch( "randovania.gui.main_online_interaction.GameSessionWindow.create_and_update", new_callable=AsyncMock) mock_create_and_update.return_value = MagicMock() mock_get_game_connection = mocker.patch( "randovania.gui.lib.common_qt_lib.get_game_connection", autospec=True) default_online_interactions._ensure_logged_in = AsyncMock( return_value=True) mock_execute_dialog.return_value = QDialog.Accepted default_online_interactions.network_client.create_new_session = AsyncMock() # Run await default_online_interactions._host_game_session() # Assert mock_execute_dialog.assert_awaited_once() default_online_interactions.network_client.create_new_session.assert_awaited_once_with( "") mock_create_and_update.assert_awaited_once_with( default_online_interactions.network_client, mock_get_game_connection.return_value, default_online_interactions.preset_manager, default_online_interactions.window_manager, default_online_interactions.options, ) mock_create_and_update.return_value.show.assert_called_once_with()
async def test_attempt_join(mock_execute_dialog: AsyncMock, skip_qtbot): # Setup mock_execute_dialog.return_value = QDialog.Accepted network_client = MagicMock() network_client.join_game_session = AsyncMock() session_a = GameSessionListEntry(id=1, name="A Game", has_password=True, state=GameSessionState.FINISHED, num_players=1, creator="You") session_b = GameSessionListEntry(id=2, name="B Game", has_password=True, state=GameSessionState.IN_PROGRESS, num_players=1, creator="You") dialog = GameSessionBrowserDialog(network_client) dialog.sessions = [session_a, session_b] dialog.update_list() dialog.table_widget.selectRow(0) # Run await dialog.attempt_join() # Assert mock_execute_dialog.assert_awaited_once() network_client.join_game_session.assert_awaited_once_with(session_b, "")
async def test_run_scan(mocker: MockerFixture, tmp_path: Path, mock_bc_integration, scan_result): # given subprocess_async_mock = AsyncMock() subprocess_async_mock.return_value.communicate = AsyncMock(return_value=("test".encode(encoding="utf-8"), "test".encode(encoding="utf-8"))) subprocess_async_mock.return_value.wait = AsyncMock(return_value=0) mocker.patch("asyncio.create_subprocess_shell", side_effect=subprocess_async_mock) # prepare local paths app_temp_dir = tmp_path / "app" app_temp_dir.mkdir() output_path = app_temp_dir / "requirements_result.json" output_path.write_text(json.dumps(scan_result)) # when result = await Scanner().run_scan( command="./twistcli coderepo scan", input_path=app_temp_dir / "requirements.txt", output_path=output_path, ) # then assert result == scan_result assert not output_path.exists() subprocess_async_mock.assert_awaited_once()
async def test_attempt_join(mock_execute_dialog: AsyncMock, skip_qtbot): # Setup utc = datetime.timezone.utc mock_execute_dialog.return_value = QDialog.Accepted network_client = MagicMock() network_client.join_game_session = AsyncMock() session_a = GameSessionListEntry( id=1, name="A Game", has_password=True, state=GameSessionState.FINISHED, num_players=1, creator="You", creation_date=datetime.datetime(year=2015, month=5, day=1, tzinfo=utc)) session_b = GameSessionListEntry(id=2, name="B Game", has_password=True, state=GameSessionState.IN_PROGRESS, num_players=1, creator="You", creation_date=datetime.datetime.now(utc) - datetime.timedelta(days=4)) dialog = GameSessionBrowserDialog(network_client) dialog.sessions = [session_a, session_b] dialog.update_list() dialog.table_widget.selectRow(0) # Run await dialog.attempt_join() # Assert mock_execute_dialog.assert_awaited_once() network_client.join_game_session.assert_awaited_once_with(session_b, "")
async def test_run_scan(mocker: MockerFixture, tmp_path: Path, mock_bc_integration, scan_result): # given bc_api_key = "abcd1234-abcd-1234-abcd-1234abcd1234" subprocess_async_mock = AsyncMock() subprocess_async_mock.return_value.wait = AsyncMock(return_value=0) mocker.patch("asyncio.create_subprocess_shell", side_effect=subprocess_async_mock) report_results_async_mock = AsyncMock(return_value=0) mocker.patch( "checkov.common.bridgecrew.vulnerability_scanning.integrations.package_scanning.package_scanning_integration.report_results_async", side_effect=report_results_async_mock, ) # prepare local paths app_temp_dir = tmp_path / "app" app_temp_dir.mkdir() output_path = app_temp_dir / "requirements_result.json" output_path.write_text(json.dumps(scan_result)) # when result = await PackageScanner().run_scan( command="./twistcli coderepo scan", bc_platform_integration=mock_bc_integration, bc_api_key=bc_api_key, input_path=app_temp_dir / "requirements.txt", output_path=output_path, ) # then assert result == 0 assert not output_path.exists() subprocess_async_mock.assert_awaited_once() report_results_async_mock.assert_awaited_once()
async def test_run_scan_fail_on_scan(mocker: MockerFixture, mock_bc_integration): # given bc_api_key = "abcd1234-abcd-1234-abcd-1234abcd1234" subprocess_async_mock = AsyncMock() subprocess_async_mock.return_value.wait = AsyncMock(return_value=1) mocker.patch("asyncio.create_subprocess_shell", side_effect=subprocess_async_mock) report_results_async_mock = AsyncMock(return_value=0) mocker.patch( "checkov.common.bridgecrew.vulnerability_scanning.integrations.package_scanning.package_scanning_integration.report_results_async", side_effect=report_results_async_mock, ) # when result = await PackageScanner().run_scan( command="./twistcli coderepo scan", bc_platform_integration=mock_bc_integration, bc_api_key=bc_api_key, input_path=Path("app/requirements.txt"), output_path=Path("app/requirements_result.json"), ) # then assert result == 1 subprocess_async_mock.assert_awaited_once() report_results_async_mock.assert_not_awaited()
async def test_run_scan_fail_on_scan(mocker: MockerFixture, mock_bc_integration): # given subprocess_async_mock = AsyncMock() subprocess_async_mock.return_value.communicate = AsyncMock(return_value=("test".encode(encoding="utf-8"), "test".encode(encoding="utf-8"))) subprocess_async_mock.return_value.wait = AsyncMock(return_value=1) mocker.patch("asyncio.create_subprocess_shell", side_effect=subprocess_async_mock) # when result = await Scanner().run_scan( command="./twistcli coderepo scan", input_path=Path("app/requirements.txt"), output_path=Path("app/requirements_result.json"), ) # then assert result == {} subprocess_async_mock.assert_awaited_once()
class AsyncMockAssert(unittest.TestCase): def setUp(self): self.mock = AsyncMock() async def _runnable_test(self, *args, **kwargs): await self.mock(*args, **kwargs) async def _await_coroutine(self, coroutine): return await coroutine def test_assert_called_but_not_awaited(self): mock = AsyncMock(AsyncClass) with assertNeverAwaited(self): mock.async_method() self.assertTrue(iscoroutinefunction(mock.async_method)) mock.async_method.assert_called() mock.async_method.assert_called_once() mock.async_method.assert_called_once_with() with self.assertRaises(AssertionError): mock.assert_awaited() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() def test_assert_called_then_awaited(self): mock = AsyncMock(AsyncClass) mock_coroutine = mock.async_method() mock.async_method.assert_called() mock.async_method.assert_called_once() mock.async_method.assert_called_once_with() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() run(self._await_coroutine(mock_coroutine)) # Assert we haven't re-called the function mock.async_method.assert_called_once() mock.async_method.assert_awaited() mock.async_method.assert_awaited_once() mock.async_method.assert_awaited_once_with() def test_assert_called_and_awaited_at_same_time(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() run(self._runnable_test()) self.mock.assert_called_once() self.mock.assert_awaited_once() def test_assert_called_twice_and_awaited_once(self): mock = AsyncMock(AsyncClass) coroutine = mock.async_method() # The first call will be awaited so no warning there # But this call will never get awaited, so it will warn here with assertNeverAwaited(self): mock.async_method() with self.assertRaises(AssertionError): mock.async_method.assert_awaited() mock.async_method.assert_called() run(self._await_coroutine(coroutine)) mock.async_method.assert_awaited() mock.async_method.assert_awaited_once() def test_assert_called_once_and_awaited_twice(self): mock = AsyncMock(AsyncClass) coroutine = mock.async_method() mock.async_method.assert_called_once() run(self._await_coroutine(coroutine)) with self.assertRaises(RuntimeError): # Cannot reuse already awaited coroutine run(self._await_coroutine(coroutine)) mock.async_method.assert_awaited() def test_assert_awaited_but_not_called(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() with self.assertRaises(TypeError): # You cannot await an AsyncMock, it must be a coroutine run(self._await_coroutine(self.mock)) with self.assertRaises(AssertionError): self.mock.assert_awaited() with self.assertRaises(AssertionError): self.mock.assert_called() def test_assert_has_calls_not_awaits(self): kalls = [call('foo')] with assertNeverAwaited(self): self.mock('foo') self.mock.assert_has_calls(kalls) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(kalls) def test_assert_has_mock_calls_on_async_mock_no_spec(self): with assertNeverAwaited(self): self.mock() kalls_empty = [('', (), {})] self.assertEqual(self.mock.mock_calls, kalls_empty) with assertNeverAwaited(self): self.mock('foo') with assertNeverAwaited(self): self.mock('baz') mock_kalls = ([call(), call('foo'), call('baz')]) self.assertEqual(self.mock.mock_calls, mock_kalls) def test_assert_has_mock_calls_on_async_mock_with_spec(self): a_class_mock = AsyncMock(AsyncClass) with assertNeverAwaited(self): a_class_mock.async_method() kalls_empty = [('', (), {})] self.assertEqual(a_class_mock.async_method.mock_calls, kalls_empty) self.assertEqual(a_class_mock.mock_calls, [call.async_method()]) with assertNeverAwaited(self): a_class_mock.async_method(1, 2, 3, a=4, b=5) method_kalls = [call(), call(1, 2, 3, a=4, b=5)] mock_kalls = [ call.async_method(), call.async_method(1, 2, 3, a=4, b=5) ] self.assertEqual(a_class_mock.async_method.mock_calls, method_kalls) self.assertEqual(a_class_mock.mock_calls, mock_kalls) def test_async_method_calls_recorded(self): with assertNeverAwaited(self): self.mock.something(3, fish=None) with assertNeverAwaited(self): self.mock.something_else.something(6, cake=sentinel.Cake) self.assertEqual(self.mock.method_calls, [("something", (3, ), { 'fish': None }), ("something_else.something", (6, ), { 'cake': sentinel.Cake })], "method calls not recorded correctly") self.assertEqual(self.mock.something_else.method_calls, [("something", (6, ), { 'cake': sentinel.Cake })], "method calls not recorded correctly") def test_async_arg_lists(self): def assert_attrs(mock): names = ('call_args_list', 'method_calls', 'mock_calls') for name in names: attr = getattr(mock, name) self.assertIsInstance(attr, _CallList) self.assertIsInstance(attr, list) self.assertEqual(attr, []) assert_attrs(self.mock) with assertNeverAwaited(self): self.mock() with assertNeverAwaited(self): self.mock(1, 2) with assertNeverAwaited(self): self.mock(a=3) self.mock.reset_mock() assert_attrs(self.mock) a_mock = AsyncMock(AsyncClass) with assertNeverAwaited(self): a_mock.async_method() with assertNeverAwaited(self): a_mock.async_method(1, a=3) a_mock.reset_mock() assert_attrs(a_mock) def test_assert_awaited(self): with self.assertRaises(AssertionError): self.mock.assert_awaited() run(self._runnable_test()) self.mock.assert_awaited() def test_assert_awaited_once(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once() run(self._runnable_test()) self.mock.assert_awaited_once() run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_awaited_once() def test_assert_awaited_with(self): msg = 'Not awaited' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') run(self._runnable_test()) msg = 'expected await not found' with self.assertRaisesRegex(AssertionError, msg): self.mock.assert_awaited_with('foo') run(self._runnable_test('foo')) self.mock.assert_awaited_with('foo') run(self._runnable_test('SomethingElse')) with self.assertRaises(AssertionError): self.mock.assert_awaited_with('foo') def test_assert_awaited_once_with(self): with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') run(self._runnable_test('foo')) self.mock.assert_awaited_once_with('foo') run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_awaited_once_with('foo') def test_assert_any_wait(self): with self.assertRaises(AssertionError): self.mock.assert_any_await('foo') run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_any_await('foo') run(self._runnable_test('foo')) self.mock.assert_any_await('foo') run(self._runnable_test('SomethingElse')) self.mock.assert_any_await('foo') def test_assert_has_awaits_no_order(self): calls = [call('foo'), call('baz')] with self.assertRaises(AssertionError) as cm: self.mock.assert_has_awaits(calls) self.assertEqual(len(cm.exception.args), 1) run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) run(self._runnable_test('foo')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls) run(self._runnable_test('baz')) self.mock.assert_has_awaits(calls) run(self._runnable_test('SomethingElse')) self.mock.assert_has_awaits(calls) def test_awaits_asserts_with_any(self): class Foo: def __eq__(self, other): pass run(self._runnable_test(Foo(), 1)) self.mock.assert_has_awaits([call(ANY, 1)]) self.mock.assert_awaited_with(ANY, 1) self.mock.assert_any_await(ANY, 1) def test_awaits_asserts_with_spec_and_any(self): class Foo: def __eq__(self, other): pass mock_with_spec = AsyncMock(spec=Foo) async def _custom_mock_runnable_test(*args): await mock_with_spec(*args) run(_custom_mock_runnable_test(Foo(), 1)) mock_with_spec.assert_has_awaits([call(ANY, 1)]) mock_with_spec.assert_awaited_with(ANY, 1) mock_with_spec.assert_any_await(ANY, 1) def test_assert_has_awaits_ordered(self): calls = [call('foo'), call('baz')] with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) run(self._runnable_test('baz')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) run(self._runnable_test('bamf')) with self.assertRaises(AssertionError): self.mock.assert_has_awaits(calls, any_order=True) run(self._runnable_test('foo')) self.mock.assert_has_awaits(calls, any_order=True) run(self._runnable_test('qux')) self.mock.assert_has_awaits(calls, any_order=True) def test_assert_not_awaited(self): self.mock.assert_not_awaited() run(self._runnable_test()) with self.assertRaises(AssertionError): self.mock.assert_not_awaited() def test_assert_has_awaits_not_matching_spec_error(self): async def f(x=None): pass self.mock = AsyncMock(spec=f) run(self._runnable_test(1)) with self.assertRaisesRegex( AssertionError, '^{}$'.format( re.escape('Awaits not found.\n' 'Expected: [call()]\n' 'Actual: [call(1)]'))) as cm: self.mock.assert_has_awaits([call()]) self.assertIsNone(cm.exception.__cause__) with self.assertRaisesRegex( AssertionError, '^{}$'.format( re.escape('Error processing expected awaits.\n' "Errors: [None, TypeError('too many positional " "arguments')]\n" 'Expected: [call(), call(1, 2)]\n' 'Actual: [call(1)]').replace( "arguments\\'", "arguments\\',?"))) as cm: self.mock.assert_has_awaits([call(), call(1, 2)]) self.assertIsInstance(cm.exception.__cause__, TypeError)
async def test_async_run(): coro = AsyncMock() f = WrappedFunction(coro, name='coro_mock') f.run() await asyncio.sleep(0.05) coro.assert_awaited_once()