test(utils): add cronParser and flattenToLeafPaths tests

Author: Bill

tests/api/utils/dangerousKeys.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+import { DANGEROUS_KEYS } from '../../src/api/utils/dangerousKeys.js';
+
+describe('dangerousKeys', () => {
+  it('should contain __proto__', () => {
+    expect(DANGEROUS_KEYS.has('__proto__')).toBe(true);
+  });
+
+  it('should contain constructor', () => {
+    expect(DANGEROUS_KEYS.has('constructor')).toBe(true);
+  });
+
+  it('should contain prototype', () => {
+    expect(DANGEROUS_KEYS.has('prototype')).toBe(true);
+  });
+
+  it('should not contain safe keys', () => {
+    expect(DANGEROUS_KEYS.has('safeKey')).toBe(false);
+    expect(DANGEROUS_KEYS.has('name')).toBe(false);
+    expect(DANGEROUS_KEYS.has('id')).toBe(false);
+  });
+
+  it('should be a Set', () => {
+    expect(DANGEROUS_KEYS).toBeInstanceOf(Set);
+    expect(DANGEROUS_KEYS.size).toBe(3);
+  });
+});

tests/utils/cronParser.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it } from 'vitest';
+import { getNextCronRun, parseCron } from '../../src/utils/cronParser.js';
+
+describe('parseCron', () => {
+  describe('wildcards', () => {
+    it('should expand * to full range for minute (0-59)', () => {
+      const result = parseCron('* * * * *');
+      expect(result.minute).toHaveLength(60);
+      expect(result.minute[0]).toBe(0);
+      expect(result.minute[59]).toBe(59);
+    });
+
+    it('should expand * to full range for hour (0-23)', () => {
+      const result = parseCron('* * * * *');
+      expect(result.hour).toHaveLength(24);
+      expect(result.hour[0]).toBe(0);
+      expect(result.hour[23]).toBe(23);
+    });
+  });
+
+  describe('single values', () => {
+    it('should parse single values for all fields', () => {
+      const result = parseCron('30 14 15 6 3');
+      expect(result.minute).toEqual([30]);
+      expect(result.hour).toEqual([14]);
+      expect(result.day).toEqual([15]);
+      expect(result.month).toEqual([6]);
+      expect(result.weekday).toEqual([3]);
+    });
+  });
+
+  describe('lists', () => {
+    it('should parse comma-separated values', () => {
+      const result = parseCron('0,15,30,45 * * * *');
+      expect(result.minute).toEqual([0, 15, 30, 45]);
+    });
+  });
+
+  describe('ranges', () => {
+    it('should parse range expressions', () => {
+      const result = parseCron('0-5 * * * *');
+      expect(result.minute).toEqual([0, 1, 2, 3, 4, 5]);
+    });
+  });
+
+  describe('steps', () => {
+    it('should parse step expressions with wildcard base', () => {
+      const result = parseCron('*/15 * * * *');
+      expect(result.minute).toEqual([0, 15, 30, 45]);
+    });
+
+    it('should parse step expressions with numeric base', () => {
+      const result = parseCron('10/5 * * * *');
+      expect(result.minute).toEqual([10, 15, 20, 25, 30, 35, 40, 45, 50, 55]);
+    });
+  });
+
+  describe('validation', () => {
+    it('should reject expressions with wrong number of fields', () => {
+      expect(() => parseCron('* * * *')).toThrow('expected 5 fields');
+      expect(() => parseCron('* * * * * *')).toThrow('expected 5 fields');
+    });
+
+    it('should reject out-of-range values', () => {
+      expect(() => parseCron('60 * * * *')).toThrow('Invalid cron value');
+      expect(() => parseCron('24 * * * *')).toThrow('Invalid cron value');
+      expect(() => parseCron('* 25 * * *')).toThrow('Invalid cron value');
+    });
+
+    it('should reject invalid range (start > end)', () => {
+      expect(() => parseCron('30-20 * * * *')).toThrow('Invalid cron range');
+    });
+
+    it('should reject invalid step values', () => {
+      expect(() => parseCron('*/0 * * * *')).toThrow('Invalid cron step');
+    });
+  });
+});
+
+describe('getNextCronRun', () => {
+  it('should find next occurrence of daily cron', () => {
+    const cron = '0 12 * * *'; // Every day at noon
+    const from = new Date('2024-06-15T10:00:00Z');
+    const next = getNextCronRun(cron, from);
+
+    expect(next.getHours()).toBe(12);
+    expect(next.getMinutes()).toBe(0);
+    expect(next.getDate()).toBe(15);
+  });
+
+  it('should advance to next day if time has passed', () => {
+    const cron = '0 12 * * *'; // Every day at noon
+    const from = new Date('2024-06-15T14:00:00Z');
+    const next = getNextCronRun(cron, from);
+
+    expect(next.getDate()).toBe(16);
+    expect(next.getHours()).toBe(12);
+  });
+
+  it('should handle hourly cron', () => {
+    const cron = '30 * * * *'; // Every hour at minute 30
+    const from = new Date('2024-06-15T10:00:00Z');
+    const next = getNextCronRun(cron, from);
+
+    expect(next.getMinutes()).toBe(30);
+    expect(next.getHours()).toBe(10);
+  });
+
+  it('should throw if no match within 2 years', () => {
+    // Impossible cron: Feb 30th
+    const cron = '0 0 30 2 *';
+    const from = new Date('2024-01-01T00:00:00Z');
+
+    expect(() => getNextCronRun(cron, from)).toThrow('No matching cron time found');
+  });
+});

