workspace-groups-remote/tests/rssh-settings-model.test.ts

743 行
29 KiB
TypeScript

/**
* Remote-SSH settings — pure-model behaviour.
*
* These tests pin the real semantics the new settings face relies on:
* the exact Host payloads, per-item import outcomes (never "selected size"
* reported as success), GiB/bytes conversion with the empty = Host-default
* convention, unsaved-draft reconciliation, and the connection-test verdict
* that keeps a successful probe with a warning as a warning.
*/
import { describe, expect, it, vi } from 'vitest'
import type { GuardDraft, ImportSummary, PrefsDraft } from '../src/client/rssh-settings/model.ts'
import type { RemoteSshWorkspace, SshConfigHost } from '../src/client/rssh-settings/contract.ts'
import {
apiErrorMessage,
bytesToGibText,
connectionTestView,
countSelected,
emptyConnectionForm,
gibTextToBytes,
guardDraftFromWorkspace,
guardDraftSignature,
guardsFromWorkspaces,
importHostKey,
importProfilePayload,
isConnectionFormValid,
isGuardDraftDirty,
isPrefsDraftDirty,
mergeImportRetry,
prefsDraftFromApi,
reconcileGuards,
reconcilePrefs,
runImport,
selectAllHosts,
selectedHosts,
splitList,
toSavePrefsPayload,
toSaveProfilePayload,
toUpdateWorkspaceGuardsPayload,
toggleHostSelection,
validateConnectionForm,
} from '../src/client/rssh-settings/model.ts'
import type { SaveProfilePayload } from '../src/client/rssh-settings/contract.ts'
/* ------------------------------------------------------------------ */
/* Fixtures */
/* ------------------------------------------------------------------ */
const HOSTS: SshConfigHost[] = [
{
name: 'alpha',
hostName: 'alpha.example.com',
port: 2222,
user: 'alice',
identityFile: '~/.ssh/alpha',
proxyJump: 'bastion.example.com',
},
{ name: 'beta', hostName: 'beta.example.com', user: 'bob' },
{ name: 'gamma', hostName: 'gamma.example.com' },
]
function hostSummary(hosts: SshConfigHost[]): string[] {
return hosts.map(importHostKey)
}
function makeSaveProfile(
results: Array<{ ok?: boolean; error?: string } | null | undefined | Error>,
) {
return vi.fn(async (_payload: SaveProfilePayload) => {
const next = results.shift()
if (next instanceof Error) throw next
return next
})
}
const WS: RemoteSshWorkspace = {
id: 'ws-1',
profileId: 'p-1',
title: 'Alpha',
remotePath: '~/project',
writeBack: true,
writeBackExclude: ['_patch/', '*.log'],
syncPaths: ['.dsh'],
syncExclude: ['data/'],
syncMaxBytes: 2147483648,
}
/* ------------------------------------------------------------------ */
/* Connection form → saveProfile payload */
/* ------------------------------------------------------------------ */
describe('connection form validation and saveProfile payload', () => {
it('accepts the default form: empty keyPath is legal (ssh-agent / ~/.ssh/config)', () => {
const form = emptyConnectionForm()
form.host = 'login.example.com'
form.user = 'alice'
expect(validateConnectionForm(form)).toEqual([])
expect(isConnectionFormValid(form)).toBe(true)
const payload = toSaveProfilePayload(form)
expect(payload.keyPath).toBe('')
expect(payload.port).toBe(22)
expect(payload.authMethod).toBe('key')
})
it('rejects an invalid port instead of silently falling back to 22', () => {
for (const port of ['', 'abc', '0', '65536', '-1', '22.5', '22abc']) {
const form = { ...emptyConnectionForm(), host: 'h', user: 'u', port }
const issues = validateConnectionForm(form)
expect(issues, `port=${JSON.stringify(port)}`).toContainEqual({
field: 'port',
messageKey: 'add.errPort',
})
expect(isConnectionFormValid(form), `port=${JSON.stringify(port)}`).toBe(false)
}
const form = { ...emptyConnectionForm(), host: 'h', user: 'u', port: ' 22 ' }
expect(validateConnectionForm(form)).toEqual([])
expect(toSaveProfilePayload(form).port).toBe(22)
})
it('reports host and user as required, together with the port issue', () => {
const form = { ...emptyConnectionForm(), host: ' ', user: '', port: 'x' }
expect(validateConnectionForm(form)).toEqual([
{ field: 'host', messageKey: 'add.errHost' },
{ field: 'user', messageKey: 'add.errUser' },
{ field: 'port', messageKey: 'add.errPort' },
])
})
it('keeps both draft fields across key/password auth switching (same form state)', () => {
const keyForm = {
...emptyConnectionForm(),
host: 'h',
user: 'u',
authMethod: 'key' as const,
keyPath: '~/.ssh/id_ed25519',
password: 'hunter2',
}
const keyPayload = toSaveProfilePayload(keyForm)
expect(keyPayload.authMethod).toBe('key')
expect(keyPayload.keyPath).toBe('~/.ssh/id_ed25519')
expect(keyPayload.password).toBe('hunter2')
const passwordForm = { ...keyForm, authMethod: 'password' as const }
const passwordPayload = toSaveProfilePayload(passwordForm)
expect(passwordPayload.authMethod).toBe('password')
expect(passwordPayload.keyPath).toBe('~/.ssh/id_ed25519')
expect(passwordPayload.password).toBe('hunter2')
})
it('carries every saveProfile field, including proxyJump and a real numeric port', () => {
const form = {
name: 'HPC',
host: 'login.example.com',
port: '2222',
user: 'alice',
authMethod: 'password' as const,
keyPath: '',
password: 'secret',
remoteRoot: '~/project',
proxyJump: 'bastion.example.com:22',
}
expect(toSaveProfilePayload(form)).toEqual({
name: 'HPC',
host: 'login.example.com',
port: 2222,
user: 'alice',
authMethod: 'password',
keyPath: '',
password: 'secret',
remoteRoot: '~/project',
proxyJump: 'bastion.example.com:22',
})
})
})
/* ------------------------------------------------------------------ */
/* SSH config import */
/* ------------------------------------------------------------------ */
describe('SSH config import — per-item outcomes', () => {
it('maps a discovered host to the exact saveProfile payload (incl. proxyJump)', () => {
expect(importProfilePayload(HOSTS[0] as SshConfigHost)).toEqual({
name: 'alpha',
host: 'alpha.example.com',
port: 2222,
user: 'alice',
authMethod: 'key',
keyPath: '~/.ssh/alpha',
password: '',
remoteRoot: '~',
proxyJump: 'bastion.example.com',
})
expect(importProfilePayload(HOSTS[2] as SshConfigHost)).toMatchObject({
port: 22,
user: '',
keyPath: '',
proxyJump: '',
})
})
it('counts every success only when every save resolves ok', async () => {
const save = makeSaveProfile([{ ok: true }, { ok: true }, { ok: true }])
const summary = await runImport(HOSTS, save)
expect(save).toHaveBeenCalledTimes(3)
expect(save.mock.calls.map(call => call[0].name)).toEqual(['alpha', 'beta', 'gamma'])
expect(summary.okCount).toBe(3)
expect(summary.failCount).toBe(0)
expect(summary.failedHosts).toEqual([])
expect(summary.outcomes.every(outcome => outcome.ok)).toBe(true)
})
it('reports real partial failures (ok:false + error text), never the selection size', async () => {
const save = makeSaveProfile([
{ ok: true },
{ ok: false, error: ' duplicate host ' },
{ ok: false, error: 'boom' },
])
const summary = await runImport(HOSTS, save)
expect(summary.okCount).toBe(1)
expect(summary.failCount).toBe(2)
expect(summary.outcomes.map(outcome => outcome.ok)).toEqual([true, false, false])
expect(summary.outcomes[1]?.error).toBe('duplicate host')
expect(summary.outcomes[2]?.error).toBe('boom')
expect(hostSummary(summary.failedHosts)).toEqual(hostSummary([HOSTS[1]!, HOSTS[2]!]))
})
it('reports every failure when all saves fail', async () => {
const save = makeSaveProfile([
{ ok: false, error: 'one' },
{ ok: false, error: 'two' },
{ ok: false, error: 'three' },
])
const summary = await runImport(HOSTS, save)
expect(summary.okCount).toBe(0)
expect(summary.failCount).toBe(3)
expect(hostSummary(summary.failedHosts)).toEqual(hostSummary(HOSTS))
expect(summary.outcomes.map(outcome => outcome.error)).toEqual(['one', 'two', 'three'])
})
it('turns thrown request errors into failures with the thrown message', async () => {
const save = makeSaveProfile([{ ok: true }, new Error('network down'), { ok: false, error: 'denied' }])
const summary = await runImport(HOSTS, save)
expect(summary.okCount).toBe(1)
expect(summary.failCount).toBe(2)
expect(summary.outcomes[1]?.ok).toBe(false)
expect(summary.outcomes[1]?.error).toBe('network down')
expect(hostSummary(summary.failedHosts)).toEqual(hostSummary([HOSTS[1]!, HOSTS[2]!]))
})
it('treats an undefined/null save result as failure (no-result), never as imported', async () => {
const save = makeSaveProfile([undefined, null])
const summary = await runImport(HOSTS.slice(0, 2), save)
expect(save).toHaveBeenCalledTimes(2)
expect(summary.okCount).toBe(0)
expect(summary.failCount).toBe(2)
expect(summary.outcomes.map(outcome => outcome.ok)).toEqual([false, false])
expect(summary.outcomes.map(outcome => outcome.errorCode)).toEqual(['no-result', 'no-result'])
expect(summary.outcomes.every(outcome => outcome.error === undefined)).toBe(true)
expect(summary.failedHosts).toHaveLength(2)
})
it('treats ok:false without error text as a failure too', async () => {
const summary = await runImport([HOSTS[1] as SshConfigHost], makeSaveProfile([{ ok: false }]))
expect(summary.okCount).toBe(0)
expect(summary.failCount).toBe(1)
expect(summary.outcomes[0]?.errorCode).toBe('no-result')
})
it('an empty selection imports nothing and calls no endpoint', async () => {
const save = makeSaveProfile([])
const summary = await runImport([], save)
expect(save).not.toHaveBeenCalled()
expect(summary).toEqual({ outcomes: [], okCount: 0, failCount: 0, failedHosts: [] })
})
it('reports progress per host only through the injected callback', async () => {
const progress: string[] = []
const summary = await runImport(HOSTS.slice(0, 2), makeSaveProfile([{ ok: true }, { ok: false }]), {
onProgress: (done, total, host) => progress.push(`${done}/${total}:${host.name}`),
})
expect(progress).toEqual(['0/2:alpha', '1/2:beta', '2/2:beta'])
expect(summary.failCount).toBe(1)
})
})
describe('failed-only retry merge', () => {
it('does not resubmit successful items and keeps their success count', async () => {
const firstSave = makeSaveProfile([{ ok: true }, { ok: false, error: 'timeout' }, { ok: false, error: 'x' }])
const first = await runImport(HOSTS, firstSave)
const retrySave = makeSaveProfile([{ ok: true }, { ok: true }])
const retry = await runImport(first.failedHosts, retrySave)
expect(retrySave).toHaveBeenCalledTimes(2)
expect(retrySave.mock.calls.map(call => call[0].name)).toEqual(['beta', 'gamma'])
expect(firstSave).toHaveBeenCalledTimes(3)
expect(firstSave.mock.calls.map(call => call[0].name)).toEqual(['alpha', 'beta', 'gamma'])
const merged = mergeImportRetry(first, retry)
expect(merged.okCount).toBe(3)
expect(merged.failCount).toBe(0)
expect(merged.failedHosts).toEqual([])
expect(merged.outcomes).toHaveLength(3)
expect(merged.outcomes.every(outcome => outcome.ok)).toBe(true)
})
it('keeps a still-failing retry item as failed with its retry reason', async () => {
const first = await runImport(
HOSTS,
makeSaveProfile([{ ok: true }, { ok: false, error: 'timeout' }, { ok: false, error: 'nope' }]),
)
const retry = await runImport(first.failedHosts, makeSaveProfile([{ ok: false, error: 'still bad' }, { ok: true }]))
const merged = mergeImportRetry(first, retry)
expect(merged.okCount).toBe(2)
expect(merged.failCount).toBe(1)
expect(hostSummary(merged.failedHosts)).toEqual(hostSummary([HOSTS[1] as SshConfigHost]))
expect(merged.outcomes).toHaveLength(3)
expect(merged.outcomes.filter(outcome => !outcome.ok)[0]?.error).toBe('still bad')
})
it('a fully failed retry keeps the merged summary fully failed', () => {
const previous: ImportSummary = {
outcomes: [
{ key: 'a|h', name: 'a', hostName: 'h', ok: false, error: 'first' },
{ key: 'b|h2', name: 'b', hostName: 'h2', ok: false, error: 'second' },
],
okCount: 0,
failCount: 2,
failedHosts: [HOSTS[0] as SshConfigHost, HOSTS[1] as SshConfigHost],
}
const retry: ImportSummary = {
outcomes: [
{ key: 'a|h', name: 'a', hostName: 'h', ok: false, errorCode: 'no-result' },
{ key: 'b|h2', name: 'b', hostName: 'h2', ok: false, error: 'second' },
],
okCount: 0,
failCount: 2,
failedHosts: [HOSTS[0] as SshConfigHost, HOSTS[1] as SshConfigHost],
}
const merged = mergeImportRetry(previous, retry)
expect(merged.okCount).toBe(0)
expect(merged.failCount).toBe(2)
expect(merged.failedHosts).toHaveLength(2)
expect(merged.outcomes.every(outcome => !outcome.ok)).toBe(true)
})
})
describe('host selection', () => {
it('selects nothing when every row is unchecked', () => {
const selected = { [importHostKey(HOSTS[0]!)]: false, [importHostKey(HOSTS[1]!)]: false }
expect(selectedHosts(HOSTS, selected)).toEqual([])
expect(countSelected(selected)).toBe(0)
})
it('selects all discovered hosts by default and counts only checked rows', () => {
const selected = selectAllHosts(HOSTS)
expect(countSelected(selected)).toBe(3)
expect(hostSummary(selectedHosts(HOSTS, selected))).toEqual(hostSummary(HOSTS))
const toggled = toggleHostSelection(selected, importHostKey(HOSTS[1]!))
expect(toggled[importHostKey(HOSTS[1]!)]).toBe(false)
expect(countSelected(toggled)).toBe(2)
expect(hostSummary(selectedHosts(HOSTS, toggled))).toEqual(
hostSummary([HOSTS[0] as SshConfigHost, HOSTS[2] as SshConfigHost]),
)
})
it('treats an empty selection map as no selection', () => {
expect(selectedHosts(HOSTS, {})).toEqual([])
expect(countSelected({})).toBe(0)
})
})
/* ------------------------------------------------------------------ */
/* GiB ↔ bytes */
/* ------------------------------------------------------------------ */
describe('sync size unit conversion and empty-value semantics', () => {
it('bytesToGibText: empty input means "use the Host default"', () => {
expect(bytesToGibText(0)).toBe('')
expect(bytesToGibText(0)).toBe('')
expect(bytesToGibText(null)).toBe('')
expect(bytesToGibText(undefined)).toBe('')
expect(bytesToGibText(Number.NaN)).toBe('')
})
it('bytesToGibText: tiny byte counts collapse to "0", GiB values round to 2 decimals', () => {
expect(bytesToGibText(2)).toBe('0')
expect(bytesToGibText(1073741824)).toBe('1')
expect(bytesToGibText(2 * 1073741824)).toBe('2')
expect(bytesToGibText(1.5 * 1073741824)).toBe('1.5')
})
it('gibTextToBytes: empty / zero / invalid all mean 0 (Host default)', () => {
expect(gibTextToBytes('')).toBe(0)
expect(gibTextToBytes('0')).toBe(0)
expect(gibTextToBytes('0.0')).toBe(0)
expect(gibTextToBytes('abc')).toBe(0)
expect(gibTextToBytes(null)).toBe(0)
expect(gibTextToBytes(undefined)).toBe(0)
})
it('gibTextToBytes: "2" and "2.0" both mean 2 GiB = 2147483648 bytes', () => {
expect(gibTextToBytes(2)).toBe(2147483648)
expect(gibTextToBytes('2')).toBe(2147483648)
expect(gibTextToBytes('2.0')).toBe(2147483648)
expect(gibTextToBytes('2.5')).toBe(2684354560)
expect(gibTextToBytes('2 GiB')).toBe(2147483648)
})
it('round-trips the default 2 GiB cap', () => {
expect(gibTextToBytes(bytesToGibText(2147483648))).toBe(2147483648)
})
})
describe('list splitting', () => {
it('accepts commas, newlines and semicolons, trimming and dropping empty entries', () => {
expect(splitList('a, b\nc; d')).toEqual(['a', 'b', 'c', 'd'])
expect(splitList('a,, b, ,\n')).toEqual(['a', 'b'])
expect(splitList('')).toEqual([])
expect(splitList(null)).toEqual([])
expect(splitList(undefined)).toEqual([])
})
})
/* ------------------------------------------------------------------ */
/* Workspace guard drafts */
/* ------------------------------------------------------------------ */
describe('workspace guard drafts', () => {
it('builds a draft from a persisted record (defaults match the Host)', () => {
expect(guardDraftFromWorkspace(WS)).toEqual({
writeBack: true,
writeBackExclude: '_patch/, *.log',
syncPaths: '.dsh',
syncExclude: 'data/',
syncMaxBytes: '2',
})
expect(guardDraftFromWorkspace({ id: 'w2', profileId: 'p' })).toEqual({
writeBack: true,
writeBackExclude: '',
syncPaths: '',
syncExclude: '',
syncMaxBytes: '',
})
expect(guardDraftFromWorkspace({ id: 'w3', profileId: 'p', writeBack: false })).toMatchObject({
writeBack: false,
})
})
it('does not call formatting-only differences dirty', () => {
const baseline = guardDraftFromWorkspace(WS)
expect(isGuardDraftDirty(baseline, baseline)).toBe(false)
expect(isGuardDraftDirty({ ...baseline, writeBackExclude: '_patch/,\n*.log' }, baseline)).toBe(false)
expect(isGuardDraftDirty({ ...baseline, syncPaths: ' .dsh ' }, baseline)).toBe(false)
expect(isGuardDraftDirty({ ...baseline, syncMaxBytes: '2.0' }, baseline)).toBe(false)
expect(isGuardDraftDirty({ ...baseline, syncMaxBytes: ' 2 ' }, baseline)).toBe(false)
expect(guardDraftSignature({ ...baseline, syncMaxBytes: '2.0' })).toBe(guardDraftSignature(baseline))
})
it('marks real edits dirty', () => {
const baseline = guardDraftFromWorkspace(WS)
expect(isGuardDraftDirty({ ...baseline, writeBackExclude: '_patch/, *.log, tmp/' }, baseline)).toBe(true)
expect(isGuardDraftDirty({ ...baseline, syncPaths: '.dsh, ..' }, baseline)).toBe(true)
expect(isGuardDraftDirty({ ...baseline, writeBack: false }, baseline)).toBe(true)
expect(isGuardDraftDirty({ ...baseline, syncMaxBytes: '3' }, baseline)).toBe(true)
expect(isGuardDraftDirty({ ...baseline, syncMaxBytes: '' }, baseline)).toBe(true)
})
it('produces the exact updateWorkspaceGuards payload for the target workspace id', () => {
const draft: GuardDraft = {
writeBack: false,
writeBackExclude: '_patch/, *.log',
syncPaths: '.dsh\nsrc',
syncExclude: 'data/, *.tmp',
syncMaxBytes: '2',
}
expect(toUpdateWorkspaceGuardsPayload('ws-1', draft)).toEqual({
id: 'ws-1',
writeBack: false,
writeBackExclude: ['_patch/', '*.log'],
syncPaths: ['.dsh', 'src'],
syncExclude: ['data/', '*.tmp'],
syncMaxBytes: 2147483648,
})
expect(toUpdateWorkspaceGuardsPayload('ws-1', { ...draft, syncMaxBytes: '' }).syncMaxBytes).toBe(0)
expect(toUpdateWorkspaceGuardsPayload('ws-1', { ...draft, syncMaxBytes: '2.0' }).syncMaxBytes).toBe(2147483648)
})
})
describe('reconcileGuards', () => {
it('keeps a dirty draft across an unrelated reload and moves its baseline to server truth', () => {
const previousDrafts = guardsFromWorkspaces([WS])
const previousBaselines = guardsFromWorkspaces([WS])
const dirtyDraft: GuardDraft = { ...previousDrafts['ws-1']!, writeBackExclude: '_patch/, *.log, tmp/' }
previousDrafts['ws-1'] = dirtyDraft
const serverWorkspace: RemoteSshWorkspace = { ...WS, writeBackExclude: ['server/'] }
const result = reconcileGuards(previousDrafts, previousBaselines, [serverWorkspace])
expect(result.drafts['ws-1']).toBe(dirtyDraft)
expect(result.baselines['ws-1']).toEqual(guardDraftFromWorkspace(serverWorkspace))
expect(isGuardDraftDirty(result.drafts['ws-1']!, result.baselines['ws-1']!)).toBe(true)
})
it('adopts server truth for a clean draft', () => {
const previousDrafts = guardsFromWorkspaces([WS])
const previousBaselines = guardsFromWorkspaces([WS])
const serverWorkspace: RemoteSshWorkspace = { ...WS, writeBack: false, syncPaths: [] }
const result = reconcileGuards(previousDrafts, previousBaselines, [serverWorkspace])
expect(result.drafts['ws-1']).toEqual(guardDraftFromWorkspace(serverWorkspace))
expect(result.baselines['ws-1']).toEqual(guardDraftFromWorkspace(serverWorkspace))
expect(isGuardDraftDirty(result.drafts['ws-1']!, result.baselines['ws-1']!)).toBe(false)
})
it('drops drafts and baselines for records deleted on the Host', () => {
const previousDrafts = guardsFromWorkspaces([WS, { id: 'ws-2', profileId: 'p-2' }])
const previousBaselines = guardsFromWorkspaces([WS, { id: 'ws-2', profileId: 'p-2' }])
const result = reconcileGuards(previousDrafts, previousBaselines, [WS])
expect(Object.keys(result.drafts)).toEqual(['ws-1'])
expect(Object.keys(result.baselines)).toEqual(['ws-1'])
expect(result.drafts['ws-2']).toBeUndefined()
})
it('treats a draft without a previous baseline as dirty so a refresh cannot wipe typed text', () => {
const typed: GuardDraft = {
writeBack: true,
writeBackExclude: 'tmp/',
syncPaths: '',
syncExclude: '',
syncMaxBytes: '',
}
const result = reconcileGuards({ 'ws-1': typed }, {}, [WS])
expect(result.drafts['ws-1']).toEqual(typed)
expect(result.baselines['ws-1']).toEqual(guardDraftFromWorkspace(WS))
})
})
/* ------------------------------------------------------------------ */
/* Global preferences */
/* ------------------------------------------------------------------ */
const PREFS: PrefsDraft = {
nodePath: '/usr/local/bin/node',
writeBackFailure: 'log',
writeBackFreshness: false,
defaultSyncPaths: '.dsh, src',
defaultSyncExclude: 'data/',
defaultSyncMaxBytes: '2',
}
describe('global preferences draft', () => {
it('projects Host preferences with the upstream defaults', () => {
expect(prefsDraftFromApi({})).toEqual({
nodePath: '',
writeBackFailure: 'error',
writeBackFreshness: true,
defaultSyncPaths: '',
defaultSyncExclude: '',
defaultSyncMaxBytes: '',
})
expect(prefsDraftFromApi({ nodePath: '/opt/node', writeBackFailure: 'log', writeBackFreshness: false, defaultSyncPaths: ['a', 'b'], defaultSyncMaxBytes: 2147483648 })).toEqual({
nodePath: '/opt/node',
writeBackFailure: 'log',
writeBackFreshness: false,
defaultSyncPaths: 'a, b',
defaultSyncExclude: '',
defaultSyncMaxBytes: '2',
})
})
it('does not call formatting-only differences dirty', () => {
expect(isPrefsDraftDirty(PREFS, PREFS)).toBe(false)
expect(isPrefsDraftDirty({ ...PREFS, defaultSyncPaths: '.dsh\nsrc' }, PREFS)).toBe(false)
expect(isPrefsDraftDirty({ ...PREFS, defaultSyncMaxBytes: '2.0' }, PREFS)).toBe(false)
expect(isPrefsDraftDirty({ ...PREFS, nodePath: ' /usr/local/bin/node ' }, PREFS)).toBe(false)
})
it('marks real edits dirty', () => {
expect(isPrefsDraftDirty({ ...PREFS, defaultSyncPaths: '.dsh, src, tests' }, PREFS)).toBe(true)
expect(isPrefsDraftDirty({ ...PREFS, writeBackFailure: 'error' }, PREFS)).toBe(true)
expect(isPrefsDraftDirty({ ...PREFS, writeBackFreshness: true }, PREFS)).toBe(true)
expect(isPrefsDraftDirty({ ...PREFS, defaultSyncMaxBytes: '3' }, PREFS)).toBe(true)
})
it('produces the exact savePrefs payload', () => {
expect(toSavePrefsPayload(PREFS)).toEqual({
nodePath: '/usr/local/bin/node',
writeBackFailure: 'log',
writeBackFreshness: false,
defaultSyncPaths: ['.dsh', 'src'],
defaultSyncExclude: ['data/'],
defaultSyncMaxBytes: 2147483648,
})
expect(toSavePrefsPayload({ ...PREFS, nodePath: ' ', defaultSyncMaxBytes: '' })).toMatchObject({
nodePath: '',
defaultSyncMaxBytes: 0,
})
})
it('keeps an unsaved preferences draft on refresh and adopts server truth for a clean one', () => {
const serverDraft: PrefsDraft = { ...PREFS, nodePath: '/server/node' }
const dirty: PrefsDraft = { ...PREFS, nodePath: '/typed/node' }
const kept = reconcilePrefs(dirty, PREFS, serverDraft)
expect(kept.draft).toEqual(dirty)
expect(kept.baseline).toEqual(serverDraft)
const clean = reconcilePrefs(PREFS, PREFS, serverDraft)
expect(clean.draft).toEqual(serverDraft)
expect(clean.baseline).toEqual(serverDraft)
const firstLoad = reconcilePrefs(null, null, serverDraft)
expect(firstLoad.draft).toEqual(serverDraft)
expect(firstLoad.baseline).toEqual(serverDraft)
})
})
/* ------------------------------------------------------------------ */
/* Guards ↔ prefs independence */
/* ------------------------------------------------------------------ */
describe('workspace guards and global preferences never overwrite each other', () => {
it('their payload shapes stay disjoint', () => {
const guardsPayload = toUpdateWorkspaceGuardsPayload('ws-1', guardDraftFromWorkspace(WS))
const prefsPayload = toSavePrefsPayload(prefsDraftFromApi({ nodePath: '/node', defaultSyncPaths: ['a'] }))
expect(Object.keys(guardsPayload).sort()).toEqual(
['id', 'syncExclude', 'syncMaxBytes', 'syncPaths', 'writeBack', 'writeBackExclude'].sort(),
)
expect(Object.keys(prefsPayload).sort()).toEqual(
['defaultSyncExclude', 'defaultSyncMaxBytes', 'defaultSyncPaths', 'nodePath', 'writeBackFailure', 'writeBackFreshness'].sort(),
)
expect(guardsPayload).not.toHaveProperty('nodePath')
expect(guardsPayload).not.toHaveProperty('writeBackFailure')
expect(prefsPayload).not.toHaveProperty('id')
expect(prefsPayload).not.toHaveProperty('writeBack')
expect(prefsPayload).not.toHaveProperty('syncPaths')
})
it('reconcileGuards and reconcilePrefs keep their own dirty drafts independently', () => {
const guards = guardsFromWorkspaces([WS])
const dirtyGuard: GuardDraft = { ...guards['ws-1']!, syncPaths: '.dsh, extra' }
const dirtyPrefs: PrefsDraft = { ...PREFS, nodePath: '/typed/node' }
const guardResult = reconcileGuards({ 'ws-1': dirtyGuard }, guards, [{ ...WS, syncPaths: ['server'] }])
const prefsResult = reconcilePrefs(dirtyPrefs, PREFS, { ...PREFS, nodePath: '/server/node' })
expect(guardResult.drafts['ws-1']).toEqual(dirtyGuard)
expect(prefsResult.draft).toEqual(dirtyPrefs)
// Never imported across the boundary: a guard draft has no prefs keys and vice versa.
expect(guardResult.drafts['ws-1']).not.toHaveProperty('nodePath')
expect(prefsResult.draft).not.toHaveProperty('syncMaxBytes')
})
it('a guard save baseline update does not touch the prefs draft', () => {
const before = toSavePrefsPayload(PREFS)
const result = reconcileGuards(guardsFromWorkspaces([WS]), guardsFromWorkspaces([WS]), [
{ ...WS, writeBackExclude: ['server/'] },
])
expect(result.drafts['ws-1']?.writeBackExclude).toBe('server/')
expect(toSavePrefsPayload(PREFS)).toEqual(before)
})
})
/* ------------------------------------------------------------------ */
/* Connection test feedback */
/* ------------------------------------------------------------------ */
describe('connectionTestView', () => {
it('plain success shows the success status and stdout detail', () => {
expect(connectionTestView({ ok: true, stdout: ' connected \n' })).toEqual({
status: 'success',
titleKey: 'connection.testOk',
warning: '',
detail: 'connected',
})
})
it('a successful probe carrying a warning stays a warning, never a plain success', () => {
const view = connectionTestView({ ok: true, warning: ' key path not found, using agent ', stdout: 'ok' })
expect(view.status).toBe('warning')
expect(view.titleKey).toBe('connection.testWarn')
expect(view.warning).toBe('key path not found, using agent')
expect(view.detail).toBe('ok')
})
it('failure joins error and stderr into pre-wrap diagnostics', () => {
const view = connectionTestView({
ok: false,
error: 'connect failed',
stderr: 'ssh: Could not resolve hostname',
exitCode: 255,
})
expect(view).toEqual({
status: 'error',
titleKey: 'connection.testFail',
warning: '',
detail: 'connect failed\nssh: Could not resolve hostname',
})
})
it('failure with only stderr, only error, or no envelope still yields the failure status', () => {
expect(connectionTestView({ ok: false, stderr: 'stderr only' }).detail).toBe('stderr only')
expect(connectionTestView({ ok: false, error: 'error only' }).detail).toBe('error only')
for (const empty of [undefined, null, {}, { ok: false }]) {
const view = connectionTestView(empty)
expect(view.status).toBe('error')
expect(view.titleKey).toBe('connection.testFail')
expect(view.detail).toBe('')
}
})
it('a failure that also carries a warning keeps both the failure status and the warning text', () => {
const view = connectionTestView({ ok: false, warning: 'identity ignored', error: 'denied' })
expect(view.status).toBe('error')
expect(view.warning).toBe('identity ignored')
expect(view.detail).toBe('denied')
})
})
describe('apiErrorMessage', () => {
it('trims the Host error and falls back when the envelope has none', () => {
expect(apiErrorMessage({ error: ' denied ' }, 'fallback')).toBe('denied')
expect(apiErrorMessage({ error: ' ' }, 'fallback')).toBe('fallback')
expect(apiErrorMessage({}, 'fallback')).toBe('fallback')
expect(apiErrorMessage(null, 'fallback')).toBe('fallback')
expect(apiErrorMessage({ error: 42 as unknown as string }, 'fallback')).toBe('fallback')
})
})