Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
12.8 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import fs from 'node:fs/promises'
import {
  cleanupNativeCommitTestHarness,
  createNativeCommitTestHarness,
  deferred,
} from '../../testSupport/appService.nativeCommitTestHarness.js'

afterEach(cleanupNativeCommitTestHarness)

describe('AppService native auth and environment commit ordering', () => {
  it('persists real version-2 GFS state as suspended_auth on logout', async () => {
    const { service } = await createNativeCommitTestHarness()
    const me = {
      id: 'user-a',
      email: '[email protected]',
      name: 'User A',
      picture: null,
      teamId: 'team-a',
      teamName: 'Team A',
      role: 'member',
    }
    service.authClient = {
      googleLogin: vi.fn().mockResolvedValue({ token: 'synthetic-session-a', me }),
    } as never
    await service.googleLogin('synthetic-google-token')
    const app = service as unknown as {
      gfsScopeIdentity: {
        ownerId: string
        teamId: string | null
        environmentKey: string
        baseUrl: string
      }
      gfsAuthEpoch: number
      persistDesktopGfsUpload(record: unknown): Promise<void>
      desktopGfsUploadStatePath(): Promise<string>
    }
    const identity = app.gfsScopeIdentity
    const uploadId = '92929292-9292-4292-8292-929292929292'
    await app.persistDesktopGfsUpload({
      version: 2,
      uploadId,
      filePath: '/tmp/payload.bin',
      fileName: 'payload.bin',
      fileSize: 4,
      target: { operation: 'create', parentRid: 'parent-a' },
      name: 'payload.bin',
      session: {
        uploadId,
        drive: 'main',
        operation: 'create',
        expectedBytes: 4,
        partBytes: 4,
        partCount: 1,
        state: 'uploading',
        contiguousBytes: 0,
        committedBytes: 0,
        committedPartCount: 0,
        activePartCount: 0,
        expiresAt: new Date(Date.now() + 60_000).toISOString(),
      },
      scope: { ...identity, drive: 'main', authEpoch: app.gfsAuthEpoch },
      status: 'active',
      updatedAt: new Date().toISOString(),
    })

    await service.logout()

    const statePath = await app.desktopGfsUploadStatePath()
    const state = JSON.parse(await fs.readFile(statePath, 'utf8')) as {
      version: number
      records: Array<{ uploadId: string; status: string }>
    }
    expect(state.version).toBe(2)
    expect(state.records).toEqual([expect.objectContaining({ uploadId, status: 'suspended_auth' })])
  })

  it('rejects desktop setup while preserving the active authenticated environment', async () => {
    const { service, runtimeConfig, restA, restB } = await createNativeCommitTestHarness()
    const me = { id: 'user-a', email: '[email protected]', teamId: 'team-a' }
    service.authClient = {
      googleLogin: vi.fn().mockResolvedValue({ token: 'synthetic-session-a', me }),
    } as never
    const setupRequest = vi.fn().mockResolvedValue({
      valid: true,
      email: '[email protected]',
      externalRestApiBaseUrl: restB,
      rpcProxyBaseUrl: 'https://rpc-b.example.test',
      appName: 'Environment B',
    })
    const serviceInternals = service as unknown as {
      memberRegistrationServiceClient: { completeDesktopSetup: typeof setupRequest }
      completeDesktopSetup: (email: string, authorizationToken: string) => Promise<unknown>
      getSessionGeneration: () => number
    }
    serviceInternals.memberRegistrationServiceClient = { completeDesktopSetup: setupRequest }

    await service.googleLogin('synthetic-google-token')
    const runtimeBeforeSetup = runtimeConfig.getDesktopRuntimeConfigState()
    const generationBeforeSetup = serviceInternals.getSessionGeneration()
    const gfsScopeBeforeSetup = service.gfsScopeIdentity

    await expect(
      serviceInternals.completeDesktopSetup('[email protected]', 'synthetic-setup-token')
    ).rejects.toThrow('desktop_setup_requires_signout')

    expect(setupRequest).not.toHaveBeenCalled()
    expect(runtimeConfig.getDesktopRuntimeConfigState()).toEqual(runtimeBeforeSetup)
    expect(runtimeConfig.config.externalRestApiBaseUrl).toBe(restA)
    expect(service.sessionToken).toBe('synthetic-session-a')
    expect(service.getCachedUserId()).toBe('user-a')
    await expect(service.getSessionState()).resolves.toMatchObject({ authenticated: true, me })
    expect(serviceInternals.getSessionGeneration()).toBe(generationBeforeSetup)
    expect(service.gfsScopeIdentity).toEqual(gfsScopeBeforeSetup)
  })

  it('rejects desktop setup while an explicit login is in flight', async () => {
    const { service } = await createNativeCommitTestHarness()
    const loginStarted = deferred<void>()
    const loginResponse = deferred<{
      token: string
      me: { id: string; email: string; teamId: string }
    }>()
    const me = { id: 'user-a', email: '[email protected]', teamId: 'team-a' }
    service.authClient = {
      googleLogin: vi.fn(() => {
        loginStarted.resolve()
        return loginResponse.promise
      }),
    } as never
    const setupRequest = vi.fn().mockRejectedValue(new Error('unexpected setup dispatch'))
    const serviceInternals = service as unknown as {
      memberRegistrationServiceClient: { completeDesktopSetup: typeof setupRequest }
      completeDesktopSetup: (email: string, authorizationToken: string) => Promise<unknown>
    }
    serviceInternals.memberRegistrationServiceClient = { completeDesktopSetup: setupRequest }

    const login = service.googleLogin('synthetic-google-token')
    await loginStarted.promise
    const generationDuringLogin = service.getSessionGeneration()
    const setupOutcome = await serviceInternals
      .completeDesktopSetup('[email protected]', 'synthetic-setup-token')
      .then(
        () => ({ error: null as unknown }),
        error => ({ error })
      )
    const generationAfterSetup = service.getSessionGeneration()
    loginResponse.resolve({ token: 'synthetic-session-a', me })
    const loginOutcome = await login.then(
      result => ({ result, error: null as unknown }),
      error => ({ result: null, error })
    )

    expect(setupOutcome.error).toBeInstanceOf(Error)
    expect((setupOutcome.error as Error).message).toBe('auth_transition_in_progress')
    expect(setupRequest).not.toHaveBeenCalled()
    expect(generationAfterSetup).toBe(generationDuringLogin)
    expect(loginOutcome.error).toBeNull()
    expect(loginOutcome.result).toMatchObject({ authenticated: true, me })
    expect(service.getSessionGeneration()).toBe(generationDuringLogin + 1)
  })

  it('uses the captured generation when login wins before setup dispatch', async () => {
    const { service } = await createNativeCommitTestHarness()
    const me = { id: 'user-a', email: '[email protected]', teamId: 'team-a' }
    service.authClient = {
      googleLogin: vi.fn().mockResolvedValue({ token: 'synthetic-session-a', me }),
    } as never
    const setupRequest = vi.fn().mockResolvedValue({
      valid: true,
      email: '[email protected]',
      externalRestApiBaseUrl: 'https://api-b.example.test',
      rpcProxyBaseUrl: 'https://rpc-b.example.test',
      appName: 'Environment B',
    })
    const app = service as unknown as {
      memberRegistrationServiceClient: { completeDesktopSetup: typeof setupRequest }
      completeDesktopSetup: (email: string, authorizationToken: string) => Promise<unknown>
      withNativeAuthEnvironmentCommit<T>(operation: () => Promise<T>): Promise<T>
    }
    app.memberRegistrationServiceClient = { completeDesktopSetup: setupRequest }
    const originalCommit = app.withNativeAuthEnvironmentCommit.bind(service)
    let commitCount = 0
    app.withNativeAuthEnvironmentCommit = async operation => {
      commitCount += 1
      if (commitCount === 2) {
        app.withNativeAuthEnvironmentCommit = originalCommit
        await service.googleLogin('synthetic-login-before-setup-dispatch')
      }
      return originalCommit(operation)
    }

    await expect(
      app.completeDesktopSetup('[email protected]', 'synthetic-setup-token')
    ).rejects.toThrow('stale_session_generation')

    expect(setupRequest).not.toHaveBeenCalled()
    expect(service.sessionToken).toBe('synthetic-session-a')
    expect(service.getCachedUserId()).toBe('user-a')
  })

  it('rejects handoff environment saves after auth changes or while auth is active', async () => {
    const { service, runtimeConfig, optionB, restA, restB } = await createNativeCommitTestHarness()
    const loginStarted = deferred<void>()
    const loginResponse = deferred<{
      token: string
      me: { id: string; email: string; teamId: string }
    }>()
    const me = { id: 'user-a', email: '[email protected]', teamId: 'team-a' }
    service.authClient = {
      googleLogin: vi.fn(() => {
        loginStarted.resolve()
        return loginResponse.promise
      }),
    } as never

    const nextConfig = {
      appName: 'Environment B',
      externalRestApiBaseUrl: restB,
      rpcProxyBaseUrl: 'https://rpc-b.example.test',
    }
    const saveRuntimeConfigForHandoff = service.saveRuntimeConfig.bind(service) as (
      config: Parameters<typeof service.saveRuntimeConfig>[0],
      expectedSessionGeneration: number
    ) => Promise<unknown>
    const expectedGeneration = service.getSessionGeneration()
    const login = service.googleLogin('synthetic-google-token')
    await loginStarted.promise
    const generationDuringLogin = service.getSessionGeneration()

    await expect(
      service.selectRuntimeConfigForHandoff(optionB.id, expectedGeneration)
    ).rejects.toThrow('stale_session_generation')
    await expect(
      service.selectRuntimeConfigForHandoff(optionB.id, generationDuringLogin)
    ).rejects.toThrow('auth_transition_in_progress')
    await expect(saveRuntimeConfigForHandoff(nextConfig, expectedGeneration)).rejects.toThrow(
      'stale_session_generation'
    )
    await expect(saveRuntimeConfigForHandoff(nextConfig, generationDuringLogin)).rejects.toThrow(
      'auth_transition_in_progress'
    )
    expect(runtimeConfig.config.externalRestApiBaseUrl).toBe(restA)

    loginResponse.resolve({ token: 'synthetic-session-a', me })
    await expect(login).resolves.toMatchObject({ authenticated: true, me })
    const authenticatedGeneration = service.getSessionGeneration()
    await expect(
      service.selectRuntimeConfigForHandoff(optionB.id, authenticatedGeneration)
    ).rejects.toThrow('desktop_setup_requires_signout')
    await expect(saveRuntimeConfigForHandoff(nextConfig, authenticatedGeneration)).rejects.toThrow(
      'desktop_setup_requires_signout'
    )
    expect(runtimeConfig.config.externalRestApiBaseUrl).toBe(restA)
    await expect(service.getSessionState()).resolves.toMatchObject({
      authenticated: true,
      me,
    })
  })

  it('keeps a pending environment selection ahead of a login commit', async () => {
    const { service, runtimeConfig, restA, restB, optionB } = await createNativeCommitTestHarness()
    const loginStarted = deferred<void>()
    const releaseLogin = deferred<void>()
    let handoffRequestRest = ''
    service.authClient = {
      googleLogin: vi.fn(async (token: string) => {
        const requestRest = runtimeConfig.config.externalRestApiBaseUrl
        if (token === 'handoff-login') {
          handoffRequestRest = requestRest
          loginStarted.resolve()
          await releaseLogin.promise
          return requestRest === restA
            ? { token: 'synthetic-session-a-next', me: { id: 'user-a' } }
            : { token: 'synthetic-session-b', me: { id: 'user-b' } }
        }
        return { token: 'synthetic-session-a', me: { id: 'user-a' } }
      }),
    } as never
    await service.googleLogin('initial-login')

    let handoffLogin: Promise<unknown> | null = null
    const selectReal = runtimeConfig.selectDesktopRuntimeConfigOption.bind(runtimeConfig)
    vi.spyOn(runtimeConfig, 'selectDesktopRuntimeConfigOption').mockImplementation(async id => {
      if (id === optionB.id) handoffLogin = service.googleLogin('handoff-login')
      await selectReal(id)
    })

    const selection = service.selectRuntimeConfig(optionB.id)
    const selectionOutcome = await selection.then(
      value => ({ status: 'fulfilled' as const, value }),
      reason => ({ status: 'rejected' as const, reason })
    )
    await loginStarted.promise
    releaseLogin.resolve()
    const loginOutcome = await handoffLogin

    expect(selectionOutcome.status).toBe('fulfilled')
    expect(handoffRequestRest).toBe(restB)
    expect(loginOutcome).toMatchObject({ authenticated: true, me: { id: 'user-b' } })
    expect(runtimeConfig.getDesktopRuntimeConfigState().activeOptionId).toBe(optionB.id)
    await expect(service.getSessionState()).resolves.toMatchObject({
      authenticated: true,
      me: { id: 'user-b' },
    })
    await expect(service.listGfsUploadSessions()).resolves.toEqual([])
    expect(service.gfsScopeIdentity).toMatchObject({
      ownerId: 'user-b',
      environmentKey: runtimeConfig.getDesktopRuntimeConfigState().envKey,
      baseUrl: restB,
    })
  })
})