tests/utils/flattenToLeafPaths.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+import { flattenToLeafPaths } from '../../src/utils/flattenToLeafPaths.js';
+
+describe('flattenToLeafPaths', () => {
+  describe('basic flattening', () => {
+    it('should flatten a simple object with primitive values', () => {
+      const obj = { a: 1, b: 'test', c: true };
+      const result = flattenToLeafPaths(obj, 'root');
+
+      expect(result).toHaveLength(3);
+      expect(result).toContainEqual(['root.a', 1]);
+      expect(result).toContainEqual(['root.b', 'test']);
+      expect(result).toContainEqual(['root.c', true]);
+    });
+
+    it('should flatten nested objects with dot notation', () => {
+      const obj = { level1: { level2: { level3: 'deep' } } };
+      const result = flattenToLeafPaths(obj, 'config');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['config.level1.level2.level3', 'deep']);
+    });
+
+    it('should handle mixed nesting depths', () => {
+      const obj = {
+        shallow: 'value',
+        nested: { child: 'childValue' },
+        deep: { a: { b: { c: 'deepest' } } },
+      };
+      const result = flattenToLeafPaths(obj, 'obj');
+
+      expect(result).toHaveLength(3);
+      expect(result).toContainEqual(['obj.shallow', 'value']);
+      expect(result).toContainEqual(['obj.nested.child', 'childValue']);
+      expect(result).toContainEqual(['obj.deep.a.b.c', 'deepest']);
+    });
+  });
+
+  describe('arrays', () => {
+    it('should treat arrays as leaf values', () => {
+      const obj = { items: [1, 2, 3] };
+      const result = flattenToLeafPaths(obj, 'data');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['data.items', [1, 2, 3]]);
+    });
+
+    it('should not recurse into array elements', () => {
+      const obj = { nested: { arr: [{ a: 1 }, { b: 2 }] } };
+      const result = flattenToLeafPaths(obj, 'x');
+
+      expect(result).toHaveLength(1);
+      expect(result[0][0]).toBe('x.nested.arr');
+      expect(Array.isArray(result[0][1])).toBe(true);
+    });
+  });
+
+  describe('dangerous keys', () => {
+    it('should skip __proto__', () => {
+      const obj = { safe: 'value', __proto__: 'malicious' };
+      const result = flattenToLeafPaths(obj, 'test');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['test.safe', 'value']);
+    });
+
+    it('should skip constructor', () => {
+      const obj = { data: 'ok', constructor: 'bad' };
+      const result = flattenToLeafPaths(obj, 'cfg');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['cfg.data', 'ok']);
+    });
+
+    it('should skip prototype', () => {
+      const obj = { value: 123, prototype: 'ignore' };
+      const result = flattenToLeafPaths(obj, 'root');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['root.value', 123]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty objects', () => {
+      const obj = {};
+      const result = flattenToLeafPaths(obj, 'empty');
+
+      expect(result).toHaveLength(0);
+    });
+
+    it('should handle null values', () => {
+      const obj = { a: null, b: { c: null } };
+      const result = flattenToLeafPaths(obj, 'x');
+
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual(['x.a', null]);
+      expect(result).toContainEqual(['x.b.c', null]);
+    });
+
+    it('should handle empty prefix', () => {
+      const obj = { key: 'value' };
+      const result = flattenToLeafPaths(obj, '');
+
+      expect(result).toHaveLength(1);
+      expect(result).toContainEqual(['.key', 'value']);
+    });
+  });
+});