intuned-runtime 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

intuned_cli/controller/__test__/test_authsession.py

@@ -1,14 +1,21 @@
+import asyncio
 from dataclasses import dataclass
 from typing import Any
+from typing import Awaitable
+from typing import Callable
+from typing import cast
 from typing import Generator
 from unittest.mock import AsyncMock
+from unittest.mock import MagicMock
 from unittest.mock import Mock
 from unittest.mock import patch
 
 import pytest
 
+from intuned_cli.controller.api import get_cli_run_options
 from intuned_cli.controller.authsession import execute_attempt_check_auth_session_cli
 from intuned_cli.controller.authsession import execute_attempt_create_auth_session_cli
+from intuned_cli.controller.authsession import execute_record_auth_session_cli
 from intuned_cli.controller.authsession import execute_run_create_auth_session_cli
 from intuned_cli.controller.authsession import execute_run_update_auth_session_cli
 from intuned_cli.controller.authsession import execute_run_validate_auth_session_cli
@@ -20,8 +27,7 @@ from intuned_cli.utils.error import CLIError
 from runtime.errors.run_api_errors import AutomationError
 from runtime.types.run_types import ProxyConfig
 from runtime.types.run_types import StorageState
-
-from .test_api import AsyncContextManagerMock
+from runtime.types.run_types import TracingDisabled
 
 
 def get_mock_console():
@@ -88,6 +94,8 @@ def shared_mocks() -> Generator[SharedMocks, Any, None]:
 class AttemptApiMocks:
     extendable_timeout: AsyncMock
     run_api: AsyncMock
+    cli_trace: AsyncMock
+    get_cli_run_options: AsyncMock
 
 
 @pytest.fixture
@@ -95,13 +103,19 @@ def attempt_api_mocks() -> Generator[AttemptApiMocks, Any, None]:
     """Mock dependencies for attempt_api tests."""
     _mock_timeout_patch = patch("intuned_cli.controller.authsession.extendable_timeout")
     _mock_run_api_patch = patch("intuned_cli.controller.authsession.run_api", new_callable=AsyncMock)
+    _mock_cli_trace_patch = patch("intuned_cli.controller.authsession.cli_trace")
+    _mock_get_cli_run_options_patch = patch(
+        "intuned_cli.controller.authsession.get_cli_run_options", new_callable=AsyncMock
+    )
 
     with (
         _mock_timeout_patch as mock_timeout,
         _mock_run_api_patch as mock_run_api,
+        _mock_cli_trace_patch as mock_cli_trace,
+        _mock_get_cli_run_options_patch as mock_get_cli_run_options,
     ):
         # Setup default return values
-        mock_timeout.return_value = AsyncContextManagerMock()
+        mock_timeout.return_value = MagicMock()
 
         # Mock run_api to return success by default
         mock_result = Mock()
@@ -109,9 +123,21 @@ def attempt_api_mocks() -> Generator[AttemptApiMocks, Any, None]:
         mock_result.payload_to_append = []
         mock_run_api.return_value = mock_result
 
+        mock_cli_trace_return_value = MagicMock()
+        mock_cli_trace_return_value.__enter__.return_value = TracingDisabled()
+        mock_cli_trace.return_value = mock_cli_trace_return_value
+
+        async def get_cli_run_options_side_effect(*args: Any, **kwargs: Any):
+            kwargs["keep_browser_open"] = False
+            return await get_cli_run_options(*args, **kwargs)
+
+        mock_get_cli_run_options.side_effect = get_cli_run_options_side_effect
+
         yield AttemptApiMocks(
             extendable_timeout=mock_timeout,
             run_api=mock_run_api,
+            cli_trace=mock_cli_trace,
+            get_cli_run_options=mock_get_cli_run_options,
         )
 
 
@@ -184,6 +210,70 @@ def execute_cli_mocks() -> Generator[ExecuteCLIMocks, Any, None]:
         )
 
 
