@pixlcore/xycli 1.0.0

package/test/api-validation.test.js

@@ -0,0 +1,170 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const Path = require('node:path');
+const utils = require('../lib/utils.js');
+const { loadTestConfig, createCheck, createTempDir, xy, json, call, cleanupFixtures } = require('./helpers/common.js');
+
+function createValidationContext() {
+	// The production app mixes every utility into one object.  Reproduce only the
+	// fatal-error behavior needed to exercise the validator without starting CLI.
+	return {
+		...utils,
+		die(message) { throw new Error(message); }
+	};
+}
+
+test('Levenshtein distance handles edits and empty strings', () => {
+	assert.equal(utils.getLevenshteinDistance('notes', 'notess'), 1);
+	assert.equal(utils.getLevenshteinDistance('kitten', 'sitting'), 3);
+	assert.equal(utils.getLevenshteinDistance('title', 'titel'), 2);
+	assert.equal(utils.getLevenshteinDistance('', 'event'), 5);
+	assert.equal(utils.getLevenshteinDistance('plugin', 'plugin'), 0);
+});
+
+test('closest string suggestions require one unambiguous nearby match', () => {
+	assert.equal(utils.findClosestString('notess', ['id', 'title', 'notes']), 'notes');
+	assert.equal(utils.findClosestString('titel', ['id', 'title', 'notes']), 'title');
+	assert.equal(utils.findClosestString('completely_unknown', ['id', 'title', 'notes']), '');
+	assert.equal(utils.findClosestString('a', ['b', 'c']), '');
+});
+
+test('body arguments always remain opaque strings', t => {
+	loadTestConfig();
+	const temp = createTempDir(t, 'xycli-body-arg-test-');
+	const body = '{\n\t"message": "opaque JSON text"\n}\n';
+	const file = Path.join(temp, 'body.json');
+	fs.writeFileSync(file, body);
+
+	assert.equal(json(['api', 'unused', '--body', body, '--dry']).body, body);
+	assert.equal(json(['api', 'unused', '--body', '@-', '--dry'], { input: body }).body, body);
+	assert.equal(json(['api', 'unused', '--body', '@' + file, '--dry']).body, body);
+});
+
+test('standard API validation accepts documented and request-only properties', () => {
+	const context = createValidationContext();
+	const requests = {
+		createAlert: { title: 'Alert', expression: '1', message: 'Yes', exclusive_actions: true },
+		updateApiKey: { id: 'key', max_per_sec: 5, description: 'Build key' },
+		createBucket: { title: 'Bucket', data: { arbitrary_nested_key: true } },
+		updateCategory: { id: 'category', actions: [{ arbitrary_nested_key: true }] },
+		createChannel: { title: 'Channel', max_per_day: 10 },
+		updateEvent: { id: 'event', params: { notess: 'Nested keys are allowed' }, update_state: { cursor: 1234 } },
+		createMonitor: { title: 'Monitor', source: 'cpu.currentLoad', divide_by_delta: true },
+		updatePlugin: { id: 'plugin', marketplace: { id: 'author/repo', version: 'v1.0.0' } },
+		createSecret: { title: 'Vault', fields: [{ name: 'TOKEN', value: 'Opaque nested value' }], web_hooks: ['hook'] },
+		updateTag: { id: 'tag', icon: 'tag-outline', notes: 'Tag notes' },
+		createTicket: { subject: 'Ticket', status: 'draft', body: '{ "opaque": true }', assignees: ['admin'] },
+		createWebHook: { title: 'Hook', url: 'https://example.com', method: 'POST', headers: [{ name: 'X-Test', value: 'yes' }] }
+	};
+	
+	Object.entries(requests).forEach( ([method, request]) => {
+		assert.doesNotThrow(() => context.validateStandardAPIRequest(method, request), method);
+	});
+	
+	// APIs outside the create/update CRUD rules retain normal pass-through behavior.
+	assert.doesNotThrow(() => context.validateStandardAPIRequest('runEvent', { arbitrary: true }));
+});
+
+test('standard API validation rejects unknown properties with careful suggestions', () => {
+	const context = createValidationContext();
+	assert.throws(
+		() => context.validateStandardAPIRequest('updateEvent', { id: 'event', notess: 'Typo' }),
+		/Unsupported property for update_event: "notess"\. Did you mean "notes"\?/
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('createPlugin', { title: 'Plugin', completely_unknown: true }),
+		/^Error: Unsupported property for create_plugin: "completely_unknown"\.$/
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('updateEvent', { id: 'event', sync: true }),
+		/Unsupported property for update_event: "sync"\./
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('updateSecret', { id: 'vault', notess: 'Typo' }),
+		/Unsupported property for update_secret: "notess"\. Did you mean "notes"\?/
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('createTag', { title: 'Tag', notess: 'Typo' }),
+		/Unsupported property for create_tag: "notess"\. Did you mean "notes"\?/
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('updateTicket', { id: 'ticket', subjec: 'Typo' }),
+		/Unsupported property for update_ticket: "subjec"\. Did you mean "subject"\?/
+	);
+	assert.throws(
+		() => context.validateStandardAPIRequest('updateWebHook', { id: 'hook', notess: 'Typo' }),
+		/Unsupported property for update_web_hook: "notess"\. Did you mean "notes"\?/
+	);
+});
+
+test('event CLI rejects phantom top-level properties before persistence', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	const stamp = Date.now();
+	const prefix = 'cli_api_validation_' + stamp;
+	const invalidID = prefix + '_invalid';
+	const eventID = prefix + '_event';
+	const title = 'CLI API Validation ' + stamp;
+	const eventIDs = new Set([invalidID, eventID]);
+	
+	try {
+		const multiple = await call('getMultiple', { lists: 'all' });
+		const category = multiple.categories[0];
+		const plugin = multiple.plugins.find( plugin => plugin.type == 'event' );
+		const group = multiple.groups[0];
+		assert.ok(category && plugin && group, 'Category, Event Plugin and server group required');
+		
+		const baseArgs = [
+			'--title', title, '--enabled', 'false', '--category', category.id,
+			'--plugin', plugin.id, '--targets', JSON.stringify([group.id]), '--triggers', '[]',
+			'--params.seed', 'Original value'
+		];
+		
+		await check('create typo is rejected with a suggestion', () => {
+			const output = xy(['event', 'create', '--id', invalidID, ...baseArgs, '--notess', 'Typo'], { fail: true });
+			assert.match(output, /Unsupported property for create_event: "notess"\. Did you mean "notes"\?/);
+		});
+		
+		await check('rejected create persists nothing', async () => {
+			const rows = (await call('getEvents', {})).rows;
+			assert.ok(!rows.some(event => event.id == invalidID));
+		});
+		
+		xy(['event', 'create', '--id', eventID, ...baseArgs, '--notes', 'Original notes']);
+		await call('updateEvent', { id: eventID, future_property: { enabled: true } });
+		
+		await check('update typo is rejected with a suggestion', () => {
+			const output = xy(['event', 'update', eventID, '--notess', 'Replacement notes'], { fail: true });
+			assert.match(output, /Unsupported property for update_event: "notess"\. Did you mean "notes"\?/);
+		});
+		
+		await check('rejected update leaves the stored event clean', () => {
+			const event = json(['event', eventID]);
+			assert.equal(event.notes, 'Original notes');
+			assert.ok(!Object.prototype.hasOwnProperty.call(event, 'notess'));
+			assert.deepEqual(event.future_property, { enabled: true });
+		});
+		
+		await check('sparse update ignores and preserves future server properties', () => {
+			xy(['event', 'update', eventID, '--notes', 'Replacement notes']);
+			const event = json(['event', eventID]);
+			assert.equal(event.notes, 'Replacement notes');
+			assert.deepEqual(event.future_property, { enabled: true });
+		});
+		
+		await check('nested arbitrary properties preserve their saved siblings', () => {
+			const request = json(['event', 'update', eventID, '--params.notess', 'Nested value', '--dry']);
+			assert.deepEqual(request, {
+				params: { seed: 'Original value', notess: 'Nested value' },
+				id: eventID
+			});
+			assert.ok(!Object.prototype.hasOwnProperty.call(request, 'future_property'));
+		});
+	}
+	finally {
+		await cleanupFixtures([
+			{ list: 'events', method: 'deleteEvent', match: event => eventIDs.has(event.id) }
+		]);
+	}
+});

