@contember/cli 2.1.0-rc.3 → 2.2.0-alpha.10

package/tests/cases/unit/transport-errors.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test } from 'bun:test'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { inspect } from 'node:util'
+import { classifyHttpStatus, toHttpTransportError, toTransportError } from '../../../src/lib/errors/TransportError.js'
+
+const context = {
+	service: 'Test API',
+	codePrefix: 'TEST_API',
+	url: 'https://user:password@example.com/path?token=secret#fragment',
+}
+
+describe('classifyHttpStatus', () => {
+	const cases = [
+		{ status: 400, kind: 'input', codeSuffix: 'BAD_REQUEST', exitCode: ExitCode.InputError },
+		{ status: 401, kind: 'forbidden', codeSuffix: 'UNAUTHORIZED', exitCode: ExitCode.Forbidden },
+		{ status: 403, kind: 'forbidden', codeSuffix: 'FORBIDDEN', exitCode: ExitCode.Forbidden },
+		{ status: 404, kind: 'not-found', codeSuffix: 'NOT_FOUND', exitCode: ExitCode.NotFound },
+		{ status: 408, kind: 'transient', codeSuffix: 'TIMEOUT', exitCode: ExitCode.Transient },
+		{ status: 409, kind: 'conflict', codeSuffix: 'CONFLICT', exitCode: ExitCode.Conflict },
+		{ status: 425, kind: 'transient', codeSuffix: 'TOO_EARLY', exitCode: ExitCode.Transient },
+		{ status: 429, kind: 'transient', codeSuffix: 'RATE_LIMITED', exitCode: ExitCode.Transient },
+		{ status: 500, kind: 'transient', codeSuffix: 'SERVER_ERROR', exitCode: ExitCode.Transient },
+	]
+
+	for (const expected of cases) {
+		test(`classifies ${expected.status}`, () => {
+			expect(classifyHttpStatus(expected.status)).toEqual({
+				kind: expected.kind,
+				codeSuffix: expected.codeSuffix,
+				exitCode: expected.exitCode,
+			})
+		})
+	}
+})
+
+describe('transport errors', () => {
+	test('creates a safe HTTP error and preserves Retry-After', () => {
+		const error = toHttpTransportError({ status: 429, retryAfter: '30' }, context)
+
+		expect(error.code).toBe('TEST_API_RATE_LIMITED')
+		expect(error.retryable).toBe(true)
+		expect(error.details).toEqual({ status: 429, retryAfter: '30', url: 'https://example.com/path' })
+		expect(JSON.stringify(error.details)).not.toContain('password')
+		expect(JSON.stringify(error.details)).not.toContain('secret')
+	})
+
+	test('drops an invalid Retry-After value', () => {
+		const error = toHttpTransportError({ status: 429, retryAfter: 'secret-response-value' }, context)
+
+		expect(error.details).toEqual({ status: 429, url: 'https://example.com/path' })
+	})
+
+	test('does not retain a raw HTTP cause', () => {
+		const cause = new Error('response included secret-http-cause')
+		const error = toHttpTransportError({ status: 500 }, context, cause)
+
+		expect(error.cause).not.toBe(cause)
+		expect(inspect(error, { depth: null })).not.toContain('secret-http-cause')
+	})
+
+	test('normalizes a rejected fetch as transient', () => {
+		const cause = new TypeError('fetch failed with private context')
+		const error = toTransportError(cause, context)
+
+		expect(error.code).toBe('TEST_API_UNREACHABLE')
+		expect(error.exitCode).toBe(ExitCode.Transient)
+		expect(error.retryable).toBe(true)
+		expect(error.message).not.toContain(cause.message)
+		expect(error.cause).not.toBe(cause)
+		expect(inspect(error, { depth: null })).not.toContain('private context')
+	})
+
+	test('keeps an existing CliError unchanged', () => {
+		const original = new CliError('known failure', { code: 'KNOWN', exitCode: ExitCode.Conflict })
+
+		expect(toTransportError(original, context)).toBe(original)
+	})
+})