+@dataclass
+class RecordAuthSessionMocks:
+    launch_chromium: AsyncMock
+    page: Mock
+    browser_context: Mock
+    # asyncio_sleep: AsyncMock
+    resolve_sleep: Callable[[], Awaitable[None]]
+
+
+@pytest.fixture
+def record_auth_session_mocks() -> Generator[RecordAuthSessionMocks, Any, None]:
+    """Mock dependencies for execute_record_auth_session_cli tests."""
+    from asyncio import sleep as original_sleep
+
+    _mock_launch_chromium = patch("runtime.browser.launch_chromium")
+    _mock_asyncio_sleep = patch("asyncio.sleep", new_callable=AsyncMock)
+    _mock_asyncio_timeout = patch("asyncio.timeout")
+    _mock_get_storage_state = patch("intuned_cli.controller.authsession.get_storage_state", new_callable=AsyncMock)
+
+    with (
+        _mock_launch_chromium as mock_launch_chromium,
+        _mock_asyncio_sleep as _mock_asyncio_sleep,
+        _mock_asyncio_timeout as _mock_asyncio_timeout,
+        _mock_get_storage_state as _mock_get_storage_state,
+    ):
+        mock_launch_chromium_return_value = Mock()
+        mock_page = Mock()
+        mock_page.url = ""
+        mock_page.wait_for_load_state = AsyncMock(return_value=None)
+        mock_page.goto = AsyncMock(return_value=None)
+
+        mock_browser_context = Mock()
+        mock_browser_context.pages = [mock_page]
+
+        mock_launch_chromium_return_value.__aenter__ = AsyncMock(return_value=(mock_browser_context, mock_page))
+        mock_launch_chromium_return_value.__aexit__ = AsyncMock(return_value=None)
+        mock_launch_chromium.return_value = mock_launch_chromium_return_value
+
+        mock_asyncio_timeout_return_value = MagicMock()
+        mock_asyncio_timeout_return_value.__aenter__.return_value = MagicMock()
+        _mock_asyncio_timeout.__aenter__.return_value = mock_asyncio_timeout_return_value
+
+        sleep_future: asyncio.Future[Any] = cast(asyncio.Future[Any], None)
+
+        async def asyncio_sleep_side_effect(_):
+            nonlocal sleep_future
+            await original_sleep(0)
+            sleep_future = asyncio.Future()
+
+        _mock_asyncio_sleep.side_effect = asyncio_sleep_side_effect
+
+        async def resolve_sleep_future():
+            await original_sleep(0)
+            if sleep_future:
+                sleep_future.set_result(None)
+
+        yield RecordAuthSessionMocks(
+            launch_chromium=mock_launch_chromium,
+            page=mock_page,
+            browser_context=mock_browser_context,
+            resolve_sleep=resolve_sleep_future,
+        )
+
+
 class TestRunCheck:
     """Test suite for Auth Session controller functions."""
 
@@ -194,10 +284,71 @@ class TestRunCheck:
             auth=_get_empty_auth_session(),
             headless=False,
             timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
         )
 
         attempt_api_mocks.extendable_timeout.assert_called_once_with(6000)
 
+    @pytest.mark.asyncio
+    async def test_uses_trace_context_manager(self, attempt_api_mocks: AttemptApiMocks):
+        """Test that attempt_api uses the trace context manager."""
+        # Import inside test to avoid circular import issues
+
+        await run_check(
+            auth=_get_empty_auth_session(),
+            headless=False,
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.cli_trace.assert_called_once_with(None)
+
+        attempt_api_mocks.cli_trace.reset_mock()
+        await run_check(
+            auth=_get_empty_auth_session(),
+            headless=False,
+            timeout=6000,
+            trace_id="trace-id",
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.cli_trace.assert_called_once_with("trace-id")
+
+    @pytest.mark.asyncio
+    async def test_uses_get_cli_run_options(self, attempt_api_mocks: AttemptApiMocks):
+        """Test that attempt_api calls get_cli_run_options with the correct parameters."""
+        # Import inside test to avoid circular import issues
+
+        await run_check(
+            auth=_get_empty_auth_session(),
+            headless=False,
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.get_cli_run_options.assert_called_once_with(
+            headless=False,
+            proxy=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.get_cli_run_options.reset_mock()
+        await run_check(
+            auth=_get_empty_auth_session(),
+            headless=True,
+            proxy="proxy",
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=True,
+        )
+        call_args = attempt_api_mocks.get_cli_run_options.call_args[1]
+        assert call_args["headless"] is True
+        assert call_args["proxy"] is not None
+        assert call_args["keep_browser_open"] is True
+
     @pytest.mark.asyncio
     async def test_calls_run_api_with_correct_parameters_and_parses_proxy(self, attempt_api_mocks: AttemptApiMocks):
         """Test that run_check calls run_api with correct parameters and parses proxy."""
@@ -216,6 +367,8 @@ class TestRunCheck:
                 headless=False,
                 timeout=999999999,
                 proxy="proxy",
+                trace_id=None,
+                keep_browser_open=False,
             )
 
             mock_parse_proxy.assert_called_once_with("proxy")
@@ -237,6 +390,8 @@ class TestRunCheck:
             auth=StorageState(cookies=[], origins=[], session_storage=[]),
             headless=False,
             timeout=999999999,
+            trace_id=None,
+            keep_browser_open=False,
         )
 
         assert result_true is True
@@ -247,6 +402,8 @@ class TestRunCheck:
             auth=_get_empty_auth_session(),
             headless=False,
             timeout=999999999,
+            trace_id=None,
+            keep_browser_open=False,
         )
 
         assert result_false is False
@@ -262,6 +419,8 @@ class TestRunCheck:
                 auth=StorageState(cookies=[], origins=[], session_storage=[]),
                 headless=False,
                 timeout=999999999,
+                trace_id=None,
+                keep_browser_open=False,
             )
 
         # Test with AutomationError - should return False, not throw
