feat: support Ints

Author: holvonixAdvay

README.md

@@ -7,8 +7,6 @@
 
 After `yarn add io-ts io-ts-fuzzer`...
 
-
-
 ````typescript
 import * as t from 'io-ts';
 import * as fuzz from 'io-ts-fuzzer';
@@ -23,7 +21,8 @@ function fuzz() {
   // Builds a particular fuzzer from the registry.
   const fuzzer = fuzz.exampleGenerator(r, target);
 
-  // Make examples.
+  // Make examples. The input number fully determines
+  // the output example.
   console.log(fuzzer.encode(0));
   console.log(fuzzer.encode(1));
   console.log(fuzzer.encode(2));
@@ -45,6 +44,16 @@ Currently supports:
 * `t.undefined`
 * `t.void`
 * `t.unknown`
+* `t.Int`
+
+## Use Cases
+
+### Verifying Decoder Behavior
+
+Given a `d = t.Decoder<I,A>` (aka a `t.Type`), `fuzz.exampleGenerator` will
+build a `t.Encoder<number,A>` that will give example instances of `A`.
+The example instances should all pass on `d.decode`, which should return
+an identical example.  No exceptions should be thrown.
 
 
 ## License

src/core/core.ts

@@ -60,6 +60,20 @@ 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,
+    },
+    id: name,
+    idType: 'name',
+  };
+}
+
 export function gen<T, C extends t.Decoder<unknown, T> & BasicType>(
   func: basicFuzzGenerator<T, C>,
   tag: C['_tag']
@@ -82,6 +96,10 @@ export function fuzzNumber(n: number): number {
   return n;
 }
 
+export function fuzzInt(n: number): t.TypeOf<typeof t.Int> {
+  return Math.floor(n) as t.TypeOf<typeof t.Int>;
+}
+
 export function fuzzString(n: number): string {
   return `${n}`;
 }
@@ -185,6 +203,7 @@ export function fuzzIntersection(
 
 export const coreFuzzers = [
   concrete(fuzzNumber, 'NumberType'),
+  concreteNamed(fuzzInt, 'Int'),
   concrete(fuzzBoolean, 'BooleanType'),
   concrete(fuzzString, 'StringType'),
   concrete(fuzzNull, 'NullType'),

test/helpers.ts

@@ -14,9 +14,10 @@ export const types = [
   t.void,
   t.unknown,
   t.array(t.string),
+  t.Int,
 
   // Complex types
-  t.type({ s: t.string, m: t.type({ n: t.number }) }),
+  t.type({ s: t.string, m: t.type({ n: t.Int }) }),
   t.type({
     s: t.union([t.string, t.number, t.partial({ n: t.number, z: t.string })]),
     m: t.type({ n: t.number }),
@@ -33,13 +34,14 @@ export interface WeirdStringBrand {
   readonly WeirdString: unique symbol;
 }
 
+const weirdString = t.brand(
+  t.string,
+  (a): a is t.Branded<string, WeirdStringBrand> => a.length > 4,
+  'WeirdString'
+);
+
 export const unknownTypes = [
-  t.Int,
-  t.union([t.string, t.Int]),
-  t.brand(
-    t.string,
-    (a): a is t.Branded<string, WeirdStringBrand> => a.length > 4,
-    'WeirdString'
-  ),
+  weirdString,
+  t.union([t.string, weirdString]),
   customStringDecoder,
 ];

test/test-registry.ts

@@ -11,8 +11,12 @@ describe('registry', () => {
           const r = lib.createCoreRegistry().getFuzzer(b);
           assert.ok(r);
           const x = r!;
-          assert.deepStrictEqual(x.idType, 'tag');
-          assert.deepStrictEqual(x.id, b._tag);
+          assert.ok(x.idType === 'tag' || x.idType === 'name');
+          if (x.idType === 'name') {
+            assert.deepStrictEqual(x.id, b.name);
+          } else {
+            assert.deepStrictEqual(x.id, b._tag);
+          }
         });
       }
     });