package/test/categories.test.js

@@ -0,0 +1,246 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const Path = require('node:path');
+const { loadTestConfig, createCheck, createTempDir, xy, json, call, cleanupFixtures } = require('./helpers/common.js');
+
+test('categories', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// Disposable CLI integration checks against the configured local xyOps server.
+	const id = 'cli_cat_test_' + Date.now();
+	const title = 'CLI Category Test ' + id;
+	const temp = createTempDir(t, 'xycli-category-test-');
+	const categories = new Set([id]);
+	const events = new Set();
+	
+	async function get() {
+		return (await call('getCategory', { id })).category;
+	}
+	try {
+		const action = { type: 'email', enabled: true, condition: 'success', users: ['admin'] };
+		const limit = { type: 'time', enabled: true, duration: 300, abort: true };
+		let preview = json(['category', 'create', '--id', id, '--title', title, '--color', 'blue', '--limit', JSON.stringify(limit), '--dry']);
+		
+		await check('dry create retains named color and resource limit', () => {
+			assert.equal(preview.color, 'blue');
+			assert.deepEqual(preview.limits, [limit]);
+		});
+		
+		await check('dry create makes no category', () => assert.equal(json(['categories', '--id', id]).length, 0));
+		
+		let created = json(['category', 'create', '--id', id, '--title', title, '--notes', 'Hello', '--color', 'blue', '--icon', 'folder-outline', '--action', JSON.stringify(action), '--limit', JSON.stringify(limit)]);
+		
+		await check('create persists defaults and complete configuration', () => {
+			assert.equal(created.id, id);
+			assert.equal(created.enabled, true);
+			assert.equal(created.color, 'blue');
+			assert.equal(created.notes, 'Hello');
+			assert.equal(created.revision, 1);
+			assert.deepEqual(created.actions, [action]);
+			assert.deepEqual(created.limits, [limit]);
+		});
+		
+		await check('get by exact ID', () => assert.deepEqual(json(['category', id]), created));
+		
+		await check('get by fuzzy title', () => assert.equal(json(['category', 'get', '--title', title.toLowerCase()]).id, id));
+		
+		await check('list search and combined filters', () => assert.equal(json(['categories', title, '--enabled', 'true', '--color', 'blue']).length, 1));
+		
+		await check('list no matches', () => assert.deepEqual(json(['categories', id, '--enabled', 'false']), []));
+		
+		await check('list sort order', () => {
+			const rows = json(['categories']);
+			assert.ok(rows.every((row, idx) => !idx || (row.sort_order || 0) >= (rows[idx - 1].sort_order || 0)));
+		});
+		
+		await check('human pagination and suggestions', () => {
+			const output = xy(['category', 'list', '--limit', '1', '--page', '2']);
+			assert.match(output, /page 2 of/);
+			assert.match(output, /Other Commands:/);
+		});
+		
+		let detail = xy(['category', id]);
+		fs.writeFileSync(Path.join(temp, 'category-detail.txt'), detail);
+		
+		await check('human detail renders indexed actions and limits', () => {
+			assert.match(detail, /CATEGORY NOTES[\s\S]*Hello/);
+			assert.match(detail, /CATEGORY ACTIONS/);
+			assert.match(detail, /CATEGORY LIMITS/);
+			assert.match(detail, /│ # │/);
+			assert.match(detail, /Send Email/);
+			assert.match(detail, /Max Run Time/);
+		});
+		
+		await check('human update shows target and parsed data', () => {
+			const output = xy(['category', 'update', id, '--notes', 'Preview', '--dry']);
+			assert.match(output, /UPDATE CATEGORY/);
+			assert.match(output, new RegExp('Category ID:\\s+' + id));
+			assert.match(output, /UPDATE DATA[\s\S]*"notes": "Preview"/);
+		});
+		
+		preview = json(['category', 'update', id, '--notes', 'Preview', '--dry']);
+		
+		await check('sparse update request excludes unrelated metadata', () => assert.deepEqual(preview, { id, notes: 'Preview' }));
+		
+		await check('dry update leaves revision unchanged', () => assert.equal(json(['category', id]).revision, 1));
+		
+		json(['category', 'update', id, '--enabled', 'false', '--actions.0.condition', 'complete', '--actions.0.enabled', 'true', '--limits.0.duration', '600']);
+		let updated = await get();
+		
+		await check('dotted update preserves other fields and increments revision', () => {
+			assert.equal(updated.enabled, false);
+			assert.equal(updated.revision, 2);
+			assert.equal(updated.created, created.created);
+			assert.deepEqual(updated.actions, [{ ...action, condition: 'complete' }]);
+			assert.deepEqual(updated.limits, [{ ...limit, duration: 600 }]);
+			assert.equal(updated.notes, 'Hello');
+		});
+		
+		json(['category', 'update', id, '--action', JSON.stringify(action), '--limit', JSON.stringify(limit)]);
+		updated = await get();
+		
+		await check('singular append preserves existing entries', () => {
+			assert.equal(updated.actions.length, 2);
+			assert.equal(updated.limits.length, 2);
+			assert.equal(updated.limits[0].duration, 600);
+		});
+		
+		json(['category', 'update', '--id', id, '--action', JSON.stringify(action), '--action', JSON.stringify({ ...action, condition: 'error' }), '--limit', JSON.stringify(limit), '--limit', JSON.stringify({ ...limit, duration: 900 })]);
+		updated = await get();
+		
+		await check('repeated singular appends', () => {
+			assert.equal(updated.actions.length, 4);
+			assert.equal(updated.limits.length, 4);
+			assert.equal(updated.limits[3].duration, 900);
+		});
+		
+		json(['category', 'update', id, '--actions.0.condition', 'warning', '--actions', JSON.stringify([action]), '--limits', '[]']);
+		updated = await get();
+		
+		await check('array replacement precedes dotted edits regardless of order', () => {
+			assert.deepEqual(updated.actions, [{ ...action, condition: 'warning' }]);
+			assert.deepEqual(updated.limits, []);
+		});
+		
+		json(['category', 'update', id, '--actions', '[]', '--limits', '[]']);
+		
+		await check('arrays can be cleared', () => assert.deepEqual(json(['category', id]).actions, []));
+		
+		const actionFile = Path.join(temp, 'action.json');
+		fs.writeFileSync(actionFile, JSON.stringify(action));
+		json(['category', 'update', id, '--action', '@' + actionFile, '--limit', '@-'], { input: JSON.stringify(limit) });
+		
+		await check('file action and stdin limit', () => {
+			const row = json(['category', id]);
+			assert.deepEqual(row.actions, [action]);
+			assert.deepEqual(row.limits, [limit]);
+		});
+		
+		json(['category', 'update', id, '--json', '@-'], { input: JSON.stringify({ notes: 'From stdin', color: 'green', sort_order: 10000 }) });
+		
+		await check('complete stdin request and sort order', () => {
+			const row = json(['category', id]);
+			assert.equal(row.notes, 'From stdin');
+			assert.equal(row.color, 'green');
+			assert.equal(row.sort_order, 10000);
+		});
+		
+		json(['category', 'update', id, '--color', 'purple']);
+		
+		await check('named color survives direct update', () => assert.equal(json(['category', id]).color, 'purple'));
+		
+		const revision = (await get()).revision;
+		await check('unconfirmed delete shows target and warning toast', () => {
+			for (const args of [['delete', id], ['delete', id, '--confirm', 'false']]) {
+				const output = xy(['category', ...args]);
+				assert.match(output, /DELETE CATEGORY/);
+				assert.match(output, /⚠️[\s\S]*Please confirm the category delete/);
+			}
+		});
+		
+		for (const args of [
+			['update', id, '--actions.99.enabled', 'true'],
+			['update', id, '--actions.0.__proto__.polluted', 'true'],
+			['update', id, '--enabled', 'perhaps'],
+			['update', id, '--title', ' '],
+			['update', id, '--actions', '{}'],
+			['update', id, '--limit', '3'],
+			['update', id, '--action', 'garbage'],
+			['update', id, '--revision', '900'],
+			['update', id, '--sort_order', '-1'],
+			['update', id, '--unknown', 'value'],
+			['update', id, '--id', 'general', '--notes', 'Wrong target'],
+			['update', title, '--enabled', 'true'],
+			['update', id],
+			['delete', title, '--confirm']
+		]) {
+			await check('reject ' + args.slice(0, 3).join(' '), () => xy(['category', ...args], { fail: true }));
+		}
+		
+		await check('invalid commands make no changes', () => assert.equal(json(['category', id]).revision, revision));
+		
+		await check('server action validation is surfaced', () => assert.match(xy(['category', 'update', id, '--action', JSON.stringify({ ...action, condition: 'invalid' })], { fail: true }), /Invalid condition/));
+		
+		// Keep test events disabled with no triggers so category email actions never fire.
+		const eventTitle = 'Category CLI Test Event ' + id;
+		const eventID = 'cli_cat_event_' + Date.now();
+		events.add(eventID);
+		xy(['event', 'create', '--id', eventID, '--title', eventTitle, '--category', id, '--enabled', 'false', '--triggers', '[]', '--params.script', 'echo category-test', '--limit', JSON.stringify(limit)]);
+		
+		await check('event create --limit regression', () => assert.ok(json(['event', eventID]).limits.some(item => item.duration === 300)));
+		
+		xy(['event', 'update', eventID, '--limit', JSON.stringify({ ...limit, duration: 1200 })]);
+		
+		await check('event update --limit regression', () => assert.ok(json(['event', eventID]).limits.some(item => item.duration === 1200)));
+		
+		await check('category deletion refuses assigned events', () => assert.match(xy(['category', 'delete', id, '--confirm'], { fail: true }), /Still in use/));
+		
+		await call('deleteEvent', { id: eventID });
+		events.delete(eventID);
+		json(['category', 'delete', id, '--confirm', '--dry']);
+		
+		await check('dry deletion preserves category', () => assert.equal(json(['category', id]).id, id));
+		
+		json(['category', 'delete', id, '--confirm']);
+		categories.delete(id);
+		
+		await check('deleted category disappears', () => assert.deepEqual(json(['categories', '--id', id]), []));
+		
+		await check('get deleted category fails', () => xy(['category', 'get', id], { fail: true }));
+		
+		const auto = json(['category', 'create', '--title', title]);
+		categories.add(auto.id);
+		
+		await check('server-generated ID', () => assert.match(auto.id, /^ca[a-z0-9_]+$/));
+		
+		const requestFile = Path.join(temp, 'category.json');
+		fs.writeFileSync(requestFile, JSON.stringify({ title: title + ' imported', enabled: false, actions: [action], limits: [limit] }));
+		const imported = json(['category', 'create', '--json', '@' + requestFile]);
+		categories.add(imported.id);
+		
+		await check('complete JSON file creation', () => {
+			assert.equal(imported.enabled, false);
+			assert.deepEqual(imported.limits, [limit]);
+		});
+		
+		for (const topic of ['categories', 'category', 'category list', 'category get', 'category create', 'category update', 'category delete']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+		
+		await check('human create suggestions', () => {
+			const humanID = id + '_human';
+			categories.add(humanID);
+			assert.match(xy(['category', 'create', '--id', humanID, '--title', title]), /Other Commands:/);
+		});
+	}
+	finally {
+		// Events must be removed before their category. Titles also catch an
+		// auto-generated ID if a create succeeded before its output was parsed.
+		await cleanupFixtures([
+			{ list: 'events', method: 'deleteEvent', match: item => events.has(item.id) },
+			{ list: 'categories', method: 'deleteCategory', match: item => categories.has(item.id) || item.title.startsWith(title) }
+		]);
+	}
+});

package/test/channels.test.js

@@ -0,0 +1,209 @@
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const Path = require('node:path');
+const { loadTestConfig, createCheck, createTempDir, xy, json, call, call: apiCall, cleanupFixtures } = require('./helpers/common.js');
+
+test('channels', async t => {
+	loadTestConfig();
+	const check = createCheck(t);
+	
+	// Disposable live CLI lifecycle.  Configure channels without invoking them.
+	const id = 'cli_channel_test_' + Date.now();
+	const title = 'CLI Channel Test ' + id;
+	const ids = new Set([id]);
+	const temp = createTempDir(t, 'xycli-channel-test-');
+	try {
+		const original = (await apiCall('getChannels')).rows;
+		const events = (await apiCall('getEvents')).rows;
+		const hooks = (await apiCall('getWebHooks')).rows;
+		const eventID = events[0] ? events[0].id : '';
+		const hookID = hooks[0] ? hooks[0].id : '';
+		
+		await check('dry creation fills defaults', () => {
+			const req = json(['channel', 'create', '--id', id, '--title', title, '--dry']);
+			assert.equal(req.enabled, true);
+			assert.equal(req.max_per_day, 0);
+			assert.deepEqual(req.users, []);
+		});
+		
+		await check('dry creation does not persist', () => assert.deepEqual(json(['channels', '--id', id]), []));
+		
+		const created = json(['channel', 'create', '--id', id, '--title', title, '--enabled', 'false', '--users', 'admin,oncall', '--user', 'admin', '--user', 'backup', '--email', 'ops@example.invalid,sre@example.invalid', '--web_hook', hookID, '--run_event', eventID, '--sound', 'attention-3.mp3', '--icon', 'bullhorn-outline', '--max_per_day', '25', '--notes', 'Hello']);
+		
+		await check('create persists all fields and deduplicates users', () => {
+			assert.equal(created.id, id);
+			assert.equal(created.enabled, false);
+			assert.equal(created.revision, 1);
+			assert.deepEqual(created.users, ['admin', 'oncall', 'backup']);
+			assert.equal(created.max_per_day, 25);
+			assert.equal(created.web_hook, hookID);
+			assert.equal(created.run_event, eventID);
+			assert.equal(created.sound, 'attention-3.mp3');
+			assert.equal(created.notes, 'Hello');
+			assert.equal(created.icon, 'bullhorn-outline');
+		});
+		
+		await check('exact ID get', () => assert.deepEqual(json(['channel', id]), created));
+		
+		await check('fuzzy title get', () => assert.equal(json(['channel', 'get', '--title', title.toLowerCase()]).id, id));
+		
+		await check('named ID get', () => assert.equal(json(['channel', 'get', '--id', id]).id, id));
+		
+		await check('combined list filters', () => assert.equal(json(['channels', title, '--enabled', 'false', '--user', 'admin']).length, 1));
+		
+		await check('username filter is exact', () => assert.equal(json(['channels', title, '--user', 'adm']).length, 0));
+		
+		await check('repeated username filters', () => assert.equal(json(['channel', 'list', title, '--user', 'admin', '--user', 'backup']).length, 1));
+		
+		await check('JSON list ignores pagination as filters', () => assert.deepEqual(json(['channels', '--id', id, '--limit', '1', '--page', '2']), [created]));
+		
+		await check('alphabetical list ordering', () => {
+			const rows = json(['channels']);
+			assert.ok(rows.every((row, idx) => !idx || rows[idx-1].title.toLowerCase().localeCompare(row.title.toLowerCase()) <= 0));
+		});
+		
+		await check('human list pagination and suggestions', () => {
+			const out = xy(['channels', '--limit', '1', '--page', '2']);
+			assert.match(out, /page 2 of/);
+			assert.match(out, /Other Commands:/);
+		});
+		
+		await check('empty human list', () => assert.match(xy(['channels', id, '--enabled', 'true']), /No filtered notification channels found/));
+		
+		await check('human detail covers configuration', () => {
+			const out = xy(['channel', id]);
+			fs.writeFileSync(Path.join(temp, 'detail.txt'), out);
+			for (const label of ['Channel Summary', 'Users', 'Web Hook', 'Run Event', 'Sound', 'Daily Cap', 'Revision', 'Channel Notes', 'Hello']) assert.ok(out.toLowerCase().includes(label.toLowerCase()));
+		});
+		
+		await check('human update shows target and parsed data', () => {
+			const out = xy(['channel', 'update', id, '--notes', 'Preview', '--dry']);
+			assert.match(out, /UPDATE CHANNEL/);
+			assert.match(out, new RegExp('Channel ID:\\s+' + id));
+			assert.match(out, /UPDATE DATA[\s\S]*"notes": "Preview"/);
+		});
+		
+		await check('sparse dry update excludes unrelated fields', () => assert.deepEqual(json(['channel', 'update', id, '--notes', 'Preview', '--dry']), { notes: 'Preview', id }));
+		
+		await check('dry update keeps revision', () => assert.equal(json(['channel', id]).revision, 1));
+		
+		json(['channel', 'update', id, '--users.1', 'replacement', '--user', 'second', '--user', 'admin', '--enabled', 'true', '--max_per_day', '10']);
+		
+		await check('indexed edits and appends preserve other fields', () => {
+			const row = json(['channel', id]);
+			assert.deepEqual(row.users, ['admin', 'replacement', 'backup', 'second']);
+			assert.equal(row.revision, 2);
+			assert.equal(row.enabled, true);
+			assert.equal(row.max_per_day, 10);
+			assert.equal(row.notes, 'Hello');
+			assert.equal(row.created, created.created);
+		});
+		
+		json(['channel', 'update', id, '--users.0', 'changed', '--users', '["first","second"]', '--user', 'third']);
+		
+		await check('list replacement precedes indexed edits', () => assert.deepEqual(json(['channel', id]).users, ['changed', 'second', 'third']));
+		
+		const userFile = Path.join(temp, 'users.json');
+		fs.writeFileSync(userFile, '["admin","oncall"]');
+		json(['channel', 'update', '--id', id, '--users', '@' + userFile]);
+		
+		await check('user list from JSON file', () => assert.deepEqual(json(['channel', id]).users, ['admin', 'oncall']));
+		
+		json(['channel', 'update', id, '--json', '@-'], { input: JSON.stringify({ notes: 'From stdin', max_per_day: 0, enabled: false }) });
+		
+		await check('complete stdin update', () => {
+			const row = json(['channel', id]);
+			assert.equal(row.notes, 'From stdin');
+			assert.equal(row.max_per_day, 0);
+			assert.equal(row.enabled, false);
+		});
+		
+		json(['channel', 'update', id, '--users', '[]', '--email', '', '--web_hook', '', '--run_event', '', '--sound', '', '--icon', '', '--notes', '']);
+		
+		await check('clear optional recipients and targets', () => {
+			const row = json(['channel', id]);
+			assert.deepEqual(row.users, []);
+			for (const key of ['email', 'web_hook', 'run_event', 'sound', 'icon', 'notes']) assert.equal(row[key], '');
+		});
+		
+		const revision = json(['channel', id]).revision;
+		await check('unconfirmed delete shows target and warning toast', () => {
+			for (const args of [['delete', id], ['delete', id, '--confirm', 'false']]) {
+				const out = xy(['channel', ...args]);
+				assert.match(out, /DELETE CHANNEL/);
+				assert.match(out, /⚠️[\s\S]*Please confirm the channel delete/);
+			}
+		});
+		
+		for (const args of [
+			['update', id, '--users.99', 'admin'], ['update', id, '--users.__proto__.x', 'bad'],
+			['update', id, '--users', '{}'], ['update', id, '--users', '[5]'], ['update', id, '--user', ''],
+			['update', id, '--title', ' '], ['update', id, '--enabled', 'perhaps'], ['update', id, '--max_per_day', '-1'],
+			['update', id, '--max_per_day', '1.5'], ['update', id, '--sound', 'bad.wav'], ['update', id, '--email', 'true'],
+			['update', id, '--revision', '99'], ['update', id, '--unknown', 'x'], ['update', id],
+			['update', title, '--notes', 'wrong'], ['update', id, '--id', 'sev1', '--notes', 'wrong'],
+			['delete', title, '--confirm']
+		]) await check('reject ' + args.slice(0,3).join(' '), () => xy(['channel', ...args], { fail: true }));
+		
+		await check('rejected requests leave revision unchanged', () => assert.equal(json(['channel', id]).revision, revision));
+		
+		await check('duplicate channel ID error is surfaced', () => assert.match(xy(['channel', 'create', '--id', id, '--title', title], { fail:true }), /already exists/));
+		
+		const auto = json(['channel', 'create', '--title', title]);
+		ids.add(auto.id);
+		
+		await check('automatic ID and default settings', () => {
+			assert.match(auto.id, /^ch/);
+			assert.equal(auto.enabled, true);
+			assert.equal(auto.max_per_day, 0);
+		});
+		
+		const reqFile = Path.join(temp, 'channel.json');
+		fs.writeFileSync(reqFile, JSON.stringify({ title: title + ' file', users: ['admin'], enabled: false }));
+		const imported = json(['channel', 'create', '--json', '@' + reqFile]);
+		ids.add(imported.id);
+		
+		await check('complete creation from JSON file', () => {
+			assert.deepEqual(imported.users, ['admin']);
+			assert.equal(imported.enabled, false);
+		});
+		
+		const humanID = id + '_human';
+		ids.add(humanID);
+		
+		await check('human creation suggestions', () => assert.match(xy(['channel', 'create', '--id', humanID, '--title', title]), /Other Commands:/));
+		
+		// Remove auxiliary fixtures before checking fuzzy searches after deletion.
+		for (const channelID of Array.from(ids)) {
+			if (channelID === id) continue;
+			json(['channel', 'delete', channelID, '--confirm']);
+			ids.delete(channelID);
+		}
+		
+		await check('dry delete request', () => assert.deepEqual(json(['channel', 'delete', id, '--confirm', '--dry']), { id }));
+		
+		await check('dry delete leaves channel', () => assert.equal(json(['channel', id]).id, id));
+		
+		json(['channel', 'delete', id, '--confirm']);
+		ids.delete(id);
+		
+		await check('delete removes channel', () => assert.deepEqual(json(['channels', '--id', id]), []));
+		
+		await check('get after deletion fails', () => xy(['channel', id], { fail:true }));
+		
+		for (const topic of ['channels', 'channel', 'channel list', 'channel get', 'channel create', 'channel update', 'channel delete']) {
+			await check('help ' + topic, () => assert.ok(xy(['help', ...topic.split(' ')]).length > 100));
+		}
+		
+		await check('existing channels remain unchanged', () => {
+			const now = json(['channels']);
+			for (const channel of original) assert.deepEqual(now.find(item => item.id === channel.id), channel);
+		});
+	}
+	finally {
+		await cleanupFixtures([
+			{ list: 'channels', method: 'deleteChannel', match: item => ids.has(item.id) || item.title.startsWith(title) }
+		]);
+	}
+});