diff --git a/src/main/ipc/filesystem.test.ts b/src/main/ipc/filesystem.test.ts index ad68010cbb7..2c66ab9ad09 100644 --- a/src/main/ipc/filesystem.test.ts +++ b/src/main/ipc/filesystem.test.ts @@ -3098,6 +3098,42 @@ describe('registerFilesystemHandlers', () => { ) }) + it('forwards the pinned head through SSH branch diff queries', async () => { + const result = { + kind: 'text', + originalContent: 'left', + modifiedContent: 'right', + originalIsBinary: false, + modifiedIsBinary: false + } + const getBranchDiff = vi.fn().mockResolvedValue([result]) + getSshGitProviderMock.mockReturnValue({ getBranchDiff }) + + registerFilesystemHandlers(store as never) + + await expect( + handlers.get('git:branchDiff')!(null, { + worktreePath: '/home/user/project', + compare: { + baseRef: 'origin/main', + baseOid: 'base-oid', + headOid: 'head-oid', + mergeBase: 'merge-base-oid' + }, + filePath: 'src/file.ts', + oldPath: 'src/old-file.ts', + connectionId: 'conn-1' + }) + ).resolves.toEqual(result) + + expect(getBranchDiff).toHaveBeenCalledWith('/home/user/project', 'merge-base-oid', { + includePatch: true, + headOid: 'head-oid', + filePath: 'src/file.ts', + oldPath: 'src/old-file.ts' + }) + }) + // Why: the original SSH Quick Open bug had two halves — relay-side policy // drift AND the main dispatcher silently dropping excludePaths before the // provider saw them. This test guards the second half: regardless of diff --git a/src/main/ipc/filesystem.ts b/src/main/ipc/filesystem.ts index 4ca9547b77c..e622480565e 100644 --- a/src/main/ipc/filesystem.ts +++ b/src/main/ipc/filesystem.ts @@ -2042,6 +2042,7 @@ export function registerFilesystemHandlers( } const results = await provider.getBranchDiff(args.worktreePath, args.compare.mergeBase, { includePatch: true, + headOid: args.compare.headOid, filePath: args.filePath, oldPath: args.oldPath }) diff --git a/src/main/providers/git-provider-contract.ts b/src/main/providers/git-provider-contract.ts index c204b9d9016..d13bf5addf9 100644 --- a/src/main/providers/git-provider-contract.ts +++ b/src/main/providers/git-provider-contract.ts @@ -66,7 +66,7 @@ export type IGitProvider = { getBranchDiff( worktreePath: string, baseRef: string, - options?: { includePatch?: boolean; filePath?: string; oldPath?: string } + options?: { includePatch?: boolean; filePath?: string; oldPath?: string; headOid?: string } ): Promise getCommitDiff( worktreePath: string, diff --git a/src/main/providers/ssh-git-provider.test.ts b/src/main/providers/ssh-git-provider.test.ts index c0613f35f2e..955e840632a 100644 --- a/src/main/providers/ssh-git-provider.test.ts +++ b/src/main/providers/ssh-git-provider.test.ts @@ -1081,6 +1081,79 @@ describe('SshGitProvider', () => { expect(result).toEqual(diffs) }) + it('getBranchDiff forwards a pinned head OID without adding it when omitted', async () => { + const headOid = 'a'.repeat(40) + mux.request.mockResolvedValue([]) + + await provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/file.ts', + headOid + }) + await provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/other-file.ts', + headOid: undefined + }) + + expect(mux.request).toHaveBeenNthCalledWith(1, 'git.branchDiff', { + worktreePath: '/home/user/repo', + baseRef: 'main', + includePatch: true, + filePath: 'src/file.ts', + headOid, + __streamResponse: true + }) + expect(mux.request).toHaveBeenNthCalledWith(2, 'git.branchDiff', { + worktreePath: '/home/user/repo', + baseRef: 'main', + includePatch: true, + filePath: 'src/other-file.ts', + __streamResponse: true + }) + }) + + it('coalesces matching branch diff heads while keeping distinct and absent heads separate', async () => { + const diffs = [{ kind: 'text', originalContent: 'old', modifiedContent: 'new' }] + const pendingDiff = deferredValue(diffs) + const firstHeadOid = 'a'.repeat(40) + const secondHeadOid = 'b'.repeat(40) + mux.request.mockReturnValue(pendingDiff.promise) + + const reads = [ + provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/file.ts', + headOid: firstHeadOid + }), + provider.getBranchDiff('/home/user/repo', 'main', { + filePath: 'src/file.ts', + headOid: firstHeadOid, + includePatch: true + }), + provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/file.ts', + headOid: secondHeadOid + }), + provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/file.ts' + }), + provider.getBranchDiff('/home/user/repo', 'main', { + includePatch: true, + filePath: 'src/file.ts', + headOid: undefined + }) + ] + + await waitForRequestCount(mux.request, 3) + expect(mux.request).toHaveBeenCalledTimes(3) + + pendingDiff.resolve() + await expect(Promise.all(reads)).resolves.toEqual(Array.from({ length: 5 }, () => diffs)) + }) + it('coalesces concurrent identical diff RPCs while in flight', async () => { const diff = { kind: 'text', diff --git a/src/main/providers/ssh-git-provider.ts b/src/main/providers/ssh-git-provider.ts index e4c306529ee..5b91eada817 100644 --- a/src/main/providers/ssh-git-provider.ts +++ b/src/main/providers/ssh-git-provider.ts @@ -41,6 +41,7 @@ type NonInteractiveExecQueueEntry = { } const NON_INTERACTIVE_TRANSPORT_TIMEOUT_MARGIN_MS = 5_000 +const ABSENT_BRANCH_DIFF_HEAD_OID = { absent: true } as const function isJsonRpcMethodNotFoundError(error: unknown): boolean { if (!error || typeof error !== 'object') { @@ -658,9 +659,10 @@ export class SshGitProvider implements IGitProvider { async getBranchDiff( worktreePath: string, baseRef: string, - options?: { includePatch?: boolean; filePath?: string; oldPath?: string } + options?: { includePatch?: boolean; filePath?: string; oldPath?: string; headOid?: string } ): Promise { const keyOptions = options ?? {} + const { headOid, ...relayOptions } = keyOptions return this.gitDiffReadDedupe.run( stableInFlightKey([ 'branchDiff', @@ -668,13 +670,15 @@ export class SshGitProvider implements IGitProvider { baseRef, keyOptions.includePatch ?? null, keyOptions.filePath ?? null, - keyOptions.oldPath ?? null + keyOptions.oldPath ?? null, + headOid === undefined ? ABSENT_BRANCH_DIFF_HEAD_OID : headOid ]), async () => (await requestGitStreamable(this.mux, 'git.branchDiff', { worktreePath, baseRef, - ...options + ...relayOptions, + ...(headOid === undefined ? {} : { headOid }) })) as GitDiffResult[] ) as Promise } diff --git a/src/main/runtime/orca-runtime-git-branch-diff.test.ts b/src/main/runtime/orca-runtime-git-branch-diff.test.ts new file mode 100644 index 00000000000..4c469758760 --- /dev/null +++ b/src/main/runtime/orca-runtime-git-branch-diff.test.ts @@ -0,0 +1,69 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' +import type { GlobalSettings } from '../../shared/types' +import { RuntimeGitCommands, type ResolvedRuntimeGitWorktree } from './orca-runtime-git' + +const getSshGitProviderMock = vi.hoisted(() => vi.fn()) + +vi.mock('../providers/ssh-git-dispatch', () => ({ + getSshGitProvider: getSshGitProviderMock +})) + +function makeWorktree(path: string): ResolvedRuntimeGitWorktree { + const worktree = { + id: 'wt-1', + repoId: 'repo-1', + path, + linkedIssue: null, + git: { + path, + branch: 'main', + isBare: false, + isMainWorktree: false, + head: 'a'.repeat(40) + } + } satisfies Partial + return worktree as unknown as ResolvedRuntimeGitWorktree +} + +describe('RuntimeGitCommands branch diff', () => { + beforeEach(() => { + getSshGitProviderMock.mockReset() + }) + + it('forwards the pinned head through normalized nested SSH paths', async () => { + const mergeBase = 'a'.repeat(40) + const headOid = 'b'.repeat(40) + const result = { + kind: 'text', + originalContent: 'left', + modifiedContent: 'right', + originalIsBinary: false, + modifiedIsBinary: false + } + const provider = { getBranchDiff: vi.fn().mockResolvedValue([result]) } + getSshGitProviderMock.mockReturnValue(provider) + const commands = new RuntimeGitCommands({ + resolveRuntimeGitTarget: async () => ({ + worktree: makeWorktree('/remote/repo'), + connectionId: 'conn-1' + }), + getRuntimeSettings: () => ({}) as GlobalSettings + }) + + await expect( + commands.getRuntimeGitBranchDiff( + 'id:wt-1', + { mergeBase, headOid }, + 'src\\file.ts', + 'src\\old-file.ts' + ) + ).resolves.toEqual(result) + + expect(provider.getBranchDiff).toHaveBeenCalledWith('/remote/repo', mergeBase, { + includePatch: true, + headOid, + filePath: 'src/file.ts', + oldPath: 'src/old-file.ts' + }) + }) +}) diff --git a/src/main/runtime/orca-runtime-git.ts b/src/main/runtime/orca-runtime-git.ts index 88fb102f7e9..0c1444c0294 100644 --- a/src/main/runtime/orca-runtime-git.ts +++ b/src/main/runtime/orca-runtime-git.ts @@ -538,6 +538,7 @@ export class RuntimeGitCommands { } const results = await provider.getBranchDiff(target.worktree.path, compare.mergeBase, { includePatch: true, + headOid: compare.headOid, filePath: relativePath, oldPath: oldRelativePath }) diff --git a/src/relay/git-handler-branch-diff-ops.ts b/src/relay/git-handler-branch-diff-ops.ts new file mode 100644 index 00000000000..98553266d85 --- /dev/null +++ b/src/relay/git-handler-branch-diff-ops.ts @@ -0,0 +1,50 @@ +import { buildDiffResult } from './git-diff-result' +import { readBlobAtOid, type GitBufferExec } from './git-handler-ops' + +const FULL_GIT_OBJECT_ID_PATTERN = /^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/ + +function assertFullGitObjectId(value: unknown, label: string): asserts value is string { + if (typeof value !== 'string' || !FULL_GIT_OBJECT_ID_PATTERN.test(value)) { + throw new Error(`${label} must be a full git object id`) + } +} + +export function parseOptionalBranchDiffHeadOid( + params: Record +): string | undefined { + if (!Object.hasOwn(params, 'headOid')) { + return undefined + } + const { headOid } = params + assertFullGitObjectId(headOid, 'headOid') + return headOid +} + +export async function branchDiffEntryAtPinnedOids( + gitBuffer: GitBufferExec, + worktreePath: string, + baseOid: string, + headOid: string, + filePath: string, + oldPath?: string +) { + assertFullGitObjectId(baseOid, 'baseRef') + assertFullGitObjectId(headOid, 'headOid') + try { + const [left, right] = await Promise.all([ + readBlobAtOid(gitBuffer, worktreePath, baseOid, oldPath ?? filePath), + readBlobAtOid(gitBuffer, worktreePath, headOid, filePath) + ]) + return [buildDiffResult(left.content, right.content, left.isBinary, right.isBinary, filePath)] + } catch { + return [ + { + kind: 'text' as const, + originalContent: '', + modifiedContent: '', + originalIsBinary: false, + modifiedIsBinary: false + } + ] + } +} diff --git a/src/relay/git-handler-branch-diff.test.ts b/src/relay/git-handler-branch-diff.test.ts new file mode 100644 index 00000000000..b52d459a3ca --- /dev/null +++ b/src/relay/git-handler-branch-diff.test.ts @@ -0,0 +1,305 @@ +import { execFileSync } from 'node:child_process' +import { mkdtempSync, rmSync, writeFileSync } from 'node:fs' +import { tmpdir } from 'node:os' +import * as path from 'node:path' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { RelayContext } from './context' +import { + branchDiffEntryAtPinnedOids, + parseOptionalBranchDiffHeadOid +} from './git-handler-branch-diff-ops' +import { GitHandler } from './git-handler' +import { branchDiffEntries, type GitBufferExec, type GitExec } from './git-handler-ops' +import { + createMockDispatcher, + gitCommit, + gitInit, + type MockDispatcher, + type RelayDispatcher +} from './git-handler-test-setup' + +const BASE_OID = 'a'.repeat(40) +const HEAD_OID = 'b'.repeat(40) +const OTHER_HEAD_OID = 'c'.repeat(40) +const FILE_PATH = 'src/file.ts' + +type GitBufferTarget = { + gitBuffer(args: string[], cwd: string): Promise +} + +type GitTarget = { + git(args: string[], cwd: string): Promise<{ stdout: string; stderr: string }> +} + +function deferredBuffer(): { promise: Promise; resolve: (content: string) => void } { + let resolve!: (value: Buffer) => void + const promise = new Promise((innerResolve) => { + resolve = innerResolve + }) + return { promise, resolve: (content) => resolve(Buffer.from(content)) } +} + +describe('pinned relay branch diff operation', () => { + it.each([ + { + name: 'addition', + status: `A\t${FILE_PATH}\n`, + left: new Error('missing'), + right: Buffer.from('added\n') + }, + { + name: 'deletion', + status: `D\t${FILE_PATH}\n`, + left: Buffer.from('deleted\n'), + right: new Error('missing') + }, + { + name: 'binary content', + status: `M\t${FILE_PATH}\n`, + left: Buffer.from([0, 1]), + right: Buffer.from([0, 2]) + }, + { + name: 'blob read failure', + status: `M\t${FILE_PATH}\n`, + left: new Error('left failed'), + right: new Error('right failed') + } + ])('matches the legacy $name result', async ({ status, left, right }) => { + const createGitBuffer = (): GitBufferExec => + vi.fn(async (args) => { + const value = args[2].startsWith(`${BASE_OID}:`) ? left : right + if (value instanceof Error) { + throw value + } + return value + }) + const git = vi.fn(async (args) => { + if (args[0] === 'rev-parse' && args.includes('HEAD')) { + return { stdout: `${HEAD_OID}\n`, stderr: '' } + } + if (args[0] === 'rev-parse' || args[0] === 'merge-base') { + return { stdout: `${BASE_OID}\n`, stderr: '' } + } + return { stdout: status, stderr: '' } + }) + + const pinned = await branchDiffEntryAtPinnedOids( + createGitBuffer(), + '/repo', + BASE_OID, + HEAD_OID, + FILE_PATH + ) + const legacy = await branchDiffEntries(git, createGitBuffer(), '/repo', BASE_OID, { + includePatch: true, + filePath: FILE_PATH + }) + + expect(pinned).toEqual(legacy) + }) + + it('treats an omitted head OID differently from a supplied invalid value', () => { + expect(parseOptionalBranchDiffHeadOid({})).toBeUndefined() + expect(() => parseOptionalBranchDiffHeadOid({ headOid: null })).toThrow( + 'headOid must be a full git object id' + ) + }) +}) + +describe('GitHandler pinned branch diff route', () => { + let dispatcher: MockDispatcher + let handler: GitHandler + + beforeEach(() => { + dispatcher = createMockDispatcher() + handler = new GitHandler(dispatcher as unknown as RelayDispatcher, new RelayContext()) + }) + + afterEach(() => { + handler.dispose() + vi.restoreAllMocks() + }) + + function request(overrides: Record = {}): Promise { + return dispatcher.callRequest('git.branchDiff', { + worktreePath: '/repo', + baseRef: BASE_OID, + headOid: HEAD_OID, + includePatch: true, + filePath: FILE_PATH, + ...overrides + }) + } + + it('starts exactly two pinned blob reads concurrently without metadata commands', async () => { + const left = deferredBuffer() + const right = deferredBuffer() + const gitBufferSpy = vi + .spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + .mockImplementation((args) => { + if (args[2] === `${BASE_OID}:${FILE_PATH}`) { + return left.promise + } + if (args[2] === `${HEAD_OID}:${FILE_PATH}`) { + return right.promise + } + throw new Error(`unexpected blob spec: ${args[2]}`) + }) + const gitSpy = vi + .spyOn(handler as unknown as GitTarget, 'git') + .mockRejectedValue(new Error('metadata command should not run')) + + const resultPromise = request() + await vi.waitFor(() => expect(gitBufferSpy).toHaveBeenCalledTimes(2)) + + expect(gitSpy).not.toHaveBeenCalled() + expect(gitBufferSpy.mock.calls.map(([args]) => args)).toEqual([ + ['show', '--end-of-options', `${BASE_OID}:${FILE_PATH}`], + ['show', '--end-of-options', `${HEAD_OID}:${FILE_PATH}`] + ]) + + left.resolve('before\n') + right.resolve('after\n') + await expect(resultPromise).resolves.toEqual([ + { + kind: 'text', + originalContent: 'before\n', + modifiedContent: 'after\n', + originalIsBinary: false, + modifiedIsBinary: false + } + ]) + }) + + it('reads the old path only from the base OID', async () => { + const oldPath = 'src/old-file.ts' + const gitBufferSpy = vi + .spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + .mockImplementation(async (args) => Buffer.from(args[2].startsWith(BASE_OID) ? 'old' : 'new')) + + await request({ oldPath }) + + expect(gitBufferSpy.mock.calls.map(([args]) => args[2])).toEqual([ + `${BASE_OID}:${oldPath}`, + `${HEAD_OID}:${FILE_PATH}` + ]) + }) + + it('coalesces the same head OID while keeping different heads independent', async () => { + const pending = deferredBuffer() + const gitBufferSpy = vi + .spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + .mockImplementation(() => pending.promise) + + const requests = [request(), request(), request({ headOid: OTHER_HEAD_OID })] + await vi.waitFor(() => expect(gitBufferSpy).toHaveBeenCalledTimes(4)) + + const specs = gitBufferSpy.mock.calls.map(([args]) => args[2]) + expect(specs.filter((spec) => spec === `${BASE_OID}:${FILE_PATH}`)).toHaveLength(2) + expect(specs.filter((spec) => spec === `${HEAD_OID}:${FILE_PATH}`)).toHaveLength(1) + expect(specs.filter((spec) => spec === `${OTHER_HEAD_OID}:${FILE_PATH}`)).toHaveLength(1) + + pending.resolve('content\n') + await Promise.all(requests) + }) + + it('rejects every supplied malformed head OID before running Git', async () => { + const gitBufferSpy = vi.spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + const invalidHeadOids = [null, 7, {}, '', 'a'.repeat(39), 'g'.repeat(40)] + + for (const headOid of invalidHeadOids) { + await expect(request({ headOid })).rejects.toThrow('headOid must be a full git object id') + } + + expect(gitBufferSpy).not.toHaveBeenCalled() + }) + + it('accepts SHA-256 object IDs', async () => { + const baseOid = 'A'.repeat(64) + const headOid = 'b'.repeat(64) + const gitBufferSpy = vi + .spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + .mockResolvedValue(Buffer.from('content\n')) + + await request({ baseRef: baseOid, headOid }) + + expect(gitBufferSpy.mock.calls.map(([args]) => args[2])).toEqual([ + `${baseOid}:${FILE_PATH}`, + `${headOid}:${FILE_PATH}` + ]) + }) + + it('requires a full base OID only on the pinned route', async () => { + const gitBufferSpy = vi.spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + + await expect(request({ baseRef: 'main' })).rejects.toThrow( + 'baseRef must be a full git object id' + ) + expect(gitBufferSpy).not.toHaveBeenCalled() + }) + + it('uses the legacy path when patch or file-path conditions are not met', async () => { + const gitSpy = vi + .spyOn(handler as unknown as GitTarget, 'git') + .mockImplementation(async (args) => { + if (args[0] === 'rev-parse' && args.includes('HEAD')) { + return { stdout: `${HEAD_OID}\n`, stderr: '' } + } + if (args[0] === 'rev-parse' || args[0] === 'merge-base') { + return { stdout: `${BASE_OID}\n`, stderr: '' } + } + return { stdout: '', stderr: '' } + }) + const gitBufferSpy = vi.spyOn(handler as unknown as GitBufferTarget, 'gitBuffer') + + await Promise.all([ + request({ baseRef: 'main', includePatch: false }), + request({ baseRef: 'main', filePath: '' }), + request({ baseRef: 'main', filePath: { malformed: true } }) + ]) + + expect(gitSpy).toHaveBeenCalledTimes(12) + expect(gitBufferSpy).not.toHaveBeenCalled() + }) + + it('keeps the requested head pinned after repository HEAD moves', async () => { + const repoPath = mkdtempSync(path.join(tmpdir(), 'relay-pinned-branch-diff-')) + try { + gitInit(repoPath) + writeFileSync(path.join(repoPath, 'file.txt'), 'base\n') + gitCommit(repoPath, 'base') + const baseOid = execFileSync('git', ['rev-parse', 'HEAD'], { + cwd: repoPath, + encoding: 'utf8' + }).trim() + + writeFileSync(path.join(repoPath, 'file.txt'), 'pinned\n') + gitCommit(repoPath, 'pinned') + const pinnedHeadOid = execFileSync('git', ['rev-parse', 'HEAD'], { + cwd: repoPath, + encoding: 'utf8' + }).trim() + + writeFileSync(path.join(repoPath, 'file.txt'), 'moved\n') + gitCommit(repoPath, 'moved') + + const result = (await request({ + worktreePath: repoPath, + baseRef: baseOid, + headOid: pinnedHeadOid, + filePath: 'file.txt' + })) as { originalContent: string; modifiedContent: string }[] + + expect(result[0]).toMatchObject({ + originalContent: 'base\n', + modifiedContent: 'pinned\n' + }) + expect( + execFileSync('git', ['show', 'HEAD:file.txt'], { cwd: repoPath, encoding: 'utf8' }) + ).toBe('moved\n') + } finally { + rmSync(repoPath, { recursive: true, force: true }) + } + }) +}) diff --git a/src/relay/git-handler.ts b/src/relay/git-handler.ts index 0abc9f5d5be..c3105ea588f 100644 --- a/src/relay/git-handler.ts +++ b/src/relay/git-handler.ts @@ -18,6 +18,10 @@ import { validateGitExecArgs, type GitExec } from './git-handler-ops' +import { + branchDiffEntryAtPinnedOids, + parseOptionalBranchDiffHeadOid +} from './git-handler-branch-diff-ops' import { buildSubmoduleInnerCommitRangeDiff, computeSubmodulePointerDiff, @@ -1148,6 +1152,7 @@ export class GitHandler { if (baseRef.startsWith('-')) { throw new Error('Base ref must not start with "-"') } + const headOid = parseOptionalBranchDiffHeadOid(params) const options = { includePatch: params.includePatch as boolean | undefined, filePath: params.filePath as string | undefined, @@ -1158,18 +1163,35 @@ export class GitHandler { 'branchDiff', worktreePath, baseRef, + headOid ?? null, options.includePatch ?? null, options.filePath ?? null, options.oldPath ?? null ]), - () => - branchDiffEntries( + () => { + if ( + headOid && + options.includePatch === true && + typeof options.filePath === 'string' && + options.filePath.length > 0 + ) { + return branchDiffEntryAtPinnedOids( + this.gitBuffer.bind(this), + worktreePath, + baseRef, + headOid, + options.filePath, + options.oldPath + ) + } + return branchDiffEntries( this.git.bind(this), this.gitBuffer.bind(this), worktreePath, baseRef, options ) + } ) return this.maybeStreamResponse(result, params, context) } diff --git a/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx b/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx index 3a5ed862d8e..e72ff75858e 100644 --- a/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx +++ b/src/renderer/src/components/editor/useEditorPanelContentState.test.tsx @@ -426,7 +426,7 @@ describe('useEditorPanelContentState', () => { connectionId: 'ssh-1' }), expect.objectContaining({ - compare: expect.objectContaining({ mergeBase: 'merge-base' }), + compare: expect.objectContaining({ headOid: 'head', mergeBase: 'merge-base' }), filePath: 'api/src/file.ts' }) )