mirror of
https://github.com/stablyai/orca.git
synced 2026-10-31 17:17:38 +00:00
Neil
61de2d8ec8
* test: load GitHub operations from their public modules * fix: sync required English entries after branch toast removal
691 lines
22 KiB
TypeScript
691 lines
22 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import type * as GithubApiRepositoryModule from './github-api-repository'
|
|
import type * as GitHubEnterpriseRepositoryModule from './github-enterprise-repository'
|
|
|
|
const { clientMocks, moduleMocks } = await vi.hoisted(async () => {
|
|
const moduleMocks = await import('./client-test-mocks')
|
|
return { clientMocks: moduleMocks.createGitHubClientMocks(), moduleMocks }
|
|
})
|
|
|
|
vi.mock('./gh-utils', () => moduleMocks.ghUtilsModuleMock(clientMocks))
|
|
vi.mock('../git/runner', () => moduleMocks.gitRunnerModuleMock(clientMocks))
|
|
vi.mock('../providers/ssh-git-dispatch', () => moduleMocks.sshGitDispatchModuleMock(clientMocks))
|
|
vi.mock('./local-git-config-signature', () =>
|
|
moduleMocks.localGitConfigSignatureModuleMock(clientMocks)
|
|
)
|
|
vi.mock('./github-enterprise-repository', async (importOriginal) =>
|
|
moduleMocks.githubEnterpriseRepositoryModuleMock(
|
|
await importOriginal<typeof GitHubEnterpriseRepositoryModule>()
|
|
)
|
|
)
|
|
vi.mock('./rate-limit', () => moduleMocks.rateLimitModuleMock(clientMocks))
|
|
vi.mock('./github-api-repository', async (importOriginal) =>
|
|
moduleMocks.githubApiRepositoryModuleMock(
|
|
clientMocks,
|
|
await importOriginal<typeof GithubApiRepositoryModule>()
|
|
)
|
|
)
|
|
|
|
import { getPRForBranch } from './client/lookup/get-pr-for-branch'
|
|
import { mergePR } from './client/merge/merge-pr'
|
|
import { resetGraphQLRateLimitGuardMocks } from './client-test-harness'
|
|
|
|
const { ghExecFileAsyncMock, getOwnerRepoMock, acquireMock, releaseMock } = clientMocks
|
|
|
|
describe('GitHub GraphQL rate-limit guard', () => {
|
|
beforeEach(() => {
|
|
resetGraphQLRateLimitGuardMocks(clientMocks)
|
|
})
|
|
|
|
afterEach(() => vi.restoreAllMocks())
|
|
|
|
it('hydrates GitHub-registered stack metadata for exact linked PRs', async () => {
|
|
getOwnerRepoMock.mockResolvedValue({ owner: 'stablyai', repo: 'orca', host: 'github.com' })
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Stack API',
|
|
state: 'OPEN',
|
|
url: 'https://github.com/stablyai/orca/pull/202',
|
|
statusCheckRollup: [],
|
|
updatedAt: '2026-08-10T00:00:00Z',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
baseRefName: 'stack/models',
|
|
headRefName: 'stack/api',
|
|
headRefOid: 'api-sha'
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Stack API',
|
|
state: 'open',
|
|
html_url: 'https://github.com/stablyai/orca/pull/202',
|
|
head: { ref: 'stack/api', sha: 'api-sha' },
|
|
base: { ref: 'stack/models', sha: 'models-sha' },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: 'main-sha' }
|
|
}
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
data: {
|
|
repository: {
|
|
pullRequest: {
|
|
stack: {
|
|
number: 51,
|
|
size: 2,
|
|
baseRefName: 'main',
|
|
entries: {
|
|
nodes: [
|
|
{
|
|
position: 1,
|
|
pullRequest: {
|
|
number: 201,
|
|
title: 'Stack models',
|
|
url: 'https://github.com/stablyai/orca/pull/201',
|
|
state: 'OPEN',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
statusCheckRollup: { state: 'SUCCESS' }
|
|
}
|
|
},
|
|
{
|
|
position: 2,
|
|
pullRequest: {
|
|
number: 202,
|
|
title: 'Stack API',
|
|
url: 'https://github.com/stablyai/orca/pull/202',
|
|
state: 'OPEN',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
statusCheckRollup: { state: 'SUCCESS' }
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
data: {
|
|
repository: {
|
|
mergeQueue: null,
|
|
ref: { rules: { nodes: [{ type: 'MERGE_QUEUE' }] } }
|
|
}
|
|
}
|
|
})
|
|
})
|
|
|
|
const pr = await getPRForBranch('/repo-root', 'stack/api', 202)
|
|
|
|
expect(pr?.stack).toMatchObject({
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
baseRefName: 'main',
|
|
entries: [
|
|
{ number: 201, position: 1 },
|
|
{ number: 202, position: 2 }
|
|
]
|
|
})
|
|
expect(pr?.mergeQueueRequired).toBe(true)
|
|
const mergeQueueMetadataCall = ghExecFileAsyncMock.mock.calls.find(
|
|
([args]) => args.includes('graphql') && args.includes('branch=main')
|
|
)
|
|
expect(mergeQueueMetadataCall?.[0]).toEqual(expect.arrayContaining(['-f', 'branch=main']))
|
|
})
|
|
|
|
const validStackHeadSha = 'a'.repeat(40)
|
|
const validStackBaseSha = 'b'.repeat(40)
|
|
const validSha256HeadSha = 'c'.repeat(64)
|
|
|
|
it.each([
|
|
{
|
|
objectFormat: 'SHA-1 with a base SHA',
|
|
headSha: validStackHeadSha,
|
|
baseSha: validStackBaseSha
|
|
},
|
|
{
|
|
objectFormat: 'SHA-256 without a base SHA',
|
|
headSha: validSha256HeadSha,
|
|
baseSha: undefined
|
|
}
|
|
])('uses async merge only for GitHub-registered stacks using $objectFormat', async (scenario) => {
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Stack API',
|
|
state: 'open',
|
|
head: { ref: 'stack/api', sha: scenario.headSha },
|
|
base: { ref: 'stack/models', sha: 'models-sha' },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: {
|
|
ref: 'main',
|
|
...(scenario.baseSha ? { sha: scenario.baseSha } : {})
|
|
}
|
|
}
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({ data: { repository: { mergeQueue: { id: 'MQ_kw' } } } })
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({ status: 'enqueued', details: { message: 'Queued' } })
|
|
})
|
|
|
|
await expect(
|
|
mergePR('/repo-root', 202, 'squash', undefined, {
|
|
owner: 'stablyai',
|
|
repo: 'orca',
|
|
host: 'github.com'
|
|
})
|
|
).resolves.toEqual({ ok: true })
|
|
|
|
const mergeCall = ghExecFileAsyncMock.mock.calls.find(([args]) =>
|
|
args.includes('repos/stablyai/orca/pulls/202/merge-async')
|
|
)
|
|
expect(mergeCall?.[0]).toEqual(
|
|
expect.arrayContaining([
|
|
'PUT',
|
|
'repos/stablyai/orca/pulls/202/merge-async',
|
|
'merge_action=merge_queue',
|
|
`sha=${scenario.headSha}`
|
|
])
|
|
)
|
|
expect(mergeCall?.[0]).not.toContain('merge_method=squash')
|
|
expect(acquireMock).toHaveBeenCalledTimes(2)
|
|
expect(releaseMock).toHaveBeenCalledTimes(2)
|
|
expect(
|
|
ghExecFileAsyncMock.mock.calls.some(([args]) => args[0] === 'pr' && args[1] === 'merge')
|
|
).toBe(false)
|
|
})
|
|
|
|
it('never falls back to legacy merge after an async stack merge transport failure', async () => {
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
state: 'open',
|
|
head: { ref: 'stack/api', sha: validStackHeadSha },
|
|
base: { ref: 'stack/models', sha: 'models-sha' },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({ data: { repository: { mergeQueue: null } } })
|
|
})
|
|
.mockRejectedValueOnce(new Error('socket closed after request submission'))
|
|
|
|
await expect(
|
|
mergePR('/repo-root', 202, 'squash', undefined, {
|
|
owner: 'stablyai',
|
|
repo: 'orca',
|
|
host: 'github.com'
|
|
})
|
|
).resolves.toEqual({ ok: false, error: 'socket closed after request submission' })
|
|
expect(
|
|
ghExecFileAsyncMock.mock.calls.some(([args]) => args[0] === 'pr' && args[1] === 'merge')
|
|
).toBe(false)
|
|
})
|
|
|
|
const stackMetadataUnavailableError =
|
|
'Could not verify GitHub pull request stack metadata. Refresh and try again.'
|
|
|
|
it.each([
|
|
{
|
|
failure: 'local transport failure',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: new Error('stack metadata unavailable'),
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'stack metadata unavailable',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'GitHub Enterprise transport failure',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: new Error('enterprise stack metadata unavailable'),
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'enterprise stack metadata unavailable',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.enterprise.test' }
|
|
},
|
|
{
|
|
failure: 'unparsable probe response over SSH',
|
|
repoPath: '/remote/repo-root',
|
|
connectionId: 'ssh-1',
|
|
probeResponse: { stdout: '' },
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'invalid JSON response',
|
|
expectedOptions: { host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'valid JSON with a non-object payload',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: { stdout: 'null' },
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'invalid response shape',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'valid JSON with an array payload',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: { stdout: '[]' },
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'invalid response shape',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'present primitive stack metadata',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: true
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'malformed stack response',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: '2',
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'incoherent stack position',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 3,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'non-positive stack number',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 0,
|
|
position: 1,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'fractional stack size',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 1,
|
|
size: 1.5,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'unsafe stack number',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: Number.MAX_SAFE_INTEGER + 1,
|
|
position: 1,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'blank stack base ref',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: ' ', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'invalid stack base SHA',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: 123 }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'invalid string stack base SHA',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { sha: validStackHeadSha },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: 'not-a-git-object-id' }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'malformed stack',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'registered stack response without a head SHA',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { ref: 'stack/api' },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'missing head SHA',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'registered stack response with an invalid head SHA',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { ref: 'stack/api', sha: {} },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'missing head SHA',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
},
|
|
{
|
|
failure: 'registered stack response with an invalid string head SHA',
|
|
repoPath: '/repo-root',
|
|
connectionId: undefined,
|
|
probeResponse: {
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
head: { ref: 'stack/api', sha: 'not-a-git-object-id' },
|
|
stack: {
|
|
number: 51,
|
|
position: 2,
|
|
size: 2,
|
|
base: { ref: 'main', sha: validStackBaseSha }
|
|
}
|
|
})
|
|
},
|
|
expectedError: stackMetadataUnavailableError,
|
|
expectedDiagnostic: 'missing head SHA',
|
|
expectedOptions: { cwd: '/repo-root', host: 'github.com' }
|
|
}
|
|
])('fails closed on $failure', async (scenario) => {
|
|
const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
|
|
if (scenario.probeResponse instanceof Error) {
|
|
ghExecFileAsyncMock.mockRejectedValueOnce(scenario.probeResponse)
|
|
} else {
|
|
ghExecFileAsyncMock.mockResolvedValueOnce(scenario.probeResponse)
|
|
}
|
|
// Why: disabling the guard must expose the legacy merge fallthrough, not fail on an unstubbed call.
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Stack API',
|
|
state: 'OPEN',
|
|
url: 'https://github.com/stablyai/orca/pull/202',
|
|
statusCheckRollup: [],
|
|
updatedAt: '2026-08-10T00:00:00Z',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
baseRefName: 'stack/models',
|
|
headRefName: 'stack/api',
|
|
headRefOid: 'api-sha'
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({ stdout: '', stderr: '' })
|
|
|
|
const result = await mergePR(scenario.repoPath, 202, 'squash', scenario.connectionId, {
|
|
owner: 'stablyai',
|
|
repo: 'orca',
|
|
host: scenario.expectedOptions.host
|
|
})
|
|
|
|
expect.soft(result).toEqual({ ok: false, error: scenario.expectedError })
|
|
expect
|
|
.soft(ghExecFileAsyncMock.mock.calls.map(([args]) => args))
|
|
.toEqual([['api', 'repos/stablyai/orca/pulls/202']])
|
|
expect.soft(ghExecFileAsyncMock.mock.calls[0]?.[1]).toEqual(scenario.expectedOptions)
|
|
expect
|
|
.soft(
|
|
ghExecFileAsyncMock.mock.calls.some(([args]) =>
|
|
args.includes('repos/stablyai/orca/pulls/202/merge-async')
|
|
)
|
|
)
|
|
.toBe(false)
|
|
expect
|
|
.soft(
|
|
ghExecFileAsyncMock.mock.calls.some(([args]) => args[0] === 'pr' && args[1] === 'merge')
|
|
)
|
|
.toBe(false)
|
|
expect.soft(acquireMock).toHaveBeenCalledTimes(1)
|
|
expect.soft(releaseMock).toHaveBeenCalledTimes(1)
|
|
expect
|
|
.soft(consoleWarnSpy)
|
|
.toHaveBeenCalledWith(
|
|
'mergePR stack metadata probe failed for stablyai/orca#202:',
|
|
scenario.expectedDiagnostic
|
|
)
|
|
expect.soft(consoleWarnSpy).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it.each([
|
|
{ stackVariant: 'omits stack', stackField: {} },
|
|
{ stackVariant: 'sets stack to null', stackField: { stack: null } }
|
|
])('keeps legacy merge when an ordinary GitHub response $stackVariant', async (scenario) => {
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 13866,
|
|
title: 'Fail closed on unavailable stack metadata',
|
|
state: 'open',
|
|
head: {
|
|
ref: 'sta-3924-stack-merge-fail-closed',
|
|
sha: validStackHeadSha
|
|
},
|
|
base: { ref: 'main', sha: validStackBaseSha },
|
|
...scenario.stackField
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 13866,
|
|
title: 'Fail closed on unavailable stack metadata',
|
|
state: 'OPEN',
|
|
url: 'https://github.com/stablyai/orca/pull/13866',
|
|
statusCheckRollup: [],
|
|
updatedAt: '2026-08-11T00:00:00Z',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
baseRefName: 'main',
|
|
baseRefOid: validStackBaseSha,
|
|
headRefName: 'sta-3924-stack-merge-fail-closed',
|
|
headRefOid: validStackHeadSha
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({ stdout: '', stderr: '' })
|
|
|
|
await expect(
|
|
mergePR('/repo-root', 13866, 'squash', undefined, {
|
|
owner: 'stablyai',
|
|
repo: 'orca',
|
|
host: 'github.com'
|
|
})
|
|
).resolves.toEqual({ ok: true })
|
|
|
|
expect(ghExecFileAsyncMock).toHaveBeenNthCalledWith(
|
|
3,
|
|
['pr', 'merge', '13866', '--squash', '--repo', 'stablyai/orca'],
|
|
expect.objectContaining({ env: expect.objectContaining({ GH_PROMPT_DISABLED: '1' }) })
|
|
)
|
|
expect(acquireMock).toHaveBeenCalledTimes(1)
|
|
expect(releaseMock).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it('keeps legacy merge for unregistered dependent PR chains', async () => {
|
|
ghExecFileAsyncMock
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Dependent API',
|
|
state: 'open',
|
|
head: { ref: 'feature/api', sha: 'api-sha' },
|
|
base: { ref: 'feature/models', sha: 'models-sha' },
|
|
stack: null
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({
|
|
stdout: JSON.stringify({
|
|
number: 202,
|
|
title: 'Dependent API',
|
|
state: 'OPEN',
|
|
url: 'https://github.com/stablyai/orca/pull/202',
|
|
statusCheckRollup: [],
|
|
updatedAt: '2026-08-10T00:00:00Z',
|
|
isDraft: false,
|
|
mergeable: 'MERGEABLE',
|
|
baseRefName: 'feature/models',
|
|
headRefOid: 'api-sha'
|
|
})
|
|
})
|
|
.mockResolvedValueOnce({ stdout: '', stderr: '' })
|
|
|
|
await expect(
|
|
mergePR('/repo-root', 202, 'squash', undefined, {
|
|
owner: 'stablyai',
|
|
repo: 'orca',
|
|
host: 'github.com'
|
|
})
|
|
).resolves.toEqual({ ok: true })
|
|
|
|
expect(ghExecFileAsyncMock).toHaveBeenNthCalledWith(
|
|
3,
|
|
['pr', 'merge', '202', '--squash', '--repo', 'stablyai/orca'],
|
|
expect.objectContaining({ env: expect.objectContaining({ GH_PROMPT_DISABLED: '1' }) })
|
|
)
|
|
})
|
|
})
|