@contember/cli 2.2.0-alpha.2 → 2.2.0-alpha.4

package/tests/cases/unit/MigrationDiffCommand.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import prompts from 'prompts'
+import { Schema } from '@contember/schema'
+import { c, createSchema } from '@contember/schema-definition'
+import { emptySchema } from '@contember/schema-utils'
+import {
+	JsonLoader,
+	MigrationCreator,
+	MigrationDescriber,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	MigrationState,
+	MigrationToExecuteOkStatus,
+	ModificationHandlerFactory,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { CliError, ExitCode } from '@contember/cli-common'
+import { MigrationDiffCommand } from '../../../src/commands/migrations/MigrationDiffCommand.js'
+import { MigrationExecutionFacade } from '../../../src/lib/migrations/MigrationExecutionFacade.js'
+import { MigrationPrinter } from '../../../src/lib/migrations/MigrationPrinter.js'
+import { SchemaLoader } from '../../../src/lib/schema/SchemaLoader.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+namespace BlogModel {
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+namespace ExistingModel {
+	export class LegacyArticle {
+		title = c.stringColumn()
+	}
+}
+
+const invalidSchema: Schema = {
+	...emptySchema,
+	acl: {
+		roles: {
+			admin: { variables: {}, stages: '*', entities: {}, inherits: ['missing'] },
+		},
+	},
+}
+
+let workDir: string
+
+beforeEach(async () => {
+	workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-diff-command-'))
+})
+
+afterEach(async () => {
+	await fs.rm(workDir, { recursive: true, force: true })
+})
+
+const listTree = async (): Promise<string[]> => {
+	const entries: string[] = []
+	const visit = async (directory: string, prefix = ''): Promise<void> => {
+		for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+			const relative = path.join(prefix, entry.name)
+			entries.push(relative)
+			if (entry.isDirectory()) {
+				await visit(path.join(directory, entry.name), relative)
+			}
+		}
+	}
+	await visit(workDir)
+	return entries.sort()
+}
+
+const buildCommand = async (schema: Schema, existingMigration = false) => {
+	const migrationsDir = path.join(workDir, 'migrations')
+	const filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+	const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const schemaMigrator = new SchemaMigrator(modificationFactory)
+	const schemaDiffer = new SchemaDiffer(schemaMigrator)
+	if (existingMigration) {
+		await filesManager.createDirIfNotExist()
+		await filesManager.createFile(
+			JSON.stringify({
+				formatVersion: VERSION_LATEST,
+				modifications: schemaDiffer.diffSchemas(emptySchema, createSchema(ExistingModel)),
+			}),
+			'2024-01-01-120000-existing',
+		)
+	}
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const stateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+	const schemaVersionBuilder = new SchemaVersionBuilder(migrationsResolver, schemaMigrator, stateManager)
+	const loader: SchemaLoader = { loadSchema: async () => schema }
+	const executionConfirmations: boolean[] = []
+	const executor = {
+		execute: async (options: Parameters<MigrationExecutionFacade['execute']>[0]) => {
+			const migrations = await migrationsResolver.getMigrationFiles()
+			const pendingFiles = existingMigration ? migrations : migrations.slice(-1)
+			const pending: MigrationToExecuteOkStatus[] = pendingFiles.map(localMigration => ({
+				state: MigrationState.TO_EXECUTE_OK,
+				version: localMigration.version,
+				name: localMigration.name,
+				localMigration,
+			}))
+			executionConfirmations.push(
+				typeof options.requireConfirmation === 'function' ? options.requireConfirmation(pending) : options.requireConfirmation,
+			)
+			return true
+		},
+	}
+	const output = createTestOutput()
+	const command = new MigrationDiffCommand(
+		loader,
+		schemaVersionBuilder,
+		new MigrationCreator(filesManager, schemaDiffer),
+		new MigrationPrinter(new MigrationDescriber(modificationFactory), output.output),
+		executor,
+		stateManager,
+		migrationsResolver,
+	)
+	return { command, migrationsDir, executionConfirmations }
+}
+
+test('declining a diff leaves a new project filesystem untouched', async () => {
+	const { command } = await buildCommand(createSchema(BlogModel))
+	const before = await listTree()
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['no'])
+
+	const error = await command.run(['change'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+	expect(await listTree()).toStrictEqual(before)
+})
+
+test('executing a new diff requires a second confirmation when older migrations are pending', async () => {
+	const { command, executionConfirmations } = await buildCommand(createSchema(BlogModel), true)
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['yes'])
+
+	await command.run(['change', '--execute'], output)
+
+	expect(executionConfirmations).toStrictEqual([true])
+})
+
+test('executing a new diff does not require a redundant second confirmation when it is the only pending migration', async () => {
+	const { command, executionConfirmations } = await buildCommand(createSchema(BlogModel))
+	const { output } = createTestOutput({ stdinTty: true, stderrTty: true })
+	prompts.inject(['yes'])
+
+	await command.run(['change', '--execute'], output)
+
+	expect(executionConfirmations).toStrictEqual([false])
+})
+
+test('non-interactive diff refusal leaves a new project filesystem untouched', async () => {
+	const { command } = await buildCommand(createSchema(BlogModel))
+	const before = await listTree()
+	const { output } = createTestOutput({ stdinTty: false })
+
+	const error = await command.run(['change'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('TTY_UNAVAILABLE')
+	expect(error instanceof CliError ? error.exitCode : null).toBe(ExitCode.InputError)
+	expect(await listTree()).toStrictEqual(before)
+})
+
+test('an invalid diff returns a structured error without changing the filesystem', async () => {
+	const { command } = await buildCommand(invalidSchema, true)
+	const before = await listTree()
+	const { output, stdout } = createTestOutput()
+
+	const error = await command.run(['change', '--yes', '--json'], output).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('SCHEMA_INVALID')
+	expect(stdout.text).toBe('')
+	expect(await listTree()).toStrictEqual(before)
+})

package/tests/cases/unit/MigrationExecuteCommand.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test'
+import { MigrationExecuteCommand } from '../../../src/commands/migrations/MigrationExecuteCommand.js'
+import { MigrationExecutionFacade } from '../../../src/lib/migrations/MigrationExecutionFacade.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+
+type ExecuteOptions = Parameters<MigrationExecutionFacade['execute']>[0]
+
+const createCommand = (changed: boolean) => {
+	const calls: ExecuteOptions[] = []
+	const command = new MigrationExecuteCommand({
+		execute: async options => {
+			calls.push(options)
+			return changed
+		},
+	})
+	return { command, calls }
+}
+
+describe('MigrationExecuteCommand', () => {
+	test('reports the completed status and forwards execution flags in JSON mode', async () => {
+		const { command, calls } = createCommand(true)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(
+			await command.run(
+				['--json', '--yes', '--force', '--until', '2025-01-01-000001-first', '--no-snapshot'],
+				output,
+			),
+		).toBe(0)
+		expect(JSON.parse(stdout.text)).toStrictEqual({ status: 'completed', until: '2025-01-01-000001-first' })
+		expect(stderr.text).toBe('')
+		expect(calls).toStrictEqual([
+			{
+				force: true,
+				until: '2025-01-01-000001-first',
+				requireConfirmation: false,
+				useSnapshot: false,
+			},
+		])
+	})
+
+	test('reports a no-op as a quiet scalar', async () => {
+		const { command, calls } = createCommand(false)
+		const { output, stdout, stderr } = createTestOutput()
+
+		expect(await command.run(['--quiet', '--yes'], output)).toBe(0)
+		expect(stdout.text).toBe('noop\n')
+		expect(stderr.text).toBe('')
+		expect(calls).toStrictEqual([
+			{
+				force: undefined,
+				until: undefined,
+				requireConfirmation: false,
+				useSnapshot: true,
+			},
+		])
+	})
+})

package/tests/cases/unit/MigrationExecutionFacade.test.ts

@@ -1,81 +1,368 @@
-import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { afterEach, beforeAll, beforeEach, expect, test } from 'bun:test'
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
 import * as path from 'node:path'
-import { createSchema, SchemaDefinition as def } from '@contember/schema-definition'
-import { Schema } from '@contember/schema'
-import { SchemaStateManager } from '@contember/migrations-client'
+import chalk from 'chalk'
+import { GraphQlClient, GraphQlClientError } from '@contember/graphql-client'
+import {
+	ExecutedMigrationInfo,
+	isSchemaMigration,
+	JsonLoader,
+	MigrationDescriber,
+	MigrationExecutor,
+	MigrationFilesManager,
+	MigrationParser,
+	MigrationsResolver,
+	MigrationsStatusResolver,
+	ModificationHandlerFactory,
+	SchemaDiffer,
+	SchemaMigrator,
+	SchemaState,
+	SchemaStateManager,
+	SchemaVersionBuilder,
+	SnapshotFile,
+	SnapshotManager,
+	SystemClient,
+	VERSION_LATEST,
+} from '@contember/migrations-client'
+import { emptySchema } from '@contember/schema-utils'
+import { c, createSchema } from '@contember/schema-definition'
+import { calculateMigrationChecksum } from '@contember/schema-migrations'
+import { CliError, ExitCode } from '@contember/cli-common'
 import { MigrationExecutionFacade } from '../../../src/lib/migrations/MigrationExecutionFacade.js'
+import { MigrationPrinter } from '../../../src/lib/migrations/MigrationPrinter.js'
+import { MigrationSnapshotFacade } from '../../../src/lib/migrations/MigrationSnapshotFacade.js'
+import { MigrationsStatusFacade } from '../../../src/lib/migrations/MigrationsStatusFacade.js'
+import { RemoteProject } from '../../../src/lib/project/RemoteProject.js'
+import { RemoteProjectProvider } from '../../../src/lib/project/RemoteProjectProvider.js'
+import { SystemClientProvider } from '../../../src/lib/SystemClientProvider.js'
+import { TenantClientProvider } from '../../../src/lib/TenantClientProvider.js'
+import { TenantApiTransport } from '../../../src/lib/tenant/TenantApiTransport.js'
+import { TenantCreateProjectDetails, TenantCreateProjectResult, TenantProjectClient } from '../../../src/lib/tenant/clients/TenantProjectClient.js'
+import { createTestOutput } from '../../../../cli-common/tests/lib/testOutput.js'
+import prompts from 'prompts'
 
-namespace BlogModel {
-	export class Author {
-		name = def.stringColumn()
+type Event =
+	| { type: 'create-project'; details: TenantCreateProjectDetails | undefined }
+	| { type: 'list-executed' }
+	| { type: 'snapshot-lookup' }
+	| { type: 'snapshot-build' }
+	| { type: 'snapshot-apply' }
+	| { type: 'execute-migrations'; schemaState: SchemaState | undefined }
+
+class RecordingSystemClient extends SystemClient {
+	constructor(
+		private readonly events: Event[],
+		private readonly executedMigrations: ExecutedMigrationInfo[],
+		private readonly missingUntilCreated: boolean,
+	) {
+		super(new GraphQlClient({ url: 'http://system.test', apiToken: 'token' }))
+	}
+
+	override async listExecutedMigrations(): Promise<ExecutedMigrationInfo[]> {
+		this.events.push({ type: 'list-executed' })
+		if (this.missingUntilCreated && !this.events.some(event => event.type === 'create-project')) {
+			throw new GraphQlClientError(
+				'Project not found',
+				'bad request',
+				{ url: 'http://system.test', query: '', variables: {} },
+				new Response(null, { status: 404 }),
+			)
+		}
+		return this.executedMigrations
+	}
+
+	override async migrateFromSnapshot(...args: Parameters<SystemClient['migrateFromSnapshot']>): Promise<void> {
+		void args
+		this.events.push({ type: 'snapshot-apply' })
 	}
 }
 
-const aclWith = (role: string): Schema['acl'] => ({
-	roles: { [role]: { variables: {}, stages: '*', entities: {} } },
-})
+class RecordingSystemClientProvider extends SystemClientProvider {
+	constructor(private readonly client: SystemClient) {
+		super(new RemoteProjectProvider())
+	}
+
+	override get(): SystemClient {
+		return this.client
+	}
+}
+
+class RecordingTenantProjectClient extends TenantProjectClient {
+	constructor(private readonly events: Event[]) {
+		super(new TenantApiTransport(new GraphQlClient({ url: 'http://tenant.test', apiToken: 'token' })))
+	}
+
+	override async createProject(
+		slug: string,
+		ignoreExisting = false,
+		details?: TenantCreateProjectDetails,
+	): Promise<TenantCreateProjectResult | null> {
+		void slug
+		void ignoreExisting
+		this.events.push({ type: 'create-project', details })
+		return null
+	}
+}
+
+class RecordingTenantClientProvider extends TenantClientProvider {
+	constructor(private readonly client: TenantProjectClient) {
+		super(new RemoteProjectProvider())
+	}
+
+	override get(): TenantProjectClient {
+		return this.client
+	}
+}
 
-let migrationsDir: string
+class RecordingMigrationExecutor extends MigrationExecutor {
+	constructor(private readonly events: Event[]) {
+		super()
+	}
+
+	override async executeMigrations(args: Parameters<MigrationExecutor['executeMigrations']>[0]): Promise<void> {
+		this.events.push({ type: 'execute-migrations', schemaState: args.schemaState })
+	}
+}
+
+class RecordingSnapshotFacade extends MigrationSnapshotFacade {
+	constructor(
+		private readonly events: Event[],
+		...args: ConstructorParameters<typeof MigrationSnapshotFacade>
+	) {
+		super(...args)
+	}
+
+	override async getUsableSnapshot(executedMigrations: ExecutedMigrationInfo[]): Promise<SnapshotFile | null> {
+		this.events.push({ type: 'snapshot-lookup' })
+		return super.getUsableSnapshot(executedMigrations)
+	}
+
+	override async buildSnapshotInput(snapshot: SnapshotFile): ReturnType<MigrationSnapshotFacade['buildSnapshotInput']> {
+		this.events.push({ type: 'snapshot-build' })
+		return super.buildSnapshotInput(snapshot)
+	}
+}
+
+let workDir: string
+
+namespace ExecutionModel {
+	export class Article {
+		title = c.stringColumn()
+	}
+}
+
+beforeAll(() => {
+	chalk.level = 0
+})
 
 beforeEach(async () => {
-	migrationsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-exec-'))
-	await new SchemaStateManager(path.join(migrationsDir, 'state')).extractState({ ...createSchema(BlogModel), acl: aclWith('admin') })
+	workDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contember-exec-'))
 })
 
 afterEach(async () => {
-	await fs.rm(migrationsDir, { recursive: true, force: true })
+	await fs.rm(workDir, { recursive: true, force: true })
 })
 
-// Drives MigrationExecutionFacade.execute with a recording migration executor and a real state manager.
-// Returns the schemaState the executor was handed plus everything written to console.log.
-const runExecute = async (opts: { until?: string }) => {
-	const schemaStateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
-	let executedSchemaState: unknown = 'not-called'
-	const migrationExecutor = {
-		executeMigrations: async (args: any) => {
-			executedSchemaState = args.schemaState
-		},
+const createHarness = async (
+	{ state = false, migration = false, snapshot = false, remoteExecuted = false, remoteMissing = false, stdinTty = false } = {},
+) => {
+	const events: Event[] = []
+	const migrationsDir = path.join(workDir, 'migrations')
+	const filesManager = new MigrationFilesManager(migrationsDir, { json: new JsonLoader(new MigrationParser()) })
+	const modificationFactory = new ModificationHandlerFactory(ModificationHandlerFactory.defaultFactoryMap)
+	const schemaMigrator = new SchemaMigrator(modificationFactory)
+	const schemaDiffer = new SchemaDiffer(schemaMigrator)
+	if (migration) {
+		await filesManager.createDirIfNotExist()
+		await filesManager.createFile(
+			JSON.stringify({ formatVersion: VERSION_LATEST, modifications: schemaDiffer.diffSchemas(emptySchema, createSchema(ExecutionModel)) }),
+			'2024-01-01-120000-init',
+		)
 	}
-	const status = {
-		migrationsToExecute: [{ version: '2024-01-01-120000', name: '2024-01-01-120000-init', localMigration: {} }],
+	const migrationsResolver = new MigrationsResolver(filesManager)
+	const stateManager = new SchemaStateManager(path.join(migrationsDir, 'state'))
+	if (state) {
+		await stateManager.extractState(emptySchema)
 	}
-
-	const facade = new MigrationExecutionFacade(
-		{ get: () => ({ listExecutedMigrations: async () => [] }) } as any, // systemClientProvider
-		{ get: () => ({ createProject: async () => {} }) } as any, // tenantClientProvider
-		{ get: () => ({ name: 'p', token: 't', endpoint: 'e' }) } as any, // projectProvider
-		{} as any, // schemaVersionBuilder (only used in the describe prompt path)
-		{} as any, // migrationPrinter
-		migrationExecutor as any,
-		{ resolveMigrationsStatus: async () => status } as any,
-		schemaStateManager,
-		{ getUsableSnapshot: async () => null } as any, // migrationSnapshotFacade — these tests exercise the no-snapshot path
+	const schemaVersionBuilder = new SchemaVersionBuilder(migrationsResolver, schemaMigrator, stateManager)
+	const snapshotManager = new SnapshotManager(path.join(migrationsDir, 'snapshot.json'))
+	const io = createTestOutput({ stdinTty, stderrTty: stdinTty })
+	const snapshotFacade = new RecordingSnapshotFacade(
+		events,
+		migrationsResolver,
+		schemaVersionBuilder,
+		schemaDiffer,
+		schemaMigrator,
+		stateManager,
+		snapshotManager,
+		io.output,
 	)
-
-	const logs: string[] = []
-	const original = console.log
-	console.log = (...args: any[]) => logs.push(args.join(' '))
-	try {
-		await facade.execute({ requireConfirmation: false, ...opts })
-	} finally {
-		console.log = original
+	if (snapshot) {
+		const prepared = await snapshotFacade.prepare()
+		await snapshotFacade.write(prepared)
+		events.splice(0)
+	}
+	const executedMigrations: ExecutedMigrationInfo[] = []
+	if (remoteExecuted) {
+		const [localMigration] = await migrationsResolver.getMigrationFiles()
+		const content = await localMigration.getContent()
+		if (!isSchemaMigration(content)) {
+			throw new Error('Expected a schema migration')
+		}
+		executedMigrations.push({
+			name: localMigration.name,
+			version: localMigration.version,
+			formatVersion: content.formatVersion,
+			checksum: calculateMigrationChecksum(content),
+			executedAt: new Date(0),
+		})
 	}
-	return { executedSchemaState, logs }
+	const systemClient = new RecordingSystemClient(events, executedMigrations, remoteMissing)
+	const systemProvider = new RecordingSystemClientProvider(systemClient)
+	const tenantProvider = new RecordingTenantClientProvider(new RecordingTenantProjectClient(events))
+	const projectProvider = new RemoteProjectProvider()
+	projectProvider.setRemoteProject(new RemoteProject('project', 'http://api.test', 'token'))
+	const migrationPrinter = new MigrationPrinter(new MigrationDescriber(modificationFactory), io.output)
+	const statusFacade = new MigrationsStatusFacade(
+		systemProvider,
+		migrationsResolver,
+		new MigrationsStatusResolver(),
+		migrationPrinter,
+		io.output,
+	)
+	const facade = new MigrationExecutionFacade(
+		systemProvider,
+		tenantProvider,
+		projectProvider,
+		schemaVersionBuilder,
+		migrationPrinter,
+		new RecordingMigrationExecutor(events),
+		statusFacade,
+		stateManager,
+		snapshotFacade,
+		io.output,
+	)
+	return { events, facade, io }
 }
 
-test('does not push schema state when --until targets a specific migration, and warns', async () => {
-	const { executedSchemaState, logs } = await runExecute({ until: '2024-01-01-120000' })
+test('non-interactive state-only execution refuses before any mutation or request', async () => {
+	const { facade, events } = await createHarness({ state: true })
+
+	const error = await facade.execute({ requireConfirmation: true }).then(() => null, (reason: unknown) => reason)
+
+	expect(error).toBeInstanceOf(CliError)
+	expect(error instanceof CliError ? error.code : null).toBe('TTY_UNAVAILABLE')
+	expect(error instanceof CliError ? error.exitCode : null).toBe(ExitCode.InputError)
+	expect(events).toStrictEqual([])
+})
+
+test('declining state-only execution does not create a project or call the executor', async () => {
+	const { facade, events } = await createHarness({ state: true, stdinTty: true })
+	prompts.inject(['no'])
+
+	const error = await facade.execute({ requireConfirmation: true }).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+	expect(events).toStrictEqual([])
+})
+
+test('does not notify confirmation when interactive execution is declined', async () => {
+	const { facade } = await createHarness({ state: true, stdinTty: true })
+	let confirmations = 0
+	prompts.inject(['no'])
+
+	await facade.execute({
+		requireConfirmation: true,
+		onConfirmed: () => {
+			confirmations++
+		},
+	}).then(() => null, () => null)
+
+	expect(confirmations).toBe(0)
+})
+
+test('does not notify confirmation when there is no migration work to confirm', async () => {
+	const { facade, events } = await createHarness({ stdinTty: true })
+	let confirmations = 0
+
+	const result = await facade.execute({
+		requireConfirmation: true,
+		onConfirmed: () => {
+			confirmations++
+		},
+	})
 
-	expect(executedSchemaState).toBeUndefined()
-	expect(logs.some(it => it.includes('Warning') && it.includes('--until'))).toBe(true)
+	expect(result).toBe(false)
+	expect(confirmations).toBe(0)
+	expect(events).toStrictEqual([])
 })
 
-test('pushes schema state when no --until is given', async () => {
-	const { executedSchemaState, logs } = await runExecute({})
+test('an already-current project with local migrations returns without prompting or mutation', async () => {
+	const { facade, events } = await createHarness({ migration: true, remoteExecuted: true })
+	let confirmations = 0
+
+	const result = await facade.execute({
+		requireConfirmation: true,
+		onConfirmed: () => {
+			confirmations++
+		},
+	})
+
+	expect(result).toBe(false)
+	expect(confirmations).toBe(0)
+	expect(events).toStrictEqual([{ type: 'list-executed' }])
+})
+
+test('declining with a usable snapshot neither builds nor applies it', async () => {
+	const { facade, events } = await createHarness({ migration: true, snapshot: true, stdinTty: true })
+	prompts.inject(['no'])
+
+	const error = await facade.execute({ requireConfirmation: true }).then(() => null, (reason: unknown) => reason)
+
+	expect(error instanceof CliError ? error.code : null).toBe('OPERATION_ABORTED')
+	expect(events).toStrictEqual([{ type: 'list-executed' }])
+})
+
+test('confirmed snapshot execution creates a tokenless project before building and applying the snapshot', async () => {
+	const { facade, events } = await createHarness({ migration: true, snapshot: true, remoteMissing: true, stdinTty: true })
+	prompts.inject(['yes'])
+
+	await facade.execute({ requireConfirmation: true })
+
+	const types = events.map(event => event.type)
+	expect(types.indexOf('list-executed')).toBeLessThan(types.indexOf('create-project'))
+	expect(events.find(event => event.type === 'create-project')).toStrictEqual({
+		type: 'create-project',
+		details: { noDeployToken: true },
+	})
+	expect(types.indexOf('snapshot-build')).toBeGreaterThan(types.indexOf('create-project'))
+	expect(types.indexOf('snapshot-apply')).toBeGreaterThan(types.indexOf('snapshot-build'))
+	expect(types.indexOf('execute-migrations')).toBeGreaterThan(types.indexOf('snapshot-apply'))
+})
+
+test('confirmed state-only execution reaches the executor with schema state', async () => {
+	const { facade, events } = await createHarness({ state: true, stdinTty: true })
+	prompts.inject(['yes'])
+
+	await facade.execute({ requireConfirmation: true })
+
+	expect(events[0]).toStrictEqual({ type: 'create-project', details: { noDeployToken: true } })
+	const execution = events.find(event => event.type === 'execute-migrations')
+	expect(execution?.type === 'execute-migrations' ? execution.schemaState : undefined).toBeDefined()
+})
+
+test('notifies confirmation once after interactive execution is accepted', async () => {
+	const { facade } = await createHarness({ state: true, stdinTty: true })
+	let confirmations = 0
+	prompts.inject(['yes'])
+
+	await facade.execute({
+		requireConfirmation: true,
+		onConfirmed: () => {
+			confirmations++
+		},
+	})
 
-	expect(executedSchemaState).toBeDefined()
-	expect(Object.keys((executedSchemaState as any).acl.roles)).toStrictEqual(['admin'])
-	expect(logs.some(it => it.includes('Warning'))).toBe(false)
+	expect(confirmations).toBe(1)
 })