Skip to content

armgit / dify

Public Imported from GitHub
0

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.

5.7 KB
Raw Blame
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')
  })
})