File size: 4,459 Bytes
a9e27c0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
import asyncio
from unittest.mock import AsyncMock

import pytest

from free_claude_code.application.code_sessions import CodeService
from free_claude_code.application.errors import ApplicationUnavailableError
from free_claude_code.runtime.application import ApplicationRuntime
from free_claude_code.runtime.configuration import ConfigurationService
from free_claude_code.runtime.provider_manager import ProviderRuntimeManager
from free_claude_code.runtime.sqlite_database import SQLiteDatabase
from tests.runtime.test_application_runtime import (
    TrackingFactory,
    TrackingMessagingRuntime,
    TrackingTranscriber,
    _settings,
)


@pytest.mark.asyncio
async def test_close_cancels_both_feature_owners_before_acquiring_config_lock():
    manager = ProviderRuntimeManager(_settings("nvidia_nim/model"))
    database = AsyncMock(spec=SQLiteDatabase)
    import_started = asyncio.Event()

    async def start_database():
        import_started.set()
        await asyncio.Event().wait()

    database.start.side_effect = start_database
    runtime = ApplicationRuntime(
        manager,
        configuration=AsyncMock(spec=ConfigurationService),
        transcriber=None,
        database=database,
    )
    close = None
    try:
        async with runtime._config_lock:
            await runtime.start()
            await asyncio.wait_for(import_started.wait(), 5)
            refresh = runtime._integrations._claude_update.task
            assert refresh is not None and not refresh.done()
            messaging_tasks = tuple(runtime._messaging._startup_tasks)
            assert len(messaging_tasks) == 2
            assert all(not task.done() for task in messaging_tasks)
            close = asyncio.create_task(runtime.close())
            results = await asyncio.wait_for(
                asyncio.gather(refresh, *messaging_tasks, return_exceptions=True), 5
            )
            assert all(isinstance(result, asyncio.CancelledError) for result in results)
            assert not close.done()
            database.close.assert_not_awaited()
        assert await asyncio.wait_for(close, 5)
        database.close.assert_awaited_once()
    finally:
        if close is not None:
            await close
        await runtime.close()


@pytest.mark.asyncio
async def test_draining_runtime_rejects_new_feature_work():
    runtime = ApplicationRuntime(
        ProviderRuntimeManager(_settings("nvidia_nim/model")),
        configuration=AsyncMock(spec=ConfigurationService),
        transcriber=None,
    )
    try:
        runtime.begin_shutdown()
        runtime._integrations.catalog_changed()
        assert runtime._integrations._vscode_update.task is None
        with pytest.raises(ApplicationUnavailableError):
            await runtime.refresh_claude_vscode()
        with pytest.raises(ApplicationUnavailableError):
            runtime._messaging.start()
        assert runtime._messaging._startup_tasks == []
    finally:
        assert await runtime.close()


@pytest.mark.asyncio
async def test_failed_messaging_drain_retains_shared_dependencies_until_retry():
    events = []
    factory = TrackingFactory()
    manager = ProviderRuntimeManager(
        _settings("nvidia_nim/model"), runtime_factory=factory
    )
    code = AsyncMock(spec=CodeService)
    database = AsyncMock(spec=SQLiteDatabase)
    code.close.side_effect = lambda: events.append("code.close")
    database.close.side_effect = lambda: events.append("database.close")
    transcriber = TrackingTranscriber(events)
    runtime = ApplicationRuntime(
        manager,
        configuration=AsyncMock(spec=ConfigurationService),
        transcriber=transcriber,
        database=database,
        code_service=code,
    )
    runtime._messaging._messaging_runtime = TrackingMessagingRuntime(
        events, fail_quiesce_once=True
    )
    try:
        assert not await runtime.close()
        assert not runtime.is_closed
        code.close.assert_not_awaited()
        database.close.assert_not_awaited()
        assert transcriber.close_calls == 0
        assert factory.runtimes[0].cleanup_calls == 0
        assert await runtime.close()
        assert events == [
            "messaging.quiesce",
            "messaging.quiesce",
            "messaging.close",
            "code.close",
            "database.close",
            "transcriber.close",
        ]
        assert factory.runtimes[0].cleanup_calls == 1
    finally:
        await runtime.close()