Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { afterEach, describe, expect, it, vi } from 'vitest'
import fs from 'node:fs/promises'
import os from 'node:os'
import path from 'node:path'
// The chat store binds to the filesystem (Electron userData). Mock it so
// passwordLogin can be asserted to bind the env-scoped store without touching
// real directories.
vi.mock('../chatStoreBinding.js', () => ({
bindChatStoreForUser: vi.fn(),
unbindChatStore: vi.fn(),
__setChatStoreBaseDirForTests: vi.fn(),
}))
describe('AppService invitation configuration lookup', () => {
const originalConfigPath = process.env.CLERUM_DESKTOP_CONFIG_PATH
const originalExternalRestApiBaseUrl = process.env.EXTERNAL_REST_API_BASE_URL
const originalRpcProxyBaseUrl = process.env.RPC_PROXY_BASE_URL
const originalProfileUiBaseUrl = process.env.PROFILE_UI_BASE_URL
const tempDirs = new Set<string>()
async function createTempConfigPath(prefix: string): Promise<string> {
const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), `${prefix}-`))
tempDirs.add(tempDir)
return path.join(tempDir, 'config.json')
}
afterEach(async () => {
if (originalConfigPath === undefined) {
delete process.env.CLERUM_DESKTOP_CONFIG_PATH
} else {
process.env.CLERUM_DESKTOP_CONFIG_PATH = originalConfigPath
}
if (originalExternalRestApiBaseUrl === undefined) {
delete process.env.EXTERNAL_REST_API_BASE_URL
} else {
process.env.EXTERNAL_REST_API_BASE_URL = originalExternalRestApiBaseUrl
}
if (originalRpcProxyBaseUrl === undefined) {
delete process.env.RPC_PROXY_BASE_URL
} else {
process.env.RPC_PROXY_BASE_URL = originalRpcProxyBaseUrl
}
if (originalProfileUiBaseUrl === undefined) {
delete process.env.PROFILE_UI_BASE_URL
} else {
process.env.PROFILE_UI_BASE_URL = originalProfileUiBaseUrl
}
vi.resetModules()
await Promise.all(
[...tempDirs].map(tempDir => fs.rm(tempDir, { recursive: true, force: true }))
)
tempDirs.clear()
})
it('accepts terminal-dot discovery when the canonical REST endpoint matches', async () => {
const configPath = await createTempConfigPath('clerum-desktop-config')
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
delete process.env.EXTERNAL_REST_API_BASE_URL
delete process.env.RPC_PROXY_BASE_URL
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const [
{ AppService },
{ config, getActiveLegacyRestOnlyEnvKey, isDesktopRuntimeConfigured, resolveEnvKey },
] = await Promise.all([import('../appService.js'), import('../config.js')])
const { bindChatStoreForUser } = await import('../chatStoreBinding.js')
const service = new AppService() as unknown as {
authClient: {
passwordLogin: ReturnType<typeof vi.fn>
getDesktopEnvironment: ReturnType<typeof vi.fn>
}
memberRegistrationServiceClient: { completeDesktopSetup: ReturnType<typeof vi.fn> }
tokenStore: { setSessionToken: ReturnType<typeof vi.fn> }
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
completeDesktopSetup: (email: string, authorizationToken: string) => Promise<unknown>
passwordLogin: (email: string, password: string) => Promise<unknown>
}
service.memberRegistrationServiceClient = {
completeDesktopSetup: vi.fn().mockResolvedValue({
valid: true,
email: '[email protected]',
externalRestApiBaseUrl: 'https://api.example.com',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Evenfire',
}),
} as never
service.authClient = {
getDesktopEnvironment: vi.fn().mockResolvedValue({
externalRestApiBaseUrl: 'https://api.example.com.',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Evenfire',
}),
passwordLogin: vi.fn().mockResolvedValue({
token: 'session-token',
me: {
id: 'user-1',
email: '[email protected]',
name: null,
picture: null,
teamId: 'team-1',
teamName: 'Marketing',
role: 'member',
},
}),
} as never
service.tokenStore = {
setSessionToken: vi.fn().mockResolvedValue(undefined),
} as never
service.rpcTokenManager = {
clear: vi.fn(),
} as never
await service.completeDesktopSetup('[email protected]', 'setup-token')
expect(config.externalRestApiBaseUrl).toBe('https://api.example.com')
expect(config.rpcProxyBaseUrl).toBe('https://rpc.example.com')
expect(service.memberRegistrationServiceClient.completeDesktopSetup).toHaveBeenCalledWith(
'[email protected]',
'setup-token'
)
expect(service.authClient.getDesktopEnvironment).toHaveBeenCalled()
expect(isDesktopRuntimeConfigured()).toBe(true)
const result = await service.passwordLogin('[email protected]', 'password123')
expect(service.authClient.passwordLogin).toHaveBeenCalledWith('[email protected]', 'password123')
expect(result).toMatchObject({ authenticated: true, me: { email: '[email protected]' } })
// The env-scoped chat store must be bound after a password login, or every
// chat:* IPC throws "Not authenticated" until something else re-binds.
expect(bindChatStoreForUser).toHaveBeenCalledWith(
'user-1',
resolveEnvKey('https://api.example.com', 'https://rpc.example.com'),
{ legacyEnvKeys: [getActiveLegacyRestOnlyEnvKey()], teamId: 'team-1' }
)
expect(config.externalRestApiBaseUrl).toBe('https://api.example.com')
expect(config.rpcProxyBaseUrl).toBe('https://rpc.example.com')
expect(config.desktopProfileUiBaseUrl).toBe('https://profile.example.com')
const persisted = JSON.parse(await fs.readFile(configPath, 'utf8')) as {
externalRestApiBaseUrl: string
rpcProxyBaseUrl: string
appName: string
}
expect(persisted).toEqual({
externalRestApiBaseUrl: 'https://api.example.com',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Evenfire',
})
})
it('does not save RPC when dotted discovery names a different REST endpoint', async () => {
const configPath = await createTempConfigPath('clerum-desktop-config-mismatched-discovery')
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
delete process.env.EXTERNAL_REST_API_BASE_URL
delete process.env.RPC_PROXY_BASE_URL
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const [{ AppService }, { config }] = await Promise.all([
import('../appService.js'),
import('../config.js'),
])
const service = new AppService() as unknown as {
authClient: { getDesktopEnvironment: ReturnType<typeof vi.fn> }
memberRegistrationServiceClient: { completeDesktopSetup: ReturnType<typeof vi.fn> }
completeDesktopSetup: (email: string, authorizationToken: string) => Promise<unknown>
}
service.memberRegistrationServiceClient = {
completeDesktopSetup: vi.fn().mockResolvedValue({
valid: true,
email: '[email protected]',
externalRestApiBaseUrl: 'https://api.example.com/confirmed',
rpcProxyBaseUrl: '',
appName: 'Evenfire',
}),
} as never
service.authClient = {
getDesktopEnvironment: vi.fn().mockResolvedValue({
externalRestApiBaseUrl: 'https://api.example.com./different',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Discovered',
}),
} as never
await service.completeDesktopSetup('[email protected]', 'setup-token')
expect(service.authClient.getDesktopEnvironment).toHaveBeenCalledOnce()
expect(config.externalRestApiBaseUrl).toBe('https://api.example.com/confirmed')
expect(config.rpcProxyBaseUrl).toBe('')
const persisted = JSON.parse(await fs.readFile(configPath, 'utf8')) as {
externalRestApiBaseUrl: string
rpcProxyBaseUrl: string
appName: string
}
expect(persisted).toEqual({
externalRestApiBaseUrl: 'https://api.example.com/confirmed',
rpcProxyBaseUrl: '',
appName: 'Evenfire',
})
})
it('does not contact member-registration-service when runtime config is already set', async () => {
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const { AppService } = await import('../appService.js')
const service = new AppService() as unknown as {
authClient: { passwordLogin: ReturnType<typeof vi.fn> }
memberRegistrationServiceClient: { completeDesktopSetup: ReturnType<typeof vi.fn> }
tokenStore: { setSessionToken: ReturnType<typeof vi.fn> }
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
passwordLogin: (email: string, password: string) => Promise<unknown>
}
service.memberRegistrationServiceClient = {
completeDesktopSetup: vi.fn(),
} as never
service.authClient = {
passwordLogin: vi.fn().mockResolvedValue({
token: 'session-token',
me: {
id: 'user-1',
email: '[email protected]',
name: null,
picture: null,
teamId: 'team-1',
teamName: 'Marketing',
role: 'member',
},
}),
} as never
service.tokenStore = {
setSessionToken: vi.fn().mockResolvedValue(undefined),
} as never
service.rpcTokenManager = {
clear: vi.fn(),
} as never
await service.passwordLogin('[email protected]', 'password123')
expect(service.memberRegistrationServiceClient.completeDesktopSetup).not.toHaveBeenCalled()
expect(service.authClient.passwordLogin).toHaveBeenCalledWith('[email protected]', 'password123')
})
it('does not repeat a failed startup restore before the login screen can paint', async () => {
const configPath = await createTempConfigPath('clerum-desktop-restore-local')
await fs.writeFile(
configPath,
JSON.stringify({
externalRestApiBaseUrl: 'http://127.0.0.1:8091',
rpcProxyBaseUrl: 'http://127.0.0.1:8094',
appName: 'Localhost',
})
)
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
process.env.EXTERNAL_REST_API_BASE_URL = 'http://127.0.0.1:8091'
process.env.RPC_PROXY_BASE_URL = 'http://127.0.0.1:8094'
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
let now = 1_000
const nowSpy = vi.spyOn(Date, 'now').mockImplementation(() => now)
const { AppService } = await import('../appService.js')
const getSessionToken = vi.fn().mockResolvedValue('stored-token')
const clearSessionToken = vi.fn().mockResolvedValue(undefined)
const service = new AppService() as unknown as {
authClient: { getMe: ReturnType<typeof vi.fn> }
tokenStore: {
getSessionToken: ReturnType<typeof vi.fn>
clearSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
initialize: () => Promise<unknown>
getSessionState: () => Promise<unknown>
}
service.authClient = {
getMe: vi.fn().mockRejectedValueOnce(new Error('fetch failed')).mockResolvedValue({
id: 'user-1',
email: '[email protected]',
name: null,
picture: null,
teamId: null,
teamName: null,
role: null,
}),
} as never
service.tokenStore = {
getSessionToken,
clearSessionToken,
} as never
service.rpcTokenManager = {
clear: vi.fn(),
} as never
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
try {
await expect(service.initialize()).resolves.toEqual({ authenticated: false, me: null })
expect(clearSessionToken).not.toHaveBeenCalled()
await expect(service.getSessionState()).resolves.toEqual({
authenticated: false,
me: null,
})
expect(getSessionToken).toHaveBeenCalledTimes(1)
expect(service.authClient.getMe).toHaveBeenCalledTimes(1)
now += 5_001
await expect(service.getSessionState()).resolves.toMatchObject({
authenticated: true,
me: { id: 'user-1' },
})
expect(getSessionToken).toHaveBeenCalledTimes(2)
expect(service.authClient.getMe).toHaveBeenCalledTimes(2)
} finally {
warn.mockRestore()
nowSpy.mockRestore()
}
})
it('fails closed when the saved-token store cannot be read', async () => {
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
vi.resetModules()
const { AppService } = await import('../appService.js')
const getMe = vi.fn()
const service = new AppService() as unknown as {
authClient: { getMe: ReturnType<typeof vi.fn> }
tokenStore: {
getSessionToken: ReturnType<typeof vi.fn>
clearSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
getSessionState: () => Promise<unknown>
}
service.authClient = { getMe } as never
service.tokenStore = {
getSessionToken: vi.fn().mockRejectedValue(new Error('keychain unavailable')),
clearSessionToken: vi.fn(),
} as never
service.rpcTokenManager = { clear: vi.fn() } as never
const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
try {
await expect(service.getSessionState()).resolves.toEqual({
authenticated: false,
me: null,
})
} finally {
warn.mockRestore()
}
expect(getMe).not.toHaveBeenCalled()
})
it('preserves the session when clearing the saved token fails', async () => {
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
vi.resetModules()
const [{ AppService }, { getActiveEnvKey, getActiveLegacyRestOnlyEnvKey }] = await Promise.all([
import('../appService.js'),
import('../config.js'),
])
const service = new AppService() as unknown as {
authClient: {
getMe: ReturnType<typeof vi.fn>
passwordLogin: ReturnType<typeof vi.fn>
}
tokenStore: {
clearSessionToken: ReturnType<typeof vi.fn>
getSessionToken: ReturnType<typeof vi.fn>
setSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
updateDesktopGfsUploadState: ReturnType<typeof vi.fn>
passwordLogin: (email: string, password: string) => Promise<unknown>
logout: () => Promise<void>
getSessionState: () => Promise<unknown>
getCachedUserId: () => string | null
gfsDispatchBlocked: boolean
}
const me = {
id: 'user-1',
email: '[email protected]',
name: null,
picture: null,
teamId: 'team-1',
teamName: 'Marketing',
role: 'member',
}
const getMe = vi.fn().mockResolvedValue(me)
const getSessionToken = vi.fn().mockResolvedValue('test-token')
service.authClient = {
passwordLogin: vi.fn().mockResolvedValue({ token: 'test-token', me }),
getMe,
} as never
service.tokenStore = {
getSessionToken,
setSessionToken: vi.fn().mockResolvedValue(undefined),
clearSessionToken: vi.fn().mockRejectedValue(new Error('keychain unavailable')),
} as never
service.rpcTokenManager = { clear: vi.fn() } as never
service.updateDesktopGfsUploadState = vi.fn().mockResolvedValue(undefined)
await service.passwordLogin('[email protected]', 'fake-password')
expect(service.getCachedUserId()).toBe('user-1')
await expect(service.logout()).rejects.toThrow(/keychain unavailable/)
expect(service.tokenStore.clearSessionToken).toHaveBeenCalledWith(getActiveEnvKey(), {
legacyEnvKeys: [getActiveLegacyRestOnlyEnvKey()],
})
await expect(service.getSessionState()).resolves.toEqual({ authenticated: true, me })
expect(service.getCachedUserId()).toBe('user-1')
expect(getSessionToken).not.toHaveBeenCalled()
expect(getMe).not.toHaveBeenCalled()
expect(service.gfsDispatchBlocked).toBe(false)
})
it('shares one saved-session restore across concurrent session-state requests', async () => {
const configPath = await createTempConfigPath('clerum-desktop-restore-single-flight')
await fs.writeFile(
configPath,
JSON.stringify({
externalRestApiBaseUrl: 'http://127.0.0.1:8091',
rpcProxyBaseUrl: 'http://127.0.0.1:8094',
appName: 'Localhost',
})
)
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
process.env.EXTERNAL_REST_API_BASE_URL = 'http://127.0.0.1:8091'
process.env.RPC_PROXY_BASE_URL = 'http://127.0.0.1:8094'
vi.resetModules()
vi.doMock('electron', () => ({
app: {
getPath: vi.fn(() => path.dirname(configPath)),
isPackaged: false,
isReady: vi.fn(() => true),
setName: vi.fn(),
setPath: vi.fn(),
},
}))
const [{ AppService }, chatStoreBinding] = await Promise.all([
import('../appService.js'),
import('../chatStoreBinding.js'),
])
chatStoreBinding.__setChatStoreBaseDirForTests(path.dirname(configPath))
const me = {
id: 'user-1',
email: '[email protected]',
name: null,
picture: null,
teamId: 'team-1',
teamName: 'Marketing',
role: 'member',
}
let resolveMe!: (value: typeof me) => void
const pendingMe = new Promise<typeof me>(resolve => {
resolveMe = resolve
})
const getSessionToken = vi.fn().mockResolvedValue('stored-token')
const getMe = vi.fn().mockReturnValue(pendingMe)
const service = new AppService() as unknown as {
authClient: { getMe: ReturnType<typeof vi.fn> }
tokenStore: {
getSessionToken: ReturnType<typeof vi.fn>
clearSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
initialize: () => Promise<unknown>
getSessionState: () => Promise<unknown>
}
service.authClient = { getMe } as never
service.tokenStore = {
getSessionToken,
clearSessionToken: vi.fn(),
} as never
service.rpcTokenManager = { clear: vi.fn() } as never
const first = service.initialize()
const second = service.getSessionState()
resolveMe(me)
await expect(Promise.all([first, second])).resolves.toEqual([
{ authenticated: true, me },
{ authenticated: true, me },
])
expect(getSessionToken).toHaveBeenCalledTimes(1)
expect(getMe).toHaveBeenCalledTimes(1)
})
it('keeps the completed logout generation when an expired restore finds no saved token', async () => {
const configPath = await createTempConfigPath('clerum-desktop-restore-after-logout')
await fs.writeFile(
configPath,
JSON.stringify({
externalRestApiBaseUrl: 'https://api.example.com',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Example',
})
)
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
vi.resetModules()
const [{ AppService }, { getActiveEnvKey }] = await Promise.all([
import('../appService.js'),
import('../config.js'),
])
const service = new AppService() as unknown as {
getSessionGeneration: () => number
getSessionState: () => Promise<unknown>
logout: () => Promise<number>
savedSessionRestoreAttemptedEnvKey: string
savedSessionRestoreAttemptedAtMs: number
tokenStore: {
clearSessionToken: ReturnType<typeof vi.fn>
getSessionToken: ReturnType<typeof vi.fn>
}
}
service.tokenStore = {
clearSessionToken: vi.fn().mockResolvedValue(undefined),
getSessionToken: vi.fn().mockResolvedValue(null),
} as never
const logoutGeneration = await service.logout()
service.savedSessionRestoreAttemptedEnvKey = getActiveEnvKey()
service.savedSessionRestoreAttemptedAtMs = 0
await expect(service.getSessionState()).resolves.toEqual({ authenticated: false, me: null })
expect(service.getSessionGeneration()).toBe(logoutGeneration)
expect(service.tokenStore.getSessionToken).toHaveBeenCalledWith(getActiveEnvKey(), {
legacyEnvKeys: expect.any(Array),
})
})
it('clears a saved token when startup session restore is rejected by the API', async () => {
const configPath = await createTempConfigPath('clerum-desktop-restore-api')
await fs.writeFile(
configPath,
JSON.stringify({
externalRestApiBaseUrl: 'https://api.example.com',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Example',
})
)
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const [{ AppService }, { resolveEnvKey }, { ApiError }] = await Promise.all([
import('../appService.js'),
import('../config.js'),
import('../httpClient.js'),
])
const clearSessionToken = vi.fn().mockResolvedValue(undefined)
const service = new AppService() as unknown as {
authClient: { getMe: ReturnType<typeof vi.fn> }
tokenStore: {
getSessionToken: ReturnType<typeof vi.fn>
clearSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
initialize: () => Promise<unknown>
}
service.authClient = {
getMe: vi.fn().mockRejectedValue(new ApiError('401 Unauthorized', 401, '')),
} as never
service.tokenStore = {
getSessionToken: vi.fn().mockResolvedValue('stored-token'),
clearSessionToken,
} as never
service.rpcTokenManager = {
clear: vi.fn(),
} as never
await expect(service.initialize()).resolves.toEqual({ authenticated: false, me: null })
expect(clearSessionToken).toHaveBeenCalledWith(
resolveEnvKey('https://api.example.com', 'https://rpc.example.com'),
{
legacyEnvKeys: [resolveEnvKey('https://api.example.com')],
}
)
})
it('clears a saved token when startup session restore is forbidden', async () => {
const configPath = await createTempConfigPath('clerum-desktop-restore-forbidden')
await fs.writeFile(
configPath,
JSON.stringify({
externalRestApiBaseUrl: 'https://api.example.com',
rpcProxyBaseUrl: 'https://rpc.example.com',
appName: 'Example',
})
)
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
process.env.EXTERNAL_REST_API_BASE_URL = 'https://api.example.com'
process.env.RPC_PROXY_BASE_URL = 'https://rpc.example.com'
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const [{ AppService }, { ApiError }] = await Promise.all([
import('../appService.js'),
import('../httpClient.js'),
])
const clearSessionToken = vi.fn().mockResolvedValue(undefined)
const service = new AppService() as unknown as {
authClient: { getMe: ReturnType<typeof vi.fn> }
tokenStore: {
getSessionToken: ReturnType<typeof vi.fn>
clearSessionToken: ReturnType<typeof vi.fn>
}
rpcTokenManager: { clear: ReturnType<typeof vi.fn> }
initialize: () => Promise<unknown>
}
service.authClient = {
getMe: vi.fn().mockRejectedValue(new ApiError('403 Forbidden', 403, '')),
} as never
service.tokenStore = {
getSessionToken: vi.fn().mockResolvedValue('stored-token'),
clearSessionToken,
} as never
service.rpcTokenManager = {
clear: vi.fn(),
} as never
await expect(service.initialize()).resolves.toEqual({ authenticated: false, me: null })
expect(clearSessionToken).toHaveBeenCalled()
})
it('persists a manually saved runtime environment', async () => {
const configPath = await createTempConfigPath('clerum-desktop-manual-config')
process.env.CLERUM_DESKTOP_CONFIG_PATH = configPath
delete process.env.EXTERNAL_REST_API_BASE_URL
delete process.env.RPC_PROXY_BASE_URL
delete process.env.PROFILE_UI_BASE_URL
vi.resetModules()
const [{ AppService }, { config, isDesktopRuntimeConfigured }] = await Promise.all([
import('../appService.js'),
import('../config.js'),
])
const service = new AppService() as unknown as {
saveRuntimeConfig: (next: {
externalRestApiBaseUrl: string
rpcProxyBaseUrl: string
appName?: string
}) => Promise<unknown>
deleteRuntimeConfig: (optionId: string) => Promise<unknown>
}
const state = await service.saveRuntimeConfig({
externalRestApiBaseUrl: 'https://example.com',
rpcProxyBaseUrl: 'https://example.com',
appName: 'Production',
})
expect(isDesktopRuntimeConfigured()).toBe(true)
expect(state).toMatchObject({
configured: true,
activeOptionId: 'custom-file',
})
expect(config.externalRestApiBaseUrl).toBe('https://example.com')
expect(config.rpcProxyBaseUrl).toBe('https://example.com')
expect(config.desktopProfileUiBaseUrl).toBe('https://example.com')
expect(config.appName).toBe('Production')
const persisted = JSON.parse(await fs.readFile(configPath, 'utf8')) as {
externalRestApiBaseUrl: string
rpcProxyBaseUrl: string
appName: string
}
expect(persisted).toEqual({
externalRestApiBaseUrl: 'https://example.com',
rpcProxyBaseUrl: 'https://example.com',
appName: 'Production',
})
const deletedState = await service.deleteRuntimeConfig('custom-file')
expect(deletedState).toMatchObject({
configured: false,
activeOptionId: null,
})
await expect(fs.access(configPath)).rejects.toThrow()
})
})