+
+
-
-
-
-
-
-
- CPU
-
-
- -
- {{ totals.cpu }}
- / {{ info.runtime.cpus }} cores
-
-
-
-
-
- Memory
-
-
-
- {{ totals.memory }}
-
- / {{ formatMemoryBytes(info.runtime.memory_bytes) }}{{ status.text }}
+
+
+
+
+
-
+
+ CPU
-
-
-
-
-
-
- Top stacks
-
-
- {{ 'cpu' === metric ? 'CPU' : 'Memory' }}
+
+
+ {{ totals.cpu }}
+ / {{ info.runtime.cpus }} cores
+
+
+
+
+
+ Memory
-
+
+
+
+ {{ totals.memory }}
+ / {{ formatMemoryBytes(info.runtime.memory_bytes) }}
+
+
+
+
+
+
+ Top stacks
+
+
+ {{ 'cpu' === metric ? 'CPU' : 'Memory' }}
-
- -
+
+ -
+ {{ stack.name }}
- {{ stack.name }}
+ {{ stack.totals.cpu }}
-
- {{ stack.totals.cpu }}
- {{ stack.totals.memory }}
-
-
-
-
-
+
{{ stack.totals.memory }}
+
+
+
+
diff --git a/frontend/app/components/stacks/StackList.vue b/frontend/app/components/stacks/StackList.vue
index 20c5565..55265ff 100644
--- a/frontend/app/components/stacks/StackList.vue
+++ b/frontend/app/components/stacks/StackList.vue
@@ -1,18 +1,25 @@
-
-
-
-
+
+
+
+
+ {{ status.text }}
+
+
-
-
-
-
-
-
-
Refresh stats
-
- Retry
-
-
-
+
-
- {{ connectionLabel }}
- Refresh stats
-
{
+ if (!selectedNode.value) {
+ return workspace.ready ? 'Node not found.' : ''
+ }
if ('paused' === selectedNode.value?.connection) {
return 'Node is paused. Resume it from Nodes to reconnect.'
}
@@ -152,20 +155,14 @@ const active = computed(() =>
runtime.value?.services.some((service) => 'running' === service.state),
)
const stats = ref | null>(null)
-const statsStream = useWorkspaceStream(
- (message) => {
- if ('stack.stats' === message.event) {
- stats.value = parseStackStats(message.data).containers
- }
- },
- () => {
- stats.value = null
- },
-)
+const statsStream = useWorkspaceStream((message) => {
+ if ('stack.stats' === message.event) {
+ stats.value = parseStackStats(message.data).containers
+ }
+})
const statsError = statsStream.error
const startStats = () => {
statsStream.stop()
- stats.value = null
if (connected.value && active.value && !isNew.value) {
statsStream.start({ type: 'stats', node: node.value, resource: name.value })
}
@@ -405,16 +402,13 @@ const load = () => {
editing.value = isNew.value
try {
- if (!selectedNode.value) {
- throw new Error('Node not found.')
- }
if ('op' in route.query) {
const { op: _legacyOp, ...query } = route.query
void router.replace({ query })
}
if (isNew.value) {
- if (selectedNode.value.stacks.some((stack) => name.value === stack.name)) {
+ if (selectedNode.value?.stacks.some((stack) => name.value === stack.name)) {
throw new Error('A stack with this name already exists. Choose another name.')
}
compose.value =
@@ -576,7 +570,16 @@ watch(
},
)
watch(() => [node.value, name.value], load, { immediate: true })
-watch([node, name, connected, active, isNew], startStats, { immediate: true })
+watch(
+ [node, name, connected, active, isNew],
+ ([nodeId, stackName, , isActive, draft], previous) => {
+ if (nodeId !== previous?.[0] || stackName !== previous?.[1] || !isActive || draft) {
+ stats.value = null
+ }
+ startStats()
+ },
+ { immediate: true },
+)
const actionCompleted = (action: StackAction | 'delete', exitCode?: number) => {
if ('delete' === action && 0 === exitCode) {
void navigateTo('/')
@@ -607,7 +610,7 @@ onBeforeUnmount(() => {
-
+
-
+
{{ runtime ? 'Refreshing stack...' : 'Loading stack...' }}
-
+ role="status"
+ class="flex items-center gap-2 text-sm text-muted"
+ >
+
+ {{ connectionError }}
+
-
-
- Retry stats
-
-
+
+ {{ statsError }}
+
{
>()
let socket: WebSocket | null = null
let timer: ReturnType | undefined
+ let streamTimer: ReturnType | undefined
let active = false
let paused = false
let retry = 1000
+ let streamRetry = 1000
let nextID = 0
+ const retryingStreams = new Set()
+
+ const transient = (status?: number): boolean =>
+ undefined !== status && (429 === status || 500 <= status)
const send = (message: object): boolean => {
if (!socket || WebSocket.OPEN !== socket.readyState) {
@@ -47,9 +53,42 @@ export const useRealtimeStore = defineStore('realtime', () => {
}
}
+ const clearStreamRetries = () => {
+ if (streamTimer) {
+ clearTimeout(streamTimer)
+ streamTimer = undefined
+ }
+ retryingStreams.clear()
+ streamRetry = 1000
+ }
+
+ const scheduleStreamRetry = (id: string) => {
+ retryingStreams.add(id)
+ if (streamTimer) {
+ return
+ }
+ const delay = streamRetry
+ streamRetry = Math.min(streamRetry * 2, 15000)
+ streamTimer = setTimeout(() => {
+ streamTimer = undefined
+ const ids = [...retryingStreams]
+ retryingStreams.clear()
+ if (!socket || WebSocket.OPEN !== socket.readyState) {
+ return
+ }
+ for (const key of ids) {
+ const reader = readers.get(key)
+ if (reader) {
+ attach(key, reader.subscription)
+ }
+ }
+ }, delay)
+ }
+
const close = () => {
clearTimeout(timer)
timer = undefined
+ clearStreamRetries()
if (socket) {
socket.onopen = null
socket.onmessage = null
@@ -142,10 +181,13 @@ export const useRealtimeStore = defineStore('realtime', () => {
failed()
return
}
- retry = 1000
if ('type' in parsed && 'error' === parsed.type) {
const failure = workspaceErrorMessage(parsed.status ?? 0, parsed.error)
if (!parsed.stream) {
+ if (transient(parsed.status)) {
+ failed()
+ return
+ }
const previous = [...readers.values()]
stop()
error.value = failure
@@ -158,16 +200,23 @@ export const useRealtimeStore = defineStore('realtime', () => {
} else {
const reader = readers.get(parsed.stream)
if (reader) {
- const transient = 429 === parsed.status || 500 <= (parsed.status ?? 0)
- readers.delete(parsed.stream)
reader.callbacks.onDisconnect(failure)
- if (!transient) {
- reader.callbacks.onRejected(parsed.status ?? 0)
+ if (transient(parsed.status) && 'stats' === reader.subscription.type) {
+ scheduleStreamRetry(parsed.stream)
+ } else {
+ readers.delete(parsed.stream)
+ if (!transient(parsed.status)) {
+ reader.callbacks.onRejected(parsed.status ?? 0)
+ }
}
}
}
return
}
+ retry = 1000
+ if ('event' in parsed && 'stack.stats' === parsed.event) {
+ streamRetry = 1000
+ }
const targets = parsed.stream
? [readers.get(parsed.stream)].filter((reader) => undefined !== reader)
: [...readers.values()].filter((reader) => 'runtime' === reader.subscription.type)
@@ -208,6 +257,7 @@ export const useRealtimeStore = defineStore('realtime', () => {
}
return {
stop: () => {
+ retryingStreams.delete(id)
if (readers.delete(id) && 'runtime' !== subscription.type) {
send({ type: 'stream.detach', stream: id })
}
diff --git a/frontend/app/store/workspace.ts b/frontend/app/store/workspace.ts
index 776064b..3a3b6b3 100644
--- a/frontend/app/store/workspace.ts
+++ b/frontend/app/store/workspace.ts
@@ -37,6 +37,31 @@ export const useWorkspaceStore = defineStore('workspace', () => {
const savingNodeOrder = ref(false)
let controller: AbortController | null = null
let jobsController = new AbortController()
+ let retryTimer: ReturnType | undefined
+ let retryDelay = 1000
+
+ const clearRetry = () => {
+ if (retryTimer) {
+ clearTimeout(retryTimer)
+ retryTimer = undefined
+ }
+ retryDelay = 1000
+ }
+ const clearLoadError = () => {
+ error.value = ''
+ clearRetry()
+ }
+ const scheduleRetry = () => {
+ if (retryTimer || !auth.authenticated) {
+ return
+ }
+ const delay = retryDelay
+ retryDelay = Math.min(retryDelay * 2, 15000)
+ retryTimer = setTimeout(() => {
+ retryTimer = undefined
+ void fetchNodes(true)
+ }, delay)
+ }
const workspaceStream = useWorkspaceStream(
(message) => {
@@ -78,6 +103,7 @@ export const useWorkspaceStore = defineStore('workspace', () => {
node.loading = event.stacks.some((stack) => stack.loading)
node.connection = 'connected'
node.error = ''
+ clearLoadError()
break
case 'stack.runtime': {
const runtime = { ...event.runtime, loading: false }
@@ -99,7 +125,9 @@ export const useWorkspaceStore = defineStore('workspace', () => {
node.paused = 'paused' === event.state
node.error =
'unavailable' === event.state ? event.message || "Couldn't connect to this node." : ''
- if ('connected' !== event.state) {
+ if ('connected' === event.state) {
+ clearLoadError()
+ } else {
node.loading = false
}
if (node.paused) {
@@ -165,6 +193,7 @@ export const useWorkspaceStore = defineStore('workspace', () => {
)
function reset() {
controller?.abort()
+ clearRetry()
workspaceStream.stop()
jobsController.abort()
jobsController = new AbortController()
@@ -172,6 +201,7 @@ export const useWorkspaceStore = defineStore('workspace', () => {
realtime.stop()
imageCheckRequests.value = {}
nodes.value = []
+ error.value = ''
ready.value = false
settingsOpen.value = false
sidebarOpen.value = false
@@ -182,24 +212,49 @@ export const useWorkspaceStore = defineStore('workspace', () => {
settingsOpen.value = true
}
- const load = async () => {
+ const failLoad = (message: string, transient: boolean) => {
+ error.value = transient ? `${message} Retrying automatically...` : message
+ ready.value = true
+ for (const node of nodes.value) {
+ if (node.paused) {
+ continue
+ }
+ if (!transient) {
+ node.connection = 'unavailable'
+ }
+ node.loading = false
+ }
+ if (transient) {
+ scheduleRetry()
+ } else {
+ clearRetry()
+ }
+ }
+
+ const fetchNodes = async (automatic: boolean) => {
+ if (!automatic) {
+ clearRetry()
+ error.value = ''
+ }
controller?.abort()
const current = new AbortController()
controller = current
- error.value = ''
try {
const response = await request('/api/nodes', { signal: current.signal })
const json = await parse_api_response(response)
+ if (current.signal.aborted) {
+ return
+ }
if (401 === response.status) {
+ auth.invalidate()
reset()
error.value = workspaceErrorMessage(response.status, "Couldn't load nodes.")
ready.value = true
return
}
if (!response.ok || 'error' in json) {
- throw new Error(workspaceErrorMessage(response.status, "Couldn't load nodes."))
- }
- if (current.signal.aborted) {
+ const transient = 429 === response.status || 500 <= response.status
+ failLoad(workspaceErrorMessage(response.status, "Couldn't load nodes."), transient)
return
}
nodes.value = json.nodes.map((node): WorkspaceNode => {
@@ -224,28 +279,26 @@ export const useWorkspaceStore = defineStore('workspace', () => {
'paused' === previous?.connection ? 'loading' : (previous?.connection ?? 'loading'),
}
})
+ clearLoadError()
ready.value = true
workspaceStream.start({ type: 'runtime' })
realtime.syncRuntime()
} catch (cause) {
- if (!current.signal.aborted) {
- error.value =
- cause instanceof Error && !(cause instanceof TypeError)
- ? cause.message
- : "Couldn't load nodes."
- ready.value = true
- for (const node of nodes.value) {
- if (node.paused) {
- continue
- }
- node.connection = 'unavailable'
- node.loading = false
- }
- notification('error', 'Stacks', error.value)
+ if (current.signal.aborted) {
+ return
}
+ const transient = cause instanceof TypeError
+ failLoad(
+ cause instanceof Error && !(cause instanceof TypeError)
+ ? cause.message
+ : "Couldn't load nodes.",
+ transient,
+ )
}
}
+ const load = () => fetchNodes(false)
+
const moveNode = async (id: string, target: string) => {
const from = nodes.value.findIndex((node) => id === node.id)
const to = nodes.value.findIndex((node) => target === node.id)
diff --git a/frontend/app/types/index.d.ts b/frontend/app/types/index.d.ts
index 3832f52..a99a085 100644
--- a/frontend/app/types/index.d.ts
+++ b/frontend/app/types/index.d.ts
@@ -270,6 +270,13 @@ export interface StackStats {
export type StackStatsTotals = Omit
+export interface NodeResourceStatus {
+ text: string
+ icon: string
+ tone: 'warning' | 'error' | 'muted'
+ spin?: boolean
+}
+
export interface NodeInfo {
runtime: RuntimeInfo
containers: Array
@@ -371,6 +378,7 @@ export interface StackListProps {
workspaceLoading: boolean
search: string
status: StackFilter
+ compact?: boolean
}
export interface Service {
diff --git a/frontend/assets.go b/frontend/assets.go
index 8445f79..ee5a0a7 100644
--- a/frontend/assets.go
+++ b/frontend/assets.go
@@ -2,8 +2,11 @@
package frontend
-import "io/fs"
+import (
+ "io/fs"
+ "os"
+)
func Assets() fs.FS {
- return nil
+ return os.DirFS("frontend/exported")
}
diff --git a/frontend/assets_test.go b/frontend/assets_test.go
new file mode 100644
index 0000000..eb64eeb
--- /dev/null
+++ b/frontend/assets_test.go
@@ -0,0 +1,37 @@
+//go:build !embed
+
+package frontend
+
+import (
+ "errors"
+ "io/fs"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func TestAssets(t *testing.T) {
+ t.Chdir(t.TempDir())
+ assets := Assets()
+ if _, err := fs.ReadFile(assets, "index.html"); !errors.Is(err, fs.ErrNotExist) {
+ t.Fatalf("missing generated assets: %v", err)
+ }
+
+ directory := filepath.Join("frontend", "exported")
+ if err := os.MkdirAll(directory, 0o755); nil != err {
+ t.Fatal(err)
+ }
+ path := filepath.Join(directory, "index.html")
+ for _, content := range []string{"first", "updated"} {
+ if err := os.WriteFile(path, []byte(content), 0o644); nil != err {
+ t.Fatal(err)
+ }
+ data, err := fs.ReadFile(assets, "index.html")
+ if nil != err {
+ t.Fatal(err)
+ }
+ if content != string(data) {
+ t.Fatalf("generated assets: got %q, want %q", data, content)
+ }
+ }
+}
diff --git a/frontend/nuxt.config.ts b/frontend/nuxt.config.ts
index 2b06d82..3893245 100644
--- a/frontend/nuxt.config.ts
+++ b/frontend/nuxt.config.ts
@@ -21,7 +21,15 @@ export default defineNuxtConfig({
scan: { globInclude: ['app/**/*.{vue,ts}', 'node_modules/@nuxt/ui/dist/shared/ui*.mjs'] },
},
},
- runtimeConfig: { public: { domain: '', version: '1.0.0' } },
+ runtimeConfig: {
+ public: {
+ domain: '',
+ version: 'dev',
+ commitSha: 'unknown',
+ buildDate: 'unknown',
+ branch: 'unknown',
+ },
+ },
app: {
buildAssetsDir: 'assets',
head: {
diff --git a/frontend/package.json b/frontend/package.json
index 6b459d4..83d05c9 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -12,7 +12,7 @@
"lint:tsc": "vue-tsc --noEmit -p tsconfig.json",
"format": "oxfmt --write app/",
"format:check": "oxfmt --check app/",
- "test": "bun test tests/"
+ "test": "bun test --randomize tests/"
},
"dependencies": {
"@iconify-json/lucide": "^1.2.0",
@@ -40,5 +40,9 @@
"vue-eslint-parser": "^10.4.1",
"vue-tsc": "^3.3.13"
},
- "trustedDependencies": ["@parcel/watcher", "esbuild", "unrs-resolver"]
+ "trustedDependencies": [
+ "@parcel/watcher",
+ "esbuild",
+ "unrs-resolver"
+ ]
}
diff --git a/frontend/tests/auth.test.ts b/frontend/tests/auth.test.ts
index ce4a806..9a88d98 100644
--- a/frontend/tests/auth.test.ts
+++ b/frontend/tests/auth.test.ts
@@ -1,20 +1,13 @@
import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'
-import { createPinia, setActivePinia } from 'pinia'
+import { createPinia, disposePinia, setActivePinia } from 'pinia'
+import type { Pinia } from 'pinia'
import type { RouteLocationNormalized } from 'vue-router'
+import { navigate } from './mocks/nuxt'
const responses: Array> = []
const calls: Array<{ path: string; options: RequestInit }> = []
const originalFetch = globalThis.fetch
-const navigate = mock((path: string, _options?: { replace?: boolean }) => path)
-
-mock.module('#app', () => ({
- useRuntimeConfig: () => ({ public: { domain: '' } }),
- defineNuxtRouteMiddleware: (middleware: (to: { name: string }) => Promise) => middleware,
- navigateTo: navigate,
-}))
-mock.module('#imports', () => ({
- useToast: () => ({ add: () => {} }),
-}))
+let pinia: Pinia
const { useAuthStore } = await import('../app/store/auth')
const { default: authGuard } = await import('../app/middleware/auth.global')
@@ -39,7 +32,8 @@ const route = (name: string): RouteLocationNormalized => ({
})
beforeEach(() => {
- setActivePinia(createPinia())
+ pinia = createPinia()
+ setActivePinia(pinia)
responses.length = 0
calls.length = 0
navigate.mockClear()
@@ -55,6 +49,8 @@ beforeEach(() => {
})
afterEach(() => {
+ disposePinia(pinia)
+ setActivePinia(undefined)
globalThis.fetch = originalFetch
})
diff --git a/frontend/tests/logs-ui.test.ts b/frontend/tests/logs-ui.test.ts
index aab7cc7..e980589 100644
--- a/frontend/tests/logs-ui.test.ts
+++ b/frontend/tests/logs-ui.test.ts
@@ -239,7 +239,9 @@ const trigger = (element: TestNode, event: string, value?: unknown) => {
}
const control = (root: TestNode, icon: string) =>
find(root, (element) => 'control' === element.type && icon === element.props.icon)
-const menuItems = (menu: TestNode): Array<{ icon: string; onSelect: () => void; disabled?: boolean }> => {
+const menuItems = (
+ menu: TestNode,
+): Array<{ icon: string; onSelect: () => void; disabled?: boolean }> => {
const items: unknown = menu.props.items
if (!Array.isArray(items)) {
throw new Error('Missing menu items')
@@ -639,13 +641,16 @@ test('empty and loading', async () => {
state.loading.value = false
await vue.nextTick()
expect(flatten(root).filter((element) => 'article' === element.type)).toHaveLength(0)
- expect(menuItems(find(root, (element) => 'menu' === element.type))
- .find((item) => 'i-lucide-download' === item.icon)?.disabled).toBe(true)
+ expect(
+ menuItems(find(root, (element) => 'menu' === element.type)).find(
+ (item) => 'i-lucide-download' === item.icon,
+ )?.disabled,
+ ).toBe(true)
})
test('download visible', async () => {
const { root } = await mountLogs()
- const originalDocument = globalThis.document
+ const originalDocument = Object.getOwnPropertyDescriptor(globalThis, 'document')
const createObjectURL = URL.createObjectURL
const revokeObjectURL = URL.revokeObjectURL
const blobs: Array = []
@@ -664,8 +669,9 @@ test('download visible', async () => {
})
Object.defineProperty(URL, 'revokeObjectURL', { configurable: true, value: revoked })
try {
- const download = menuItems(find(root, (element) => 'menu' === element.type))
- .find((item) => 'i-lucide-download' === item.icon)
+ const download = menuItems(find(root, (element) => 'menu' === element.type)).find(
+ (item) => 'i-lucide-download' === item.icon,
+ )
expect(download?.disabled).toBe(false)
download?.onSelect()
expect(link.click).toHaveBeenCalledTimes(1)
@@ -674,7 +680,11 @@ test('download visible', async () => {
expect(await blobs[0]?.text()).toBe(`${JSON.stringify(entry)}\n`)
expect(revoked).toHaveBeenCalledWith('blob:logs')
} finally {
- Object.defineProperty(globalThis, 'document', { configurable: true, value: originalDocument })
+ if (originalDocument) {
+ Object.defineProperty(globalThis, 'document', originalDocument)
+ } else {
+ Reflect.deleteProperty(globalThis, 'document')
+ }
Object.defineProperty(URL, 'createObjectURL', { configurable: true, value: createObjectURL })
Object.defineProperty(URL, 'revokeObjectURL', { configurable: true, value: revokeObjectURL })
}
diff --git a/frontend/tests/mocks/nuxt.ts b/frontend/tests/mocks/nuxt.ts
new file mode 100644
index 0000000..fc1e0d0
--- /dev/null
+++ b/frontend/tests/mocks/nuxt.ts
@@ -0,0 +1,13 @@
+import { mock } from 'bun:test'
+import type { RouteMiddleware } from '#app'
+
+export const navigate = mock((path: string, _options?: { replace?: boolean }) => path)
+export const addToast = mock((_message: { title: string; description: string }) => {})
+
+// Bun shares module mocks between files, so register the Nuxt stubs only once.
+mock.module('#app', () => ({
+ useRuntimeConfig: () => ({ public: { domain: '' } }),
+ defineNuxtRouteMiddleware: (middleware: RouteMiddleware) => middleware,
+ navigateTo: navigate,
+}))
+mock.module('#imports', () => ({ useToast: () => ({ add: addToast }) }))
diff --git a/frontend/tests/stack-ui.test.ts b/frontend/tests/stack-ui.test.ts
index 166a000..a4fda94 100644
--- a/frontend/tests/stack-ui.test.ts
+++ b/frontend/tests/stack-ui.test.ts
@@ -2,6 +2,7 @@ import { afterEach, describe, expect, mock, test } from 'bun:test'
import { compileScript, parse, registerTS } from '@vue/compiler-sfc'
import * as ts from 'typescript'
import * as vue from 'vue'
+import { createReusableTemplate } from '@vueuse/core'
import type { Component } from 'vue'
import type { DropdownMenuItem } from '@nuxt/ui'
import type {
@@ -58,6 +59,10 @@ const renderer = vue.createRenderer({
return siblings[siblings.indexOf(element) + 1] ?? null
},
insert: (element, parent, anchor) => {
+ if (element.parent) {
+ const previous = element.parent.children
+ previous.splice(previous.indexOf(element), 1)
+ }
element.parent = parent
const index = anchor ? parent.children.indexOf(anchor) : -1
if (-1 === index) {
@@ -78,6 +83,8 @@ const flatten = (element: TestNode): Array => [
...element.children.flatMap(flatten),
]
const alerts = (root: TestNode) => flatten(root).filter((element) => 'alert' === element.type)
+const statuses = (root: TestNode) =>
+ flatten(root).filter((element) => 'status' === element.props.role)
test('node header', async () => {
const item = vue.reactive({
@@ -90,15 +97,19 @@ test('node header', async () => {
error: '',
loading: false,
})
+ const route = vue.reactive({
+ path: '/stacks/node/app',
+ params: { node: 'node', stack: 'app' },
+ })
const component = await loadComponent('StackList', {
- '#app': { useRoute: () => ({ params: {} }) },
+ '#app': { useRoute: () => route },
'#components': { NuxtLink: stub('a') },
'@nuxt/ui/components/Alert.vue': { default: stub('alert') },
'@nuxt/ui/components/Badge.vue': { default: stub('badge') },
'@nuxt/ui/components/Icon.vue': { default: stub('icon') },
'~/utils/stacks': await import('../app/utils/stacks'),
})
- const collapsed = vue.reactive>({ node: false })
+ const collapsed = vue.reactive>({ node: true })
const selected = mock(() => {})
const root = node('root')
const app = renderer.createApp({
@@ -114,6 +125,16 @@ test('node header', async () => {
})
app.mount(root)
apps.push(app)
+ expect(collapsed.node).toBe(true)
+ const header = flatten(root).find((element) => 'button' === element.type)
+ expect(header?.props['aria-expanded']).toBe(false)
+
+ route.path = '/stacks/node/worker'
+ route.params.stack = 'worker'
+ await vue.nextTick()
+ expect(collapsed.node).toBe(true)
+ expect(header?.props['aria-expanded']).toBe(false)
+
const states: Array = [
'connected',
'loading',
@@ -127,9 +148,8 @@ test('node header', async () => {
await vue.nextTick()
expect(alerts(root)).toHaveLength('connected' === connection ? 1 : 0)
}
- const header = flatten(root).find((element) => 'button' === element.type)
- expect(header?.props['aria-expanded']).toBe(true)
- for (const value of [true, false]) {
+ expect(header?.props['aria-expanded']).toBe(false)
+ for (const value of [false, true]) {
if ('function' !== typeof header?.props.onClick) {
throw new Error('Missing node toggle')
}
@@ -139,6 +159,10 @@ test('node header', async () => {
expect(header.props['aria-expanded']).toBe(!value)
expect(selected).not.toHaveBeenCalled()
}
+ expect(collapsed.node).toBe(true)
+ collapsed.node = false
+ await vue.nextTick()
+ expect(header?.props['aria-expanded']).toBe(true)
item.stacks.push({
name: 'app',
@@ -183,6 +207,138 @@ test('node header', async () => {
services[1]!.auto_update = false
await vue.nextTick()
expect(automationIcons()).toHaveLength(0)
+
+ collapsed.node = true
+ await vue.nextTick()
+ expect(header?.props['aria-expanded']).toBe(false)
+
+ app.unmount()
+ apps.splice(apps.indexOf(app), 1)
+ const remountRoot = node('root')
+ const remounted = renderer.createApp({
+ setup: () => () =>
+ vue.h(component, {
+ nodes: [item],
+ workspaceLoading: false,
+ search: '',
+ status: 'all',
+ collapsed,
+ onSelected: selected,
+ }),
+ })
+ remounted.mount(remountRoot)
+ apps.push(remounted)
+ expect(collapsed.node).toBe(true)
+ expect(
+ flatten(remountRoot).find((element) => 'button' === element.type)?.props['aria-expanded'],
+ ).toBe(false)
+})
+
+test('compact stacks', async () => {
+ const item: WorkspaceNode = {
+ id: 'node',
+ name: 'Node',
+ public_host: '',
+ stacks: [
+ { name: 'app', status: 'running', loading: false, services: [] },
+ { name: 'worker', status: 'stopped', loading: false, services: [] },
+ ],
+ health: null,
+ connection: 'connected',
+ error: '',
+ loading: false,
+ }
+ const route = vue.reactive({
+ path: '/stacks/node/app',
+ params: { node: 'node', stack: 'app' },
+ })
+ const close = mock(() => {})
+ const selected = mock(() => {})
+ const component = await loadComponent('StackList', {
+ '#app': { useRoute: () => route },
+ '#components': { NuxtLink: stub('a') },
+ '@nuxt/ui/components/Alert.vue': { default: stub('alert') },
+ '@nuxt/ui/components/Badge.vue': { default: stub('badge') },
+ '@nuxt/ui/components/Button.vue': { default: stub('button') },
+ '@nuxt/ui/components/Icon.vue': { default: stub('icon') },
+ '@nuxt/ui/components/Popover.vue': {
+ default: vue.defineComponent({
+ setup:
+ (_, { slots }) =>
+ () =>
+ vue.h('popover', [slots.default?.(), slots.content?.({ close })]),
+ }),
+ },
+ '~/utils/stacks': await import('../app/utils/stacks'),
+ })
+ const collapsed = vue.reactive>({ node: true })
+ const filters = vue.reactive({ search: '', status: 'all', compact: true })
+ const root = node('root')
+ const app = renderer.createApp({
+ setup: () => () =>
+ vue.h(component, {
+ nodes: [item],
+ workspaceLoading: false,
+ ...filters,
+ collapsed,
+ onSelected: selected,
+ }),
+ })
+ app.mount(root)
+ apps.push(app)
+
+ expect(collapsed.node).toBe(true)
+ const links = () => flatten(root).filter((element) => 'a' === element.type)
+ expect(links().map((element) => element.props.to)).toEqual([
+ '/stacks/node/app',
+ '/stacks/node/worker',
+ ])
+ expect(links()[0]?.props['aria-current']).toBe('page')
+ filters.search = 'work'
+ await vue.nextTick()
+ expect(links().map((element) => element.props.to)).toEqual(['/stacks/node/worker'])
+ filters.status = 'running'
+ await vue.nextTick()
+ expect(links()).toHaveLength(0)
+ filters.search = ''
+ await vue.nextTick()
+ expect(links().map((element) => element.props.to)).toEqual(['/stacks/node/app'])
+
+ const link = links()[0]
+ if ('function' !== typeof link?.props.onClick) {
+ throw new Error('Missing stack selection')
+ }
+ link.props.onClick()
+ expect(close).toHaveBeenCalledTimes(1)
+ expect(selected).toHaveBeenCalledTimes(1)
+
+ filters.compact = false
+ await vue.nextTick()
+ expect(flatten(root).filter((element) => 'popover' === element.type)).toHaveLength(0)
+ collapsed.node = true
+ await vue.nextTick()
+ expect(collapsed.node).toBe(true)
+ route.path = '/stacks/node/worker'
+ route.params.stack = 'worker'
+ await vue.nextTick()
+ expect(collapsed.node).toBe(true)
+
+ app.unmount()
+ apps.splice(apps.indexOf(app), 1)
+ const remountRoot = node('root')
+ const remounted = renderer.createApp({
+ setup: () => () =>
+ vue.h(component, {
+ nodes: [item],
+ workspaceLoading: false,
+ ...filters,
+ collapsed,
+ onSelected: selected,
+ }),
+ })
+ remounted.mount(remountRoot)
+ apps.push(remounted)
+ expect(collapsed.node).toBe(true)
})
const stub = (tag: string) =>
@@ -206,6 +362,7 @@ const loadComponent = async (file: string, dependencies: Record
})
const imports: Record = {
vue,
+ '@vueuse/core': { createReusableTemplate },
'@nuxt/ui/components/Tooltip.vue': { default: stub('tooltip') },
...dependencies,
}
@@ -219,17 +376,22 @@ const loadComponent = async (file: string, dependencies: Record
}
const apps: Array> = []
-const originalWindow = globalThis.window
-const originalInput = globalThis.HTMLInputElement
+const originalWindow = Object.getOwnPropertyDescriptor(globalThis, 'window')
+const originalInput = Object.getOwnPropertyDescriptor(globalThis, 'HTMLInputElement')
afterEach(() => {
for (const app of apps.splice(0)) {
app.unmount()
}
- Object.defineProperty(globalThis, 'window', { value: originalWindow, configurable: true })
- Object.defineProperty(globalThis, 'HTMLInputElement', {
- value: originalInput,
- configurable: true,
- })
+ for (const [key, descriptor] of [
+ ['window', originalWindow],
+ ['HTMLInputElement', originalInput],
+ ] as const) {
+ if (descriptor) {
+ Object.defineProperty(globalThis, key, descriptor)
+ } else {
+ Reflect.deleteProperty(globalThis, key)
+ }
+ }
})
test('overview attention', async () => {
@@ -342,7 +504,11 @@ test('overview attention', async () => {
)
expect(count('i-lucide-triangle-alert')).toBe(1)
expect(count('i-lucide-server')).toBe('1 / 1')
- expect(searchLogs).toHaveBeenCalledWith({ levels: ['warning', 'error'], node: '', search: '' })
+ expect(searchLogs).toHaveBeenCalledWith({
+ levels: ['info', 'warning', 'error'],
+ node: '',
+ search: '',
+ })
for (const id of ['updates-heading', 'busy-heading', 'recent-errors-heading']) {
expect(flatten(root).some((element) => id === element.props['aria-labelledby'])).toBe(false)
}
@@ -524,13 +690,52 @@ test('overview attention', async () => {
fields: { node_id: item.id, node_name: item.name },
}))
await vue.nextTick()
- const logRows = flatten(root).filter((element) => undefined !== element.props['data-log-id'])
- expect(logRows.map((element) => element.props['data-log-id'])).toEqual([6, 5, 4, 3, 2])
- expect(flatten(logRows[0]!).find((element) => 'a' === element.type)?.props.to).toEqual({
+ const logRows = () =>
+ flatten(root).filter((element) => undefined !== element.props['data-log-id'])
+ expect(logRows().map((element) => element.props['data-log-id'])).toEqual([6, 5, 4, 3, 2])
+ expect(flatten(logRows()[0]!).find((element) => 'a' === element.type)?.props.to).toEqual({
path: '/logs',
- query: { levels: 'warning,error', node: 'office' },
+ query: { levels: 'info,warning,error', node: 'office' },
})
+ const base = logEntries.value[0]!
+ logEntries.value.push(
+ { ...base, id: 7, level: 'info' },
+ { ...base, id: 8, level: 'info', fields: { automatic: true, status: 'running' } },
+ { ...base, id: 9, level: 'info', fields: { automatic: false, status: 'succeeded' } },
+ { ...base, id: 10, level: 'debug', fields: { automatic: true, status: 'succeeded' } },
+ {
+ ...base,
+ id: 11,
+ level: 'INFO',
+ fields: {
+ ...base.fields,
+ automatic: true,
+ status: 'succeeded',
+ stack: 'app',
+ service: 'web',
+ },
+ },
+ )
+ await vue.nextTick()
+ expect(logRows().map((element) => element.props['data-log-id'])).toEqual([11, 6, 5, 4, 3])
+ const success = logRows()[0]!
+ expect(
+ flatten(success).some(
+ (element) => 'badge' === element.type && 'success' === element.props.color,
+ ),
+ ).toBe(true)
+ expect(flatten(success).find((element) => 'a' === element.type)?.props.to).toEqual({
+ path: '/logs',
+ query: { levels: 'info,warning,error', node: 'office' },
+ })
+ logEntries.value.push(
+ { ...base, id: 12, level: 'warning' },
+ { ...base, id: 13, fields: { automatic: true, status: 'failed' } },
+ )
+ await vue.nextTick()
+ expect(logRows().map((element) => element.props['data-log-id'])).toEqual([13, 12, 11, 6, 5])
+
const check = flatten(root).find(
(element) =>
'button' === element.type &&
@@ -683,16 +888,9 @@ const mountLogs = async (busy = false, draft = false) => {
draft,
})
const component = await loadComponent('StackLogs', {
- '@nuxt/ui/components/Alert.vue': {
- default: vue.defineComponent({
- setup:
- (_, { slots }) =>
- () =>
- vue.h('alert', [slots.default?.(), slots.actions?.()]),
- }),
- },
'@nuxt/ui/components/Button.vue': { default: stub('button') },
'@nuxt/ui/components/Card.vue': { default: stub('section') },
+ '@nuxt/ui/components/Icon.vue': { default: stub('icon') },
'~/components/stacks/OutputTerminal.vue': {
default: vue.defineComponent({
setup: (_, { expose }) => {
@@ -907,7 +1105,8 @@ describe('Stack logs', () => {
view.fail()
view.props.busy = true
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
+ expect(alerts(view.root)).toHaveLength(0)
view.reconnect()
expect(view.start).toHaveBeenCalledTimes(1)
view.log('paused')
@@ -923,11 +1122,11 @@ describe('Stack logs', () => {
view.fail()
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
view.props.showErrors = true
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
view.reconnect()
expect(view.start).toHaveBeenCalledTimes(2)
})
@@ -936,48 +1135,49 @@ describe('Stack logs', () => {
const view = await mountLogs()
view.fail()
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
+ expect(alerts(view.root)).toHaveLength(0)
view.props.connected = false
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
view.workspace.streamError = 'server-error-sentinel'
view.props.connected = true
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
view.workspace.streamError = ''
view.workspace.error = 'workspace-error-sentinel'
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
view.workspace.error = ''
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
view.reconnect()
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
})
test('output retries', async () => {
const view = await mountLogs()
view.fail()
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
view.reconnect()
await vue.nextTick()
expect(view.start).toHaveBeenCalledTimes(2)
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
view.fail()
await vue.nextTick()
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
view.reconnect()
await vue.nextTick()
expect(view.start).toHaveBeenCalledTimes(3)
- expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(0)
})
test('offline failure output', async () => {
@@ -1137,7 +1337,7 @@ describe('Stack logs', () => {
view.props.busy = false
await vue.nextTick()
expect(view.start).toHaveBeenCalledTimes(1)
- expect(alerts(view.root)).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
view.reconnect()
view.log('future-container-output')
expect(view.start).toHaveBeenCalledTimes(2)
@@ -2183,7 +2383,10 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
let leave = async (): Promise => true
let failAction = true
const now = vue.ref(new Date('2026-11-03T03:55:52Z'))
- const statsStart = mock((_subscription: { type: 'stats'; node: string; resource: string }) => {})
+ const statsError = vue.ref('')
+ const statsStart = mock((_subscription: { type: 'stats'; node: string; resource: string }) => {
+ statsError.value = ''
+ })
const statsStop = mock(() => {})
let statsMessage = (_message: WorkspaceStreamMessage) => {}
let statsDisconnected = () => {}
@@ -2234,15 +2437,16 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
}),
})
const store = { useWorkspaceStore: () => workspace }
+ const route = vue.reactive({
+ params: { node: item.id, stack: 'app' },
+ query: { op: 'stale', tab: 'logs' },
+ })
const child = await loadComponent(
`../../pages/${'stack' === page ? 'stacks/[node]/[stack]' : 'nodes/[node]'}`,
{
pinia: { storeToRefs: vue.toRefs },
'#app': {
- useRoute: () => ({
- params: { node: item.id, stack: 'app' },
- query: { op: 'stale', tab: 'logs' },
- }),
+ useRoute: () => route,
useRouter: () => ({ replace }),
navigateTo: navigate,
useHead: () => {},
@@ -2299,11 +2503,11 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
'~/composables/useWorkspaceStream': {
useWorkspaceStream: (
onMessage: typeof statsMessage,
- onDisconnect: typeof statsDisconnected,
+ onDisconnect: typeof statsDisconnected = () => {},
) => {
statsMessage = onMessage
statsDisconnected = onDisconnect
- return { start: statsStart, stop: statsStop, error: vue.ref('') }
+ return { start: statsStart, stop: statsStop, error: statsError }
},
},
'~/store/auth': { useAuthStore: () => auth },
@@ -2359,12 +2563,14 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
})
app.mount(root)
apps.push(app)
- expect(alerts(root)).toHaveLength(1)
+ expect(alerts(root)).toHaveLength(0)
+ expect(statuses(root)).toHaveLength(1)
workspace.streamError = 'server-error-sentinel'
await vue.nextTick()
expect(alerts(root)).toHaveLength(1)
expect(alerts(root)[0]?.props.title).toBe(workspace.streamError)
+ expect(statuses(root)).toHaveLength(0)
workspace.error = 'workspace-error-sentinel'
await vue.nextTick()
@@ -2374,8 +2580,8 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
workspace.error = ''
workspace.streamError = ''
await vue.nextTick()
- expect(alerts(root)).toHaveLength(1)
- expect(alerts(root)[0]?.props.title).toBe(item.error)
+ expect(alerts(root)).toHaveLength(0)
+ expect(statuses(root)).toHaveLength(1)
item.connection = 'connected'
item.error = ''
@@ -2386,8 +2592,8 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
item.connection = 'paused'
item.paused = true
await vue.nextTick()
- expect(alerts(root)).toHaveLength(1)
- expect(alerts(root)[0]?.props.color).toBe('neutral')
+ expect(alerts(root)).toHaveLength(0)
+ expect(statuses(root)).toHaveLength(1)
item.connection = 'connected'
item.paused = false
await new Promise((resolve) => setImmediate(resolve))
@@ -2459,7 +2665,22 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
expect(badgeText('i-lucide-cpu')).toContain(containerStats.cpu)
statsDisconnected()
await vue.nextTick()
- expect(cpuCard()?.props.value).toBe('-')
+ expect(cpuCard()?.props.value).toBe('2.03%')
+ statsError.value = 'stats-error-sentinel'
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(1)
+ expect(alerts(root)).toHaveLength(0)
+ workspace.streamError = 'stream-error-sentinel'
+ await vue.nextTick()
+ expect(alerts(root)).toHaveLength(1)
+ expect(statuses(root)).toHaveLength(0)
+ expect(cpuCard()?.props.value).toBe('2.03%')
+ workspace.streamError = ''
+ statsError.value = ''
+ statsMessage({ event: 'stack.stats', data: JSON.stringify({ containers: [containerStats] }) })
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(0)
+ expect(cpuCard()?.props.value).toBe(containerStats.cpu)
const service = item.stacks[0]!.services[0]!
const automationBadge = () =>
@@ -2552,16 +2773,15 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
const runtime = item.stacks[0]!
runtime.error = 'runtime-error-sentinel'
await vue.nextTick()
- expect(alerts(root)).toHaveLength(1)
- expect(alerts(root)[0]?.props.title).toBe(runtime.error)
- expect(alerts(root)[0]?.props.description).toBeUndefined()
+ expect(alerts(root)).toHaveLength(0)
+ expect(statuses(root)).toHaveLength(1)
expect(flatten(root).find((element) => 'logs' === element.type)?.props.showErrors).toBe(false)
item.connection = 'unavailable'
item.error = 'node-error-sentinel'
await vue.nextTick()
- expect(alerts(root)).toHaveLength(1)
- expect(alerts(root)[0]?.props.title).toBe(item.error)
+ expect(alerts(root)).toHaveLength(0)
+ expect(statuses(root)).toHaveLength(1)
item.connection = 'connected'
item.error = ''
@@ -2636,6 +2856,33 @@ test.each(['stack', 'node'] as const)('%s page alerts', async (page) => {
complete('delete', 0)
expect(navigate).toHaveBeenCalledTimes(1)
expect(navigate).toHaveBeenCalledWith('/')
+
+ route.params.stack = 'pending'
+ item.loading = true
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(1)
+ expect(alerts(root)).toHaveLength(0)
+ expect(flatten(root).find((element) => 'logs' === element.type)?.props.connected).toBe(false)
+ expect(
+ flatten(root).some(
+ (element) => 'button' === element.type && 'i-lucide-refresh-cw' === element.props.icon,
+ ),
+ ).toBe(false)
+ item.stacks = [{ ...runtime, name: 'pending', error: '' }]
+ item.loading = false
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(0)
+ expect(flatten(root).find((element) => 'logs' === element.type)?.props.connected).toBe(true)
+
+ route.params.node = 'late'
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(1)
+ expect(alerts(root)).toHaveLength(0)
+ workspace.nodes.push({ ...item, id: 'late' })
+ await vue.nextTick()
+ expect(statuses(root)).toHaveLength(0)
+ expect(alerts(root)).toHaveLength(0)
+ expect(notify).toHaveBeenCalledTimes(1)
}
})
@@ -2670,6 +2917,193 @@ const resourceInfo = (containers: Array): NodeInfo => ({
checked_at: '2026-11-11T12:00:00Z',
})
+describe('Node page recovery', () => {
+ const cleanups: Array<() => void> = []
+ afterEach(() => {
+ for (const cleanup of cleanups.splice(0)) {
+ cleanup()
+ }
+ })
+
+ const mountPage = async () => {
+ const item = vue.reactive({
+ id: 'node',
+ name: 'Node',
+ public_host: '',
+ stacks: [],
+ health: null,
+ connection: 'connected',
+ error: '',
+ loading: false,
+ })
+ const workspace = vue.reactive({
+ nodes: [item] as Array,
+ error: '',
+ streamError: '',
+ })
+ const route = vue.reactive({ params: { node: item.id } })
+ const calls: Array<{
+ url: string
+ signal: AbortSignal | null | undefined
+ reply: ReturnType>
+ }> = []
+ const notify = mock(() => {})
+ const component = await loadComponent('../../pages/nodes/[node]', {
+ pinia: { storeToRefs: vue.toRefs },
+ '#app': { useRoute: () => route, useHead: () => {} },
+ '#imports': { definePageMeta: () => {} },
+ 'vue-router': { onBeforeRouteLeave: () => {} },
+ '@nuxt/ui/components/Alert.vue': { default: stub('alert') },
+ '@nuxt/ui/components/Button.vue': { default: stub('button') },
+ '@nuxt/ui/components/Icon.vue': { default: stub('icon') },
+ '~/components/StatCard.vue': { default: stub('stat') },
+ '~/store/workspace': { useWorkspaceStore: () => workspace },
+ '~/utils/node': await import('../app/utils/node'),
+ '~/utils/stacks': await import('../app/utils/stacks'),
+ '~/utils': {
+ request: (url: string, options: RequestInit) => {
+ const reply = Promise.withResolvers()
+ calls.push({ url, signal: options.signal, reply })
+ return reply.promise
+ },
+ parse_api_response: (response: Response) => response.json(),
+ notification: notify,
+ },
+ })
+
+ const originalSetTimeout = Object.getOwnPropertyDescriptor(globalThis, 'setTimeout')
+ const originalClearTimeout = Object.getOwnPropertyDescriptor(globalThis, 'clearTimeout')
+ const timers = new Map void>()
+ let timerId = 0
+ Object.defineProperty(globalThis, 'setTimeout', {
+ value: (callback: () => void) => {
+ timers.set(++timerId, callback)
+ return timerId
+ },
+ configurable: true,
+ })
+ Object.defineProperty(globalThis, 'clearTimeout', {
+ value: (id: number) => timers.delete(id),
+ configurable: true,
+ })
+
+ const root = node('root')
+ const app = renderer.createApp(component)
+ app.mount(root)
+ let mounted = true
+ const unmount = () => {
+ if (mounted) {
+ app.unmount()
+ mounted = false
+ }
+ }
+ cleanups.push(() => {
+ unmount()
+ if (originalSetTimeout) {
+ Object.defineProperty(globalThis, 'setTimeout', originalSetTimeout)
+ } else {
+ Reflect.deleteProperty(globalThis, 'setTimeout')
+ }
+ if (originalClearTimeout) {
+ Object.defineProperty(globalThis, 'clearTimeout', originalClearTimeout)
+ } else {
+ Reflect.deleteProperty(globalThis, 'clearTimeout')
+ }
+ })
+ return {
+ root,
+ item,
+ workspace,
+ calls,
+ notify,
+ timers,
+ unmount,
+ respond: async (index: number, payload: NodeInfo | GenericError, status = 200) => {
+ calls[index]!.reply.resolve(Response.json(payload, { status }))
+ await new Promise((resolve) => setImmediate(resolve))
+ await vue.nextTick()
+ },
+ fire: () => {
+ const entry = [...timers.entries()][0]
+ if (!entry) {
+ throw new Error('Missing retry timer')
+ }
+ timers.delete(entry[0])
+ entry[1]()
+ },
+ }
+ }
+
+ const renderedText = (root: TestNode) =>
+ flatten(root)
+ .map((element) => element.text)
+ .join(' ')
+ const refreshButton = (root: TestNode) =>
+ flatten(root).find(
+ (element) => 'button' === element.type && 'i-lucide-refresh-cw' === element.props.icon,
+ )
+
+ test('stats retry recovers', async () => {
+ const view = await mountPage()
+ expect(view.calls).toHaveLength(1)
+ expect(statuses(view.root)).toHaveLength(1)
+ expect(refreshButton(view.root)).toBeUndefined()
+ await view.respond(0, { error: { code: 503, message: 'failure-sentinel' } }, 503)
+ expect(view.timers.size).toBe(1)
+ expect(alerts(view.root)).toHaveLength(0)
+ expect(statuses(view.root)).toHaveLength(1)
+ expect(refreshButton(view.root)).toBeUndefined()
+ expect(view.notify).not.toHaveBeenCalled()
+
+ view.fire()
+ expect(view.calls).toHaveLength(2)
+ await view.respond(1, resourceInfo([resourceContainer('after', '2%', '1GiB')]))
+ expect(statuses(view.root)).toHaveLength(0)
+ expect(renderedText(view.root)).toContain('after')
+ expect(refreshButton(view.root)).toBeDefined()
+ expect(view.timers.size).toBe(0)
+ })
+
+ test('stats cleanup', async () => {
+ const view = await mountPage()
+ const signal = view.calls[0]?.signal
+ view.unmount()
+ expect(signal?.aborted).toBe(true)
+ expect(view.timers.size).toBe(0)
+ })
+
+ test('stats stop on reset', async () => {
+ const view = await mountPage()
+ await view.respond(0, { error: { code: 503, message: 'failure-sentinel' } }, 503)
+ expect(view.timers.size).toBe(1)
+ view.workspace.nodes = []
+ await vue.nextTick()
+ expect(view.timers.size).toBe(0)
+ })
+
+ test('reconnect retains stats', async () => {
+ const view = await mountPage()
+ await view.respond(0, resourceInfo([resourceContainer('before', '1%', '1GiB')]))
+ expect(renderedText(view.root)).toContain('before')
+
+ view.item.connection = 'reconnecting'
+ view.item.error = 'connection-sentinel'
+ await vue.nextTick()
+ expect(statuses(view.root)).toHaveLength(1)
+ expect(renderedText(view.root)).toContain('before')
+ expect(alerts(view.root)).toHaveLength(0)
+
+ view.item.connection = 'connected'
+ await vue.nextTick()
+ expect(view.calls).toHaveLength(2)
+ expect(renderedText(view.root)).toContain('before')
+ await view.respond(1, resourceInfo([resourceContainer('after', '2%', '1GiB')]))
+ expect(renderedText(view.root)).toContain('after')
+ expect(renderedText(view.root)).not.toContain('before')
+ expect(statuses(view.root)).toHaveLength(0)
+ })
+})
+
describe('Node resources', () => {
const cleanups: Array<() => void> = []
afterEach(() => {
@@ -2824,18 +3258,13 @@ describe('Node resources', () => {
const links = () =>
flatten(view.root)
.filter((element) => 'a' === element.type)
- // The test renderer inserts moved nodes without removing their old position.
- .filter((element, index, elements) => index === elements.lastIndexOf(element))
.slice(1)
.map((element) => element.props.to)
expect(links()).toEqual(['/stacks/node/small', '/stacks/node/large', '/stacks/node/decimal'])
- const metrics = (icon: string) => [
- ...new Set(
- flatten(view.root).filter(
- (element) => 'badge' === element.type && icon === element.props.icon,
- ),
- ),
- ]
+ const metrics = (icon: string) =>
+ flatten(view.root).filter(
+ (element) => 'badge' === element.type && icon === element.props.icon,
+ )
expect(metrics('i-lucide-cpu')).toHaveLength(3)
expect(metrics('i-lucide-memory-stick')).toHaveLength(3)
const toggles = flatten(view.root).filter(
@@ -2856,11 +3285,16 @@ describe('Node resources', () => {
expect(values.some((value) => value.includes('private-'))).toBe(false)
})
- test('offline aborts and clears samples', async () => {
- const view = await mountResources('paused')
- expect(view.calls).toHaveLength(0)
- view.item.connection = 'connected'
- await vue.nextTick()
+ const inlineStatus = (root: TestNode) =>
+ flatten(root).filter((element) => 'status' === element.props.role)
+ const inlineStatusText = (root: TestNode) =>
+ inlineStatus(root)
+ .flatMap(flatten)
+ .map((element) => element.text)
+ .join(' ')
+
+ test('node change clears samples', async () => {
+ const view = await mountResources()
expect(view.calls).toHaveLength(1)
view.item.id = 'other'
await vue.nextTick()
@@ -2870,13 +3304,42 @@ describe('Node resources', () => {
expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(false)
await view.respond(1, resourceInfo([]))
expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(true)
- view.tick()
+ })
+
+ test('offline keeps sample', async () => {
+ const view = await mountResources()
+ await view.respond(0, resourceInfo([resourceContainer('live', '1%', '1GiB')]))
view.item.connection = 'unavailable'
+ view.item.error = 'connection-sentinel'
await vue.nextTick()
- expect(view.calls[2]?.signal?.aborted).toBe(true)
- expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(false)
expect(view.intervals.size).toBe(0)
- await view.respond(2, resourceInfo([]))
+ expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(true)
+ expect(inlineStatus(view.root)).toHaveLength(1)
+ expect(inlineStatusText(view.root)).toContain('connection-sentinel')
+ expect(alerts(view.root)).toHaveLength(0)
+
+ view.item.connection = 'reconnecting'
+ view.item.error = ''
+ await vue.nextTick()
+ expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(true)
+ expect(inlineStatus(view.root)).toHaveLength(1)
+
+ view.item.connection = 'connected'
+ await vue.nextTick()
+ expect(view.calls).toHaveLength(2)
+ expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(true)
+ expect(view.intervals.size).toBe(1)
+ await view.respond(1, resourceInfo([resourceContainer('live', '2%', '1GiB')]))
+ expect(
+ flatten(view.root)
+ .map((element) => element.text)
+ .join(' '),
+ ).toContain('0.5%')
+ expect(inlineStatus(view.root)).toHaveLength(0)
+ view.item.connection = 'paused'
+ await vue.nextTick()
+ expect(flatten(view.root).some((element) => 'dd' === element.type)).toBe(false)
+ expect(inlineStatus(view.root)).toHaveLength(1)
expect(view.notify).not.toHaveBeenCalled()
})
@@ -2887,15 +3350,18 @@ describe('Node resources', () => {
view.tick()
await view.respond(1, { error: { code: 503, message: 'failure-sentinel' } }, 503)
expect(sampled()).toContain('0.25%')
- expect(view.notify).toHaveBeenCalledTimes(1)
- const retry = flatten(view.root).find((element) => 'i-lucide-refresh-cw' === element.props.icon)
- const pending = trigger(retry, 'onClick')
+ expect(view.notify).not.toHaveBeenCalled()
+ expect(alerts(view.root)).toHaveLength(0)
+ expect(inlineStatusText(view.root)).toContain('failure-sentinel')
+ expect(
+ flatten(view.root).some(
+ (element) => 'button' === element.type && 'i-lucide-refresh-cw' === element.props.icon,
+ ),
+ ).toBe(false)
+ view.tick()
await view.respond(2, resourceInfo([resourceContainer('live', '2%', '1GiB')]))
- await pending
expect(sampled()).toContain('0.5%')
- expect(flatten(view.root).some((element) => 'i-lucide-refresh-cw' === element.props.icon)).toBe(
- false,
- )
+ expect(inlineStatus(view.root)).toHaveLength(0)
})
test('visible refresh and cleanup', async () => {
@@ -2920,3 +3386,84 @@ describe('Node resources', () => {
expect(view.notify).not.toHaveBeenCalled()
})
})
+
+const footerLinkStub = vue.defineComponent({
+ props: {
+ to: { type: String, default: '' },
+ target: { type: String, default: '' },
+ rel: { type: String, default: '' },
+ },
+ setup:
+ (props, { slots }) =>
+ () =>
+ vue.h('a', { to: props.to, target: props.target, rel: props.rel }, slots.default?.()),
+})
+
+const footerTooltipStub = vue.defineComponent({
+ props: { text: { type: String, default: '' } },
+ setup:
+ (props, { slots }) =>
+ () =>
+ vue.h('tooltip', { text: props.text }, slots.default?.()),
+})
+
+const mountFooter = async (config: {
+ version: string
+ commitSha: string
+ buildDate: string
+ branch: string
+}) => {
+ const runtimeConfig = vue.reactive({ public: config })
+ const component = await loadComponent('../AppFooter', {
+ '#app': { useRuntimeConfig: () => runtimeConfig },
+ '#components': { NuxtLink: footerLinkStub },
+ '@nuxt/ui/components/Icon.vue': { default: stub('icon') },
+ '@nuxt/ui/components/Tooltip.vue': { default: footerTooltipStub },
+ })
+ const root = node('root')
+ const app = renderer.createApp(component)
+ app.mount(root)
+ apps.push(app)
+ return root
+}
+
+test('footer metadata', async () => {
+ const sha = '0123456789abcdef0123456789abcdef01234567'
+ const root = await mountFooter({
+ version: 'v0.1.4',
+ commitSha: sha,
+ buildDate: '2026-11-16',
+ branch: 'master',
+ })
+ const elements = flatten(root)
+ expect(
+ elements.filter((element) => 'a' === element.type).map((element) => element.props.to),
+ ).toEqual([
+ 'https://github.com/arabcoders/dcompose',
+ `https://github.com/arabcoders/dcompose/commit/${sha}`,
+ ])
+ const texts = elements.map((element) => element.text)
+ expect(texts).toContain('v0.1.4')
+ expect(texts).toContain('2026-11-16')
+ expect(texts).toContain('master')
+ expect(texts).toContain(sha.slice(0, 7))
+ expect(elements.find((element) => 'tooltip' === element.type)?.props.text).toBe(sha)
+})
+
+test('footer unknown commit', async () => {
+ const root = await mountFooter({
+ version: 'dev',
+ commitSha: 'unknown',
+ buildDate: 'unknown',
+ branch: 'unknown',
+ })
+ const elements = flatten(root)
+ const links = elements.filter((element) => 'a' === element.type)
+ expect(links.map((element) => element.props.to)).toEqual([
+ 'https://github.com/arabcoders/dcompose',
+ ])
+ expect(elements.some((element) => 'tooltip' === element.type)).toBe(false)
+ const texts = elements.map((element) => element.text)
+ expect(texts).toContain('dev')
+ expect(texts.filter((text) => 'unknown' === text)).toHaveLength(3)
+})
diff --git a/frontend/tests/workspace-stream.test.ts b/frontend/tests/workspace-stream.test.ts
index 4d65dab..7f02f8e 100644
--- a/frontend/tests/workspace-stream.test.ts
+++ b/frontend/tests/workspace-stream.test.ts
@@ -4,14 +4,7 @@ import { effectScope, nextTick } from 'vue'
import type { Pinia } from 'pinia'
import type { EffectScope } from 'vue'
import type { StackEvent } from '../app/types'
-
-const navigate = mock((_path: string, _options?: { replace?: boolean }) => {})
-mock.module('#app', () => ({
- useRuntimeConfig: () => ({ public: { domain: '' } }),
- navigateTo: navigate,
-}))
-const addToast = mock((_message: { title: string; description: string }) => {})
-mock.module('#imports', () => ({ useToast: () => ({ add: addToast }) }))
+import { addToast, navigate } from './mocks/nuxt'
const { useWorkspaceStream } = await import('../app/composables/useWorkspaceStream')
const { useRealtimeStore } = await import('../app/store/realtime')
@@ -53,9 +46,9 @@ class TestSocket {
}
}
-const originalSocket = globalThis.WebSocket
+const originalSocket = Object.getOwnPropertyDescriptor(globalThis, 'WebSocket')
const originalFetch = globalThis.fetch
-const originalLocation = globalThis.location
+const originalLocation = Object.getOwnPropertyDescriptor(globalThis, 'location')
const originalStorage = Object.getOwnPropertyDescriptor(globalThis, 'localStorage')
const readStorage = mock((_key: string): string | null => null)
const writeStorage = mock((_key: string, _value: string) => {})
@@ -67,6 +60,11 @@ const callbacks = () => ({
onDisconnect: mock(() => {}),
onRejected: mock(() => {}),
})
+const flush = async () => {
+ for (let index = 0; index < 10; index++) {
+ await Promise.resolve()
+ }
+}
beforeEach(() => {
jest.useFakeTimers()
@@ -105,13 +103,18 @@ beforeEach(() => {
afterEach(() => {
scope.stop()
disposePinia(pinia)
- Object.defineProperty(globalThis, 'WebSocket', { value: originalSocket, configurable: true })
- Object.defineProperty(globalThis, 'location', { value: originalLocation, configurable: true })
+ setActivePinia(undefined)
globalThis.fetch = originalFetch
- if (originalStorage) {
- Object.defineProperty(globalThis, 'localStorage', originalStorage)
- } else {
- Reflect.deleteProperty(globalThis, 'localStorage')
+ for (const [key, descriptor] of [
+ ['WebSocket', originalSocket],
+ ['location', originalLocation],
+ ['localStorage', originalStorage],
+ ] as const) {
+ if (descriptor) {
+ Object.defineProperty(globalThis, key, descriptor)
+ } else {
+ Reflect.deleteProperty(globalThis, key)
+ }
}
jest.useRealTimers()
})
@@ -323,6 +326,121 @@ describe('Shared connection', () => {
expect(stats.onMessage).toHaveBeenCalledTimes(1)
})
+ test('stats retry', () => {
+ const realtime = useRealtimeStore()
+ const stats = callbacks()
+ const logs = callbacks()
+ realtime.subscribe({ type: 'stats', node: 'n', resource: 'app' }, stats)
+ realtime.subscribe({ type: 'logs', node: 'n', resource: 'app' }, logs)
+ const socket = TestSocket.instances[0]!
+ socket.open()
+ const attach = { type: 'stats.attach', stream: 'reader-1', node: 'n', resource: 'app' }
+ const statsAttachments = () =>
+ socket.sent.filter((message) => 'stats.attach' === message.type).length
+ expect(socket.sent).toContainEqual(attach)
+
+ socket.message({ type: 'error', stream: 'reader-1', status: 503, error: 'unavailable' })
+ expect(stats.onDisconnect).toHaveBeenCalledTimes(1)
+ expect(stats.onRejected).not.toHaveBeenCalled()
+ expect(socket.closed).toBe(false)
+ jest.advanceTimersByTime(1000)
+ expect(statsAttachments()).toBe(2)
+
+ socket.message({ type: 'error', stream: 'reader-1', status: 429, error: 'busy' })
+ expect(stats.onDisconnect).toHaveBeenCalledTimes(2)
+ jest.advanceTimersByTime(1999)
+ expect(statsAttachments()).toBe(2)
+ jest.advanceTimersByTime(1)
+ expect(statsAttachments()).toBe(3)
+
+ socket.message({
+ type: 'event',
+ stream: 'reader-1',
+ event: 'stack.stats',
+ payload: { containers: [] },
+ })
+ expect(stats.onMessage).toHaveBeenCalledTimes(1)
+ expect(logs.onMessage).not.toHaveBeenCalled()
+ expect(statsAttachments()).toBe(3)
+ })
+
+ test('logs transient error', () => {
+ const realtime = useRealtimeStore()
+ const logs = callbacks()
+ realtime.subscribe({ type: 'logs', node: 'n', resource: 'app' }, logs)
+ const socket = TestSocket.instances[0]!
+ socket.open()
+ socket.message({ type: 'error', stream: 'reader-1', status: 503, error: 'unavailable' })
+ expect(logs.onDisconnect).toHaveBeenCalledTimes(1)
+ expect(logs.onRejected).not.toHaveBeenCalled()
+ expect(socket.closed).toBe(false)
+ jest.advanceTimersByTime(60000)
+ expect(socket.sent.filter((message) => 'logs.attach' === message.type)).toHaveLength(1)
+ })
+
+ test('global transient error', () => {
+ const realtime = useRealtimeStore()
+ const runtime = callbacks()
+ realtime.subscribe({ type: 'runtime' }, runtime)
+ const socket = TestSocket.instances[0]!
+ socket.open()
+ socket.message({ type: 'error', status: 503, error: 'unavailable' })
+ expect(runtime.onDisconnect).toHaveBeenCalledTimes(1)
+ expect(runtime.onRejected).not.toHaveBeenCalled()
+ expect(socket.closed).toBe(true)
+ expect(realtime.error).not.toBe('')
+ jest.advanceTimersByTime(1000)
+ const replacement = TestSocket.instances[1]!
+ replacement.open()
+ expect(realtime.error).toBe('')
+ replacement.message({ type: 'event', event: 'nodes.changed', payload: {} })
+ expect(runtime.onMessage).toHaveBeenCalledTimes(1)
+ })
+
+ test('healthy snapshot', async () => {
+ let healthy = true
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ if ('/api/nodes' !== path) {
+ throw new Error(`Unexpected request: ${path}`)
+ }
+ return healthy
+ ? Response.json({ nodes: [{ id: 'n', name: 'Office', public_host: '' }] })
+ : Response.json({ error: { code: 503, message: 'unavailable' } }, { status: 503 })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ const socket = TestSocket.instances[0]!
+ socket.open()
+ const snapshot = {
+ type: 'event',
+ event: 'node.snapshot',
+ payload: {
+ node: 'n',
+ health: { status: 'ok', version: '1', api_version: 1 },
+ stacks: [],
+ },
+ }
+
+ healthy = false
+ await workspace.load()
+ expect(workspace.error).not.toBe('')
+ socket.message(snapshot)
+ expect(workspace.error).toBe('')
+
+ socket.onerror?.()
+ expect(workspace.streamError).not.toBe('')
+ jest.advanceTimersByTime(1000)
+ const replacement = TestSocket.instances[1]!
+ replacement.open()
+ replacement.message(snapshot)
+ expect(workspace.streamError).toBe('')
+ })
+
test('navigation', async () => {
const previousMessage = mock(() => {})
const nextMessage = mock(() => {})
@@ -499,6 +617,172 @@ describe('Shared connection', () => {
})
})
+describe('Workspace bootstrap', () => {
+ test('transient retry', async () => {
+ let attempts = 0
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ if ('/api/nodes' !== path) {
+ throw new Error(`Unexpected request: ${path}`)
+ }
+ attempts++
+ if (1 === attempts) {
+ throw new TypeError('fetch failed')
+ }
+ if (2 === attempts) {
+ return Response.json({ error: { code: 503, message: 'unavailable' } }, { status: 503 })
+ }
+ return Response.json({ nodes: [{ id: 'n', name: 'Office', public_host: '' }] })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ expect(workspace.error).not.toBe('')
+ expect(workspace.ready).toBe(true)
+ expect(workspace.nodes).toEqual([])
+ expect(addToast).not.toHaveBeenCalled()
+
+ jest.advanceTimersByTime(1000)
+ await flush()
+ expect(requests).toHaveLength(2)
+ expect(addToast).not.toHaveBeenCalled()
+ expect(workspace.error).not.toBe('')
+
+ jest.advanceTimersByTime(2000)
+ await flush()
+ expect(requests).toHaveLength(3)
+ expect(workspace.nodes.map((node) => node.id)).toEqual(['n'])
+ expect(workspace.error).toBe('')
+ expect(addToast).not.toHaveBeenCalled()
+ expect(TestSocket.instances).toHaveLength(1)
+
+ jest.advanceTimersByTime(60000)
+ await flush()
+ expect(requests).toHaveLength(3)
+ })
+
+ test('stale data', async () => {
+ let healthy = true
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ if ('/api/nodes' !== path) {
+ throw new Error(`Unexpected request: ${path}`)
+ }
+ return healthy
+ ? Response.json({ nodes: [{ id: 'n', name: 'Office', public_host: '' }] })
+ : Response.json({ error: { code: 502, message: 'unavailable' } }, { status: 502 })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ workspace.nodes[0]!.stacks = [{ name: 'app', status: 'running', services: [], loading: false }]
+ workspace.nodes[0]!.connection = 'connected'
+ healthy = false
+ await workspace.load()
+ expect(workspace.nodes[0]!.stacks).toHaveLength(1)
+ expect(workspace.nodes[0]!.connection).toBe('connected')
+ expect(workspace.error).not.toBe('')
+
+ healthy = true
+ jest.advanceTimersByTime(1000)
+ await flush()
+ expect(workspace.nodes[0]!.stacks).toHaveLength(1)
+ expect(workspace.error).toBe('')
+ })
+
+ test('permanent failure', async () => {
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ return '/api/nodes' === path
+ ? Response.json({ error: { code: 403, message: 'forbidden' } }, { status: 403 })
+ : Response.json({ nodes: [] })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ expect(workspace.error).not.toBe('')
+ expect(useAuthStore().authenticated).toBe(true)
+ jest.advanceTimersByTime(60000)
+ await flush()
+ expect(requests).toHaveLength(1)
+ expect(addToast).not.toHaveBeenCalled()
+ })
+
+ test('unauthorized failure', async () => {
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ return '/api/nodes' === path
+ ? Response.json({ error: { code: 401, message: 'unauthorized' } }, { status: 401 })
+ : Response.json({ nodes: [] })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ await nextTick()
+ expect(useAuthStore().authenticated).toBe(false)
+ jest.advanceTimersByTime(60000)
+ await flush()
+ expect(requests).toHaveLength(1)
+ })
+
+ test('logout cleanup', async () => {
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ return '/api/nodes' === path
+ ? Response.json({ error: { code: 503, message: 'unavailable' } }, { status: 503 })
+ : Response.json({ nodes: [] })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ expect(requests).toHaveLength(1)
+ expect(addToast).not.toHaveBeenCalled()
+
+ useAuthStore().invalidate()
+ await nextTick()
+ jest.advanceTimersByTime(60000)
+ await flush()
+ expect(requests).toHaveLength(1)
+ expect(workspace.nodes).toEqual([])
+ })
+
+ test('dispose cleanup', async () => {
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request): Promise => {
+ const path = String(input)
+ requests.push(path)
+ return '/api/nodes' === path
+ ? Response.json({ error: { code: 503, message: 'unavailable' } }, { status: 503 })
+ : Response.json({ nodes: [] })
+ },
+ { preconnect: originalFetch.preconnect },
+ )
+ const workspace = useWorkspaceStore()
+ await workspace.load()
+ expect(requests).toHaveLength(1)
+
+ workspace.$dispose()
+ jest.advanceTimersByTime(60000)
+ await flush()
+ expect(requests).toHaveLength(1)
+ })
+})
+
describe('Live stack actions', () => {
test('forbidden workspace', async () => {
const workspace = useWorkspaceStore()
diff --git a/internal/agent/channel.go b/internal/agent/channel.go
index 2da2dfb..306b73d 100644
--- a/internal/agent/channel.go
+++ b/internal/agent/channel.go
@@ -7,6 +7,7 @@ import (
"fmt"
"io"
"log/slog"
+ "net"
"net/http"
"sync"
"sync/atomic"
@@ -182,13 +183,17 @@ func (a *agent) channelError(ctx context.Context, peer, operation string, err er
)
return
}
- if errors.Is(err, io.EOF) {
+ // The WebSocket reader can close the socket before it cancels ctx,
+ // so a concurrent writer may see net.ErrClosed during a normal disconnect.
+ if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) {
slog.Info(
- fmt.Sprintf("DCompose peer %s disconnected from node %q without a WebSocket close handshake.", peer, a.config.Global.NodeID),
+ fmt.Sprintf("DCompose peer %s disconnected from node %q: %v", peer, a.config.Global.NodeID, err),
"peer",
peer,
"node",
a.config.Global.NodeID,
+ "error",
+ err,
)
return
}
diff --git a/internal/agent/channel_test.go b/internal/agent/channel_test.go
index 305dd6d..9f15dc1 100644
--- a/internal/agent/channel_test.go
+++ b/internal/agent/channel_test.go
@@ -6,6 +6,7 @@ import (
"errors"
"fmt"
"io"
+ "net"
"net/http"
"net/http/httptest"
"os"
@@ -272,10 +273,12 @@ func TestChannelErrors(t *testing.T) {
canceled bool
}{
{"eof", "INFO", fmt.Errorf("failed to read frame header: %w", io.EOF), false},
+ {"closed", "INFO", fmt.Errorf("failed to write frame: %w", net.ErrClosed), false},
{"normal", "DEBUG", websocket.CloseError{Code: websocket.StatusNormalClosure}, false},
{"going-away", "DEBUG", websocket.CloseError{Code: websocket.StatusGoingAway}, false},
{"partial", "WARN", fmt.Errorf("failed to read: %w", io.ErrUnexpectedEOF), false},
{"protocol", "WARN", websocket.CloseError{Code: websocket.StatusProtocolError}, false},
+ {"invalid-json", "WARN", websocket.CloseError{Code: websocket.StatusInvalidFramePayloadData}, false},
{"failure", "WARN", errors.New("connection reset by peer"), false},
{"canceled", "", io.EOF, true},
} {
@@ -323,7 +326,6 @@ func TestChannelErrors(t *testing.T) {
func TestChannelDisconnect(t *testing.T) {
for _, mode := range []string{"abrupt", "normal", "going-away", "invalid-json"} {
t.Run(mode, func(t *testing.T) {
- logs := captureAutomaticLogs(t)
a, _ := fixture(t)
if w := pairRequest(a, a.pairingToken); http.StatusOK != w.Code {
t.Fatal("could not pair node", w.Code)
@@ -358,10 +360,6 @@ func TestChannelDisconnect(t *testing.T) {
defer a.events.mu.Unlock()
return 0 == len(a.events.subscribers)
})
- warned := strings.Contains(logs.text(), `"level":"WARN"`)
- if ("invalid-json" == mode) != warned {
- t.Fatal("incorrect disconnect severity", logs.text())
- }
if !a.config.Global.Paired || "" != a.pairingToken {
t.Fatal("connection loss reset pairing")
}
diff --git a/internal/agent/events_test.go b/internal/agent/events_test.go
index e5dbafc..c54d5fb 100644
--- a/internal/agent/events_test.go
+++ b/internal/agent/events_test.go
@@ -109,9 +109,13 @@ func TestRuntimeProgressive(t *testing.T) {
if nil != json.Unmarshal(data, &snapshot) || !snapshot.Stacks[0].Loading || "running" != snapshot.Stacks[0].Status {
t.Fatalf("cached reconnect: %s", data)
}
- pids, _ := os.ReadFile(filepath.Join(fake, "event-pids"))
- if 1 != len(strings.Fields(string(pids))) {
- t.Fatalf("duplicate monitors: %s", pids)
+ eventually(t, func() bool {
+ pids, _ := os.ReadFile(filepath.Join(fake, "event-pids"))
+ return 0 < len(strings.Fields(string(pids)))
+ })
+ pids, err := os.ReadFile(filepath.Join(fake, "event-pids"))
+ if nil != err || 1 != len(strings.Fields(string(pids))) {
+ t.Fatalf("duplicate monitors: %s (%v)", pids, err)
}
}
@@ -286,6 +290,10 @@ func TestMonitorRecovery(t *testing.T) {
seed(t, a, "demo", "compose.yaml")
reader := openEvents(t, streamServer(t, a), "/events")
reader.until(t, "stack.runtime")
+ eventually(t, func() bool {
+ pids, _ := os.ReadFile(filepath.Join(fake, "event-pids"))
+ return 1 == len(strings.Fields(string(pids)))
+ })
argv, _ := os.ReadFile(filepath.Join(fake, "argv"))
args := strings.SplitN(string(argv), "<--since><", 2)
if 2 != len(args) {
@@ -309,10 +317,10 @@ func TestMonitorRecovery(t *testing.T) {
}
}
reader.until(t, "stack.runtime")
- pids, _ := os.ReadFile(filepath.Join(fake, "event-pids"))
- if 2 > len(strings.Fields(string(pids))) {
- t.Fatal("monitor did not restart")
- }
+ eventually(t, func() bool {
+ pids, _ := os.ReadFile(filepath.Join(fake, "event-pids"))
+ return 2 <= len(strings.Fields(string(pids)))
+ })
write(t, filepath.Join(fake, "ps"), `[{"State":"running"}]`)
write(
t,
diff --git a/internal/agent/info_test.go b/internal/agent/info_test.go
index c80ba43..fc48155 100644
--- a/internal/agent/info_test.go
+++ b/internal/agent/info_test.go
@@ -16,17 +16,19 @@ import (
type infoEngine struct {
engine.Driver
- t *testing.T
- err error
- calls int
+ t *testing.T
+ err error
+ calls int
+ deadline time.Time
}
func (e *infoEngine) NodeInfo(ctx context.Context) (engine.NodeInfo, error) {
e.calls++
deadline, ok := ctx.Deadline()
- if !ok || 30*time.Second < time.Until(deadline) || 29*time.Second > time.Until(deadline) {
+ if !ok {
e.t.Fatalf("node info deadline: %v, set: %t", deadline, ok)
}
+ e.deadline = deadline
return engine.NodeInfo{
Runtime: engine.RuntimeInfo{Name: "home", Version: "27.5.1", CPUs: 8, MemoryBytes: 16777216000},
Containers: []engine.ContainerStats{{ID: "container", Name: "web", CPU: "2.50%", Memory: "12MiB / 1GiB"}},
@@ -46,6 +48,9 @@ func TestNodeInfo(t *testing.T) {
if 200 != w.Code || 1 != driver.calls || "home" != info.Runtime.Name || 1 != len(info.Containers) || "2.50%" != info.Containers[0].CPU {
t.Fatalf("info: %d %s", w.Code, w.Body)
}
+ if driver.deadline.Before(before.Add(30*time.Second)) || driver.deadline.After(time.Now().Add(30*time.Second)) {
+ t.Fatalf("node info deadline: %v", driver.deadline)
+ }
if info.CheckedAt.Before(before) || info.CheckedAt.After(time.Now()) || time.UTC != info.CheckedAt.Location() {
t.Fatalf("checked at: %v", info.CheckedAt)
}
diff --git a/internal/agent/live_actions_test.go b/internal/agent/live_actions_test.go
index d9128f7..f752b3c 100644
--- a/internal/agent/live_actions_test.go
+++ b/internal/agent/live_actions_test.go
@@ -1,7 +1,6 @@
package agent
import (
- "context"
"encoding/json"
"os"
"path/filepath"
@@ -17,10 +16,10 @@ func TestRuntimeBusy(t *testing.T) {
seed(t, a, "slow", "compose.yaml")
write(t, filepath.Join(fake, "block-slow"), "")
states := make(chan stackRuntime, 1)
- go func() {
- state, _ := a.runtimeStatus(context.Background(), "slow")
+ a.work.Go(func() {
+ state, _ := a.runtimeStatus(a.ctx, "slow")
states <- state
- }()
+ })
eventually(t, func() bool { _, err := os.Stat(filepath.Join(fake, "ps-slow")); return nil == err })
a.setStackBusy("slow", true)
if err := os.Remove(filepath.Join(fake, "block-slow")); nil != err {
diff --git a/internal/agent/shells_test.go b/internal/agent/shells_test.go
index 557c9a9..e5d30e2 100644
--- a/internal/agent/shells_test.go
+++ b/internal/agent/shells_test.go
@@ -57,11 +57,11 @@ func createdShell(t *testing.T, a *agent, body string) *shellSession {
t.Fatalf("creation response: %s", w.Body)
}
a.mu.Lock()
+ defer a.mu.Unlock()
s := a.shells[result.ID]
if nil != a.ops[result.ID] || a.busy["demo"] {
t.Fatal("shell registered as stack operation")
}
- a.mu.Unlock()
return s
}
diff --git a/internal/agent/stats_test.go b/internal/agent/stats_test.go
index bac0e7f..f195aba 100644
--- a/internal/agent/stats_test.go
+++ b/internal/agent/stats_test.go
@@ -105,15 +105,16 @@ func statsCommands(t *testing.T, a *agent) (chan<- protocol.ChannelMessage, <-ch
defer close(done)
a.channelCommands(ctx, "stats-test", commands, outgoing, cancel)
}()
- t.Cleanup(func() {
+ stop := func() {
cancel()
select {
case <-done:
case <-time.After(2 * time.Second):
t.Error("stats channel did not stop")
}
- })
- return commands, outgoing, cancel
+ }
+ t.Cleanup(stop)
+ return commands, outgoing, stop
}
func TestChannelStatsCancel(t *testing.T) {
diff --git a/internal/engine/podman/testmain_test.go b/internal/engine/podman/testmain_test.go
index 3a33012..2a440e9 100644
--- a/internal/engine/podman/testmain_test.go
+++ b/internal/engine/podman/testmain_test.go
@@ -8,5 +8,10 @@ import (
)
func TestMain(m *testing.M) {
+ // Local command fixtures must not inherit the developer's remote endpoint.
+ // Socket tests select their endpoint explicitly with t.Setenv.
+ if err := os.Unsetenv("CONTAINER_HOST"); nil != err {
+ panic(err)
+ }
os.Exit(testutil.Run(m))
}
diff --git a/internal/server/channel_test.go b/internal/server/channel_test.go
index bae1720..2a6b501 100644
--- a/internal/server/channel_test.go
+++ b/internal/server/channel_test.go
@@ -366,15 +366,10 @@ func TestChannelPin(t *testing.T) {
node.Fingerprint = strings.Repeat("A", 43) + "="
s.config.Nodes["home"] = node
s.nodes["home"] = nodeClient(node)
- startChannels(t, s)
- frames, _ := s.subscribeWorkspace()
- select {
- case frame := <-frames:
- if !strings.Contains(string(frame), `"state":"unavailable"`) {
- t.Fatal(string(frame))
- }
- case <-time.After(2 * time.Second):
- t.Fatal("missing pin failure")
+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+ defer cancel()
+ if _, err := dialChannel(&nodeChannel{node: node, client: s.nodes["home"], ctx: ctx}); !errors.Is(err, errFingerprint) {
+ t.Fatal("missing pin failure", err)
}
if 0 != f.count.Load() || 0 != f.health.Load() {
t.Fatal("unpinned node reached HTTP endpoint")
diff --git a/internal/server/event_tickets_test.go b/internal/server/event_tickets_test.go
index a289617..925be17 100644
--- a/internal/server/event_tickets_test.go
+++ b/internal/server/event_tickets_test.go
@@ -397,10 +397,10 @@ func TestTicketDeadline(t *testing.T) {
s.config.Global.WebsocketOrigins = []string{eventTicketOrigin}
app := httptest.NewServer(s)
t.Cleanup(app.Close)
+ started := time.Now()
conn := dialEventTicket(t, app, "/api/events", http.Header{"Origin": {eventTicketOrigin}})
ctx, cancel := context.WithTimeout(context.Background(), 7*time.Second)
defer cancel()
- started := time.Now()
if _, _, err := conn.Read(ctx); nil == err || nil != ctx.Err() {
t.Fatal("missing first-auth deadline close")
}
diff --git a/internal/server/events_test.go b/internal/server/events_test.go
index 334c19f..5380bed 100644
--- a/internal/server/events_test.go
+++ b/internal/server/events_test.go
@@ -339,28 +339,31 @@ func TestBrowserNodeFailure(t *testing.T) {
t.Fatal("node failure affected another subscription", got)
}
sendRuntime(t, healthy, "stack.runtime", readFixture(t, "stack-runtime.json"))
+ nextConnection(t, first)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
- for {
+ healthyRuntime, reconnected := false, false
+ for !healthyRuntime || !reconnected {
var message protocol.ChannelMessage
if err := wsjson.Read(ctx, browser, &message); nil != err {
t.Fatal("node failure closed workspace", err)
}
- if "stack.runtime" == message.Event {
- if "" != message.Stream || !strings.Contains(string(message.Payload), `"node":"other"`) {
+ var payload struct {
+ Node string `json:"node"`
+ Name string `json:"name"`
+ }
+ if err := json.Unmarshal(message.Payload, &payload); nil != err {
+ t.Fatal(err)
+ }
+ // Disconnects also publish the failed node's cached stack runtime.
+ if "stack.runtime" == message.Event && "other" == payload.Node && "demo" == payload.Name {
+ if "" != message.Stream {
t.Fatal(message)
}
- break
+ healthyRuntime = true
}
- }
- nextConnection(t, first)
- for {
- var message protocol.ChannelMessage
- if err := wsjson.Read(ctx, browser, &message); nil != err {
- t.Fatal("reconnected node snapshot missing", err)
- }
- if "node.snapshot" == message.Event && strings.Contains(string(message.Payload), `"node":"home"`) {
- break
+ if "node.snapshot" == message.Event && "home" == payload.Node {
+ reconnected = true
}
}
}
diff --git a/internal/server/pause_test.go b/internal/server/pause_test.go
index 9282744..1355809 100644
--- a/internal/server/pause_test.go
+++ b/internal/server/pause_test.go
@@ -169,16 +169,22 @@ func TestPauseChannel(t *testing.T) {
t.Fatal("pause did not cancel active node work")
}
s.hubMu.Lock()
- if nil != s.channels["home"] || nil != channel.conn || 0 != len(channel.streams) || 0 != len(channel.shells) ||
- nil != s.runtime["home"].snapshot {
- t.Fatal("pause retained channel or cached runtime")
- }
+ retainedRuntime := nil != s.channels["home"] || nil != channel.conn || 0 != len(channel.streams) || 0 != len(channel.shells) ||
+ nil != s.runtime["home"].snapshot
+ retainedImages := false
for key := range s.images.stacks {
if "home" == key.node {
- t.Fatal("pause retained node image work")
+ retainedImages = true
+ break
}
}
s.hubMu.Unlock()
+ if retainedRuntime {
+ t.Fatal("pause retained channel or cached runtime")
+ }
+ if retainedImages {
+ t.Fatal("pause retained node image work")
+ }
select {
case message := <-subscription.subscriber:
if "error" != message.Type || 409 != message.Status {
diff --git a/internal/server/registry_inspect_test.go b/internal/server/registry_inspect_test.go
index 9a57cd8..fedf2a5 100644
--- a/internal/server/registry_inspect_test.go
+++ b/internal/server/registry_inspect_test.go
@@ -244,25 +244,25 @@ func TestRegistrySharedMetadata(t *testing.T) {
return s.registryClient.InspectConfig(registryNodeContext(context.Background(), node), key.ImageKey, config, age)
}
amd := lookup("home", time.Hour)
- if "sha256:"+strings.Repeat("a", 64) != amd.Digest || !now.Equal(amd.CheckedAt) || 3 != len(one.requests) {
- t.Fatalf("first lookup: %+v requests=%v", amd, one.requests)
+ if "sha256:"+strings.Repeat("a", 64) != amd.Digest || !now.Equal(amd.CheckedAt) || 3 != imageRequests(one) {
+ t.Fatalf("first lookup: %+v requests=%d", amd, imageRequests(one))
}
- if result := lookup("away", time.Hour); amd.Digest != result.Digest || 0 != len(two.requests) {
- t.Fatalf("same image refetched: %+v requests=%v", result, two.requests)
+ if result := lookup("away", time.Hour); amd.Digest != result.Digest || 0 != imageRequests(two) {
+ t.Fatalf("same image refetched: %+v requests=%d", result, imageRequests(two))
}
key.Architecture = "arm64"
arm := lookup("away", time.Hour)
- if "sha256:"+strings.Repeat("b", 64) != arm.Digest || !amd.CheckedAt.Equal(arm.CheckedAt) || 1 != len(two.requests) {
- t.Fatalf("mixed platform root not shared: %+v requests=%v", arm, two.requests)
+ if "sha256:"+strings.Repeat("b", 64) != arm.Digest || !amd.CheckedAt.Equal(arm.CheckedAt) || 1 != imageRequests(two) {
+ t.Fatalf("mixed platform root not shared: %+v requests=%d", arm, imageRequests(two))
}
clock.Store(now.Add(30 * time.Minute).UnixNano())
custom := lookup("away", 30*time.Minute)
- if !custom.CheckedAt.Equal(now.Add(30*time.Minute)) || 2 != len(two.requests) {
+ if !custom.CheckedAt.Equal(now.Add(30*time.Minute)) || 2 != imageRequests(two) {
t.Fatalf("custom interval did not refresh HEAD: %+v", custom)
}
clock.Store(now.Add(31 * time.Minute).UnixNano())
manual := lookup("home", 0)
- if !manual.CheckedAt.Equal(now.Add(31*time.Minute)) || 4 != len(one.requests) {
+ if !manual.CheckedAt.Equal(now.Add(31*time.Minute)) || 4 != imageRequests(one) {
t.Fatalf("manual check did not refresh HEAD: %+v", manual)
}
}
diff --git a/internal/server/settings_test.go b/internal/server/settings_test.go
index 6e15921..863fba9 100644
--- a/internal/server/settings_test.go
+++ b/internal/server/settings_test.go
@@ -628,6 +628,7 @@ func TestConfigRace(t *testing.T) {
defer up.Close()
s := persistedServer(t, up)
var workers sync.WaitGroup
+ defer workers.Wait()
for i := 0; 4 > i; i++ {
workers.Go(func() {
for j := 0; 12 > j; j++ {
@@ -650,5 +651,4 @@ func TestConfigRace(t *testing.T) {
t.Fatal("concurrent write failed")
}
}
- workers.Wait()
}