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