mirror of
https://github.com/pnpm/pnpm.git
synced 2026-06-28 09:55:39 -04:00
fc2f33912e
The TypeScript pnpm CLI freezes at v11; pnpm 12 will be the Rust pacquet port. To make that split legible, all TypeScript source, test, and build directories move under a new top-level pnpm11/ directory. The name states the version boundary rather than implying a behavioral fork, since the two stacks are meant to behave identically. Scope is source-only: the shared workspace root stays at the repo root. pnpm-workspace.yaml, package.json, pnpm-lock.yaml, .pnpmfile.cjs, .meta-updater, __patches__, .changeset, .husky, and the lint/spell configs remain in place, so one pnpm workspace and one Cargo workspace still span all three products. pnpr/client and pacquet/tasks/registry-mock stay as cross-product workspace members. Rewiring the move required: - pnpm-workspace.yaml globs prefixed with pnpm11/ - root package.json script paths, eslint.config.mjs, tsconfig.lint.json, .gitignore, and CODEOWNERS updated - .meta-updater/src/index.ts literals repointed (pnpm11/pnpm/package.json, pnpm11/__utils__, pnpm11/__typings__, and the main package directory) - regenerated every moved package's repository/homepage URL via meta-updater - pnpm11/pnpm/bundle-deps.ts and __utils__/scripts/src/typecheck-only.ts climb one more level to reach the repo root .meta-updater stays at the repo root because @pnpm/meta-updater resolves its config at <cwd>/.meta-updater/main.mjs. TS CI (.github/workflows/ci.yml) now only runs when pnpm11/-relevant paths change, via a dorny/paths-filter changes job plus a TS CI / Success aggregate gate; branch protection should require only that gate.
502 lines
16 KiB
TypeScript
502 lines
16 KiB
TypeScript
import { describe, expect, it } from '@jest/globals'
|
|
import {
|
|
pollForWebAuthToken,
|
|
type WebAuthContext,
|
|
type WebAuthFetchOptions,
|
|
type WebAuthFetchResponse,
|
|
WebAuthTimeoutError,
|
|
} from '@pnpm/network.web-auth'
|
|
|
|
function createMockResponse (init: {
|
|
ok: boolean
|
|
status: number
|
|
json?: unknown
|
|
headers?: WebAuthFetchResponse['headers']
|
|
}): WebAuthFetchResponse {
|
|
let bodyConsumed = false
|
|
return {
|
|
ok: init.ok,
|
|
status: init.status,
|
|
json: async () => {
|
|
if (bodyConsumed) throw new Error('Unexpected double consumption of response body')
|
|
bodyConsumed = true
|
|
return init.json ?? {}
|
|
},
|
|
headers: init.headers ?? {
|
|
get: name => {
|
|
throw new Error(`Unexpected call to headers.get: ${name}`)
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
const createMockContext = (overrides?: Partial<WebAuthContext>): WebAuthContext => ({
|
|
Date: { now: () => 0 },
|
|
setTimeout: (cb: () => void) => cb(),
|
|
fetch: async () => createMockResponse({
|
|
ok: false,
|
|
status: 404,
|
|
}),
|
|
...overrides,
|
|
})
|
|
|
|
const fetchOptions: WebAuthFetchOptions = { method: 'GET' }
|
|
|
|
describe('pollForWebAuthToken', () => {
|
|
it('returns token when doneUrl responds with 200 and token', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount < 3) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => '1' },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'web-token-123' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('web-token-123')
|
|
expect(fetchCallCount).toBe(3)
|
|
})
|
|
|
|
it('passes doneUrl and fetchOptions to fetch', async () => {
|
|
const capturedArgs: Array<{ url: string, options: WebAuthFetchOptions }> = []
|
|
const opts: WebAuthFetchOptions = {
|
|
method: 'GET',
|
|
timeout: 5000,
|
|
retry: { retries: 3 },
|
|
}
|
|
const context = createMockContext({
|
|
fetch: async (url: string, options: WebAuthFetchOptions): Promise<WebAuthFetchResponse> => {
|
|
capturedArgs.push({ url, options })
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.example.com/done', fetchOptions: opts })
|
|
expect(capturedArgs).toEqual([{ url: 'https://registry.example.com/done', options: opts }])
|
|
})
|
|
|
|
it('respects Retry-After header when polling', async () => {
|
|
const setTimeoutDelays: number[] = []
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: (name: string) => name === 'retry-after' ? '5' : null },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
// First setTimeout is the default 1s poll interval,
|
|
// second is the additional delay (5s Retry-After minus the 1s already waited),
|
|
// third is the default 1s poll interval for the next iteration.
|
|
expect(setTimeoutDelays).toStrictEqual([1000, 4000, 1000])
|
|
})
|
|
|
|
it('ignores Retry-After when value is not a finite number', async () => {
|
|
const setTimeoutDelays: number[] = []
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => 'not-a-number' },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
// Only the default 1s poll intervals, no additional Retry-After delay.
|
|
expect(setTimeoutDelays).toStrictEqual([1000, 1000])
|
|
})
|
|
|
|
it('ignores Retry-After when value is null', async () => {
|
|
const setTimeoutDelays: number[] = []
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => null },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(setTimeoutDelays).toStrictEqual([1000, 1000])
|
|
})
|
|
|
|
it('skips additional delay when Retry-After is less than poll interval', async () => {
|
|
const setTimeoutDelays: number[] = []
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: (name: string) => name === 'retry-after' ? '0.5' : null },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
// Retry-After of 0.5s (500ms) is less than the 1s poll interval already waited,
|
|
// so no additional delay is added.
|
|
expect(setTimeoutDelays).toStrictEqual([1000, 1000])
|
|
})
|
|
|
|
it('caps Retry-After additional delay to remaining timeout', async () => {
|
|
let time = 0
|
|
const setTimeoutDelays: number[] = []
|
|
const context = createMockContext({
|
|
Date: { now: () => time },
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
time += ms
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
json: { token: 'tok' },
|
|
headers: { get: (name: string) => name === 'retry-after' ? '60' : null },
|
|
}),
|
|
})
|
|
// Use a 10s timeout so the 60s Retry-After gets capped.
|
|
await expect(pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions, timeoutMs: 10_000 }))
|
|
.rejects.toBeInstanceOf(WebAuthTimeoutError)
|
|
// The first delay is the 1s poll interval. The additional delay from
|
|
// Retry-After (59s) should be capped to the remaining timeout (~9s).
|
|
expect(setTimeoutDelays[0]).toBe(1000)
|
|
expect(setTimeoutDelays[1]).toBeLessThanOrEqual(9000)
|
|
})
|
|
|
|
it('throws WebAuthTimeoutError when timeout expires during Retry-After wait', async () => {
|
|
let time = 0
|
|
const timeoutMs = 5000
|
|
const context = createMockContext({
|
|
Date: {
|
|
now: () => time,
|
|
},
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
time += ms
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
// After the 1s poll interval, time is 1000.
|
|
// Remaining is 4000. Retry-After is 100s, so additional is 99000,
|
|
// capped to 4000. After that wait, time = 5000, which equals timeout.
|
|
// Next iteration: now - startTime > timeoutMs → throw.
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: (name: string) => name === 'retry-after' ? '100' : null },
|
|
})
|
|
},
|
|
})
|
|
await expect(pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions, timeoutMs }))
|
|
.rejects.toMatchObject({ timeout: timeoutMs })
|
|
})
|
|
|
|
it('continues polling when fetch throws', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
throw new Error('network failure')
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('tok')
|
|
expect(fetchCallCount).toBe(2)
|
|
})
|
|
|
|
it('continues polling when response is not ok', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: false,
|
|
status: 404,
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('tok')
|
|
expect(fetchCallCount).toBe(2)
|
|
})
|
|
|
|
it('continues polling when response.json() throws', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return {
|
|
headers: { get: () => null },
|
|
json: async () => {
|
|
throw new Error('invalid json')
|
|
},
|
|
ok: true,
|
|
status: 200,
|
|
}
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('tok')
|
|
expect(fetchCallCount).toBe(2)
|
|
})
|
|
|
|
it('continues polling when response body has no token', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { something: 'else' },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('tok')
|
|
expect(fetchCallCount).toBe(2)
|
|
})
|
|
|
|
it('continues polling when token is empty string', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: '' },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'real-tok' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('real-tok')
|
|
expect(fetchCallCount).toBe(2)
|
|
})
|
|
|
|
it('throws WebAuthTimeoutError after timeout', async () => {
|
|
let time = 0
|
|
const context = createMockContext({
|
|
Date: { now: () => time },
|
|
setTimeout: (cb: () => void) => {
|
|
time += 6 * 60 * 1000 // Jump past timeout
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => null },
|
|
}),
|
|
})
|
|
await expect(pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions }))
|
|
.rejects.toBeInstanceOf(WebAuthTimeoutError)
|
|
})
|
|
|
|
it('uses custom timeout value', async () => {
|
|
let time = 0
|
|
const customTimeoutMs = 3000
|
|
const context = createMockContext({
|
|
Date: { now: () => time },
|
|
setTimeout: (cb: () => void) => {
|
|
time += 2000
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => null },
|
|
}),
|
|
})
|
|
await expect(pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions, timeoutMs: customTimeoutMs }))
|
|
.rejects.toMatchObject({ timeout: customTimeoutMs })
|
|
})
|
|
|
|
it('recovers after multiple consecutive fetch errors', async () => {
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount <= 5) {
|
|
throw new Error(`failure #${fetchCallCount}`)
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'recovered' },
|
|
})
|
|
},
|
|
})
|
|
const token = await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
expect(token).toBe('recovered')
|
|
expect(fetchCallCount).toBe(6)
|
|
})
|
|
|
|
it('waits pollIntervalMs before each fetch call', async () => {
|
|
const setTimeoutDelays: number[] = []
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
setTimeoutDelays.push(ms)
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount < 4) {
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => null },
|
|
})
|
|
}
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 200,
|
|
json: { token: 'tok' },
|
|
})
|
|
},
|
|
})
|
|
await pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions })
|
|
// Each iteration waits 1000ms before fetching.
|
|
expect(setTimeoutDelays).toStrictEqual([1000, 1000, 1000, 1000])
|
|
})
|
|
|
|
it('throws WebAuthTimeoutError immediately when remaining time is zero during Retry-After', async () => {
|
|
let time = 0
|
|
const timeoutMs = 2000
|
|
let fetchCallCount = 0
|
|
const context = createMockContext({
|
|
Date: { now: () => time },
|
|
setTimeout: (cb: () => void, ms: number) => {
|
|
time += ms
|
|
cb()
|
|
},
|
|
fetch: async (): Promise<WebAuthFetchResponse> => {
|
|
fetchCallCount++
|
|
if (fetchCallCount === 1) {
|
|
// After poll interval (1s), time = 1000, remaining = 1000.
|
|
// Retry-After = 10s → additional = 9000 > remaining.
|
|
// Capped to remaining (1000). After that wait, time = 2000.
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: (name: string) => name === 'retry-after' ? '10' : null },
|
|
})
|
|
}
|
|
// This second fetch still returns 202, but the next timeout check
|
|
// should trigger the error since time (2000) - start (0) = 2000 > 2000? No, it's equal.
|
|
// Actually the condition is `>` so 2000 > 2000 is false. So it waits another 1s, then 3000 > 2000 is true.
|
|
return createMockResponse({
|
|
ok: true,
|
|
status: 202,
|
|
headers: { get: () => null },
|
|
})
|
|
},
|
|
})
|
|
await expect(pollForWebAuthToken({ context, doneUrl: 'https://registry.npmjs.org/auth/done', fetchOptions, timeoutMs }))
|
|
.rejects.toMatchObject({ timeout: timeoutMs })
|
|
})
|
|
})
|