feat: support date from io-ts-types. This new dependency is added as a peer -- code using it is only imported on calling loadIoTsTypesFuzzers() (#11)

BREAKING CHANGE: `core` exports re-organized; some removed.  From here on,
only breaking changes to exports from `index.ts` will be deemed breaking
changes for the package.

Author: holvonixAdvay

README.md

@@ -6,7 +6,7 @@
 
 ## Quick Start
 
-After `yarn add io-ts io-ts-fuzzer`...
+After `yarn add fp-ts io-ts io-ts-fuzzer`...
 
 ````typescript
 import * as t from 'io-ts';
@@ -31,7 +31,7 @@ console.log(fuzzer.encode([493, fuzz.fuzzContext()]));
 
 ## Types Supported
 
-Currently supports (and their nested closure):
+Currently supports (along with their nested closure):
 
 * `t.array`
 * `t.boolean`
@@ -55,6 +55,10 @@ Currently supports (and their nested closure):
 * `t.UnknownArray`
 * `t.void`
 
+If you additionally do `yarn add monocle-ts io-ts-types` and register
+the `io-ts-types` extra fuzzers via `r.register(...await loadIoTsTypesFuzzers)`, the following additional types will be supported:
+* `date`
+
 ## Use Cases
 
 ### Generating Conforming Examples and Verifying Decoder Behavior

package.json

@@ -115,9 +115,15 @@
     "concurrently": "^4.1.1",
     "gts": "^1.1.0",
     "husky": "^3.0.2",
+    "io-ts-types": "^0.5.0",
     "mocha": "^6.2.0",
+    "monocle-ts": "^2.0.0",
     "nyc": "^14.1.1",
     "ts-mocha": "^6.0.0",
     "typescript": "~3.5.0"
+  },
+  "peerDependencies": {
+    "io-ts-types": "^0.5.0",
+    "monocle-ts": "^2.0.0"
   }
 }

src/core/core.ts src/core.ts

@@ -5,19 +5,12 @@ import {
   fuzzGenerator,
   FuzzContext,
   FuzzerUnit,
-} from '../fuzzer';
+  concreteFuzzerByName,
+} from './fuzzer';
 import { isLeft, isRight } from 'fp-ts/lib/Either';
-import * as rnd from 'seedrandom';
+import { rngi, rng } from './rng';
 
-function rng(seed: number) {
-  return rnd.tychei(`${seed}`, { global: false });
-}
-
-function rngi(seed: number) {
-  return Math.abs(rng(seed).int32());
-}
-
-export type BasicType =
+type BasicType =
   | t.AnyArrayType
   | t.ArrayType<t.Mixed>
   | t.BooleanType
@@ -43,22 +36,19 @@ export type BasicType =
   | t.DictionaryType<t.Mixed, t.Mixed>
   | t.RefinementType<t.Mixed>;
 
-export type basicFuzzGenerator<
+type basicFuzzGenerator<
   T,
   C extends t.Decoder<unknown, T> & BasicType
 > = fuzzGenerator<T, C>;
 
-export type basicLiteralConcreteFuzzer<
+type basicLiteralConcreteFuzzer<
   T,
   C extends t.Decoder<unknown, T> & BasicType
 > = ConcreteFuzzer<T>['func'];
 
-export type BasicFuzzer<
-  T,
-  C extends t.Decoder<unknown, T> & BasicType
-> = Fuzzer<T, C>;
+type BasicFuzzer<T, C extends t.Decoder<unknown, T> & BasicType> = Fuzzer<T, C>;
 