@@ -272,10 +431,43 @@ class TestRunCheck:
                 auth=StorageState(cookies=[], origins=[], session_storage=[]),
                 headless=False,
                 timeout=999999999,
+                trace_id=None,
+                keep_browser_open=False,
             )
 
 
 class TestRunCheckWithRetries:
+    @pytest.mark.asyncio
+    async def test_calls_check_with_trace_id_correctly(self, with_retries_mocks: WithRetriesMocks):
+        """Test that run_check_with_retries calls run_check with the correct trace_id."""
+
+        await run_check_with_retries(
+            auth=_get_empty_auth_session(),
+            retries=10,
+            headless=False,
+            timeout=999999999,
+            trace=False,
+            keep_browser_open=False,
+        )
+
+        with_retries_mocks.run_check.assert_called()
+        call_args = with_retries_mocks.run_check.call_args
+        assert call_args[1]["trace_id"] is None
+
+        with_retries_mocks.run_check.reset_mock()
+
+        await run_check_with_retries(
+            auth=_get_empty_auth_session(),
+            retries=10,
+            headless=False,
+            timeout=999999999,
+            trace=True,
+            keep_browser_open=False,
+        )
+        with_retries_mocks.run_check.assert_called()
+        call_args = with_retries_mocks.run_check.call_args
+        assert isinstance(call_args[1]["trace_id"], str)
+
     @pytest.mark.asyncio
     async def test_retries_the_check_if_it_fails(self, with_retries_mocks: WithRetriesMocks):
         """Test that run_check_with_retries retries the check if it fails."""
@@ -286,6 +478,8 @@ class TestRunCheckWithRetries:
             retries=10,
             headless=False,
             timeout=999999999,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert result is True
@@ -301,6 +495,8 @@ class TestRunCheckWithRetries:
             retries=10,
             headless=False,
             timeout=999999999,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert result is False
@@ -318,6 +514,8 @@ class TestRunCheckWithRetries:
             retries=10,
             headless=False,
             timeout=999999999,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert result is True
@@ -335,6 +533,8 @@ class TestRunCheckWithRetries:
                 retries=10,
                 headless=False,
                 timeout=999999999,
+                trace=False,
+                keep_browser_open=False,
             )
 
         with_retries_mocks.run_check.assert_called_once()
@@ -350,10 +550,71 @@ class TestRunCreate:
             auth_session_input={},
             headless=False,
             timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
         )
 
         attempt_api_mocks.extendable_timeout.assert_called_once_with(6000)
 
