feat: support arrays, intersection, null, undefined, void, unknown

Author: holvonixAdvay

README.md

@@ -37,6 +37,12 @@ Currently supports:
 * `t.union`
 * `t.type` (interface)
 * `t.partial`
+* `t.intersection`
+* `t.array`
+* `t.null`
+* `t.undefined`
+* `t.void`
+* `t.unknown`
 
 
 ## License

src/core/core.ts

@@ -22,6 +22,7 @@ export type BasicType =
   | t.PartialType<any>
   | t.DictionaryType<t.Any, t.Any>
   | t.UnionType<t.Any[]>
+  | t.IntersectionType<t.Any[]>
   // tslint:disable-next-line:no-any
   | t.InterfaceType<any>
   | t.TupleType<t.Any[]>
@@ -85,6 +86,20 @@ export function fuzzString(n: number): string {
   return `${n}`;
 }
 
+export function fuzzNull(): null {
+  return null;
+}
+
+export function fuzzUndefined(): undefined {
+  return undefined;
+}
+
+export function fuzzVoid(): void {}
+
+export function fuzzUnknown(n: number): unknown {
+  return n;
+}
+
 // tslint:disable-next-line:no-any
 export function fuzzUnion(b: t.UnionType<t.Any[]>): ConcreteFuzzer<any> {
   return {
@@ -113,6 +128,22 @@ export function fuzzInterface(
   };
 }
 
+export function fuzzArray(
+  b: t.ArrayType<t.Mixed>
+  // tslint:disable-next-line:no-any
+): ConcreteFuzzer<any[]> {
+  return {
+    children: [b.type],
+    func: (n, h0) => {
+      const ret = [];
+      for (let index = 0; index < n % 103; index++) {
+        ret.push(h0.encode(n + index));
+      }
+      return ret;
+    },
+  };
+}
+
 // tslint:disable-next-line:no-any
 export function fuzzPartial(b: t.PartialType<t.Props>): ConcreteFuzzer<any> {
   const keys = Object.getOwnPropertyNames(b.props);
@@ -131,11 +162,38 @@ export function fuzzPartial(b: t.PartialType<t.Props>): ConcreteFuzzer<any> {
   };
 }
 
+export function fuzzIntersection(
+  b: t.IntersectionType<t.Any[]>
+  // tslint:disable-next-line:no-any
+): ConcreteFuzzer<any> {
+  return {
+    children: b.types,
+    func: (n, ...h) => {
+      // tslint:disable-next-line:no-any
+      let ret: any = undefined;
+      h.forEach((v, i) => {
+        if (ret === undefined) {
+          ret = v.encode(n);
+        } else {
+          ret = { ...ret, ...v.encode(n) };
+        }
+      });
+      return ret;
+    },
+  };
+}
+
 export const coreFuzzers = [
   concrete(fuzzNumber, 'NumberType'),
   concrete(fuzzBoolean, 'BooleanType'),
   concrete(fuzzString, 'StringType'),
+  concrete(fuzzNull, 'NullType'),
+  concrete(fuzzUndefined, 'UndefinedType'),
+  concrete(fuzzVoid, 'VoidType'),
+  concrete(fuzzUnknown, 'UnknownType'),
   gen(fuzzUnion, 'UnionType'),
   gen(fuzzInterface, 'InterfaceType'),
   gen(fuzzPartial, 'PartialType'),
+  gen(fuzzArray, 'ArrayType'),
+  gen(fuzzIntersection, 'IntersectionType'),
 ];

test/helpers.ts

@@ -0,0 +1,24 @@
+import * as t from 'io-ts';
+
+export const types = [
+  // Simple 0- or 1-depth types
+  t.number,
+  t.string,
+  t.boolean,
+  t.union([t.string, t.number, t.boolean]),
+  t.intersection([t.type({ s: t.string }), t.type({ m: t.number })]),
+  t.type({ s: t.string, m: t.number }),
+  t.partial({ s: t.string, m: t.number }),
+  t.null,
+  t.undefined,
+  t.void,
+  t.unknown,
+  t.array(t.string),
+
+  // Complex types
+  t.type({ s: t.string, m: t.type({ n: t.number }) }),
+  t.type({
+    s: t.union([t.string, t.number, t.partial({ n: t.number, z: t.string })]),
+    m: t.type({ n: t.number }),
+  }),
+];

test/test-index.ts

@@ -1,35 +1,20 @@
 import * as assert from 'assert';
 import * as lib from '../src/';
 
-import * as t from 'io-ts';
 import { exampleGenerator } from '../src/';
 import { isRight, Right } from 'fp-ts/lib/Either';
+import { types } from './helpers';
 
-describe('io-ts-fuzzer', () => {
-  const types = [
-    // Simple 0- or 1-depth types
-    t.number,
-    t.string,
-    t.boolean,
-    t.union([t.string, t.number, t.boolean]),
-    t.type({ s: t.string, m: t.number }),
-    t.partial({ s: t.string, m: t.number }),
-
-    // Complex types
-    t.type({ s: t.string, m: t.type({ n: t.number }) }),
-    t.type({
-      s: t.union([t.string, t.number, t.partial({ n: t.number, z: t.string })]),
-      m: t.type({ n: t.number }),
-    }),
-  ];
+const count = 103;
 
+describe('io-ts-fuzzer', () => {
   describe('correctly fuzzes', () => {
     for (const b of types) {
       describe(`\`${b.name}\` objects`, () => {
         const r = lib.createCoreRegistry()!;
 
         // tslint:disable-next-line:ban
-        for (const n of [...Array(100).keys()]) {
+        for (const n of [...Array(count).keys()]) {
           it(`for input ${n}`, () => {
             // tslint:disable-next-line:no-any
             const p = exampleGenerator<any>(r, b).encode;

test/test-registry.ts

@@ -1,19 +1,12 @@
 import * as assert from 'assert';
 import * as lib from '../src/registry';
 
-import * as t from 'io-ts';
+import { types } from './helpers';
 
 describe('registry', () => {
   describe('#createCoreRegistry', () => {
-    const basicTypes = [
-      t.number,
-      t.string,
-      t.boolean,
-      t.union([t.string, t.number, t.boolean]),
-    ];
-
     describe('#getFuzzer', () => {
-      for (const b of basicTypes) {
+      for (const b of types) {
         it(`has a fuzzer for \`${b.name}\` type`, () => {
           const r = lib.createCoreRegistry().getFuzzer(b);
           assert.ok(r);