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 { TokenStore } from './token-store'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test'
import { localFile } from './local-file'
import { detectTokenStore, getTokenStore, keyringDurable } from './manager'
import { TOKENS_SCHEMA } from './token-store'
const DBUS_SESSION = 'DBUS_SESSION_BUS_ADDRESS'
const sys = vi.hoisted(() => ({ platform: 'darwin' as NodeJS.Platform }))
vi.mock('@/sys', async (importOriginal) => ({
...(await importOriginal<typeof import('@/sys')>()),
platform: () => sys.platform,
}))
const file = localFile('', TOKENS_SCHEMA, () => {})
beforeEach(() => {
sys.platform = 'darwin'
})
afterEach(() => {
vi.unstubAllEnvs()
})
function memStore(label: string): TokenStore & { _label: string } {
const map = new Map<string, string>()
const k = (h: string, e: string): string => `${h} ${e}`
return {
_label: label,
async read(host: string, email: string): Promise<string> {
return map.get(k(host, email)) ?? ''
},
async write(host: string, email: string, bearer: string): Promise<void> {
map.set(k(host, email), bearer)
},
async remove(host: string, email: string): Promise<void> {
map.delete(k(host, email))
},
}
}
describe('detectTokenStore', () => {
it('skips the probe and returns the file store when asked', async () => {
const k = memStore('keyring')
const f = memStore('file')
const writeSpy = vi.spyOn(k, 'write')
const result = await detectTokenStore({
file,
skipKeyring: true,
factory: { keyring: () => k, file: () => f },
})
expect(writeSpy).not.toHaveBeenCalled()
expect(result.mode).toBe('file')
expect(result.store).toBe(f)
})
it('returns keychain store when probe succeeds', async () => {
const k = memStore('keyring')
const f = memStore('file')
const result = await detectTokenStore({
file,
factory: { keyring: () => k, file: () => f },
})
expect(result.mode).toBe('keychain')
expect(result.store).toBe(k)
})
it('falls back to file when keyring set throws', async () => {
const k = memStore('keyring')
const f = memStore('file')
k.write = vi.fn(() => {
throw new Error('locked')
}) as TokenStore['write']
const result = await detectTokenStore({
file,
factory: { keyring: () => k, file: () => f },
})
expect(result.mode).toBe('file')
expect(result.store).toBe(f)
})
it('falls back to file when probe round-trip mismatches', async () => {
const k = memStore('keyring')
const f = memStore('file')
k.read = vi.fn(async () => 'something-else') as TokenStore['read']
const result = await detectTokenStore({
file,
factory: { keyring: () => k, file: () => f },
})
expect(result.mode).toBe('file')
expect(result.store).toBe(f)
})
it('falls back to file when keyring constructor throws', async () => {
const f = memStore('file')
const result = await detectTokenStore({
file,
factory: {
keyring: () => {
throw new Error('no backend')
},
file: () => f,
},
})
expect(result.mode).toBe('file')
expect(result.store).toBe(f)
})
it('cleans up probe entry after successful probe', async () => {
const k = memStore('keyring')
const f = memStore('file')
await detectTokenStore({
file,
factory: { keyring: () => k, file: () => f },
})
expect(await k.read('__difyctl_probe__', '__difyctl_probe__')).toBe('')
})
it('removes the probe entry even when the probe read throws', async () => {
const k = memStore('keyring')
const f = memStore('file')
const removeSpy = vi.spyOn(k, 'remove')
k.read = vi.fn(() => {
throw new Error('read boom')
}) as TokenStore['read']
const result = await detectTokenStore({
file,
factory: { keyring: () => k, file: () => f },
})
expect(removeSpy).toHaveBeenCalledWith('__difyctl_probe__', '__difyctl_probe__')
expect(result.mode).toBe('file')
expect(result.store).toBe(f)
})
})
describe('getTokenStore', () => {
it('constructs the keychain backend without probing when mode is keychain', () => {
const k = memStore('keyring')
const f = memStore('file')
k.write = vi.fn(() => {
throw new Error('probe must never run on the read path')
}) as TokenStore['write']
const store = getTokenStore('keychain', {
file,
factory: { keyring: () => k, file: () => f },
})
expect(store).toBe(k)
})
it('constructs the file backend when mode is file, never touching the keyring', () => {
const keyringFactory = vi.fn(() => memStore('keyring'))
const f = memStore('file')
const store = getTokenStore('file', {
file,
factory: { keyring: keyringFactory, file: () => f },
})
expect(store).toBe(f)
expect(keyringFactory).not.toHaveBeenCalled()
})
})
describe('keyringDurable', () => {
it.each([
['linux', undefined, false],
['linux', '', false],
['linux', 'unix:path=/run/user/1000/bus', true],
['darwin', undefined, true],
['win32', undefined, true],
['freebsd', undefined, true],
] as const)('%s with DBus %o → %s', (platform, dbus, durable) => {
sys.platform = platform
vi.stubEnv(DBUS_SESSION, dbus)
expect(keyringDurable()).toBe(durable)
})
it('a non-durable keyring skips the probe and uses the file store', async () => {
sys.platform = 'linux'
vi.stubEnv(DBUS_SESSION, undefined)
const k = memStore('keyring')
const f = memStore('file')
const writeSpy = vi.spyOn(k, 'write')
const result = await detectTokenStore({ file, factory: { keyring: () => k, file: () => f } })
expect(writeSpy).not.toHaveBeenCalled()
expect(result.mode).toBe('file')
})
})