chore: implement more tests

Author: glennmichael123

src/types/integer.ts

@@ -1,4 +1,3 @@
-import type { IntegerValidator } from '../validators/integer'
 import type { NumberValidatorType } from './number'
 
 export interface IntegerValidatorType extends NumberValidatorType {

src/validators/decimal.ts

@@ -1,25 +1,31 @@
 import type { DecimalValidatorOptions, DecimalValidatorType, ValidationNames } from '../types'
-import isDecimal from '../lib/isDecimal'
 import isDivisibleBy from '../lib/isDivisibleBy'
-import { BaseValidator } from './base'
+import { NumberValidator } from './numbers'
 
-export class DecimalValidator extends BaseValidator<number> implements DecimalValidatorType {
+export class DecimalValidator extends NumberValidator implements DecimalValidatorType {
   public name: ValidationNames = 'decimal'
 
   constructor() {
     super()
     this.addRule({
       name: 'decimal',
       test: (value: unknown): value is number => {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
+        // First check if it's a number
+        if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {
           return false
         }
-        return isDecimal(String(value), {})
+        // Check if it's a finite number (all numbers in JS are decimals)
+        return true
       },
       message: 'Must be a valid decimal number',
     })
   }
 
+  // Override test method to handle type checking
+  test(value: unknown): boolean {
+    return this.validate(value as number).valid
+  }
+
   min(min: number): this {
     return this.addRule({
       name: 'min',

src/validators/float.ts

@@ -1,25 +1,34 @@
 import type { FloatOptions, FloatValidatorType, ValidationNames } from '../types'
 import isDivisibleBy from '../lib/isDivisibleBy'
-import isFloat from '../lib/isFloat'
 import { BaseValidator } from './base'
+import { NumberValidator } from './numbers'
 
-export class FloatValidator extends BaseValidator<number> implements FloatValidatorType {
+export class FloatValidator extends NumberValidator implements FloatValidatorType {
   public name: ValidationNames = 'float'
 
   constructor() {
     super()
+    // Override the base number validation to ensure it's a float
+    // Remove the existing number rule and add our own
+    this.rules = this.rules.filter(rule => rule.name !== 'number')
     this.addRule({
-      name: 'float',
+      name: 'number',
       test: (value: unknown): value is number => {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
+        // First check if it's a number
+        if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {
           return false
         }
-        return isFloat(String(value), {})
+        // All numbers in JavaScript are floats, so just check if it's finite
+        return true
       },
       message: 'Must be a valid float number',
     })
   }
 
+  test(value: unknown): boolean {
+    return this.validate(value as number).valid
+  }
+
   min(min: number): this {
     return this.addRule({
       name: 'min',

src/validators/integer.ts

@@ -1,5 +1,4 @@
 import type { IntegerValidatorType, ValidationNames } from '../types'
-import isInt from '../lib/isInt'
 import { NumberValidator } from './numbers'
 
 export class IntegerValidator extends NumberValidator implements IntegerValidatorType {
@@ -8,17 +7,63 @@ export class IntegerValidator extends NumberValidator implements IntegerValidato
   constructor() {
     super()
     // Override the base number validation to ensure it's an integer
+    // Remove the existing number rule and add our own
+    this.rules = this.rules.filter(rule => rule.name !== 'number')
     this.addRule({
-      name: 'integer',
+      name: 'number',
       test: (value: unknown): value is number => {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
+        // First check if it's a number
+        if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {
           return false
         }
-        return isInt(String(value), {})
+        // Then check if it's an integer
+        return Number.isInteger(value)
       },
       message: 'Must be a valid integer',
     })
   }
+
+  min(min: number): this {
+    return this.addRule({
+      name: 'min',
+      test: (value: number) => value >= min,
+      message: 'Must be at least {min}',
+      params: { min },
+    })
+  }
+
+  max(max: number): this {
+    return this.addRule({
+      name: 'max',
+      test: (value: number) => value <= max,
+      message: 'Must be at most {max}',
+      params: { max },
+    })
+  }
+
+  positive(): this {
+    return this.addRule({
+      name: 'positive',
+      test: (value: number) => value > 0,
+      message: 'Must be a positive integer',
+    })
+  }
+
+  negative(): this {
+    return this.addRule({
+      name: 'negative',
+      test: (value: number) => value < 0,
+      message: 'Must be a negative integer',
+    })
+  }
+
+  custom(fn: (value: number) => boolean, message: string): this {
+    return this.addRule({
+      name: 'custom',
+      test: fn,
+      message,
+    })
+  }
 }
 
 // Export a function to create integer validators

src/validators/json.ts

@@ -1,4 +1,4 @@
-import type { JsonValidatorType, ValidationNames } from '../types'
+import type { IsJSONOptions, JsonValidatorType, ValidationNames } from '../types'
 import { BaseValidator } from './base'
 
 export class JsonValidator extends BaseValidator<string> implements JsonValidatorType {
@@ -9,11 +9,22 @@ export class JsonValidator extends BaseValidator<string> implements JsonValidato
     this.addRule({
       name: 'json',
       test: (value: unknown): value is string => {
+        // First check if it's a string
         if (typeof value !== 'string') {
           return false
         }
+
+        // Check if it's empty
+        if (value.trim() === '') {
+          return false
+        }
+
         try {
-          JSON.parse(value)
+          const parsed = JSON.parse(value)
+          // By default, reject primitive values
+          if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean' || parsed === null) {
+            return false
+          }
           return true
         }
         catch {
@@ -24,6 +35,11 @@ export class JsonValidator extends BaseValidator<string> implements JsonValidato
     })
   }
 
+  // Override test method to handle type checking
+  test(value: unknown): boolean {
+    return this.validate(value as string).valid
+  }
+
   min(min: number): this {
     return this.addRule({
       name: 'min',

src/validators/smallint.ts

@@ -1,21 +1,25 @@
 import type { SmallintValidatorType, ValidationNames } from '../types'
 import isDivisibleBy from '../lib/isDivisibleBy'
-import isInt from '../lib/isInt'
 import { BaseValidator } from './base'
+import { NumberValidator } from './numbers'
 
-export class SmallintValidator extends BaseValidator<number> implements SmallintValidatorType {
+export class SmallintValidator extends NumberValidator implements SmallintValidatorType {
   public name: ValidationNames = 'smallint'
 
   constructor() {
     super()
+    // Override the base number validation to ensure it's a smallint
+    // Remove the existing number rule and add our own
+    this.rules = this.rules.filter(rule => rule.name !== 'number')
     this.addRule({
-      name: 'smallint',
+      name: 'number',
       test: (value: unknown): value is number => {
-        if (typeof value !== 'number' || Number.isNaN(value)) {
+        // First check if it's a number
+        if (typeof value !== 'number' || Number.isNaN(value) || !Number.isFinite(value)) {
           return false
         }
         // Check if it's an integer
-        if (!isInt(String(value), {})) {
+        if (!Number.isInteger(value)) {
           return false
         }
         // Check if it's within smallint range (-32,768 to 32,767)
@@ -84,6 +88,11 @@ export class SmallintValidator extends BaseValidator<number> implements Smallint
       message,
     })
   }
+
+  // Override test method to handle type checking
+  test(value: unknown): boolean {
+    return this.validate(value as number).valid
+  }
 }
 
 // Export a function to create smallint validators

src/validators/time.ts

@@ -1,4 +1,4 @@
-import type { TimeValidatorType, ValidationNames } from '../types'
+import type { IsTimeOptions, TimeValidatorType, ValidationNames } from '../types'
 import { BaseValidator } from './base'
 
 export class TimeValidator extends BaseValidator<string> implements TimeValidatorType {
@@ -9,17 +9,29 @@ export class TimeValidator extends BaseValidator<string> implements TimeValidato
     this.addRule({
       name: 'time',
       test: (value: unknown): value is string => {
+        // First check if it's a string
         if (typeof value !== 'string') {
           return false
         }
-        // Basic time format validation (HH:MM:SS or HH:MM)
+
+        // Check if it's empty
+        if (value.trim() === '') {
+          return false
+        }
+
+        // Default to 24-hour format
         const timeRegex = /^([01]?[0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$/
         return timeRegex.test(value)
       },
-      message: 'Must be a valid time format (HH:MM:SS or HH:MM)',
+      message: 'Must be a valid time format',
     })
   }
 
+  // Override test method to handle type checking
+  test(value: unknown): boolean {
+    return this.validate(value).valid
+  }
+
   min(min: string): this {
     return this.addRule({
       name: 'min',

test/validators/decimal.test.ts

@@ -0,0 +1,28 @@
+import { decimal } from '../../src/validators/decimal'
+
+describe('decimalValidator', () => {
+  it('should validate decimal numbers', () => {
+    const validator = decimal()
+    expect(validator.test(123.45)).toBe(true)
+    expect(validator.test(-45.67)).toBe(true)
+    expect(validator.test(0.1)).toBe(true)
+    expect(validator.test(123)).toBe(true) // integers are valid decimals
+  })
+
+  it('should reject non-number values', () => {
+    const validator = decimal()
+    expect(validator.test('123.45')).toBe(false)
+    expect(validator.test(null)).toBe(false)
+    expect(validator.test(undefined)).toBe(false)
+    expect(validator.test(Number.NaN)).toBe(false)
+  })
+
+  it('should validate with min/max options', () => {
+    const validator = decimal().min(0).max(10)
+    expect(validator.test(5.5)).toBe(true)
+    expect(validator.test(0)).toBe(true)
+    expect(validator.test(10)).toBe(true)
+    expect(validator.test(-0.1)).toBe(false)
+    expect(validator.test(10.1)).toBe(false)
+  })
+})

test/validators/float.test.ts

@@ -0,0 +1,35 @@
+import { float } from '../../src/validators/float'
+
+describe('floatValidator', () => {
+  it('should validate float numbers', () => {
+    const validator = float()
+    expect(validator.test(3.14)).toBe(true)
+    expect(validator.test(-2.5)).toBe(true)
+    expect(validator.test(0)).toBe(true)
+    expect(validator.test(123)).toBe(true) // integers are valid floats
+  })
+
+  it('should reject non-number values', () => {
+    const validator = float()
+    expect(validator.test('3.14')).toBe(false)
+    expect(validator.test(null)).toBe(false)
+    expect(validator.test(undefined)).toBe(false)
+    expect(validator.test(Number.NaN)).toBe(false)
+  })
+
+  it('should validate with min/max options', () => {
+    const validator = float().min(0).max(10)
+    expect(validator.test(5.5)).toBe(true)
+    expect(validator.test(0)).toBe(true)
+    expect(validator.test(10)).toBe(true)
+    expect(validator.test(-0.1)).toBe(false)
+    expect(validator.test(10.1)).toBe(false)
+  })
+
+  it('should handle edge cases', () => {
+    const validator = float()
+    expect(validator.test(Number.POSITIVE_INFINITY)).toBe(true)
+    expect(validator.test(Number.NEGATIVE_INFINITY)).toBe(true)
+    expect(validator.test(Number.NaN)).toBe(false)
+  })
+})

test/validators/integer.test.ts

@@ -0,0 +1,34 @@
+import { integer } from '../../src/validators/integer'
+
+describe('integerValidator', () => {
+  it('should validate integer numbers', () => {
+    const validator = integer()
+    expect(validator.test(0)).toBe(true)
+    expect(validator.test(123)).toBe(true)
+    expect(validator.test(-456)).toBe(true)
+    expect(validator.test(3.14)).toBe(false)
+  })
+
+  it('should reject non-number values', () => {
+    const validator = integer()
+    expect(validator.test('123')).toBe(false)
+    expect(validator.test(null)).toBe(false)
+    expect(validator.test(undefined)).toBe(false)
+    expect(validator.test(Number.NaN)).toBe(false)
+  })
+
+  it('should validate with min/max options', () => {
+    const validator = integer().min(0).max(10)
+    expect(validator.test(0)).toBe(true)
+    expect(validator.test(10)).toBe(true)
+    expect(validator.test(-1)).toBe(false)
+    expect(validator.test(11)).toBe(false)
+  })
+
+  it('should handle edge cases', () => {
+    const validator = integer()
+    expect(validator.test(Number.POSITIVE_INFINITY)).toBe(false)
+    expect(validator.test(Number.NEGATIVE_INFINITY)).toBe(false)
+    expect(validator.test(Number.NaN)).toBe(false)
+  })
+})