ccfa60c1f2
All checks were successful
CI (PR) / checks (pull_request) Successful in 3m5s
PR Ready + auto-merge / ready-automerge (pull_request) Successful in 4m40s
Promote plan-issue Related on main merge / plan-issue-ready (pull_request) Has been skipped
Main merge flips claimed issues to done + in-prod / issue-done (pull_request) Successful in 13s
O sintoma primário da Issue (deadlock do waitForChecks no próprio pending) já tinha sido entregue pelo OPS61. O secundário — o rollup `checks` reportava SUCCESS com um shard de e2e vermelho porque o Forgejo 9.0.3 reporta o resultado do ÚLTIMO shard como o parent de matrix no `needs` (runs 604/607/610; o `needs.<job>.results` do GitHub não existe neste runner) — foi eliminado estruturalmente pelo OPS62 (mergeado durante a execução): ci-pr.yml e ci.yml viraram jobs únicos sequenciais, sem matrix/shard, e o status do job `checks` já é o veredito honesto da cascata. O que este item entrega: (a) teste-pino no waitForChecks (cenário run 607: rollup verde + shard vermelho → o CLI LANÇA "Checks falharam" — nunca confia no rollup sozinho; invariante de defesa válido e que pegaria qualquer matrix que volte); (b) docs honestas (agent-pr-workflow.mdc, AGENT-OPS.md) com a narrativa do parent de matrix e da eliminação estrutural pelo OPS62. O script ci-rollup-check.mjs e os edits de workflow planejados foram descartados no gate (redundantes pós-OPS62). Unit 2392 verdes; gates locais ok.
855 lines
25 KiB
TypeScript
855 lines
25 KiB
TypeScript
import { afterEach, describe, expect, it, vi } from 'vitest'
|
|
|
|
import { createApi } from '../../scripts/lib/forgejo-api.mjs'
|
|
|
|
type FetchCall = {
|
|
url: string
|
|
method?: string
|
|
init?: { headers?: Record<string, string>; method?: string; body?: string }
|
|
body?: unknown
|
|
}
|
|
|
|
const ok = (body: unknown, status = 200) =>
|
|
new Response(typeof body === 'string' ? body : JSON.stringify(body), {
|
|
status,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
})
|
|
|
|
describe('forgejo-api', () => {
|
|
it('builds the request with token, JSON body and explicit User-Agent', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
base: 'https://git.solla.dev/api/v1',
|
|
token: 'tok',
|
|
repository: 'fsolla/teqo',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push({ url: String(url), init })
|
|
return ok({ number: 1, title: 'x', body: '', state: 'open', created_at: '', labels: [] })
|
|
},
|
|
})
|
|
|
|
await api.createIssue({ title: 't', body: 'b' })
|
|
|
|
expect(calls).toHaveLength(1)
|
|
expect(calls[0].url).toBe('https://git.solla.dev/api/v1/repos/fsolla/teqo/issues')
|
|
expect(calls[0].init!.method).toBe('POST')
|
|
expect(calls[0].init!.headers!.Authorization).toBe('token tok')
|
|
expect(calls[0].init!.headers!['User-Agent']).toContain('teqo-agent-scripts')
|
|
expect(JSON.parse(calls[0].init!.body!)).toEqual({ title: 't', body: 'b' })
|
|
})
|
|
|
|
it('defaults the base URL to git.solla.dev with the default repo path', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
calls.push({ url: String(url) })
|
|
return ok([{ number: 1, title: '', body: '', state: 'open', created_at: '', labels: [] }])
|
|
},
|
|
})
|
|
|
|
await api.listIssues()
|
|
|
|
expect(calls[0].url).toContain('https://git.solla.dev/api/v1/repos/fsolla/teqo/issues?')
|
|
})
|
|
|
|
it('normalizes state and labels to the gh-flavored contract', async () => {
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async () =>
|
|
ok({
|
|
number: 7,
|
|
title: 't',
|
|
body: 'b',
|
|
state: 'closed',
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
labels: [{ name: 'ready', color: '0E8A16' }],
|
|
}),
|
|
})
|
|
|
|
const issue = await api.getIssue(7)
|
|
|
|
expect(issue.state).toBe('CLOSED')
|
|
expect(issue.labels).toEqual([{ name: 'ready', color: '0E8A16' }])
|
|
expect(issue.createdAt).toBe('2026-01-01T00:00:00Z')
|
|
})
|
|
|
|
it('throws with the API error body on non-2xx', async () => {
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return ok('{"message":"nope"}', 403)
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/403/)
|
|
await expect(api.listIssues()).rejects.toThrow(/nope/)
|
|
expect(calls).toBe(2)
|
|
})
|
|
|
|
it('fails closed when no token is available', async () => {
|
|
delete process.env.FORGEJO_API_TOKEN
|
|
delete process.env.GITHUB_TOKEN
|
|
const api = createApi({ fetchImpl: async () => ok('[]') })
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/Sem token/)
|
|
})
|
|
|
|
it('setLabels removes by id and adds by name', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push({ url: String(url), method: init?.method, body: init?.body })
|
|
if (String(url).endsWith('/labels') && init?.method === 'GET') {
|
|
return ok([{ name: 'blocked', id: 42 }])
|
|
}
|
|
return ok(null)
|
|
},
|
|
})
|
|
|
|
await api.setLabels(5, { add: ['ready'], remove: ['blocked'] })
|
|
|
|
expect(calls.map((call) => [call.method, call.url])).toEqual([
|
|
['GET', 'https://git.solla.dev/api/v1/repos/fsolla/teqo/issues/5/labels'],
|
|
['DELETE', 'https://git.solla.dev/api/v1/repos/fsolla/teqo/issues/5/labels/42'],
|
|
['POST', 'https://git.solla.dev/api/v1/repos/fsolla/teqo/issues/5/labels'],
|
|
])
|
|
expect(JSON.parse(calls[2].body as string)).toEqual({ labels: ['ready'] })
|
|
})
|
|
|
|
it('workflowDispatch posts inputs and ref', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push({ url: String(url), body: JSON.parse(String(init?.body ?? '{}')) })
|
|
return ok(null)
|
|
},
|
|
})
|
|
|
|
await api.workflowDispatch('agent-pool.yml', { ref: 'main', inputs: { action: 'tick' } })
|
|
|
|
expect(calls[0].url).toContain('/actions/workflows/agent-pool.yml/dispatches')
|
|
expect(calls[0].body).toEqual({ ref: 'main', inputs: { action: 'tick' } })
|
|
})
|
|
|
|
it('merges with rebase (repo canonical merge style)', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push({ url: String(url), body: JSON.parse(String(init?.body ?? '{}')) })
|
|
return ok(null)
|
|
},
|
|
})
|
|
|
|
await api.mergePullRequest(4)
|
|
|
|
expect(calls[0].url).toContain('/pulls/4/merge')
|
|
expect(calls[0].body).toEqual({ Do: 'rebase' })
|
|
})
|
|
|
|
it('waitForChecks returns once every status is settled and no failure exists', async () => {
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
poll += 1
|
|
const statuses =
|
|
poll < 2
|
|
? [{ context: 'CI / static', status: 'pending' }]
|
|
: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
]
|
|
return ok({ statuses })
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(pr).toBeTruthy()
|
|
expect(poll).toBe(2)
|
|
})
|
|
|
|
it('waitForChecks keeps polling while mergeable is still being computed', async () => {
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
poll += 1
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: poll < 2 ? null : true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(poll).toBe(2)
|
|
expect(pr.mergeable).toBe(true)
|
|
})
|
|
|
|
it('waitForChecks fails fast when the PR is not mergeable', async () => {
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: false,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
await expect(api.waitForChecks(4, { pollMs: 1 })).rejects.toThrow(/não mergeável/)
|
|
})
|
|
|
|
it('waitForChecks stops when the PR is converted to draft mid-wait (OPS57 veto)', async () => {
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
poll += 1
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
is_draft: poll >= 3,
|
|
head: { ref: 'OPS57-x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses:
|
|
poll <= 2
|
|
? [{ context: 'CI / static', status: 'pending' }]
|
|
: [{ context: 'CI / static', status: 'success' }],
|
|
})
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(poll).toBe(3)
|
|
expect(pr.isDraft).toBe(true)
|
|
})
|
|
|
|
it('waitForChecks keeps polling while the CI (PR) checks rollup has not posted (OPS61 gate)', async () => {
|
|
let statusPoll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
statusPoll += 1
|
|
// First snapshots: every POSTED status is green — but jobs that were
|
|
// not scheduled yet (docs-guards/unit/checks) posted nothing. The
|
|
// rollup is the only context that exists once the WHOLE cascade
|
|
// settled; without the gate a snapshot can look green before the
|
|
// cascade finished.
|
|
const statuses =
|
|
statusPoll < 3
|
|
? [{ context: 'CI / static', status: 'success' }]
|
|
: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
]
|
|
return ok({ statuses })
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(pr).toBeTruthy()
|
|
expect(statusPoll).toBe(3)
|
|
})
|
|
|
|
it('waitForChecks throws when the CI (PR) checks rollup reports failure', async () => {
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'failure' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
await expect(api.waitForChecks(4, { pollMs: 1 })).rejects.toThrow(/Checks falharam/)
|
|
})
|
|
|
|
it('waitForChecks throws when a matrix shard is red even if the rollup is green (run 607, OPS64)', async () => {
|
|
// Forgejo reports the LAST shard's result as the matrix parent result, so
|
|
// the ci-pr `checks` rollup job can post SUCCESS with e2e (1) red (runs
|
|
// 604/607/610). The CLI must NEVER trust the rollup alone: it scans the
|
|
// individual shard statuses (`CI (PR) / e2e (1)` = failure) and refuses to
|
|
// merge — this is what kept PR #55 out of main red in run 607.
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 55,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'OPS59-x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / e2e (1) (pull_request)', status: 'failure' },
|
|
{ context: 'CI (PR) / e2e (2) (pull_request)', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
await expect(api.waitForChecks(55, { pollMs: 1 })).rejects.toThrow(/Checks falharam/)
|
|
})
|
|
|
|
it('waitForChecks ignores the safety-net own status, pending for the whole run (OPS61 finding)', async () => {
|
|
let statusPoll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
statusPoll += 1
|
|
// Forgejo posts the job's own commit status as pending at job start
|
|
// and flips it only at the end — the pre-OPS61 `pending.length === 0`
|
|
// gate was unsatisfiable and no PR was ever merged by the CLI (every
|
|
// Forgejo merge was manual). The own context must never gate.
|
|
return ok({
|
|
statuses: [
|
|
{
|
|
context: 'PR Ready + auto-merge / ready-automerge (pull_request)',
|
|
status: 'pending',
|
|
},
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(pr).toBeTruthy()
|
|
expect(statusPoll).toBe(1)
|
|
})
|
|
|
|
it('waitForChecks does not treat mergeable=false as conflict before the rollup settles (OPS61)', async () => {
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url) => {
|
|
if (String(url).includes('/pulls/')) {
|
|
poll += 1
|
|
const settled = poll >= 3
|
|
return ok({
|
|
number: 4,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: settled ? true : false,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses:
|
|
poll < 3
|
|
? [{ context: 'CI / static', status: 'success' }]
|
|
: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
const pr = await api.waitForChecks(4, { pollMs: 1 })
|
|
|
|
expect(poll).toBe(3)
|
|
expect(pr.mergeable).toBe(true)
|
|
})
|
|
|
|
it('autoMerge verifies the merge by re-reading the PR (POST answers 200 + empty body)', async () => {
|
|
const calls: string[] = []
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push(`${init?.method ?? 'GET'} ${url}`)
|
|
if (String(url).includes('/merge')) return new Response('', { status: 200 })
|
|
if (String(url).includes('/pulls/')) {
|
|
poll += 1
|
|
const merged = poll > 1
|
|
return ok({
|
|
number: 27,
|
|
state: merged ? 'closed' : 'open',
|
|
merged,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
const result = await api.autoMerge(27, { pollMs: 1 })
|
|
|
|
expect(result).toEqual({
|
|
attempted: true,
|
|
merged: true,
|
|
pr: expect.objectContaining({ merged: true }),
|
|
})
|
|
expect(calls.filter((call) => call.includes('/merge'))).toHaveLength(1)
|
|
expect(
|
|
calls.filter(
|
|
(call) => call === 'GET https://git.solla.dev/api/v1/repos/fsolla/teqo/pulls/27',
|
|
),
|
|
).toHaveLength(2)
|
|
})
|
|
|
|
it('autoMerge rethrows when the merge POST fails and the PR stays open', async () => {
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, _init) => {
|
|
if (String(url).includes('/merge'))
|
|
return ok('{"message":"PR not in mergeable state"}', 405)
|
|
if (String(url).includes('/pulls/')) {
|
|
return ok({
|
|
number: 27,
|
|
state: 'open',
|
|
merged: false,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
await expect(api.autoMerge(27, { pollMs: 1 })).rejects.toThrow(/405/)
|
|
})
|
|
|
|
it('autoMerge reports merged when a concurrent actor merged after our POST failed', async () => {
|
|
let poll = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, _init) => {
|
|
if (String(url).includes('/merge'))
|
|
return ok('{"message":"Pull request was already merged"}', 405)
|
|
if (String(url).includes('/pulls/')) {
|
|
poll += 1
|
|
const merged = poll > 1
|
|
return ok({
|
|
number: 27,
|
|
state: merged ? 'closed' : 'open',
|
|
merged,
|
|
mergeable: true,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
}
|
|
return ok({
|
|
statuses: [
|
|
{ context: 'CI / static', status: 'success' },
|
|
{ context: 'CI (PR) / checks (pull_request)', status: 'success' },
|
|
],
|
|
})
|
|
},
|
|
})
|
|
|
|
const result = await api.autoMerge(27, { pollMs: 1 })
|
|
|
|
expect(result).toEqual({
|
|
attempted: true,
|
|
merged: true,
|
|
pr: expect.objectContaining({ merged: true }),
|
|
})
|
|
})
|
|
|
|
it('autoMerge is a no-op for an already merged PR (no POST)', async () => {
|
|
const calls: string[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push(`${init?.method ?? 'GET'} ${url}`)
|
|
return ok({
|
|
number: 4,
|
|
state: 'closed',
|
|
merged: true,
|
|
mergeable: false,
|
|
head: { ref: 'x', sha: 'abc' },
|
|
})
|
|
},
|
|
})
|
|
|
|
const result = await api.autoMerge(4, { pollMs: 1 })
|
|
|
|
expect(result).toEqual({
|
|
attempted: false,
|
|
merged: true,
|
|
pr: expect.objectContaining({ merged: true }),
|
|
})
|
|
expect(calls.some((call) => call.includes('/merge'))).toBe(false)
|
|
})
|
|
|
|
it('getFileContents decodes base64 and updateFile sends sha', async () => {
|
|
const calls: FetchCall[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
fetchImpl: async (url, init) => {
|
|
calls.push({
|
|
url: String(url),
|
|
method: init?.method,
|
|
body: init?.body ? JSON.parse(String(init.body)) : null,
|
|
})
|
|
if (init?.method === 'GET') {
|
|
return ok({ content: Buffer.from('{"a":1}').toString('base64'), sha: 'shasha' })
|
|
}
|
|
return ok(null)
|
|
},
|
|
})
|
|
|
|
const file = await api.getFileContents('pool-state.json', 'pool-state')
|
|
expect(file.content).toBe('{"a":1}')
|
|
expect(file.sha).toBe('shasha')
|
|
|
|
await api.updateFile('pool-state.json', {
|
|
message: 'm',
|
|
content: '{"a":2}',
|
|
branch: 'pool-state',
|
|
sha: 'shasha',
|
|
})
|
|
expect(calls.at(-1)!.method).toBe('PUT')
|
|
expect(
|
|
Buffer.from((calls.at(-1)!.body as { content: string }).content, 'base64').toString(),
|
|
).toBe('{"a":2}')
|
|
expect((calls.at(-1)!.body as { sha: string }).sha).toBe('shasha')
|
|
})
|
|
|
|
describe('retry with backoff (OPS67)', () => {
|
|
const issueOk = [{ number: 1, title: '', body: '', state: 'open', created_at: '', labels: [] }]
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks()
|
|
})
|
|
|
|
const silentWarn = () => vi.spyOn(console, 'warn').mockImplementation(() => {})
|
|
|
|
const brokenBody = () =>
|
|
new Response(
|
|
new ReadableStream({
|
|
start: (controller) => controller.error(new TypeError('terminated')),
|
|
}),
|
|
{ status: 200 },
|
|
)
|
|
|
|
it('retries a transient network failure and succeeds', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const sleeps: number[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 100,
|
|
jitter: false,
|
|
sleepImpl: async (ms) => {
|
|
sleeps.push(ms)
|
|
},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
if (calls === 1) throw new TypeError('fetch failed')
|
|
return ok(issueOk)
|
|
},
|
|
})
|
|
|
|
const issues = await api.listIssues()
|
|
|
|
expect(calls).toBe(2)
|
|
expect(sleeps).toEqual([100])
|
|
expect(issues).toHaveLength(1)
|
|
})
|
|
|
|
it('retries a transient network failure on write methods too', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
jitter: false,
|
|
sleepImpl: async () => {},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
if (calls === 1) throw new TypeError('fetch failed')
|
|
return ok(null)
|
|
},
|
|
})
|
|
|
|
await api.addComment(1, 'x')
|
|
|
|
expect(calls).toBe(2)
|
|
})
|
|
|
|
it('retries a GET whose body stream drops mid-read', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
jitter: false,
|
|
sleepImpl: async () => {},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return calls === 1 ? brokenBody() : ok(issueOk)
|
|
},
|
|
})
|
|
|
|
const issues = await api.listIssues()
|
|
|
|
expect(calls).toBe(2)
|
|
expect(issues).toHaveLength(1)
|
|
})
|
|
|
|
it('does not retry a write whose body drops after a status was received', async () => {
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return calls === 1 ? brokenBody() : ok(null)
|
|
},
|
|
})
|
|
|
|
await expect(api.addComment(1, 'x')).rejects.toThrow(/terminated/)
|
|
expect(calls).toBe(1)
|
|
})
|
|
|
|
it('throws after exhausting retries on a persistent network failure', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
jitter: false,
|
|
sleepImpl: async () => {},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
throw new TypeError('fetch failed')
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/fetch failed/)
|
|
expect(calls).toBe(3)
|
|
})
|
|
|
|
it('honors retries: 0 as a single attempt', async () => {
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 0,
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
throw new TypeError('fetch failed')
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/fetch failed/)
|
|
expect(calls).toBe(1)
|
|
})
|
|
|
|
it('grows the backoff exponentially between retries', async () => {
|
|
const warn = silentWarn()
|
|
let calls = 0
|
|
const sleeps: number[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 3,
|
|
backoffMs: 100,
|
|
jitter: false,
|
|
sleepImpl: async (ms) => {
|
|
sleeps.push(ms)
|
|
},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
throw new TypeError('fetch failed')
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/fetch failed/)
|
|
expect(calls).toBe(4)
|
|
expect(sleeps).toEqual([100, 200, 400])
|
|
expect(warn.mock.calls.flat().join(' ')).toContain('tentativa 1/4')
|
|
})
|
|
|
|
it('applies the ±20% jitter around the exponential delay', async () => {
|
|
silentWarn()
|
|
vi.spyOn(Math, 'random').mockReturnValue(0.5)
|
|
const sleeps: number[] = []
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 100,
|
|
jitter: true,
|
|
sleepImpl: async (ms) => {
|
|
sleeps.push(ms)
|
|
},
|
|
fetchImpl: async () => {
|
|
throw new TypeError('fetch failed')
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/fetch failed/)
|
|
expect(sleeps).toEqual([100, 200])
|
|
})
|
|
|
|
it('does not retry 4xx responses', async () => {
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 3,
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return ok('{"message":"nope"}', 403)
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/403/)
|
|
expect(calls).toBe(1)
|
|
})
|
|
|
|
it('retries 5xx responses on GET', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
jitter: false,
|
|
sleepImpl: async () => {},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return calls === 1 ? ok('{"message":"boom"}', 502) : ok(issueOk)
|
|
},
|
|
})
|
|
|
|
const issues = await api.listIssues()
|
|
|
|
expect(calls).toBe(2)
|
|
expect(issues).toHaveLength(1)
|
|
})
|
|
|
|
it('throws the API error after exhausting 5xx retries on GET', async () => {
|
|
silentWarn()
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
backoffMs: 0,
|
|
jitter: false,
|
|
sleepImpl: async () => {},
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return ok('{"message":"boom"}', 503)
|
|
},
|
|
})
|
|
|
|
await expect(api.listIssues()).rejects.toThrow(/503/)
|
|
expect(calls).toBe(3)
|
|
})
|
|
|
|
it('does not retry 5xx responses on write methods', async () => {
|
|
let calls = 0
|
|
const api = createApi({
|
|
token: 'tok',
|
|
retries: 2,
|
|
fetchImpl: async () => {
|
|
calls += 1
|
|
return ok('{"message":"boom"}', 503)
|
|
},
|
|
})
|
|
|
|
await expect(api.addComment(1, 'x')).rejects.toThrow(/503/)
|
|
expect(calls).toBe(1)
|
|
})
|
|
})
|
|
})
|