runspec-node 0.3.0

package/tests/test_types.test.ts

@@ -0,0 +1,110 @@
+import { coerce, registerType, listTypes } from '../src/types';
+import type { ArgSpec } from '../src/models';
+
+function spec(overrides: Partial<ArgSpec> = {}): ArgSpec {
+  return { name: 'test', ...overrides } as ArgSpec;
+}
+
+// ── str ───────────────────────────────────────────────────────────────────────
+
+test('coerces string', () => {
+  expect(coerce('hello', spec({ type: 'str' }))).toBe('hello');
+});
+
+test('coerces number to string', () => {
+  expect(coerce(42, spec({ type: 'str' }))).toBe('42');
+});
+
+// ── int ───────────────────────────────────────────────────────────────────────
+
+test('coerces integer string', () => {
+  expect(coerce('42', spec({ type: 'int' }))).toBe(42);
+});
+
+test('coerces number to int', () => {
+  expect(coerce(10, spec({ type: 'int' }))).toBe(10);
+});
+
+test('rejects float string as int', () => {
+  expect(() => coerce('3.14', spec({ type: 'int' }))).toThrow();
+});
+
+test('int respects range', () => {
+  expect(() => coerce('50', spec({ type: 'int', range: [1, 32] }))).toThrow();
+});
+
+test('int within range passes', () => {
+  expect(coerce('4', spec({ type: 'int', range: [1, 32] }))).toBe(4);
+});
+
+// ── float ─────────────────────────────────────────────────────────────────────
+
+test('coerces float string', () => {
+  expect(coerce('3.14', spec({ type: 'float' }))).toBeCloseTo(3.14);
+});
+
+test('rejects invalid float', () => {
+  expect(() => coerce('abc', spec({ type: 'float' }))).toThrow();
+});
+
+// ── bool ─────────────────────────────────────────────────────────────────────
+
+test('coerces true string', () => {
+  expect(coerce('true', spec({ type: 'bool' }))).toBe(true);
+});
+
+test('coerces yes string', () => {
+  expect(coerce('yes', spec({ type: 'bool' }))).toBe(true);
+});
+
+test('coerces false string', () => {
+  expect(coerce('false', spec({ type: 'bool' }))).toBe(false);
+});
+
+test('coerces boolean directly', () => {
+  expect(coerce(true, spec({ type: 'bool' }))).toBe(true);
+});
+
+test('rejects invalid bool', () => {
+  expect(() => coerce('maybe', spec({ type: 'bool' }))).toThrow();
+});
+
+// ── flag ─────────────────────────────────────────────────────────────────────
+
+test('flag true when boolean true', () => {
+  expect(coerce(true, spec({ type: 'flag' }))).toBe(true);
+});
+
+test('flag false when boolean false', () => {
+  expect(coerce(false, spec({ type: 'flag' }))).toBe(false);
+});
+
+// ── path ─────────────────────────────────────────────────────────────────────
+
+test('coerces path to absolute', () => {
+  const result = coerce('/tmp/data', spec({ type: 'path' })) as string;
+  expect(result).toBe('/tmp/data');
+  expect(result.startsWith('/')).toBe(true);
+});
+
+// ── choice ───────────────────────────────────────────────────────────────────
+
+test('accepts valid choice', () => {
+  expect(coerce('json', spec({ type: 'choice', options: ['json', 'csv'] }))).toBe('json');
+});
+
+test('rejects invalid choice', () => {
+  expect(() => coerce('xml', spec({ type: 'choice', options: ['json', 'csv'] }))).toThrow();
+});
+
+// ── custom types ──────────────────────────────────────────────────────────────
+
+test('registerType adds custom coercer', () => {
+  registerType('upper', (v) => String(v).toUpperCase());
+  expect(coerce('hello', spec({ type: 'upper' }))).toBe('HELLO');
+  expect(listTypes()).toContain('upper');
+});
+
+test('unknown type throws', () => {
+  expect(() => coerce('x', spec({ type: 'nonexistent-xyz' }))).toThrow();
+});

package/tests/test_validator.test.ts

