test: cover backup and system contracts

.github/workflows/e2e-ephemeral.yml

@@ -37,7 +37,7 @@ jobs:
 
             - name: Run E2E suite
               id: e2e
-              timeout-minutes: 11
+              timeout-minutes: 15
               run: npm test
 
             - name: Collect failure diagnostics

src/clients/caprover.ts

@@ -22,6 +22,15 @@ interface ServerInfo {
 type Theme = NonNullable<
     Awaited<ReturnType<CapRoverAPI['getAllThemes']>>['themes']
 >[number]
+type VersionInfo = Awaited<ReturnType<CapRoverAPI['getVersionInfo']>>
+type LoadBalancerInfo = Awaited<ReturnType<CapRoverAPI['getLoadBalancerInfo']>>
+type NodeInfo = Awaited<ReturnType<CapRoverAPI['getAllNodes']>>['nodes'][number]
+type ProFeaturesState = Awaited<
+    ReturnType<CapRoverAPI['getProFeaturesState']>
+>['proFeaturesState']
+type ProConfigs = Awaited<
+    ReturnType<CapRoverAPI['getProConfigs']>
+>['proConfigs']
 
 const API_TIMEOUT_MS = 30_000
 const DEPLOYMENT_TIMEOUT_MS = 90_000
@@ -53,6 +62,42 @@ export class CapRoverClient {
         )
     }
 
+    getVersionInfo(): Promise<VersionInfo> {
+        return this.request(
+            () => this.api.getVersionInfo(),
+            'retrieving CapRover version information'
+        )
+    }
+
+    getLoadBalancerInfo(): Promise<LoadBalancerInfo> {
+        return this.request(
+            () => this.api.getLoadBalancerInfo(),
+            'retrieving load-balancer information'
+        )
+    }
+
+    getAllNodes(): Promise<{ nodes: NodeInfo[] }> {
+        return this.request(() => this.api.getAllNodes(), 'listing Swarm nodes')
+    }
+
+    getProFeaturesState(): Promise<ProFeaturesState> {
+        return this.request(
+            () => this.api.getProFeaturesState(),
+            'retrieving Pro feature state'
+        ).then((response) => response.proFeaturesState)
+    }
+
+    getProConfigs(): Promise<ProConfigs> {
+        return this.request(
+            () => this.api.getProConfigs(),
+            'retrieving Pro configuration'
+        ).then((response) => response.proConfigs)
+    }
+
+    createBackup(): Promise<{ downloadToken: string }> {
+        return this.request(() => this.api.createBackup(), 'creating backup')
+    }
+
     getAllThemes(): Promise<{ themes: Theme[] | undefined }> {
         return this.request(() => this.api.getAllThemes(), 'listing themes')
     }
@@ -297,4 +342,12 @@ export class CapRoverClient {
     }
 }
 
-export type { AppDefinition, Theme }
+export type {
+    AppDefinition,
+    LoadBalancerInfo,
+    NodeInfo,
+    ProConfigs,
+    ProFeaturesState,
+    Theme,
+    VersionInfo,
+}

src/clients/http.ts

@@ -7,6 +7,13 @@ export interface HttpResult {
     headers: Headers
 }
 
+export interface BinaryHttpResult {
+    status: number
+    body: Buffer
+    finalUrl: string
+    headers: Headers
+}
+
 export interface HttpRequestOptions {
     headers?: HeadersInit
     redirect?: RequestRedirect
@@ -33,6 +40,24 @@ export class HttpClient {
         }
     }
 
+    async getBinary(
+        url: string,
+        options: HttpRequestOptions = {}
+    ): Promise<BinaryHttpResult> {
+        const response = await fetch(url, {
+            headers: options.headers,
+            redirect: options.redirect ?? 'follow',
+            signal: AbortSignal.timeout(this.requestTimeoutMs),
+        })
+
+        return {
+            status: response.status,
+            body: Buffer.from(await response.arrayBuffer()),
+            finalUrl: response.url,
+            headers: response.headers,
+        }
+    }
+
     async getStatus(url: string): Promise<number> {
         return (await this.get(url)).status
     }

src/inspectors/docker.ts

@@ -73,6 +73,19 @@ interface DockerSwarmInfo {
     NodeID?: string
 }
 
