evaldoc 1.0.0

package/tests/unit/validate.test.js

@@ -0,0 +1,408 @@
+/**
+ * Unit tests for the pure input-validation module (functions/src/validate.js).
+ */
+
+const {
+  validate,
+  isEmail,
+  clampInt,
+  isHexColor,
+  boundedString,
+} = require('../../functions/src/validate');
+
+describe('validate() - string type', () => {
+  test('happy path: trims and coerces', () => {
+    const r = validate({ name: { type: 'string' } }, { name: '  hi  ' });
+    expect(r.ok).toBe(true);
+    expect(r.value.name).toBe('hi');
+  });
+
+  test('coerces non-string to string', () => {
+    const r = validate({ name: { type: 'string' } }, { name: 42 });
+    expect(r.ok).toBe(true);
+    expect(r.value.name).toBe('42');
+  });
+
+  test('maxLength truncates', () => {
+    const r = validate({ s: { type: 'string', maxLength: 3 } }, { s: 'abcdef' });
+    expect(r.ok).toBe(true);
+    expect(r.value.s).toBe('abc');
+  });
+
+  test('required empty -> error', () => {
+    const r = validate({ s: { type: 'string', required: true } }, { s: '   ' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.s).toMatch(/required/);
+  });
+
+  test('min length failure', () => {
+    const r = validate({ s: { type: 'string', min: 5 } }, { s: 'ab' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.s).toMatch(/at least/);
+  });
+
+  test('max length failure (after truncate not applied without maxLength)', () => {
+    const r = validate({ s: { type: 'string', max: 3 } }, { s: 'abcdef' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.s).toMatch(/at most/);
+  });
+
+  test('min/max within bounds passes', () => {
+    const r = validate({ s: { type: 'string', min: 2, max: 5 } }, { s: 'abc' });
+    expect(r.ok).toBe(true);
+    expect(r.value.s).toBe('abc');
+  });
+
+  test('optional empty string is allowed', () => {
+    const r = validate({ s: { type: 'string' } }, { s: '' });
+    expect(r.ok).toBe(true);
+    expect(r.value.s).toBe('');
+  });
+});
+
+describe('validate() - email type', () => {
+  test('valid email lowercased & trimmed', () => {
+    const r = validate({ e: { type: 'email' } }, { e: '  Foo@Bar.COM ' });
+    expect(r.ok).toBe(true);
+    expect(r.value.e).toBe('foo@bar.com');
+  });
+
+  test('invalid: no @', () => {
+    const r = validate({ e: { type: 'email' } }, { e: 'foobar.com' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.e).toMatch(/valid email/);
+  });
+
+  test('invalid: no domain dot', () => {
+    const r = validate({ e: { type: 'email' } }, { e: 'foo@bar' });
+    expect(r.ok).toBe(false);
+  });
+
+  test('invalid: spaces', () => {
+    const r = validate({ e: { type: 'email' } }, { e: 'fo o@bar.com' });
+    expect(r.ok).toBe(false);
+  });
+
+  test('invalid: double @', () => {
+    const r = validate({ e: { type: 'email' } }, { e: 'a@b@c.com' });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe('validate() - int type', () => {
+  test('happy path', () => {
+    const r = validate({ n: { type: 'int' } }, { n: '7' });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBe(7);
+  });
+
+  test('clamps below min to min', () => {
+    const r = validate({ n: { type: 'int', min: 1, max: 60 } }, { n: 0 });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBe(1);
+  });
+
+  test('clamps above max to max', () => {
+    const r = validate({ n: { type: 'int', min: 1, max: 60 } }, { n: 100 });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBe(60);
+  });
+
+  test('in-range unchanged', () => {
+    const r = validate({ n: { type: 'int', min: 1, max: 60 } }, { n: 30 });
+    expect(r.value.n).toBe(30);
+  });
+
+  test('non-number -> error when no default', () => {
+    const r = validate({ n: { type: 'int' } }, { n: 'abc' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.n).toMatch(/integer/);
+  });
+
+  test('non-number -> uses default when provided', () => {
+    const r = validate({ n: { type: 'int', default: 5 } }, { n: 'abc' });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBe(5);
+  });
+
+  test('parses float to int via parseInt', () => {
+    const r = validate({ n: { type: 'int' } }, { n: '12.9' });
+    expect(r.value.n).toBe(12);
+  });
+});
+
+describe('validate() - number type', () => {
+  test('happy path float', () => {
+    const r = validate({ n: { type: 'number' } }, { n: '3.14' });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBeCloseTo(3.14);
+  });
+
+  test('clamps to min', () => {
+    const r = validate({ n: { type: 'number', min: 0, max: 1 } }, { n: -2 });
+    expect(r.value.n).toBe(0);
+  });
+
+  test('clamps to max', () => {
+    const r = validate({ n: { type: 'number', min: 0, max: 1 } }, { n: 5 });
+    expect(r.value.n).toBe(1);
+  });
+
+  test('non-number -> error', () => {
+    const r = validate({ n: { type: 'number' } }, { n: 'xyz' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.n).toMatch(/number/);
+  });
+
+  test('non-number -> default', () => {
+    const r = validate({ n: { type: 'number', default: 1.5 } }, { n: 'xyz' });
+    expect(r.ok).toBe(true);
+    expect(r.value.n).toBe(1.5);
+  });
+});
+
+describe('validate() - boolean type', () => {
+  test('accepts true', () => {
+    const r = validate({ b: { type: 'boolean' } }, { b: true });
+    expect(r.value.b).toBe(true);
+  });
+
+  test('accepts false', () => {
+    const r = validate({ b: { type: 'boolean' } }, { b: false });
+    expect(r.value.b).toBe(false);
+  });
+
+  test('non-boolean ignored (omitted) when optional', () => {
+    const r = validate({ b: { type: 'boolean' } }, { b: 'true' });
+    expect(r.ok).toBe(true);
+    expect('b' in r.value).toBe(false);
+  });
+
+  test('non-boolean required -> error', () => {
+    const r = validate({ b: { type: 'boolean', required: true } }, { b: 'yes' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.b).toMatch(/boolean/);
+  });
+
+  test('numeric 1 is not a boolean', () => {
+    const r = validate({ b: { type: 'boolean' } }, { b: 1 });
+    expect('b' in r.value).toBe(false);
+  });
+});
+
+describe('validate() - enum type', () => {
+  test('valid value', () => {
+    const r = validate({ c: { type: 'enum', values: ['a', 'b'] } }, { c: 'a' });
+    expect(r.ok).toBe(true);
+    expect(r.value.c).toBe('a');
+  });
+
+  test('invalid value -> error', () => {
+    const r = validate({ c: { type: 'enum', values: ['a', 'b'] } }, { c: 'z' });
+    expect(r.ok).toBe(false);
+    expect(r.errors.c).toMatch(/one of/);
+  });
+
+  test('invalid value -> default when provided', () => {
+    const r = validate(
+      { c: { type: 'enum', values: ['a', 'b'], default: 'a' } },
+      { c: 'z' }
+    );
+    expect(r.ok).toBe(true);
+    expect(r.value.c).toBe('a');
+  });
+
+  test('empty values array -> error for any input', () => {
+    const r = validate({ c: { type: 'enum', values: [] } }, { c: 'a' });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe('validate() - hexColor type', () => {
+  test('valid lowercase', () => {
+    const r = validate({ c: { type: 'hexColor' } }, { c: '#aabbcc' });
+    expect(r.ok).toBe(true);
+    expect(r.value.c).toBe('#aabbcc');
+  });
+
+  test('valid uppercase', () => {
+    const r = validate({ c: { type: 'hexColor' } }, { c: '#FFAA00' });
+    expect(r.ok).toBe(true);
+  });
+
+  test('invalid: missing #', () => {
+    const r = validate({ c: { type: 'hexColor' } }, { c: 'aabbcc' });
+    expect(r.ok).toBe(false);
+  });
+
+  test('invalid: 3-digit short form', () => {
+    const r = validate({ c: { type: 'hexColor' } }, { c: '#abc' });
+    expect(r.ok).toBe(false);
+  });
+
+  test('invalid: non-hex char', () => {
+    const r = validate({ c: { type: 'hexColor' } }, { c: '#gggggg' });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe('validate() - required / optional / default', () => {
+  test('absent + required -> error', () => {
+    const r = validate({ x: { type: 'string', required: true } }, {});
+    expect(r.ok).toBe(false);
+    expect(r.errors.x).toMatch(/required/);
+  });
+
+  test('absent + default -> uses default', () => {
+    const r = validate({ x: { type: 'string', default: 'd' } }, {});
+    expect(r.ok).toBe(true);
+    expect(r.value.x).toBe('d');
+  });
+
+  test('absent + optional + no default -> omitted', () => {
+    const r = validate({ x: { type: 'string' } }, {});
+    expect(r.ok).toBe(true);
+    expect('x' in r.value).toBe(false);
+  });
+
+  test('null treated as absent', () => {
+    const r = validate({ x: { type: 'string', default: 'd' } }, { x: null });
+    expect(r.value.x).toBe('d');
+  });
+
+  test('undefined treated as absent -> required error', () => {
+    const r = validate({ x: { type: 'string', required: true } }, { x: undefined });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe('validate() - multiple fields mixed', () => {
+  test('all valid', () => {
+    const r = validate(
+      {
+        name: { type: 'string', required: true },
+        age: { type: 'int', min: 0, max: 120 },
+        email: { type: 'email' },
+      },
+      { name: 'Bob', age: 200, email: 'BOB@X.com' }
+    );
+    expect(r.ok).toBe(true);
+    expect(r.value).toEqual({ name: 'Bob', age: 120, email: 'bob@x.com' });
+  });
+
+  test('mixed ok and errors -> ok:false with correct errors map', () => {
+    const r = validate(
+      {
+        name: { type: 'string', required: true },
+        email: { type: 'email' },
+        color: { type: 'hexColor' },
+      },
+      { name: '', email: 'bad', color: '#aabbcc' }
+    );
+    expect(r.ok).toBe(false);
+    expect(r.errors.name).toBeDefined();
+    expect(r.errors.email).toBeDefined();
+    expect(r.errors.color).toBeUndefined();
+    expect(r.value.color).toBe('#aabbcc');
+  });
+
+  test('unknown type produces error', () => {
+    const r = validate({ x: { type: 'banana' } }, { x: 1 });
+    expect(r.ok).toBe(false);
+    expect(r.errors.x).toMatch(/unknown type/);
+  });
+});
+
+describe('validate() - edge cases', () => {
+  test('empty rules -> ok', () => {
+    const r = validate({}, { anything: 1 });
+    expect(r.ok).toBe(true);
+    expect(r.value).toEqual({});
+  });
+
+  test('null input handled gracefully', () => {
+    const r = validate({ x: { type: 'string', default: 'd' } }, null);
+    expect(r.ok).toBe(true);
+    expect(r.value.x).toBe('d');
+  });
+
+  test('null rules -> ok', () => {
+    const r = validate(null, { x: 1 });
+    expect(r.ok).toBe(true);
+  });
+});
+
+describe('isEmail()', () => {
+  test('valid', () => {
+    expect(isEmail('a@b.com')).toBe(true);
+  });
+  test('valid with mixed case/space', () => {
+    expect(isEmail('  A@B.COM ')).toBe(true);
+  });
+  test('invalid no tld dot', () => {
+    expect(isEmail('a@b')).toBe(false);
+  });
+  test('non-string', () => {
+    expect(isEmail(123)).toBe(false);
+  });
+  test('empty', () => {
+    expect(isEmail('')).toBe(false);
+  });
+});
+
+describe('clampInt()', () => {
+  test('within range', () => {
+    expect(clampInt(5, 1, 10, 0)).toBe(5);
+  });
+  test('below min', () => {
+    expect(clampInt(-3, 1, 10, 0)).toBe(1);
+  });
+  test('above max', () => {
+    expect(clampInt(99, 1, 10, 0)).toBe(10);
+  });
+  test('non-number returns fallback', () => {
+    expect(clampInt('abc', 1, 10, 7)).toBe(7);
+  });
+  test('parses numeric string', () => {
+    expect(clampInt('4', 1, 10, 0)).toBe(4);
+  });
+  test('no bounds returns parsed value', () => {
+    expect(clampInt('42', undefined, undefined, 0)).toBe(42);
+  });
+});
+
+describe('isHexColor()', () => {
+  test('valid', () => {
+    expect(isHexColor('#abcdef')).toBe(true);
+  });
+  test('valid uppercase', () => {
+    expect(isHexColor('#ABCDEF')).toBe(true);
+  });
+  test('invalid short', () => {
+    expect(isHexColor('#abc')).toBe(false);
+  });
+  test('invalid no hash', () => {
+    expect(isHexColor('abcdef')).toBe(false);
+  });
+  test('non-string', () => {
+    expect(isHexColor(null)).toBe(false);
+  });
+});
+
+describe('boundedString()', () => {
+  test('trims', () => {
+    expect(boundedString('  hi ', 10)).toBe('hi');
+  });
+  test('truncates', () => {
+    expect(boundedString('abcdef', 3)).toBe('abc');
+  });
+  test('null -> empty', () => {
+    expect(boundedString(null, 10)).toBe('');
+  });
+  test('coerces number', () => {
+    expect(boundedString(123, 10)).toBe('123');
+  });
+  test('no maxLen leaves length', () => {
+    expect(boundedString('abcdef')).toBe('abcdef');
+  });
+});