package/tests/cases/unit/workspace-update-api.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from 'bun:test'
+import { CliError } from '@contember/cli-common'
+import {
+	DockerComposeAccess,
+	PackageUpdateWorkspace,
+	PackageUpdateWorkspaceResolver,
+	WorkspaceUpdateApiCommand,
+} from '../../../src/commands/workspace/WorkspaceUpdateApiCommand.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+const defaultUpdatedDependencies = [
+	{ name: '@contember/schema' },
+	{ name: '@contember/schema-definition' },
+	{ name: '@contember/cli' },
+]
+
+const createPackageWorkspace = (
+	onWrite: () => void,
+	updatedDependencies: readonly { name: string }[] = defaultUpdatedDependencies,
+): PackageUpdateWorkspace => ({
+	findDefinedDependencies: packageName => [{
+		name: packageName,
+		version: '2.1.0',
+		isDev: false,
+		pckg: { dir: '/workspace', isRoot: true },
+	}],
+	updateEverywhere: async () => {
+		onWrite()
+		return updatedDependencies
+	},
+})
+
+describe('WorkspaceUpdateApiCommand', () => {
+	test('validates every input before package or docker-compose writes', async () => {
+		let packageWrites = 0
+		let dockerWrites = 0
+		const packageWorkspace = createPackageWorkspace(() => packageWrites++)
+		const resolver: PackageUpdateWorkspaceResolver = { resolve: async () => packageWorkspace }
+		const dockerCompose: DockerComposeAccess = {
+			tryReadMainDockerComposeConfig: async () => ({ services: { engine: 'malformed-service' } }),
+			updateMainDockerComposeConfig: async () => {
+				dockerWrites++
+			},
+		}
+		const command = new WorkspaceUpdateApiCommand(resolver, dockerCompose)
+		const { output } = createTestOutput()
+
+		const promise = command.run(['2.2.0'], output)
+		await expect(promise).rejects.toBeInstanceOf(CliError)
+		await expect(promise).rejects.toMatchObject({ code: 'INVALID_WORKSPACE_UPDATE' })
+		expect(packageWrites).toBe(0)
+		expect(dockerWrites).toBe(0)
+	})
+
+	test('updates known images and preserves services without images', async () => {
+		let packageWrites = 0
+		let writtenCompose: unknown
+		const packageWorkspace = createPackageWorkspace(() => packageWrites++)
+		const resolver: PackageUpdateWorkspaceResolver = { resolve: async () => packageWorkspace }
+		const dockerCompose: DockerComposeAccess = {
+			tryReadMainDockerComposeConfig: async () => ({
+				services: {
+					engine: { image: 'contember/engine-ee:2.1.0', environment: { MODE: 'test' } },
+					custom: { build: '.' },
+				},
+			}),
+			updateMainDockerComposeConfig: async updater => {
+				writtenCompose = updater({})
+			},
+		}
+		const command = new WorkspaceUpdateApiCommand(resolver, dockerCompose)
+		const { output, stdout, stderr } = createTestOutput()
+
+		await command.run(['2.2.0'], output)
+
+		expect(packageWrites).toBe(1)
+		expect(writtenCompose).toEqual({
+			services: {
+				engine: { image: 'contember/engine:2.2.0', environment: { MODE: 'test' } },
+				custom: { build: '.' },
+			},
+		})
+		expect(stdout.text).toBe('')
+		expect(stderr.lines).toStrictEqual([
+			'Updating docker-compose',
+			'docker-compose service engine updated',
+			'API versions updated',
+			'Restart server to apply changes',
+		])
+	})
+
+	test('returns updated package and service names as JSON', async () => {
+		const packageWorkspace = createPackageWorkspace(() => {}, [
+			{ name: '@contember/schema' },
+			{ name: '@contember/schema' },
+			{ name: '@contember/cli' },
+		])
+		const resolver: PackageUpdateWorkspaceResolver = { resolve: async () => packageWorkspace }
+		const dockerCompose: DockerComposeAccess = {
+			tryReadMainDockerComposeConfig: async () => ({
+				services: {
+					engine: { image: 'contember/engine:2.1.0' },
+					custom: { build: '.' },
+				},
+			}),
+			updateMainDockerComposeConfig: async () => {},
+		}
+		const { output, stdout, stderr } = createTestOutput()
+
+		await new WorkspaceUpdateApiCommand(resolver, dockerCompose).run(['2.2.0', '--json'], output)
+
+		expect(JSON.parse(stdout.text)).toStrictEqual({
+			version: '2.2.0',
+			updatedPackages: ['@contember/schema', '@contember/cli'],
+			updatedServices: ['engine'],
+		})
+		expect(stderr.text).toBe('')
+	})
+
+	test('returns stable scalar lines in quiet mode', async () => {
+		const packageWorkspace = createPackageWorkspace(() => {}, [{ name: '@contember/schema' }])
+		const resolver: PackageUpdateWorkspaceResolver = { resolve: async () => packageWorkspace }
+		const dockerCompose: DockerComposeAccess = {
+			tryReadMainDockerComposeConfig: async () => ({ services: { engine: { image: 'contember/engine:2.1.0' } } }),
+			updateMainDockerComposeConfig: async () => {},
+		}
+		const { output, stdout, stderr } = createTestOutput()
+
+		await new WorkspaceUpdateApiCommand(resolver, dockerCompose).run(['2.2.0', '--quiet'], output)
+
+		expect(stdout.lines).toStrictEqual(['2.2.0', '@contember/schema', 'engine'])
+		expect(stderr.text).toBe('')
+	})
+
+	test('reports an empty update plan without inventing changed names', async () => {
+		const packageWorkspace = createPackageWorkspace(() => {}, [])
+		const resolver: PackageUpdateWorkspaceResolver = { resolve: async () => packageWorkspace }
+		const dockerCompose: DockerComposeAccess = {
+			tryReadMainDockerComposeConfig: async () => ({ services: { custom: { build: '.' } } }),
+			updateMainDockerComposeConfig: async () => {},
+		}
+		const { output, stdout } = createTestOutput()
+
+		await new WorkspaceUpdateApiCommand(resolver, dockerCompose).run(['2.2.0', '--json'], output)
+
+		expect(JSON.parse(stdout.text)).toStrictEqual({
+			version: '2.2.0',
+			updatedPackages: [],
+			updatedServices: [],
+		})
+	})
+})