+export interface DockerNode {
+    ID: string
+    Spec: { Role: 'manager' | 'worker'; Availability: string }
+    ManagerStatus?: { Leader?: boolean }
+    Description: {
+        Hostname: string
+        Platform: { Architecture: string; OS: string }
+        Resources: { NanoCPUs: number; MemoryBytes: number }
+        Engine: { EngineVersion: string }
+    }
+    Status: { Addr: string; State: string }
+}
+
 interface DockerUpdateConfig {
     Parallelism?: number
     Delay?: number
@@ -241,6 +254,26 @@ export class DockerInspector {
         return nodeId
     }
 
+    async getNodes(): Promise<DockerNode[]> {
+        const listed = await this.exec('docker node ls --quiet')
+        const nodeIds = listed.stdout
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+
+        for (const nodeId of nodeIds) {
+            if (!/^[a-z0-9]{25}$/.test(nodeId)) {
+                throw new Error(`Docker returned an invalid node ID: ${nodeId}`)
+            }
+        }
+        if (!nodeIds.length) return []
+
+        const inspected = await this.exec(
+            `docker node inspect ${nodeIds.map(shellQuote).join(' ')}`
+        )
+        return parseJson<DockerNode[]>(inspected.stdout, 'Swarm nodes')
+    }
+
     async getServicePlacementConstraints(appName: string): Promise<string[]> {
         const service = await this.getService(appName)
         return service.Spec?.TaskTemplate?.Placement?.Constraints ?? []

src/test-selection.ts

@@ -13,11 +13,11 @@ export const coreFiles = [
     'tests/one-click.test.ts',
 ]
 export const destructiveFiles = [
+    'tests/system-defaults.test.ts',
     'tests/persistent-storage.test.ts',
     'tests/custom-ports.test.ts',
     'tests/themes.test.ts',
     'tests/backup.test.ts',
-    'tests/system-defaults.test.ts',
     'tests/disk-cleanup.test.ts',
     'tests/system-nginx.test.ts',
     'tests/one-click-repositories.test.ts',

src/test-sequencer.ts

@@ -0,0 +1,31 @@
+import { BaseSequencer } from 'vitest/node'
+
+const SYSTEM_DEFAULTS_FILE = 'tests/system-defaults.test.ts'
+
+export function prioritizeSystemDefaults<T extends { moduleId: string }>(
+    files: T[]
+): T[] {
+    const defaults: T[] = []
+    const rest: T[] = []
+
+    for (const spec of files) {
+        const file = spec.moduleId.replaceAll('\\', '/')
+        if (
+            file === SYSTEM_DEFAULTS_FILE ||
+            file.endsWith(`/${SYSTEM_DEFAULTS_FILE}`)
+        ) {
+            defaults.push(spec)
+        } else {
+            rest.push(spec)
+        }
+    }
+
+    return [...defaults, ...rest]
+}
+
+export class CapRoverSequencer extends BaseSequencer {
+    override async sort(files: Parameters<BaseSequencer['sort']>[0]) {
+        const sorted = await super.sort(files)
+        return prioritizeSystemDefaults(sorted)
+    }
+}

tests/backup.test.ts

@@ -0,0 +1,127 @@
+import { execFile as execFileCallback } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+import { expect, test } from 'vitest'
+import { loadConfig } from '../src/config'
+import { createTestNames } from '../src/helpers/names'
+import { eventually } from '../src/helpers/retry'
+import { cleanUpApp, withTestContext } from '../src/helpers/test-context'
+import { requireEphemeral } from '../src/test-selection'
+
+const execFile = promisify(execFileCallback)
+
+test('backup download is inspectable, contains owned configuration, and is one-time', async () => {
+    requireEphemeral()
+    await withTestContext(async (context, cleanup) => {
+        const { initialAppName: appName } = createTestNames()
+        const marker = `backup-${randomUUID()}`
+        cleanUpApp(context, cleanup, appName)
+        await context.caprover.createApp(appName)
+        await context.caprover.updateApp(appName, { description: marker })
+        expect((await context.caprover.getApp(appName)).description).toBe(
+            marker
+        )
+
+        const { downloadToken } = await context.caprover.createBackup()
+        expect(downloadToken.length).toBeGreaterThan(0)
+        const downloadUrl = backupUrl(downloadToken)
+
+        const invalid = await context.http.getBinary(
+            backupUrl(`${downloadToken}x`)
+        )
+        expect(invalid.status).toBe(200)
+        expect(isTarArchive(invalid)).toBe(false)
+        expect(parseEnvelopeStatus(invalid.body)).toBe(1106)
+
+        const archive = await context.http.getBinary(downloadUrl)
+        expect(archive.status).toBeGreaterThanOrEqual(200)
+        expect(archive.status).toBeLessThan(300)
+        expect(archive.body.length).toBeGreaterThan(0)
+        expect(archive.headers.get('content-disposition')).toContain(
+            'caprover-backup-'
+        )
+        expect(isTarArchive(archive)).toBe(true)
+
+        const directory = await mkdtemp(join(tmpdir(), 'caprover-e2e-backup-'))
+        try {
+            const archivePath = join(directory, 'backup.tar')
+            await writeFile(archivePath, archive.body)
+            const entries = await tarList(archivePath)
+            expect(entries).toContain('meta/backup.json')
+            expect(entries).toContain('data/config-captain.json')
+            expect(entries).not.toContain('data/data/config-captain.json')
+
+            const meta = JSON.parse(
+                await tarRead(archivePath, 'meta/backup.json')
+            ) as { nodes?: Array<{ nodeId?: string }>; salt?: string }
+            expect(meta.nodes?.length).toBeGreaterThan(0)
+            expect(new Set(meta.nodes?.map((node) => node.nodeId))).toEqual(
+                new Set(
+                    (await context.caprover.getAllNodes()).nodes.map(
+                        (node) => node.nodeId
+                    )
+                )
+            )
+            expect(typeof meta.salt).toBe('string')
+            expect(meta.salt?.length).toBeGreaterThan(0)
+
+            const config = JSON.parse(
+                await tarRead(archivePath, 'data/config-captain.json')
+            ) as {
+                appDefinitions?: Record<string, { description?: string }>
+            }
+            expect(config.appDefinitions?.[appName]?.description).toBe(marker)
+        } finally {
+            await rm(directory, { recursive: true, force: true })
+        }
+
+        await eventually(
+            async () => {
+                const repeated = await context.http.getBinary(downloadUrl)
+                expect(isTarArchive(repeated)).toBe(false)
+                expect(repeated.status).toBe(404)
+            },
+            { description: 'one-time backup download to become unavailable' }
+        )
+    })
+})
+
+function backupUrl(downloadToken: string): string {
+    const url = new URL('/api/v2/downloads/', loadConfig().caproverUrl)
+    url.searchParams.set('namespace', 'captain')
+    url.searchParams.set('downloadToken', downloadToken)
+    return url.toString()
+}
+
+function isTarArchive(response: { status: number; headers: Headers }): boolean {
+    return (
+        response.status >= 200 &&
+        response.status < 300 &&
+        response.headers.get('content-disposition')?.includes('.tar') === true
+    )
+}
+
+function parseEnvelopeStatus(body: Buffer): number | undefined {
+    try {
+        const value = JSON.parse(body.toString('utf8')) as { status?: unknown }
+        return typeof value.status === 'number' ? value.status : undefined
+    } catch {
+        return undefined
+    }
+}
+
+async function tarList(archivePath: string): Promise<string[]> {
+    const { stdout } = await execFile('tar', ['-tf', archivePath])
+    return stdout
+        .split(/\r?\n/)
+        .map((entry) => entry.replace(/^\.\//, ''))
+        .filter(Boolean)
+}
+
+async function tarRead(archivePath: string, entry: string): Promise<string> {
+    const { stdout } = await execFile('tar', ['-xOf', archivePath, entry])
+    return stdout
+}

tests/system-defaults.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from 'vitest'
+import { loadConfig } from '../src/config'
+import { withTestContext } from '../src/helpers/test-context'
+import { requireEphemeral } from '../src/test-selection'
+
+test('fresh provisioning has expected system and Pro defaults', async () => {
+    requireEphemeral()
+    await withTestContext(async (context) => {
+        const [server, apps, nodes, proState, proConfigs] = await Promise.all([
+            context.caprover.getServerInfo(),
+            context.caprover.getApps(),
+            context.caprover.getAllNodes(),
+            context.caprover.getProFeaturesState(),
+            context.caprover.getProConfigs(),
+        ])
+
+        expect(server.rootDomain).toBe(apps.rootDomain)
+        expect(server.rootDomain).toMatch(/^e2e-[a-z0-9-]+\./)
+        expect(server.hasRootSsl).toBe(true)
+        expect(server.forceSsl).toBe(true)
+        expect(new URL(loadConfig().caproverUrl).hostname).toBe(
+            `${server.captainSubDomain}.${server.rootDomain}`
+        )
+
+        expect(nodes.nodes).toHaveLength(1)
+        expect(nodes.nodes[0]).toMatchObject({
+            type: 'manager',
+            isLeader: true,
+        })
+        expect(nodes.nodes[0].nodeId).toBe(
+            await context.docker.getLocalManagerNodeId()
+        )
+
+        expect(proState.isSubscribed).toBe(false)
+        expect(typeof proState.isFeatureFlagEnabled).toBe('boolean')
+        expect(proConfigs.alerts).toEqual([])
+    })
+})