Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
import type { CodeResponse, PollRequest, PollResult, PollSuccess } from './device-api'
import type { Clock } from './device-flow'
import { startMock } from '@test/fixtures/dify-mock/server'
import { describe, expect, it, vi } from 'vite-plus/test'
import { BaseError } from '@/errors/base'
import { ErrorCode, ExitCode } from '@/errors/codes'
import { isCancelled } from '@/plugins/commands/cancel'
import { deviceApi } from './device-api'
import {
awaitAuthorization,
DEFAULT_INTERVAL_MS,
MAX_INTERVAL_MS,
POLL_RETRY_ATTEMPTS,
POLL_RETRY_CAP_MS,
POLL_RETRY_INITIAL_MS,
pollAuthorization,
realClock,
} from './device-flow'
const successPayload: PollSuccess = {
token: 'dfoa_xyz',
account: { id: 'a', email: 'e', name: 'n' },
workspaces: [{ id: 'w', name: 'W', role: 'owner' }],
default_workspace_id: 'w',
token_id: 't',
}
class FakeClock implements Clock {
sleeps: number[] = []
cancelled = false
cancelAt: number | undefined
async sleepMs(ms: number): Promise<void> {
this.sleeps.push(ms)
if (this.cancelAt !== undefined && this.sleeps.length >= this.cancelAt) this.cancelled = true
}
isCancelled(): boolean {
return this.cancelled
}
}
function fakeApi(scripted: PollResult[]): { pollOnce: (req: PollRequest) => Promise<PollResult> } {
let i = 0
return {
pollOnce: async () => {
const r = scripted[i++]
if (r === undefined) throw new Error('scripted-api: out of responses')
return r
},
}
}
const code: CodeResponse = {
device_code: 'dc',
user_code: 'ABCD-1234',
verification_uri: 'https://dify.example/device',
expires_in: 900,
interval: 1,
}
describe('awaitAuthorization', () => {
it('returns success on first approved poll', async () => {
const api = fakeApi([{ status: 'approved', success: successPayload }])
const clock = new FakeClock()
const result = await awaitAuthorization(api, code, { clock })
expect(result.token).toBe('dfoa_xyz')
expect(clock.sleeps).toHaveLength(0)
})
it('keeps polling on pending then returns approved', async () => {
const api = fakeApi([
{ status: 'pending' },
{ status: 'pending' },
{ status: 'approved', success: successPayload },
])
const clock = new FakeClock()
const result = await awaitAuthorization(api, code, { clock })
expect(result.token).toBe('dfoa_xyz')
expect(clock.sleeps).toEqual([1000, 1000])
})
it('doubles interval on slow_down (capped at max)', async () => {
const api = fakeApi([
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'approved', success: successPayload },
])
const clock = new FakeClock()
const result = await awaitAuthorization(api, code, { clock })
expect(result.token).toBe('dfoa_xyz')
expect(clock.sleeps).toEqual([2000, 4000])
})
it('caps interval at MAX_INTERVAL_MS', async () => {
const api = fakeApi([
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'slow_down' },
{ status: 'approved', success: successPayload },
])
const clock = new FakeClock()
await awaitAuthorization(api, { ...code, interval: 10 }, { clock })
const last = clock.sleeps[clock.sleeps.length - 1]!
expect(last).toBe(MAX_INTERVAL_MS)
})
it('throws BaseError on expired', async () => {
const api = fakeApi([{ status: 'expired' }])
const clock = new FakeClock()
await expect(awaitAuthorization(api, code, { clock })).rejects.toThrow(/expired/)
})
it('throws BaseError on denied', async () => {
const api = fakeApi([{ status: 'denied' }])
const clock = new FakeClock()
await expect(awaitAuthorization(api, code, { clock })).rejects.toThrow(/denied/)
})
it('uses default interval when CodeResponse.interval is 0', async () => {
const api = fakeApi([{ status: 'pending' }, { status: 'approved', success: successPayload }])
const clock = new FakeClock()
await awaitAuthorization(api, { ...code, interval: 0 }, { clock })
expect(clock.sleeps[0]).toBe(DEFAULT_INTERVAL_MS)
})
it('rejects when clock signals cancelled', async () => {
const api = fakeApi([
{ status: 'pending' },
{ status: 'pending' },
{ status: 'pending' },
{ status: 'pending' },
{ status: 'approved', success: successPayload },
])
const clock = new FakeClock()
clock.cancelAt = 2
// Cancelling is neither an expiry (exit 4) nor a usage mistake (exit 2).
const err = await awaitAuthorization(api, code, { clock }).catch((e: unknown) => e)
expect(err).toMatchObject({ code: 'unknown', message: 'cancelled' })
expect((err as BaseError).exit()).toBe(ExitCode.Generic)
})
it('realClock reports the run-wide cancellation flag, not a constant', async () => {
expect(realClock().isCancelled).toBe(isCancelled)
expect(realClock().isCancelled()).toBe(false)
})
it('exposes constants matching Go reference', () => {
expect(POLL_RETRY_ATTEMPTS).toBe(5)
expect(POLL_RETRY_INITIAL_MS).toBe(1000)
expect(POLL_RETRY_CAP_MS).toBe(16_000)
expect(MAX_INTERVAL_MS).toBe(60_000)
expect(DEFAULT_INTERVAL_MS).toBe(5000)
})
it('preserves dfoe_ token kind through state machine', async () => {
const externalSuccess: PollSuccess = {
token: 'dfoe_xxx',
subject_type: 'external_sso',
subject_email: '[email protected]',
subject_issuer: 'https://issuer',
}
const api = fakeApi([{ status: 'approved', success: externalSuccess }])
const clock = new FakeClock()
const result = await awaitAuthorization(api, code, { clock })
expect(result.token).toBe('dfoe_xxx')
expect(result.subject_type).toBe('external_sso')
})
it('propagates BaseError thrown by api.pollOnce', async () => {
const api = {
pollOnce: vi
.fn()
.mockRejectedValue(new BaseError({ code: ErrorCode.ServerError, message: 'old server' })),
}
const clock = new FakeClock()
await expect(awaitAuthorization(api, code, { clock })).rejects.toThrow(/old server/)
})
})
it('does not retry device polling after cancellation during backoff', async () => {
const mock = await startMock({ scenario: 'server-5xx' })
const clock = new FakeClock()
clock.sleepMs = async (ms) => {
clock.sleeps.push(ms)
clock.cancelled = true
mock.setScenario('happy')
}
try {
const api = deviceApi(mock.url, { insecure: true })
await expect(awaitAuthorization(api, code, { clock })).rejects.toMatchObject({
code: ErrorCode.Unknown,
message: 'cancelled',
})
expect(mock.requestCount).toBe(1)
expect(clock.sleeps).toEqual([POLL_RETRY_INITIAL_MS])
} finally {
await mock.stop()
}
})
it('does not poll a resumed authorization when already cancelled', async () => {
const pollOnce = vi.fn().mockResolvedValue({ status: 'approved', success: successPayload })
const clock = new FakeClock()
clock.cancelled = true
await expect(pollAuthorization({ pollOnce }, code.device_code, { clock })).rejects.toMatchObject({
code: ErrorCode.Unknown,
message: 'cancelled',
})
expect(pollOnce).not.toHaveBeenCalled()
})
it('does not accept approval if cancellation happened while polling', async () => {
const clock = new FakeClock()
const pollOnce = async (): Promise<PollResult> => {
clock.cancelled = true
return { status: 'approved', success: successPayload }
}
await expect(awaitAuthorization({ pollOnce }, code, { clock })).rejects.toMatchObject({
code: ErrorCode.Unknown,
message: 'cancelled',
})
expect(clock.sleeps).toEqual([])
})