@@ -0,0 +1,120 @@
+import { validateArgs, validateGroups, raiseIfErrors } from '../src/validator';
+import { RunSpecError } from '../src/errors';
+import type { ArgSpec, GroupSpec } from '../src/models';
+
+function argSpec(overrides: Partial<ArgSpec> = {}): ArgSpec {
+  return { name: 'test', ...overrides } as ArgSpec;
+}
+
+function groupSpec(overrides: Partial<GroupSpec> = {}): GroupSpec {
+  return { name: 'g', args: [], ...overrides } as GroupSpec;
+}
+
+// ── validateArgs ──────────────────────────────────────────────────────────────
+
+test('passes when required arg present', () => {
+  const errors = validateArgs({ name: 'Alice' }, { name: argSpec({ name: 'name', required: true }) });
+  expect(errors).toHaveLength(0);
+});
+
+test('errors when required arg missing', () => {
+  const errors = validateArgs({ name: undefined }, { name: argSpec({ name: 'name', required: true }) });
+  expect(errors).toHaveLength(1);
+  expect(errors[0]).toContain('--name');
+});
+
+test('passes when optional arg missing', () => {
+  const errors = validateArgs({ verbose: undefined }, { verbose: argSpec({ name: 'verbose', required: false }) });
+  expect(errors).toHaveLength(0);
+});
+
+test('error message includes type', () => {
+  const errors = validateArgs(
+    { input: undefined },
+    { input: argSpec({ name: 'input', required: true, type: 'path' }) },
+  );
+  expect(errors[0]).toContain('path');
+});
+
+test('error message includes env tip when env set', () => {
+  const errors = validateArgs(
+    { apiKey: undefined },
+    { apiKey: argSpec({ name: 'api-key', required: true, env: 'API_KEY' }) },
+  );
+  expect(errors[0]).toContain('API_KEY');
+});
+
+// ── validateGroups ────────────────────────────────────────────────────────────
+
+test('exclusive: passes when one provided', () => {
+  const errors = validateGroups({ format: 'json', raw: undefined }, { g: groupSpec({ args: ['format', 'raw'], exclusive: true }) });
+  expect(errors).toHaveLength(0);
+});
+
+test('exclusive: errors when two provided', () => {
+  const errors = validateGroups({ format: 'json', raw: true }, { g: groupSpec({ args: ['format', 'raw'], exclusive: true }) });
+  expect(errors).toHaveLength(1);
+  expect(errors[0]).toContain('Conflicting');
+});
+
+test('inclusive: passes when all provided', () => {
+  const errors = validateGroups(
+    { apiKey: 'x', apiEndpoint: 'y' },
+    { g: groupSpec({ args: ['apiKey', 'apiEndpoint'], inclusive: true }) },
+  );
+  expect(errors).toHaveLength(0);
+});
+
+test('inclusive: errors when partial', () => {
+  const errors = validateGroups(
+    { apiKey: 'x', apiEndpoint: undefined },
+    { g: groupSpec({ args: ['apiKey', 'apiEndpoint'], inclusive: true }) },
+  );
+  expect(errors).toHaveLength(1);
+  expect(errors[0]).toContain('Incomplete');
+});
+
+test('atLeastOne: passes when one provided', () => {
+  const errors = validateGroups({ a: 'x', b: undefined }, { g: groupSpec({ args: ['a', 'b'], atLeastOne: true }) });
+  expect(errors).toHaveLength(0);
+});
+
+test('atLeastOne: errors when none provided', () => {
+  const errors = validateGroups({ a: undefined, b: undefined }, { g: groupSpec({ args: ['a', 'b'], atLeastOne: true }) });
+  expect(errors).toHaveLength(1);
+});
+
+test('exactlyOne: passes when exactly one provided', () => {
+  const errors = validateGroups({ a: 'x', b: undefined }, { g: groupSpec({ args: ['a', 'b'], exactlyOne: true }) });
+  expect(errors).toHaveLength(0);
+});
+
+test('exactlyOne: errors when none provided', () => {
+  const errors = validateGroups({ a: undefined, b: undefined }, { g: groupSpec({ args: ['a', 'b'], exactlyOne: true }) });
+  expect(errors).toHaveLength(1);
+});
+
+test('exactlyOne: errors when two provided', () => {
+  const errors = validateGroups({ a: 'x', b: 'y' }, { g: groupSpec({ args: ['a', 'b'], exactlyOne: true }) });
+  expect(errors).toHaveLength(1);
+});
+
+// ── raiseIfErrors ─────────────────────────────────────────────────────────────
+
+test('raiseIfErrors does not throw on empty list', () => {
+  expect(() => raiseIfErrors([])).not.toThrow();
+});
+
+test('raiseIfErrors throws RunSpecError with all messages', () => {
+  expect(() => raiseIfErrors(['error one', 'error two'])).toThrow(RunSpecError);
+});
+
+test('raiseIfErrors message joins errors', () => {
+  try {
+    raiseIfErrors(['first', 'second']);
+    fail('should have thrown');
+  } catch (e) {
+    expect((e as Error).message).toContain('first');
+    expect((e as Error).message).toContain('second');
+  }
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "strict": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}