+    @pytest.mark.asyncio
+    async def test_uses_trace_context_manager(self, attempt_api_mocks: AttemptApiMocks):
+        """Test that run_create uses the trace context manager."""
+        attempt_api_mocks.run_api.return_value = _create_success_result("session")
+
+        await run_create(
+            auth_session_input={},
+            headless=False,
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.cli_trace.assert_called_once_with(None)
+
+        attempt_api_mocks.cli_trace.reset_mock()
+        await run_create(
+            auth_session_input={},
+            headless=False,
+            timeout=6000,
+            trace_id="trace-id",
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.cli_trace.assert_called_once_with("trace-id")
+
+    @pytest.mark.asyncio
+    async def test_uses_get_cli_run_options(self, attempt_api_mocks: AttemptApiMocks):
+        """Test that run_create calls get_cli_run_options with the correct parameters."""
+        attempt_api_mocks.run_api.return_value = _create_success_result("session")
+
+        await run_create(
+            auth_session_input={},
+            headless=False,
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.get_cli_run_options.assert_called_once_with(
+            headless=False,
+            proxy=None,
+            keep_browser_open=False,
+        )
+
+        attempt_api_mocks.get_cli_run_options.reset_mock()
+        await run_create(
+            auth_session_input={},
+            headless=True,
+            proxy="proxy",
+            timeout=6000,
+            trace_id=None,
+            keep_browser_open=True,
+        )
+        call_args = attempt_api_mocks.get_cli_run_options.call_args[1]
+        assert call_args["headless"] is True
+        assert call_args["proxy"] is not None
+        assert call_args["keep_browser_open"] is True
+
     @pytest.mark.asyncio
     async def test_calls_run_api_with_correct_parameters_and_parses_proxy(self, attempt_api_mocks: AttemptApiMocks):
         """Test that run_create calls run_api with correct parameters and parses proxy."""
@@ -372,6 +633,8 @@ class TestRunCreate:
                 headless=False,
                 timeout=999999999,
                 proxy="proxy",
+                trace_id=None,
+                keep_browser_open=False,
             )
 
             mock_parse_proxy.assert_called_once_with("proxy")
@@ -394,6 +657,8 @@ class TestRunCreate:
             auth_session_input={},
             headless=False,
             timeout=999999999,
+            trace_id=None,
+            keep_browser_open=False,
         )
 
         assert storage_state == "session"
@@ -409,10 +674,45 @@ class TestRunCreate:
                 auth_session_input={},
                 headless=False,
                 timeout=999999999,
+                trace_id=None,
+                keep_browser_open=False,
             )
 
 
 class TestRunCreateWithRetries:
+    @pytest.mark.asyncio
+    async def test_calls_create_with_trace_id_correctly(self, with_retries_mocks: WithRetriesMocks):
+        """Test that run_create_with_retries calls run_create with the correct trace_id."""
+
+        await run_create_with_retries(
+            auth_session_id="testId",
+            auth_session_input={},
+            retries=10,
+            headless=False,
+            timeout=999999999,
+            trace=False,
+            keep_browser_open=False,
+        )
+
+        with_retries_mocks.run_create.assert_called()
+        call_args = with_retries_mocks.run_create.call_args
+        assert call_args[1]["trace_id"] is None
+
+        with_retries_mocks.run_create.reset_mock()
+
+        await run_create_with_retries(
+            auth_session_id="testId",
+            auth_session_input={},
+            retries=10,
+            headless=False,
+            timeout=999999999,
+            trace=True,
+            keep_browser_open=False,
+        )
+        with_retries_mocks.run_create.assert_called()
+        call_args = with_retries_mocks.run_create.call_args
+        assert isinstance(call_args[1]["trace_id"], str)
+
     @pytest.mark.asyncio
     async def test_saves_the_auth_session_instance(self, with_retries_mocks: WithRetriesMocks):
         """Test that run_create_with_retries saves the auth session instance."""
@@ -427,6 +727,8 @@ class TestRunCreateWithRetries:
             retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert with_retries_mocks.run_create.call_count == 1
@@ -449,6 +751,8 @@ class TestRunCreateWithRetries:
             retries=10,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert with_retries_mocks.run_create.call_count == 2
@@ -465,6 +769,8 @@ class TestRunCreateWithRetries:
                 retries=3,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
         assert with_retries_mocks.run_create.call_count == 3
@@ -482,6 +788,8 @@ class TestRunCreateWithRetries:
                 retries=10,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
         with_retries_mocks.run_create.assert_called_once()
