Return error if the input value is null

keito-jp · keito-jp · commit 6ee99100ce7c · 2016-11-24T15:35:36.000+09:00
diff --git a/lib/validators/enum.ts b/lib/validators/enum.ts
@@ -31,15 +31,19 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition
   }
 
   public validate(input: T): IValidationError<T, IEnumValidatorDefinition<T>> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
     for (let i = 0; i < this.definition.enum.length; i++) {
       const e = this.definition.enum[i];
       if (e === input) {
         return;
       }
     }
-    return {
-      definition: this.definition,
-      input,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/format.ts b/lib/validators/format.ts
@@ -32,6 +32,15 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin
   }
 
   public validate(input: string): IValidationError<string, IFormatValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+
+    if (input == null) {
+      return invalid;
+    }
+
     const {format} = this.definition;
     switch (format) {
       case "date-time": {
@@ -66,10 +75,7 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin
       }
 
     }
-    return {
-      definition: this.definition,
-      input,
-    };
+    return invalid;
   }
 
   // stolen from https://golang.org/src/net/dnsclient.go
diff --git a/lib/validators/max_items.ts b/lib/validators/max_items.ts
@@ -22,12 +22,16 @@ export class MaxItemsValidator implements IValidator<any, IMaxItemsValidatorDefi
   }
 
   public validate(input: IHasLength): IValidationError<any, IMaxItemsValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
     if (input.length <= this.definition.maxItems) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/max_length.ts b/lib/validators/max_length.ts
@@ -20,12 +20,16 @@ export class MaxLengthValidator implements IValidator<string, IMaxLengthValidato
   }
 
   public validate(input: string): IValidationError<string, IMaxLengthValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
     if (input.length <= this.definition.maxLength) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/maximum.ts b/lib/validators/maximum.ts
@@ -15,22 +15,24 @@ export class MaximumValidator implements IValidator<number, IMaximumValidatorDef
   }
 
   public validate(input: number): IValidationError<number, IMaximumValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
+
     if (!this.definition.exclusive) {
       if (input <= this.definition.maximum) {
         return;
       }
-      return {
-        input,
-        definition: this.definition,
-      };
+      return invalid;
     }
 
     if (input < this.definition.maximum) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/min_items.ts b/lib/validators/min_items.ts
@@ -22,12 +22,16 @@ export class MinItemsValidator implements IValidator<any, IMinItemsValidatorDefi
   }
 
   public validate(input: IHasLength): IValidationError<any, IMinItemsValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
     if (input.length >= this.definition.minItems) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/min_length.ts b/lib/validators/min_length.ts
@@ -20,12 +20,16 @@ export class MinLengthValidator implements IValidator<string, IMinLengthValidato
   }
 
   public validate(input: string): IValidationError<string, IMinLengthValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
     if (input.length >= this.definition.minLength) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/minimum.ts b/lib/validators/minimum.ts
@@ -15,22 +15,24 @@ export class MinimumValidator implements IValidator<number, IMinimumValidatorDef
   }
 
   public validate(input: number): IValidationError<number, IMinimumValidatorDefinition> {
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+    if (input == null) {
+      return invalid;
+    }
+
     if (!this.definition.exclusive) {
       if (input >= this.definition.minimum) {
         return;
       }
-      return {
-        input,
-        definition: this.definition,
-      };
+      return invalid;
     }
 
     if (input > this.definition.minimum) {
       return;
     }
-    return {
-      input,
-      definition: this.definition,
-    };
+    return invalid;
   }
 }
diff --git a/lib/validators/pattern.ts b/lib/validators/pattern.ts
@@ -29,12 +29,16 @@ export class PatternValidator implements IValidator<string, IPatternValidatorDef
   }
 
   public validate(input: string): IValidationError<string, IPatternValidatorDefinition> {
-    if (this.regExp.test(input)) {
-      return;
-    }
-    return {
+    const invalid = {
       definition: this.definition,
       input,
     };
+    if (input == null) {
+      return invalid;
+    }
+    if (this.regExp.test(input)) {
+      return;
+    }
+    return invalid;
   }
 }
