import { worktreeCreateGit } from '../git/worktree-create-git-executor' import { resolveGitAdmissionTier } from '../git/command-runner/git-operation-executor' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' // Isolate fetch mocks from orca-runtime.test.ts; pin §3.3 eviction, freshness and concurrent-call sharing. const gitExecFileAsyncMock = vi.hoisted(() => vi.fn()) vi.mock('../git/runner', async (importOriginal) => { const actual = (await importOriginal()) as Record return { ...actual, gitExecFileAsync: gitExecFileAsyncMock } }) import { OrcaRuntimeService } from './orca-runtime' import { RuntimeRemoteFetchController } from './runtime-remote-fetch-controller' import { _resetCanonicalRepoKeyCacheForTests } from '../git/canonical-repo-key' function isFetchArgs(argv: unknown): argv is string[] { if (!Array.isArray(argv)) { return false } let commandIndex = 0 while (argv[commandIndex] === '-c' && typeof argv[commandIndex + 1] === 'string') { commandIndex += 2 } return argv[commandIndex] === 'fetch' } function fetchCallCount(): number { return gitExecFileAsyncMock.mock.calls.filter(([argv]) => isFetchArgs(argv)).length } function exactBaseRefreshOptions(cwd: string): { cwd: string timeout: number useConfiguredSshCommandForNetwork: boolean } { return { cwd, timeout: 60_000, useConfiguredSshCommandForNetwork: true } } function exactBaseRefreshArgs(branch = 'main'): string[] { return [ '-c', 'maintenance.auto=false', '-c', 'maintenance.commit-graph.auto=0', '-c', 'gc.auto=0', 'fetch', '--no-tags', 'origin', `+refs/heads/${branch}:refs/remotes/origin/${branch}` ] } // STA-1292: bound Windows credential-manager hangs so worktree creation cannot wedge. function fullRemoteFetchOptions(cwd: string): { cwd: string; timeout: number } { return { cwd, timeout: 60_000 } } function mockFetchResults(results: unknown[]): void { let fetchIndex = 0 gitExecFileAsyncMock.mockImplementation((argv: string[]) => { if (argv[0] === 'rev-parse') { return Promise.reject(new Error('not a repo in cache-key test')) } const result = results[fetchIndex++] return result instanceof Promise ? result : Promise.resolve(result) }) } describe('OrcaRuntimeService.fetchRemoteWithCache', () => { const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } it.each([undefined, 'Ubuntu'])( 'inherits create priority through fetch adapters on %s', async (wslDistro) => worktreeCreateGit.run(async () => { gitExecFileAsyncMock.mockImplementation(async (argv: string[]) => { expect(resolveGitAdmissionTier()).toBe('interactive') return { stdout: argv[0] === 'remote' ? 'origin\n' : '/priority-repo/.git\n', stderr: '' } }) const runtime = new OrcaRuntimeService() const options = wslDistro ? { wslDistro } : {} const base = await runtime.resolveRemoteTrackingBase( '/priority-repo', 'origin/main', options ) expect(base).not.toBeNull() if (!base) { throw new Error('expected a remote base') } await expect(runtime.hasRemoteTrackingRef('/priority-repo', base, options)).resolves.toBe( true ) await expect( runtime.getOrStartRemoteTrackingBaseRefresh('/priority-repo', base, options) ).resolves.toEqual({ ok: true }) expect(fetchCallCount()).toBe(1) for (const [, execOptions] of gitExecFileAsyncMock.mock.calls) { expect(execOptions).toMatchObject({ cwd: '/priority-repo', ...options }) } }) ) beforeEach(() => { _resetCanonicalRepoKeyCacheForTests() gitExecFileAsyncMock.mockReset() }) afterEach(() => { vi.useRealTimers() }) it('evicts the in-flight Map entry on rejection so the next caller re-fetches', async () => { mockFetchResults([Promise.reject(new Error('network down')), { stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) await runtime.fetchRemoteWithCache('/repo/a', 'origin') await runtime.fetchRemoteWithCache('/repo/a', 'origin') expect(fetchCallCount()).toBe(2) }) it('serializes two concurrent callers onto a single git fetch', async () => { let resolveFetch!: () => void const pending = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveFetch = () => resolve({ stdout: '', stderr: '' }) }) mockFetchResults([pending]) const runtime = new OrcaRuntimeService(null) const first = runtime.fetchRemoteWithCache('/repo/c', 'origin') const second = runtime.fetchRemoteWithCache('/repo/c', 'origin') // Canonicalization delays dispatch several microtasks; let both callers join before resolving. for (let tick = 0; tick < 8; tick += 1) { await Promise.resolve() } expect(fetchCallCount()).toBe(1) resolveFetch() await Promise.all([first, second]) expect(fetchCallCount()).toBe(1) }) it('skips the fetch inside the 30s freshness window after a successful fetch', async () => { mockFetchResults([{ stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) await runtime.fetchRemoteWithCache('/repo/d', 'origin') await runtime.fetchRemoteWithCache('/repo/d', 'origin') expect(fetchCallCount()).toBe(1) }) it('evicts the oldest canonical key after 512 distinct repo paths', async () => { const owner = new RuntimeRemoteFetchController() const resolve = vi.spyOn(owner, 'getCanonicalRepoKey').mockImplementation(async (path) => path) for (let index = 0; index < 513; index += 1) { await owner.getCanonicalFetchKey(`/repo/cache-${index}`, 'origin') } await owner.getCanonicalFetchKey('/repo/cache-1', 'origin') expect(resolve).toHaveBeenCalledTimes(513) await owner.getCanonicalFetchKey('/repo/cache-0', 'origin') expect(resolve).toHaveBeenCalledTimes(514) }) it('evicts the oldest successful freshness entry after 512 distinct repo paths', async () => { vi.useFakeTimers({ toFake: ['Date'] }) vi.setSystemTime(10_000) mockFetchResults(Array.from({ length: 514 }, () => ({ stdout: '', stderr: '' }))) const owner = new RuntimeRemoteFetchController() for (let index = 0; index < 513; index += 1) { await owner.getOrStartRemoteFetch(`/repo/cache-${index}`, 'origin') } await owner.getOrStartRemoteFetch('/repo/cache-1', 'origin') expect(fetchCallCount()).toBe(513) await owner.getOrStartRemoteFetch('/repo/cache-0', 'origin') expect(fetchCallCount()).toBe(514) }) it('keeps successful fetch freshness independent between owners', async () => { mockFetchResults([ { stdout: '', stderr: '' }, { stdout: '', stderr: '' } ]) const first = new RuntimeRemoteFetchController() const second = new RuntimeRemoteFetchController() await first.getOrStartRemoteFetch('/repo/isolated', 'origin') await second.getOrStartRemoteFetch('/repo/isolated', 'origin') expect(fetchCallCount()).toBe(2) await first.getOrStartRemoteFetch('/repo/isolated', 'origin') await second.getOrStartRemoteFetch('/repo/isolated', 'origin') expect(fetchCallCount()).toBe(2) }) it.each([ 'main', 'a'.repeat(40), 'refs/remotes/main', '', 'origin/', '/main', 'refs/remotes/origin/', 'refs/remotes//main' ])( 'does not launch Git for a base without both remote and branch components: %s', async (base) => { const runtime = new OrcaRuntimeService(null) await expect(runtime.resolveRemoteTrackingBase('/repo/e', base)).resolves.toBeNull() await expect( runtime.resolveRemoteTrackingBase('/repo/e', base, { wslDistro: 'Ubuntu' }) ).resolves.toBeNull() expect(gitExecFileAsyncMock).not.toHaveBeenCalled() } ) it('resolves remote-tracking bases with longest configured remote matching', async () => { gitExecFileAsyncMock.mockResolvedValue({ stdout: 'foo\nfoo/bar\norigin\n', stderr: '' }) const runtime = new OrcaRuntimeService(null) await expect(runtime.resolveRemoteTrackingBase('/repo/e', 'foo/bar/main')).resolves.toEqual({ remote: 'foo/bar', branch: 'main', ref: 'refs/remotes/foo/bar/main', base: 'foo/bar/main' }) }) it.each(['refs/heads/feature/加', 'refs/tags/release'])( 'does not reinterpret a qualified nonremote ref through a remote named refs: %s', async (base) => { gitExecFileAsyncMock.mockResolvedValue({ stdout: 'refs\n', stderr: '' }) const runtime = new OrcaRuntimeService(null) for (const options of [{}, { wslDistro: 'Ubuntu' }]) { await expect( runtime.resolveRemoteTrackingBase('/repo/e', base, options) ).resolves.toBeNull() } expect(gitExecFileAsyncMock).not.toHaveBeenCalled() } ) it('preserves a qualified remote whose name begins with refs', async () => { gitExecFileAsyncMock.mockResolvedValue({ stdout: 'refs/heads\n', stderr: '' }) const runtime = new OrcaRuntimeService(null) await expect( runtime.resolveRemoteTrackingBase('/repo/e', 'refs/remotes/refs/heads/feature/加') ).resolves.toEqual({ remote: 'refs/heads', branch: 'feature/加', ref: 'refs/remotes/refs/heads/feature/加', base: 'refs/heads/feature/加' }) }) it('resolves full remote-tracking refs with longest configured remote matching', async () => { gitExecFileAsyncMock.mockResolvedValue({ stdout: 'foo\nfoo/bar\norigin\n', stderr: '' }) const runtime = new OrcaRuntimeService(null) await expect( runtime.resolveRemoteTrackingBase('/repo/e', 'refs/remotes/foo/bar/main') ).resolves.toEqual({ remote: 'foo/bar', branch: 'main', ref: 'refs/remotes/foo/bar/main', base: 'foo/bar/main' }) }) it('refreshes a remote-tracking base with an exact no-tags refspec', async () => { mockFetchResults([{ stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) await runtime.getOrStartRemoteTrackingBaseRefresh('/repo/f', { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' }) expect(gitExecFileAsyncMock).toHaveBeenCalledWith( exactBaseRefreshArgs(), exactBaseRefreshOptions('/repo/f') ) }) it('keeps automatic maintenance enabled for ordinary full remote fetches', async () => { mockFetchResults([{ stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) await runtime.getOrStartRemoteFetch('/repo/full-maintenance', 'origin') expect(gitExecFileAsyncMock).toHaveBeenCalledWith( ['fetch', 'origin'], fullRemoteFetchOptions('/repo/full-maintenance') ) }) it('shares an in-flight remote-tracking base refresh and reuses exact-base freshness', async () => { let resolveFetch!: () => void const pending = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveFetch = () => resolve({ stdout: '', stderr: '' }) }) mockFetchResults([pending, { stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) const first = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g', base) const second = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g', base) await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) resolveFetch() await Promise.all([first, second]) await runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g', base) expect(fetchCallCount()).toBe(1) }) it.each(['create-first', 'success', 'main', 'other'])('Create sharing: %s', async (scenario) => { vi.useFakeTimers() let finishFetch = () => {} gitExecFileAsyncMock.mockImplementation((argv: string[], options) => { return !isFetchArgs(argv) ? Promise.resolve({ stdout: '/repo/.git' }) : fetchCallCount() > 1 ? Promise.resolve({ stdout: '' }) : new Promise((resolve, reject) => { finishFetch = () => resolve({ stdout: '' }) options.signal?.addEventListener('abort', () => reject(new Error('expired'))) }) }) const runtime = new RuntimeRemoteFetchController() const firstCreate = scenario === 'create-first' ? runtime.getOrStartRemoteTrackingBaseRefresh('/repo/pr', base) : null const preview = runtime.refreshRemoteTrackingBaseForPreview('/repo/pr', base) await vi.waitFor(() => expect(fetchCallCount()).toBe(1)) setTimeout(() => finishFetch(), scenario === 'success' ? 5_000 : 15_000) await vi.advanceTimersByTimeAsync(scenario === 'success' ? 0 : 11_000) const next = scenario === 'other' ? { ...base, branch: 'other', ref: 'refs/remotes/origin/other' } : base const create = firstCreate ?? runtime.getOrStartRemoteTrackingBaseRefresh('/repo/pr', next) const sibling = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/pr', next) await vi.advanceTimersByTimeAsync(scenario === 'success' ? 5_000 : 4_000) await expect(preview).resolves.toMatchObject({ ok: scenario === 'success' }) await expect(create).resolves.toEqual({ ok: true }) await expect(sibling).resolves.toEqual({ ok: true }) expect(fetchCallCount()).toBe(scenario === 'main' || scenario === 'other' ? 2 : 1) }) it.each([false, true])('shares root freshness after canceled lookup: %s', async (lateTimer) => { vi.useFakeTimers() let releaseLookup = () => {} gitExecFileAsyncMock.mockImplementation(async (_argv, options) => { if (options.signal) { await new Promise((resolve) => { releaseLookup = resolve options.signal.addEventListener('abort', resolve) }) expect(options.signal.aborted).toBe(!lateTimer) expect(options.canStart()).toBe(false) throw Object.assign(new Error('canceled'), { name: lateTimer ? 'AbortError' : 'Error' }) } return { stdout: '/repo/.git' } }) const controller = new RuntimeRemoteFetchController() await controller.getCanonicalRepoKey('/repo') const preview = controller.refreshRemoteTrackingBaseForPreview('/repo-linked', base) await vi.advanceTimersByTimeAsync(0) vi.setSystemTime(Date.now() + (lateTimer ? 10_000 : 0)) await vi.advanceTimersByTimeAsync(lateTimer ? 0 : 10_000) if (lateTimer) { releaseLookup() } await expect(preview).resolves.toEqual({ ok: false, errorKind: 'git_error' }) expect(fetchCallCount()).toBe(0) await controller.getOrStartRemoteTrackingBaseRefresh('/repo', base) await controller.getOrStartRemoteTrackingBaseRefresh('/repo-linked', base) const recoveredKey = await controller.getCanonicalRepoKey('/repo-linked') expect(recoveredKey).toBe('local::/repo/.git') expect(fetchCallCount()).toBe(1) }) it('does not advance exact-base freshness when a remote-tracking refresh fails', async () => { mockFetchResults([Promise.reject(new Error('network down')), { stdout: '', stderr: '' }]) const runtime = new OrcaRuntimeService(null) const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } await expect( runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g-fail', base) ).resolves.toEqual({ ok: false, errorKind: 'git_error' }) await expect( runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g-fail', base) ).resolves.toEqual({ ok: true }) expect(fetchCallCount()).toBe(2) }) it('does not treat a recent full remote fetch as exact-base freshness', async () => { mockFetchResults([ { stdout: '', stderr: '' }, { stdout: '', stderr: '' } ]) const runtime = new OrcaRuntimeService(null) const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } await runtime.getOrStartRemoteFetch('/repo/g-full', 'origin') await expect( runtime.getOrStartRemoteTrackingBaseRefresh('/repo/g-full', base) ).resolves.toEqual({ ok: true }) expect(fetchCallCount()).toBe(2) }) it('queues a full remote fetch behind an in-flight remote-tracking base refresh', async () => { let resolveBaseFetch!: () => void let resolveFullFetch!: () => void const pendingBaseFetch = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveBaseFetch = () => resolve({ stdout: '', stderr: '' }) }) const pendingFullFetch = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveFullFetch = () => resolve({ stdout: '', stderr: '' }) }) mockFetchResults([pendingBaseFetch, pendingFullFetch]) const runtime = new OrcaRuntimeService(null) const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } const baseRefresh = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/h', base) await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) const fullFetch = runtime.getOrStartRemoteFetch('/repo/h', 'origin') await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) resolveBaseFetch() await vi.waitFor(() => expect(fetchCallCount()).toBe(2)) resolveFullFetch() await expect(Promise.all([baseRefresh, fullFetch])).resolves.toEqual([ { ok: true }, { ok: true } ]) const fetchCalls = gitExecFileAsyncMock.mock.calls.filter(([argv]) => isFetchArgs(argv)) expect(fetchCalls).toEqual([ [exactBaseRefreshArgs(), exactBaseRefreshOptions('/repo/h')], [['fetch', 'origin'], fullRemoteFetchOptions('/repo/h')] ]) }) it('runs a queued exact base refresh after an in-flight full remote fetch succeeds', async () => { let resolveFullFetch!: () => void let resolveBaseFetch!: () => void const pendingFullFetch = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveFullFetch = () => resolve({ stdout: '', stderr: '' }) }) const pendingBaseFetch = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveBaseFetch = () => resolve({ stdout: '', stderr: '' }) }) mockFetchResults([pendingFullFetch, pendingBaseFetch]) const runtime = new OrcaRuntimeService(null) const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } const fullFetch = runtime.getOrStartRemoteFetch('/repo/i', 'origin') await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) const baseRefresh = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/i', base) await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) resolveFullFetch() await vi.waitFor(() => expect(fetchCallCount()).toBe(2)) resolveBaseFetch() await expect(Promise.all([fullFetch, baseRefresh])).resolves.toEqual([ { ok: true }, { ok: true } ]) const fetchCalls = gitExecFileAsyncMock.mock.calls.filter(([argv]) => isFetchArgs(argv)) expect(fetchCalls).toEqual([ [['fetch', 'origin'], fullRemoteFetchOptions('/repo/i')], [exactBaseRefreshArgs(), exactBaseRefreshOptions('/repo/i')] ]) }) it('runs a queued exact base refresh when an in-flight full remote fetch fails', async () => { let rejectFullFetch!: () => void let resolveBaseFetch!: () => void const pendingFullFetch = new Promise<{ stdout: string; stderr: string }>((_resolve, reject) => { rejectFullFetch = () => reject(new Error('network unavailable')) }) const pendingBaseFetch = new Promise<{ stdout: string; stderr: string }>((resolve) => { resolveBaseFetch = () => resolve({ stdout: '', stderr: '' }) }) mockFetchResults([pendingFullFetch, pendingBaseFetch]) const runtime = new OrcaRuntimeService(null) const base = { remote: 'origin', branch: 'main', ref: 'refs/remotes/origin/main', base: 'origin/main' } const fullFetch = runtime.getOrStartRemoteFetch('/repo/i-fail', 'origin') await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) const baseRefresh = runtime.getOrStartRemoteTrackingBaseRefresh('/repo/i-fail', base) await new Promise((resolve) => setTimeout(resolve, 0)) expect(fetchCallCount()).toBe(1) rejectFullFetch() await vi.waitFor(() => expect(fetchCallCount()).toBe(2)) resolveBaseFetch() await expect(Promise.all([fullFetch, baseRefresh])).resolves.toEqual([ { ok: false, errorKind: 'git_error' }, { ok: true } ]) const fetchCalls = gitExecFileAsyncMock.mock.calls.filter(([argv]) => isFetchArgs(argv)) expect(fetchCalls).toEqual([ [['fetch', 'origin'], fullRemoteFetchOptions('/repo/i-fail')], [exactBaseRefreshArgs(), exactBaseRefreshOptions('/repo/i-fail')] ]) }) })