@@ -498,6 +806,8 @@ class TestExecuteAuthSessionValidateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         shared_mocks.assert_api_file_exists.assert_called_once_with("auth-sessions", "check")
@@ -516,6 +826,8 @@ class TestExecuteAuthSessionValidateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert execute_cli_mocks.run_check_with_retries.call_count == 1
@@ -535,6 +847,8 @@ class TestExecuteAuthSessionValidateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -554,6 +868,8 @@ class TestExecuteAuthSessionValidateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         # Should call assert for both check and create APIs
@@ -578,6 +894,8 @@ class TestExecuteAuthSessionValidateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -598,6 +916,8 @@ class TestExecuteAuthSessionValidateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -618,6 +938,8 @@ class TestExecuteAuthSessionValidateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -636,6 +958,8 @@ class TestExecuteAuthSessionValidateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         assert result == auth
@@ -655,6 +979,8 @@ class TestExecuteAuthSessionCreateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         # Should assert both create and check API files exist
@@ -674,6 +1000,8 @@ class TestExecuteAuthSessionCreateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -692,6 +1020,8 @@ class TestExecuteAuthSessionCreateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -709,6 +1039,8 @@ class TestExecuteAuthSessionCreateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         # run_create_with_retries is tested to save in its own tests, so just verify it was called here
@@ -731,6 +1063,8 @@ class TestExecuteAuthSessionCreateCLI:
             create_retries=1,
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         # Verify that store was called with the provided id
@@ -754,6 +1088,8 @@ class TestExecuteAuthSessionUpdateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -770,6 +1106,8 @@ class TestExecuteAuthSessionUpdateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
             # Should use the provided input data
@@ -780,9 +1118,10 @@ class TestExecuteAuthSessionUpdateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
-                proxy=None,
                 metadata=mock_metadata,
                 log=False,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -798,6 +1137,8 @@ class TestExecuteAuthSessionUpdateCLI:
                 create_retries=1,
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
             # Should use the provided input data
@@ -814,6 +1155,8 @@ class TestExecuteAttemptAuthSessionCLI:
             id="testId",
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         shared_mocks.assert_api_file_exists.assert_called_once_with("auth-sessions", "check")
@@ -827,6 +1170,8 @@ class TestExecuteAttemptAuthSessionCLI:
             id="testId",
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
     @pytest.mark.asyncio
@@ -839,6 +1184,8 @@ class TestExecuteAttemptAuthSessionCLI:
                 id="testId",
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
 
@@ -851,6 +1198,8 @@ class TestExecuteAttemptCreateAuthSessionCLI:
             input_data={},
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         shared_mocks.assert_api_file_exists.assert_called_once_with("auth-sessions", "create")
@@ -868,6 +1217,8 @@ class TestExecuteAttemptCreateAuthSessionCLI:
                 input_data={},
                 headless=False,
                 timeout=30,
+                trace=False,
+                keep_browser_open=False,
             )
 
     @pytest.mark.asyncio
@@ -879,15 +1230,17 @@ class TestExecuteAttemptCreateAuthSessionCLI:
             input_data={},
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         execute_cli_mocks.run_create_with_retries.assert_called_once()
         call_args = execute_cli_mocks.run_create_with_retries.call_args.kwargs
         assert call_args["auth_session_input"] == {}
-        assert call_args["retries"] == 1
+        assert call_args["retries"] is None
         assert call_args["headless"] is False
         assert call_args["timeout"] == 30
-        assert call_args["proxy"] is None
+        assert call_args.get("proxy") is None
 
     @pytest.mark.asyncio
     async def test_uses_auth_session_id_to_save_if_provided(self, execute_cli_mocks: ExecuteCLIMocks):
@@ -899,9 +1252,147 @@ class TestExecuteAttemptCreateAuthSessionCLI:
             input_data={},
             headless=False,
             timeout=30,
+            trace=False,
+            keep_browser_open=False,
         )
 
         # Verify that store was called with the provided id
         execute_cli_mocks.run_create_with_retries.assert_called_once()
         call_args = execute_cli_mocks.run_create_with_retries.call_args.kwargs
         assert call_args["auth_session_id"] == "customId"
