feat: support interfaces and partials

Author: holvonixAdvay

README.md

@@ -16,7 +16,7 @@ function fuzz() {
   const r = fuzz.createCoreRegistry();
 
   // Type to fuzz
-  const target = t.union([t.string, t.number, t.boolean]);
+  const target = t.union([t.string, t.type({n:t.number, b:t.boolean})]);
 
   // Builds a particular fuzzer from the registry.
   const fuzzer = fuzz.exampleGenerator(r, target);
@@ -29,6 +29,15 @@ function fuzz() {
 }
 ````
 
+Currently supports:
+
+* `t.number`
+* `t.string`
+* `t.boolean`
+* `t.union`
+* `t.type` (interface)
+* `t.partial`
+
 
 ## License
 

src/core/core.ts

@@ -73,20 +73,20 @@ export function gen<T, C extends t.Decoder<unknown, T> & BasicType>(
   };
 }
 
-export function fuzzBoolean(n: number) {
+export function fuzzBoolean(n: number): boolean {
   return n % 2 === 0;
 }
 
-export function fuzzNumber(n: number) {
+export function fuzzNumber(n: number): number {
   return n;
 }
 
-export function fuzzString(n: number) {
+export function fuzzString(n: number): string {
   return `${n}`;
 }
 
 // tslint:disable-next-line:no-any
-export function fuzzUnion(b: t.UnionC<any>): ConcreteFuzzer<any> {
+export function fuzzUnion(b: t.UnionType<t.Any[]>): ConcreteFuzzer<any> {
   return {
     children: b.types,
     func: (n, ...h) => {
@@ -95,9 +95,47 @@ export function fuzzUnion(b: t.UnionC<any>): ConcreteFuzzer<any> {
   };
 }
 
+export function fuzzInterface(
+  b: t.InterfaceType<t.Props>
+  // tslint:disable-next-line:no-any
+): ConcreteFuzzer<any> {
+  const keys = Object.getOwnPropertyNames(b.props);
+  const vals = keys.map(k => b.props[k]);
+  return {
+    children: vals,
+    func: (n, ...h) => {
+      const ret = Object.create(null);
+      h.forEach((v, i) => {
+        ret[keys[i]] = v.encode(n);
+      });
+      return ret;
+    },
+  };
+}
+
+// tslint:disable-next-line:no-any
+export function fuzzPartial(b: t.PartialType<t.Props>): ConcreteFuzzer<any> {
+  const keys = Object.getOwnPropertyNames(b.props);
+  const vals = keys.map(k => b.props[k]);
+  return {
+    children: vals,
+    func: (n, ...h) => {
+      const ret = Object.create(null);
+      h.forEach((v, i) => {
+        if (n & (2 ** i)) {
+          ret[keys[i]] = v.encode(n);
+        }
+      });
+      return ret;
+    },
+  };
+}
+
 export const coreFuzzers = [
   concrete(fuzzNumber, 'NumberType'),
   concrete(fuzzBoolean, 'BooleanType'),
   concrete(fuzzString, 'StringType'),
   gen(fuzzUnion, 'UnionType'),
+  gen(fuzzInterface, 'InterfaceType'),
+  gen(fuzzPartial, 'PartialType'),
 ];

test/test-index.ts

@@ -3,27 +3,46 @@ import * as lib from '../src/';
 
 import * as t from 'io-ts';
 import { exampleGenerator } from '../src/';
-import { isRight } from 'fp-ts/lib/Either';
+import { isRight, Right } from 'fp-ts/lib/Either';
 
 describe('io-ts-fuzzer', () => {
-  const basicTypes = [
+  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 }),
+    }),
   ];
 
   describe('correctly fuzzes', () => {
-    for (const b of basicTypes) {
+    for (const b of types) {
       describe(`\`${b.name}\` objects`, () => {
         const r = lib.createCoreRegistry()!;
 
         // tslint:disable-next-line:ban
-        for (const n of [...Array(5).keys()]) {
+        for (const n of [...Array(100).keys()]) {
           it(`for input ${n}`, () => {
-            const p = exampleGenerator(r, b).encode;
+            // tslint:disable-next-line:no-any
+            const p = exampleGenerator<any>(r, b).encode;
             const v = p(n);
-            assert.ok(isRight(b.decode(v)), `must decode ${v}`);
+            // tslint:disable-next-line:no-any
+            const d = b.decode(v) as any;
+            assert.ok(isRight(d), `must decode ${JSON.stringify(v)}`);
+            assert.deepStrictEqual(
+              // tslint:disable-next-line:no-any
+              (d as Right<any>).right,
+              v,
+              `must decode ${JSON.stringify(v)}`
+            );
           });
         }
       });