-export function concrete<T, C extends t.Decoder<unknown, T> & BasicType>(
+function concrete<T, C extends t.Decoder<unknown, T> & BasicType>(
   func: basicLiteralConcreteFuzzer<T, C>,
   tag: C['_tag']
 ): BasicFuzzer<T, C> {
@@ -73,22 +63,7 @@ export function concrete<T, C extends t.Decoder<unknown, T> & BasicType>(
   };
 }
 
-export function concreteNamed<T, C extends t.Decoder<unknown, T>>(
-  func: ConcreteFuzzer<T>['func'],
-  name: C['name']
-): Fuzzer<T, C> {
-  return {
-    impl: {
-      type: 'fuzzer',
-      func,
-      mightRecurse: false,
-    },
-    id: name,
-    idType: 'name',
-  };
-}
-
-export function gen<T, C extends t.Decoder<unknown, T> & BasicType>(
+function gen<T, C extends t.Decoder<unknown, T> & BasicType>(
   func: basicFuzzGenerator<T, C>,
   tag: C['_tag']
 ): BasicFuzzer<T, C> {
@@ -138,7 +113,7 @@ const fuzzUnknownWithType = (codec: t.Decoder<unknown, unknown>) => (
     mightRecurse: false,
     children: [codec],
     func: (ctx, n, h0) =>
-      ctx.shouldGoDeeper() ? h0.encode([rngi(n), ctx.deeper()]) : rngi(n),
+      ctx.mayRecurse() ? h0.encode([rngi(n), ctx.recursed()]) : rngi(n),
   };
 };
 
@@ -165,7 +140,7 @@ export function fuzzUnion(b: t.UnionType<t.Mixed[]>): ConcreteFuzzer<unknown> {
     children: b.types,
     func: (ctx, n, ...h0) => {
       const r = rng(n);
-      const h1 = ctx.shouldGoDeeper() ? h0 : h0.filter(f => !f.mightRecurse);
+      const h1 = ctx.mayRecurse() ? h0 : h0.filter(f => !f.mightRecurse);
       const h = h1.length === 0 ? h0 : h1;
       return h[Math.abs(r.int32()) % h.length].encode([r.int32(), ctx]);
     },
@@ -242,7 +217,7 @@ function arrayFuzzFunc(maxLength: number) {
   return (ctx: FuzzContext, n: number, h0: FuzzerUnit<unknown>) => {
     const ret: unknown[] = [];
     const r = rng(n);
-    if (!ctx.shouldGoDeeper() && h0.mightRecurse) {
+    if (!ctx.mayRecurse() && h0.mightRecurse) {
       return ret;
     }
     const ml = Math.abs(r.int32()) % maxLength;
@@ -278,7 +253,7 @@ const fuzzReadonlyArrayWithMaxLength = (maxLength: number) => (
     func: (ctx, n, h0) => {
       const ret: unknown[] = [];
       const r = rng(n);
-      if (!ctx.shouldGoDeeper() && h0.mightRecurse) {
+      if (!ctx.mayRecurse() && h0.mightRecurse) {
         return ret;
       }
       const ml = Math.abs(r.int32()) % maxLength;
@@ -310,7 +285,7 @@ export function anyArrayFuzzer(maxLength: number = defaultMaxArrayLength) {
 
 export const defaultExtraProps = { ___0000_extra_: t.number };
 
-const fuzzPartialWithExtraCodec = (extra: t.Props) => (
+export const fuzzPartialWithExtraCodec = (extra: t.Props) => (
   b: t.PartialType<t.Props>
 ): ConcreteFuzzer<unknown> => {
   const kk = Object.getOwnPropertyNames(b.props);
@@ -328,7 +303,7 @@ const fuzzPartialWithExtraCodec = (extra: t.Props) => (
       const ret = Object.create(null);
       const r = rng(n0);
       h.forEach((v, i) => {
-        if ((ctx.shouldGoDeeper() || !v.mightRecurse) && r.int32() % 2 === 0) {
+        if ((ctx.mayRecurse() || !v.mightRecurse) && r.int32() % 2 === 0) {
           // Only allow key indices from the original type
           // or added keys not present in original type.
           if (i < kk.length || !kk.includes(keys[i])) {
@@ -345,7 +320,7 @@ export function partialFuzzer(extra: t.Props = defaultExtraProps) {
   return gen(fuzzPartialWithExtraCodec(extra), 'PartialType');
 }
 
-const fuzzInterfaceWithExtraCodec = (extra: t.Props) => (
+export const fuzzInterfaceWithExtraCodec = (extra: t.Props) => (
   b: t.InterfaceType<t.Props>
 ): ConcreteFuzzer<unknown> => {
   const kk = Object.getOwnPropertyNames(b.props);
@@ -366,7 +341,7 @@ const fuzzInterfaceWithExtraCodec = (extra: t.Props) => (
         if (i < kk.length) {
           ret[keys[i]] = v.encode([r.int32(), ctx]);
         } else if (
-          (ctx.shouldGoDeeper() || !v.mightRecurse) &&
+          (ctx.mayRecurse() || !v.mightRecurse) &&
           r.int32() % 2 === 0
         ) {
           // Only allow added keys not present in original type.
@@ -417,9 +392,9 @@ export function fuzzIntersection(
   };
 }
 
-export const coreFuzzers = [
+export const coreFuzzers: ReadonlyArray<Fuzzer> = [
   concrete(fuzzNumber, 'NumberType'),
-  concreteNamed(fuzzInt, 'Int'),
+  concreteFuzzerByName(fuzzInt, 'Int'),
   concrete(fuzzBoolean, 'BooleanType'),
   concrete(fuzzString, 'StringType'),
   concrete(fuzzNull, 'NullType'),
@@ -439,4 +414,4 @@ export const coreFuzzers = [
   gen(fuzzKeyof, 'KeyofType'),
   gen(fuzzTuple, 'TupleType'),
   gen(fuzzRecursive, 'RecursiveType'),
-];
+] as ReadonlyArray<Fuzzer>;

src/core/index.ts

@@ -0,0 +1,8 @@
+import { FuzzContext, concreteFuzzerByName } from '../fuzzer';
+import { rngi } from '../rng';
+
+export function fuzzDate(_: FuzzContext, n: number): Date {
+  return new Date(rngi(n) / 1000.0);
+}
+
+export const fuzzers = [concreteFuzzerByName(fuzzDate, 'Date')];

src/extra-fuzzers/io-ts-types.ts

@@ -0,0 +1,12 @@
+import { Fuzzer } from './fuzzer';
+
+async function loadExtras(str: string): Promise<Array<Fuzzer<unknown>>> {
+  const x = (await import(`./extra-fuzzers/${str}`)) as {
+    fuzzers: Array<Fuzzer<unknown>>;
+  };
+  return x.fuzzers;
+}
+
+export async function loadIoTsTypesFuzzers(): Promise<Array<Fuzzer<unknown>>> {
+  return loadExtras('io-ts-types');
+}

src/extras.ts

@@ -3,13 +3,13 @@ import { Registry } from './registry';
 
 export interface FuzzContext {
   /**
-   * context for the next .
+   * context for the next level of recursion.
    */
-  deeper(): FuzzContext;
+  recursed(): FuzzContext;
   /**
    * false iff the fuzzer should not recurse deeper.
    */
-  shouldGoDeeper(): boolean;
+  mayRecurse(): boolean;
 }
 
 export interface Fuzzer<
@@ -40,6 +40,21 @@ export interface ConcreteFuzzer<T> {
   ) => T;
 }
 
+export function concreteFuzzerByName<T, C extends t.Decoder<unknown, T>>(
+  func: ConcreteFuzzer<T>['func'],
+  name: C['name']
+): Fuzzer<T, C> {
+  return {
+    impl: {
+      type: 'fuzzer',
+      func,
+      mightRecurse: false,
+    },
+    id: name,
+    idType: 'name',
+  };
+}
+
 export type fuzzGenerator<T, C extends t.Decoder<unknown, T>> = (
   b: C
 ) => ConcreteFuzzer<T>;
@@ -52,12 +67,12 @@ const defaultContextOpt = {
 
 export function fuzzContext(opt: ContextOpts = defaultContextOpt): FuzzContext {
   class FC implements FuzzContext {
-    constructor(private readonly mrh: number) {}
-    deeper(): FuzzContext {
-      return new FC(this.mrh - 1);
+    constructor(private readonly maxRecursionHint: number) {}
+    recursed(): FuzzContext {
+      return new FC(this.maxRecursionHint - 1);
     }
-    shouldGoDeeper(): boolean {
-      return this.mrh > 0;
+    mayRecurse(): boolean {
+      return this.maxRecursionHint > 0;
     }
   }
   const ropt = { ...defaultContextOpt, ...opt };
@@ -94,7 +109,7 @@ function encoderFunction<T>(
   children: Array<FuzzerUnit<unknown>>
 ): ExampleGenerator<T>['encode'] {
   return (a: [number, FuzzContext]) => {
-    return k.func(k.mightRecurse ? a[1].deeper() : a[1], a[0], ...children);
+    return k.func(k.mightRecurse ? a[1].recursed() : a[1], a[0], ...children);
   };
 }
 
@@ -159,13 +174,11 @@ export function exampleGenerator<T>(
   return ret;
 }
 
-export const defaultMaxRecursionHint = 5;
-
 export function exampleOf<T>(
   d: t.Decoder<unknown, T>,
   r: Registry,
   a: number,
-  maxRecursionHint: number = defaultMaxRecursionHint
+  maxRecursionHint?: number
 ): T {
   return exampleGenerator(r, d).encode([a, fuzzContext({ maxRecursionHint })]);
 }

src/fuzzer.ts

@@ -23,4 +23,7 @@ Third-party dependencies may have their own licenses.
 
 export * from './registry';
 export * from './fuzzer';
-export * from './core/';
+export * from './extras';
+
+import * as core from './core';
+export { core };

src/index.ts

@@ -1,13 +1,14 @@
 import { Fuzzer, ExampleGenerator, exampleGenerator } from './fuzzer';
 import * as t from 'io-ts';
-import { coreFuzzers, arrayFuzzer } from './core/';
 import {
   partialFuzzer,
   interfaceFuzzer,
   readonlyArrayFuzzer,
   anyArrayFuzzer,
   unknownFuzzer,
-} from './core/core';
+  arrayFuzzer,
+  coreFuzzers,
+} from './core';
 
 export interface Registry {
   register<T, U extends t.Decoder<unknown, T>>(v0: Fuzzer<T, U>): Registry;

src/registry.ts

@@ -0,0 +1,9 @@
+import * as rnd from 'seedrandom';
+
+export function rng(seed: number) {
+  return rnd.tychei(`${seed}`, { global: false });
+}
+
+export function rngi(seed: number) {
+  return Math.abs(rng(seed).int32());
+}