@dalmore/api-contracts 1.0.5 → 1.0.6

package/src/common/types/common.types.spec.ts

@@ -0,0 +1,336 @@
+import { PaginationOptionsZod, numberPrecisionSchema } from './common.types';
+import { z } from 'zod';
+
+describe('PaginationOptionsZod', () => {
+  it('should use default values when no values are provided', () => {
+    const result = PaginationOptionsZod.parse({});
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should use provided values when they are valid', () => {
+    const result = PaginationOptionsZod.parse({ page: 2, limit: 20 });
+    expect(result).toEqual({ page: 2, limit: 20 });
+  });
+
+  it('should transform page 0 to page 1', () => {
+    const result = PaginationOptionsZod.parse({ page: 0 });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should transform limit 0 to limit 10', () => {
+    const result = PaginationOptionsZod.parse({ limit: 0 });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should coerce string values to numbers', () => {
+    const result = PaginationOptionsZod.parse({ page: '3', limit: '15' });
+    expect(result).toEqual({ page: 3, limit: 15 });
+  });
+
+  it('should handle negative values without transformation', () => {
+    const result = PaginationOptionsZod.parse({ page: -1, limit: -5 });
+    expect(result).toEqual({ page: -1, limit: -5 });
+  });
+
+  it('should handle decimal values', () => {
+    const result = PaginationOptionsZod.parse({ page: 2.5, limit: 15.7 });
+    expect(result).toEqual({ page: 2.5, limit: 15.7 });
+  });
+
+  it('should throw an error for non-numeric string values', () => {
+    expect(() => {
+      PaginationOptionsZod.parse({ page: 'abc' });
+    }).toThrow();
+  });
+
+  it('should accept empty string values and convert them to defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: '' });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should accept undefined values and use defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: undefined });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should handle null values by using defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: null, limit: null });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should handle objects with extra properties', () => {
+    const result = PaginationOptionsZod.parse({
+      page: 5,
+      limit: 25,
+      sort: 'asc',
+      filter: 'active',
+    });
+    expect(result).toEqual({ page: 5, limit: 25 });
+  });
+
+  it('should handle string numbers with leading zeros', () => {
+    const result = PaginationOptionsZod.parse({ page: '01', limit: '05' });
+    expect(result).toEqual({ page: 1, limit: 5 });
+  });
+
+  it('should handle exponential notation', () => {
+    const result = PaginationOptionsZod.parse({ page: 1e2, limit: 1e1 });
+    expect(result).toEqual({ page: 100, limit: 10 });
+  });
+});
+
+describe('numberPrecisionSchema', () => {
+  describe('default precision (2 decimal places)', () => {
+    it('should transform numbers with more than 2 decimal places', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.456)).toBe(123.46);
+      expect(schema.parse(123.456789)).toBe(123.46);
+      expect(schema.parse(0.999)).toBe(1.0);
+    });
+
+    it('should keep numbers with exactly 2 decimal places unchanged', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.45)).toBe(123.45);
+      expect(schema.parse(0.99)).toBe(0.99);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+    });
+
+    it('should pad numbers with fewer than 2 decimal places', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.4)).toBe(123.4);
+      expect(schema.parse(123)).toBe(123.0);
+      expect(schema.parse(0.5)).toBe(0.5);
+    });
+
+    it('should handle whole numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(100)).toBe(100.0);
+      expect(schema.parse(0)).toBe(0.0);
+      expect(schema.parse(999)).toBe(999.0);
+    });
+
+    it('should handle negative numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(-123.456)).toBe(-123.46);
+      expect(schema.parse(-123.45)).toBe(-123.45);
+      expect(schema.parse(-100)).toBe(-100.0);
+    });
+
+    it('should handle zero', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(0)).toBe(0.0);
+      expect(schema.parse(0.0)).toBe(0.0);
+      expect(schema.parse(0.001)).toBe(0.0);
+    });
+
+    it('should handle very small numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(0.001)).toBe(0.0);
+      expect(schema.parse(0.004)).toBe(0.0);
+      expect(schema.parse(0.005)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+    });
+
+    it('should handle very large numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(999999999.123456)).toBe(999999999.12);
+      expect(schema.parse(1234567890.99)).toBe(1234567890.99);
+    });
+
+    it('should handle numbers with floating point precision issues', () => {
+      const schema = numberPrecisionSchema();
+      // Common floating point issue: 0.1 + 0.2 = 0.30000000000000004
+      expect(schema.parse(0.1 + 0.2)).toBe(0.3);
+      expect(schema.parse(0.1 + 0.7)).toBe(0.8);
+    });
+  });
+
+  describe('custom precision values', () => {
+    it('should work with precision 0 (whole numbers)', () => {
+      const schema = numberPrecisionSchema(0);
+      expect(schema.parse(123.456)).toBe(123);
+      expect(schema.parse(123.5)).toBe(124);
+      expect(schema.parse(123.4)).toBe(123);
+      expect(schema.parse(0.9)).toBe(1);
+    });
+
+    it('should work with precision 1', () => {
+      const schema = numberPrecisionSchema(1);
+      expect(schema.parse(123.45)).toBe(123.5);
+      expect(schema.parse(123.44)).toBe(123.4);
+      expect(schema.parse(123.456)).toBe(123.5);
+    });
+
+    it('should work with precision 3', () => {
+      const schema = numberPrecisionSchema(3);
+      expect(schema.parse(123.4567)).toBe(123.457);
+      expect(schema.parse(123.456)).toBe(123.456);
+      expect(schema.parse(123.4)).toBe(123.4);
+    });
+
+    it('should work with precision 4', () => {
+      const schema = numberPrecisionSchema(4);
+      expect(schema.parse(123.45678)).toBe(123.4568);
+      expect(schema.parse(123.4567)).toBe(123.4567);
+      expect(schema.parse(123.4)).toBe(123.4);
+    });
+
+    it('should work with precision 6', () => {
+      const schema = numberPrecisionSchema(6);
+      expect(schema.parse(123.4567890123)).toBe(123.456789);
+      expect(schema.parse(123.456789)).toBe(123.456789);
+    });
+  });
+
+  describe('with base schema constraints', () => {
+    it('should apply positive constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().positive());
+      expect(schema.parse(123.456)).toBe(123.46);
+      expect(() => schema.parse(-123.456)).toThrow();
+      expect(() => schema.parse(0)).toThrow();
+    });
+
+    it('should apply max constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().max(1000));
+      expect(schema.parse(999.99)).toBe(999.99);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+      expect(() => schema.parse(1000.01)).toThrow();
+    });
+
+    it('should apply min constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().min(0.01));
+      expect(schema.parse(0.01)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(() => schema.parse(0.005)).toThrow();
+    });
+
+    it('should apply multiple constraints', () => {
+      const schema = numberPrecisionSchema(
+        2,
+        z.number().positive().min(0.01).max(999999999),
+      );
+      expect(schema.parse(500.99)).toBe(500.99);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(() => schema.parse(-100)).toThrow();
+      expect(() => schema.parse(0.005)).toThrow();
+      expect(() => schema.parse(1000000000)).toThrow();
+    });
+  });
+
+  describe('rounding behavior', () => {
+    it('should round up correctly', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.455)).toBe(123.46);
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(0.995)).toBe(1.0);
+    });
+
+    it('should round down correctly', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.444)).toBe(123.44);
+      expect(schema.parse(123.441)).toBe(123.44);
+    });
+
+    it("should handle banker's rounding (round half to even)", () => {
+      const schema = numberPrecisionSchema(2);
+      // JavaScript's toFixed uses standard rounding, not banker's rounding
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(123.435)).toBe(123.44);
+    });
+
+    it('should handle edge cases in rounding', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(0.004)).toBe(0.0);
+      expect(schema.parse(0.005)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(schema.parse(0.025)).toBe(0.03);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very small positive numbers', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(0.0001)).toBe(0.0);
+      expect(schema.parse(0.0005)).toBe(0.0);
+      expect(schema.parse(0.0006)).toBe(0.0);
+    });
+
+    it('should handle very large numbers', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(Number.MAX_SAFE_INTEGER)).toBe(
+        Number(Number.MAX_SAFE_INTEGER.toFixed(2)),
+      );
+    });
+
+    it('should handle numbers at precision boundaries', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.444)).toBe(123.44);
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(123.446)).toBe(123.45);
+    });
+
+    it('should handle scientific notation', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(1.23e2)).toBe(123.0);
+      expect(schema.parse(1.234e2)).toBe(123.4);
+      expect(schema.parse(1.2345e2)).toBe(123.45);
+    });
+
+    it('should handle Infinity', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(Infinity)).toBe(Infinity);
+      expect(schema.parse(-Infinity)).toBe(-Infinity);
+    });
+
+    it('should handle NaN', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(() => schema.parse(NaN)).toThrow();
+    });
+  });
+
+  describe('real-world scenarios', () => {
+    it('should handle currency amounts', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(122.4444)).toBe(122.44);
+      expect(schema.parse(99.995)).toBe(100.0);
+      expect(schema.parse(0.01)).toBe(0.01);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+    });
+
+    it('should handle percentage values', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(12.3456)).toBe(12.35);
+      expect(schema.parse(99.999)).toBe(100.0);
+      expect(schema.parse(0.123)).toBe(0.12);
+    });
+
+    it('should handle measurement values with different precision', () => {
+      const schema3 = numberPrecisionSchema(3);
+      expect(schema3.parse(12.34567)).toBe(12.346);
+      expect(schema3.parse(0.1234)).toBe(0.123);
+    });
+  });
+
+  describe('integration with Zod features', () => {
+    it('should work with safeParse', () => {
+      const schema = numberPrecisionSchema(2);
+      const result = schema.safeParse(123.456);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toBe(123.46);
+      }
+    });
+
+    it('should work with safeParse for invalid input', () => {
+      const schema = numberPrecisionSchema(2, z.number().positive());
+      const result = schema.safeParse(-123.456);
+      expect(result.success).toBe(false);
+    });
+
+    it('should preserve type information', () => {
+      const schema = numberPrecisionSchema(2);
+      const result = schema.parse(123.456);
+      expect(typeof result).toBe('number');
+    });
+  });
+});