+
+
+class TestExecuteRecordAuthSessionCLI:
+    @pytest.mark.asyncio
+    async def test_launches_browser_with_app_mode(
+        self,
+        record_auth_session_mocks: RecordAuthSessionMocks,
+        with_retries_mocks: WithRetriesMocks,
+        execute_cli_mocks: ExecuteCLIMocks,
+    ):
+        """Test that execute_record_auth_session_cli launches browser with app mode."""
+        record_auth_session_mocks.page.url = "url"
+        await execute_record_auth_session_cli(
+            start_url="url",
+            finish_url="url",
+            headless=False,
+            timeout=30,
+            trace=False,
+            keep_browser_open=False,
+        )
+
+        record_auth_session_mocks.launch_chromium.assert_called_once()
+        call_args = record_auth_session_mocks.launch_chromium.call_args.kwargs
+        assert call_args["app_mode_initial_url"] == "url"
+        assert call_args["headless"] is False
+
+    @pytest.mark.asyncio
+    async def test_navigates_to_start_url_if_pages_does_not_load_with_it(
+        self,
+        record_auth_session_mocks: RecordAuthSessionMocks,
+        with_retries_mocks: WithRetriesMocks,
+        execute_cli_mocks: ExecuteCLIMocks,
+    ):
+        record_auth_session_mocks.page.url = "finish_url"
+
+        """Test that execute_record_auth_session_cli navigates to start_url if page does not load with it."""
+        await execute_record_auth_session_cli(
+            start_url="start_url",
+            finish_url="finish_url",
+            headless=False,
+            timeout=30,
+            trace=False,
+            keep_browser_open=False,
+        )
+
+        record_auth_session_mocks.page.goto.assert_called_once_with("start_url")
+
+    @pytest.mark.asyncio
+    async def test_waits_for_finish_url(
+        self,
+        record_auth_session_mocks: RecordAuthSessionMocks,
+        with_retries_mocks: WithRetriesMocks,
+        execute_cli_mocks: ExecuteCLIMocks,
+    ):
+        """Test that execute_record_auth_session_cli waits for finish_url."""
+        import asyncio
+
+        record_auth_session_mocks.page.url = "start_url"
+
+        record_task = asyncio.create_task(
+            execute_record_auth_session_cli(
+                start_url="start_url",
+                finish_url="finish_url",
+                headless=False,
+                timeout=30,
+                trace=False,
+                keep_browser_open=False,
+            )
+        )
+
+        # simulate time passing without URL changing
+        await record_auth_session_mocks.resolve_sleep()
+        await record_auth_session_mocks.resolve_sleep()
+        await record_auth_session_mocks.resolve_sleep()
+        assert record_task.done() is False
+
+        record_auth_session_mocks.page.url = "finish_url"
+
+        await record_auth_session_mocks.resolve_sleep()
+
+        await record_task
+
+    @pytest.mark.asyncio
+    async def test_throws_if_timeout(
+        self,
+        record_auth_session_mocks: RecordAuthSessionMocks,
+        with_retries_mocks: WithRetriesMocks,
+        execute_cli_mocks: ExecuteCLIMocks,
+    ):
+        """Test that execute_record_auth_session_cli throws if timeout."""
+        import asyncio as mocked_asyncio
+
+        record_task = asyncio.create_task(
+            execute_record_auth_session_cli(
+                start_url="start_url",
+                finish_url="finish_url",
+                headless=False,
+                timeout=30,
+                trace=False,
+                keep_browser_open=False,
+            )
+        )
+
+        # simulate time passing without URL changing
+        await record_auth_session_mocks.resolve_sleep()
+        await record_auth_session_mocks.resolve_sleep()
+        await record_auth_session_mocks.resolve_sleep()
+        assert record_task.done() is False
+
+        cast(AsyncMock, mocked_asyncio.sleep).side_effect = asyncio.TimeoutError()
+
+        await record_auth_session_mocks.resolve_sleep()
+
+        with pytest.raises(CLIError, match="Timeout"):
+            await record_task
+
+    @pytest.mark.asyncio
+    async def test_stores_auth_session_and_validates_if_successful(
+        self,
+        record_auth_session_mocks: RecordAuthSessionMocks,
+        with_retries_mocks: WithRetriesMocks,
+        execute_cli_mocks: ExecuteCLIMocks,
+    ):
+        """Test that execute_record_auth_session_cli stores auth session and validates it if successful."""
+        record_auth_session_mocks.page.url = "url"
+        await execute_record_auth_session_cli(
+            start_url="url",
+            finish_url="url",
+            headless=False,
+            timeout=30,
+            trace=False,
+            keep_browser_open=False,
+        )
+
+        with_retries_mocks.store_auth_session_instance.assert_called_once()
+        execute_cli_mocks.run_check_with_retries.assert_called_once()