diff --git a/lib/validators/required.ts b/lib/validators/required.ts
@@ -32,18 +32,22 @@ export class RequiredValidator implements IValidator<any, IRequiredValidatorDefi
   }
 
   public validate(input: any): IValidationError<any, IRequiredValidatorDefinition> {
-    const {required} = this.definition;
+    const invalid = {
+      definition: this.definition,
+      input,
+    };
+
+    if (input == null) {
+      return invalid;
+    }
 
+    const {required} = this.definition;
     for (let i = 0; i < required.length; i++) {
       const key = required[i];
       if (input[key] == null) {
-        return {
-          definition: this.definition,
-          input,
-        };
+        return invalid;
       }
     }
-
     return;
   }
 }
diff --git a/test/enum_test.ts b/test/enum_test.ts
@@ -42,6 +42,36 @@ describe("EnumValidator", () => {
 
   describe("validate()", () => {
 
+    it(`should be valid if the input value is null`, () => {
+      const definition = {
+        enum: [
+          "foo",
+          "bar",
+          "baz",
+        ],
+      };
+      const validator = new EnumValidator(definition);
+      [
+        {
+          input: null,
+          expected: {
+            input: null,
+            definition,
+          },
+        },
+        {
+          input: undefined,
+          expected: {
+            input: undefined,
+            definition,
+          },
+        },
+      ].forEach(({input, expected}) => {
+        const actual = validator.validate(input);
+        assert.deepEqual(actual, expected);
+      });
+    });
+
     it(`should be valid if the input value exists in the enum values`, () => {
       const definition = {
         enum: [
diff --git a/test/format_test.ts b/test/format_test.ts
@@ -6,6 +6,32 @@ describe("FormatValidator", () => {
 
   describe("validate()", () => {
 
+    it(`should be valid if the input value is null`, () => {
+      const definition = {
+        format: "date-time",
+      };
+      const validator = new FormatValidator(definition);
+      [
+        {
+          input: null,
+          expected: {
+            input: null,
+            definition,
+          },
+        },
+        {
+          input: undefined,
+          expected: {
+            input: undefined,
+            definition,
+          },
+        },
+      ].forEach(({input, expected}) => {
+        const actual = validator.validate(input);
+        assert.deepEqual(actual, expected);
+      });
+    });
+
     it(`should be valid if the input value matches the date-time format`, () => {
       const definition = {
         format: "date-time",
diff --git a/test/max_items_test.ts b/test/max_items_test.ts
@@ -24,6 +24,32 @@ describe("MaxItemsValidator", () => {
 
   describe("validate()", () => {
 
+    it(`should be valid if the input value is null`, () => {
+      const definition = {
+        maxItems: 3,
+      };
+      const validator = new MaxItemsValidator(definition);
+      [
+        {
+          input: null,
+          expected: {
+            input: null,
+            definition,
+          },
+        },
+        {
+          input: undefined,
+          expected: {
+            input: undefined,
+            definition,
+          },
+        },
+      ].forEach(({input, expected}) => {
+        const actual = validator.validate(input);
+        assert.deepEqual(actual, expected);
+      });
+    });
+
     it(`should be valid if the size of the input is less than, or or equal to, the value of maxItems`, () => {
       const definition = {
         maxItems: 3,
diff --git a/test/max_length_test.ts b/test/max_length_test.ts
@@ -24,6 +24,32 @@ describe("MaxLengthValidator", () => {
 
   describe("validate()", () => {
 
+    it(`should be valid if the input value is null`, () => {
+      const definition = {
+        maxLength: 3,
+      };
+      const validator = new MaxLengthValidator(definition);
+      [
+        {
+          input: null,
+          expected: {
+            input: null,
+            definition,
+          },
+        },
+        {
+          input: undefined,
+          expected: {
+            input: undefined,
+            definition,
+          },
+        },
+      ].forEach(({input, expected}) => {
+        const actual = validator.validate(input);
+        assert.deepEqual(actual, expected);
+      });
+    });
+
     it(`should be valid if the length of the input value is lower than the max length`, () => {
       const definition = {
         maxLength: 3,
diff --git a/test/maximum_test.ts b/test/maximum_test.ts
diff --git a/test/min_items_test.ts b/test/min_items_test.ts
diff --git a/test/min_length_test.ts b/test/min_length_test.ts
diff --git a/test/minimum_test.ts b/test/minimum_test.ts
diff --git a/test/pattern_test.ts b/test/pattern_test.ts
diff --git a/test/required_test.ts b/test/required_test.ts

Original file line number	Diff line number	Diff line change
`@@ -31,15 +31,19 @@ export class EnumValidator<T> implements IValidator<{}, IEnumValidatorDefinition`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public validate(input: T): IValidationError<T, IEnumValidatorDefinition<T>> {`
	`34`	`+ const invalid = {`
	`35`	`+ definition: this.definition,`
	`36`	`+ input,`
	`37`	`+ };`
	`38`	`+ if (input == null) {`
	`39`	`+ return invalid;`
	`40`	`+ }`
`34`	`41`	`for (let i = 0; i < this.definition.enum.length; i++) {`
`35`	`42`	`const e = this.definition.enum[i];`
`36`	`43`	`if (e === input) {`
`37`	`44`	`return;`
`38`	`45`	`}`
`39`	`46`	`}`
`40`		`- return {`
`41`		`- definition: this.definition,`
`42`		`- input,`
`43`		`- };`
	`47`	`+ return invalid;`
`44`	`48`	`}`
`45`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,15 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public validate(input: string): IValidationError<string, IFormatValidatorDefinition> {`
	`35`	`+ const invalid = {`
	`36`	`+ definition: this.definition,`
	`37`	`+ input,`
	`38`	`+ };`
	`39`	`+`
	`40`	`+ if (input == null) {`
	`41`	`+ return invalid;`
	`42`	`+ }`
	`43`	`+`
`35`	`44`	`const {format} = this.definition;`
`36`	`45`	`switch (format) {`
`37`	`46`	`case "date-time": {`
`@@ -66,10 +75,7 @@ export class FormatValidator implements IValidator<string, IFormatValidatorDefin`
`66`	`75`	`}`
`67`	`76`
`68`	`77`	`}`
`69`		`- return {`
`70`		`- definition: this.definition,`
`71`		`- input,`
`72`		`- };`
	`78`	`+ return invalid;`
`73`	`79`	`}`
`74`	`80`
`75`	`81`	`// stolen from https://golang.org/src/net/dnsclient.go`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,16 @@ export class MaxItemsValidator implements IValidator<any, IMaxItemsValidatorDefi`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public validate(input: IHasLength): IValidationError<any, IMaxItemsValidatorDefinition> {`
	`25`	`+ const invalid = {`
	`26`	`+ definition: this.definition,`
	`27`	`+ input,`
	`28`	`+ };`
	`29`	`+ if (input == null) {`
	`30`	`+ return invalid;`
	`31`	`+ }`
`25`	`32`	`if (input.length <= this.definition.maxItems) {`
`26`	`33`	`return;`
`27`	`34`	`}`
`28`		`- return {`
`29`		`- input,`
`30`		`- definition: this.definition,`
`31`		`- };`
	`35`	`+ return invalid;`
`32`	`36`	`}`
`33`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,16 @@ export class MaxLengthValidator implements IValidator<string, IMaxLengthValidato`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public validate(input: string): IValidationError<string, IMaxLengthValidatorDefinition> {`
	`23`	`+ const invalid = {`
	`24`	`+ definition: this.definition,`
	`25`	`+ input,`
	`26`	`+ };`
	`27`	`+ if (input == null) {`
	`28`	`+ return invalid;`
	`29`	`+ }`
`23`	`30`	`if (input.length <= this.definition.maxLength) {`
`24`	`31`	`return;`
`25`	`32`	`}`
`26`		`- return {`
`27`		`- input,`
`28`		`- definition: this.definition,`
`29`		`- };`
	`33`	`+ return invalid;`
`30`	`34`	`}`
`31`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,22 +15,24 @@ export class MaximumValidator implements IValidator<number, IMaximumValidatorDef`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public validate(input: number): IValidationError<number, IMaximumValidatorDefinition> {`
	`18`	`+ const invalid = {`
	`19`	`+ definition: this.definition,`
	`20`	`+ input,`
	`21`	`+ };`
	`22`	`+ if (input == null) {`
	`23`	`+ return invalid;`
	`24`	`+ }`
	`25`	`+`
`18`	`26`	`if (!this.definition.exclusive) {`
`19`	`27`	`if (input <= this.definition.maximum) {`
`20`	`28`	`return;`
`21`	`29`	`}`
`22`		`- return {`
`23`		`- input,`
`24`		`- definition: this.definition,`
`25`		`- };`
	`30`	`+ return invalid;`
`26`	`31`	`}`
`27`	`32`
`28`	`33`	`if (input < this.definition.maximum) {`
`29`	`34`	`return;`
`30`	`35`	`}`
`31`		`- return {`
`32`		`- input,`
`33`		`- definition: this.definition,`
`34`		`- };`
	`36`	`+ return invalid;`
`35`	`37`	`}`
`36`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,16 @@ export class MinItemsValidator implements IValidator<any, IMinItemsValidatorDefi`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`public validate(input: IHasLength): IValidationError<any, IMinItemsValidatorDefinition> {`
	`25`	`+ const invalid = {`
	`26`	`+ definition: this.definition,`
	`27`	`+ input,`
	`28`	`+ };`
	`29`	`+ if (input == null) {`
	`30`	`+ return invalid;`
	`31`	`+ }`
`25`	`32`	`if (input.length >= this.definition.minItems) {`
`26`	`33`	`return;`
`27`	`34`	`}`
`28`		`- return {`
`29`		`- input,`
`30`		`- definition: this.definition,`
`31`		`- };`
	`35`	`+ return invalid;`
`32`	`36`	`}`
`33`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,12 +20,16 @@ export class MinLengthValidator implements IValidator<string, IMinLengthValidato`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public validate(input: string): IValidationError<string, IMinLengthValidatorDefinition> {`
	`23`	`+ const invalid = {`
	`24`	`+ definition: this.definition,`
	`25`	`+ input,`
	`26`	`+ };`
	`27`	`+ if (input == null) {`
	`28`	`+ return invalid;`
	`29`	`+ }`
`23`	`30`	`if (input.length >= this.definition.minLength) {`
`24`	`31`	`return;`
`25`	`32`	`}`
`26`		`- return {`
`27`		`- input,`
`28`		`- definition: this.definition,`
`29`		`- };`
	`33`	`+ return invalid;`
`30`	`34`	`}`
`31`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,22 +15,24 @@ export class MinimumValidator implements IValidator<number, IMinimumValidatorDef`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public validate(input: number): IValidationError<number, IMinimumValidatorDefinition> {`
	`18`	`+ const invalid = {`
	`19`	`+ definition: this.definition,`
	`20`	`+ input,`
	`21`	`+ };`
	`22`	`+ if (input == null) {`
	`23`	`+ return invalid;`
	`24`	`+ }`
	`25`	`+`
`18`	`26`	`if (!this.definition.exclusive) {`
`19`	`27`	`if (input >= this.definition.minimum) {`
`20`	`28`	`return;`
`21`	`29`	`}`
`22`		`- return {`
`23`		`- input,`
`24`		`- definition: this.definition,`
`25`		`- };`
	`30`	`+ return invalid;`
`26`	`31`	`}`
`27`	`32`
`28`	`33`	`if (input > this.definition.minimum) {`
`29`	`34`	`return;`
`30`	`35`	`}`
`31`		`- return {`
`32`		`- input,`
`33`		`- definition: this.definition,`
`34`		`- };`
	`36`	`+ return invalid;`
`35`	`37`	`}`
`36`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,18 +32,22 @@ export class RequiredValidator implements IValidator<any, IRequiredValidatorDefi`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public validate(input: any): IValidationError<any, IRequiredValidatorDefinition> {`
`35`		`- const {required} = this.definition;`
	`35`	`+ const invalid = {`
	`36`	`+ definition: this.definition,`
	`37`	`+ input,`
	`38`	`+ };`
	`39`	`+`
	`40`	`+ if (input == null) {`
	`41`	`+ return invalid;`
	`42`	`+ }`
`36`	`43`
	`44`	`+ const {required} = this.definition;`
`37`	`45`	`for (let i = 0; i < required.length; i++) {`
`38`	`46`	`const key = required[i];`
`39`	`47`	`if (input[key] == null) {`
`40`		`- return {`
`41`		`- definition: this.definition,`
`42`		`- input,`
`43`		`- };`
	`48`	`+ return invalid;`
`44`	`49`	`}`
`45`	`50`	`}`
`46`		`-`
`47`	`51`	`return;`
`48`	`52`	`}`
`49`	`53`	`}`