feat: support exact types

Author: holvonixAdvay

README.md

@@ -51,6 +51,7 @@ Currently supports (and their nested closure):
 * `t.literal`
 * `t.keyof`
 * `t.tuple`
+* `t.exact`
 
 ## Use Cases
 

src/core/core.ts

@@ -1,6 +1,6 @@
 import * as t from 'io-ts';
 import { Fuzzer, ConcreteFuzzer, fuzzGenerator } from '../fuzzer';
-import { isLeft } from 'fp-ts/lib/Either';
+import { isLeft, isRight } from 'fp-ts/lib/Either';
 
 export type BasicType =
   | t.NumberType
@@ -18,15 +18,15 @@ export type BasicType =
   | t.LiteralType<string | number | boolean>
   | t.KeyofType<{ [key: string]: unknown }>
   | t.TupleType<t.Mixed[]>
+  | t.ExactType<t.Mixed>
   // not yet supported:
   | t.AnyArrayType
   | t.AnyDictionaryType
   | t.RefinementType<t.Mixed>
   | t.RecursiveType<t.Mixed>
   | t.DictionaryType<t.Mixed, t.Mixed>
   | t.ReadonlyType<t.Mixed>
-  | t.ReadonlyArrayType<t.Mixed>
-  | t.ExactType<t.Mixed>;
+  | t.ReadonlyArrayType<t.Mixed>;
 
 export type basicFuzzGenerator<
   T,
@@ -156,6 +156,21 @@ export function fuzzTuple(
   };
 }
 
+export function fuzzExact(b: t.ExactC<t.HasProps>): ConcreteFuzzer<unknown> {
+  return {
+    children: [b.type],
+    func: (n, h0) => {
+      const r = h0.encode(n);
+      const d = b.decode(r);
+      /* istanbul ignore if */
+      if (!isRight(d)) {
+        throw new Error(`codec failed to decode underlying example`);
+      }
+      return d.right;
+    },
+  };
+}
+
 export const defaultMaxArrayLength = 13;
 
 const fuzzArrayWithMaxLength = (maxLength: number = defaultMaxArrayLength) => (
@@ -291,19 +306,20 @@ export function fuzzIntersection(
 
 export const coreFuzzers = [
   concrete(fuzzNumber, 'NumberType'),
+  concreteNamed(fuzzInt, 'Int'),
   concrete(fuzzBoolean, 'BooleanType'),
   concrete(fuzzString, 'StringType'),
   concrete(fuzzNull, 'NullType'),
   concrete(fuzzUndefined, 'UndefinedType'),
   concrete(fuzzVoid, 'VoidType'),
   concrete(fuzzUnknown, 'UnknownType'),
-  gen(fuzzUnion, 'UnionType'),
   interfaceFuzzer(),
   partialFuzzer(),
   arrayFuzzer(),
+  gen(fuzzExact, 'ExactType'),
+  gen(fuzzUnion, 'UnionType'),
   gen(fuzzIntersection, 'IntersectionType'),
   gen(fuzzLiteral, 'LiteralType'),
   gen(fuzzKeyof, 'KeyofType'),
   gen(fuzzTuple, 'TupleType'),
-  concreteNamed(fuzzInt, 'Int'),
 ];

test/helpers.ts

@@ -11,6 +11,22 @@ export const types = [
   t.type({ s: t.string, m: t.number, ___0000_extra_: t.string }),
   t.partial({ s: t.string, m: t.number }),
   t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+  t.exact(t.type({ s: t.string, m: t.number })),
+  t.exact(t.type({ s: t.string, m: t.number, ___0000_extra_: t.string })),
+  t.exact(t.partial({ s: t.string, m: t.number })),
+  t.exact(t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean })),
+  t.exact(
+    t.intersection([
+      t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+      t.type({ s: t.string, j: t.boolean }),
+    ])
+  ),
+  t.exact(
+    t.intersection([
+      t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+      t.type({ s2: t.string, j: t.boolean }),
+    ])
+  ),
   t.null,
   t.undefined,
   t.void,

test/test-fuzzer.ts

@@ -4,6 +4,7 @@ import * as lib from '../src/fuzzer';
 import { types, unknownTypes, runtimeFailTypes } from './helpers';
 import { createCoreRegistry } from '../src/registry';
 import { isRight } from 'fp-ts/lib/Either';
+import { inspect } from 'util';
 
 describe('fuzzer', () => {
   describe('#exampleGenerator', () => {
@@ -31,7 +32,8 @@ describe('fuzzer', () => {
     for (const b of types) {
       it(`can fuzz \`${b.name}\` type`, () => {
         const r = createCoreRegistry();
-        assert.ok(isRight(b.decode(lib.exampleOf(b, r, 0))));
+        const ex = lib.exampleOf(b, r, 0);
+        assert.ok(isRight(b.decode(ex)), inspect(ex));
       });
     }
     for (const b of runtimeFailTypes) {