feat: allow customizable max length of array fuzzing

Author: holvonixAdvay

src/core/core.ts

@@ -155,26 +155,39 @@ export function fuzzInterface(
     func: (n, ...h) => {
       const ret = Object.create(null);
       h.forEach((v, i) => {
-        ret[keys[i]] = v.encode(n);
+        ret[keys[i]] = v.encode(n + i);
       });
       return ret;
     },
   };
 }
 
-export function fuzzArray(b: t.ArrayType<t.Mixed>): ConcreteFuzzer<unknown[]> {
+export const defaultMaxArrayLength = 13;
+
+const fuzzArrayWithMaxLength = (maxLength: number = defaultMaxArrayLength) => (
+  b: t.ArrayType<t.Mixed>
+): ConcreteFuzzer<unknown[]> => {
   return {
     children: [b.type],
     func: (n, h0) => {
       const ret = [];
-      for (let index = 0; index < n % 13; index++) {
+      for (let index = 0; index < n % maxLength; index++) {
         ret.push(h0.encode(n + index));
       }
       return ret;
     },
   };
+};
+
+export function arrayFuzzer(maxLength: number = defaultMaxArrayLength) {
+  return gen(fuzzArrayWithMaxLength(maxLength), 'ArrayType');
 }
 
+/**
+ * @deprecated
+ */
+export const fuzzArray = fuzzArrayWithMaxLength();
+
 export function fuzzPartial(
   b: t.PartialType<t.Props>
 ): ConcreteFuzzer<unknown> {
@@ -186,7 +199,7 @@ export function fuzzPartial(
       const ret = Object.create(null);
       h.forEach((v, i) => {
         if (n & (2 ** i)) {
-          ret[keys[i]] = v.encode(n);
+          ret[keys[i]] = v.encode(n + i);
         }
       });
       return ret;
@@ -203,9 +216,9 @@ export function fuzzIntersection(
       let ret: unknown = undefined;
       h.forEach((v, i) => {
         if (ret === undefined) {
-          ret = v.encode(n);
+          ret = v.encode(n + i);
         } else {
-          ret = { ...ret, ...v.encode(n) };
+          ret = { ...ret, ...v.encode(n + i) };
         }
       });
       return ret;
@@ -225,7 +238,7 @@ export const coreFuzzers = [
   gen(fuzzUnion, 'UnionType'),
   gen(fuzzInterface, 'InterfaceType'),
   gen(fuzzPartial, 'PartialType'),
-  gen(fuzzArray, 'ArrayType'),
+  arrayFuzzer(),
   gen(fuzzIntersection, 'IntersectionType'),
   gen(fuzzLiteral, 'LiteralType'),
   gen(fuzzKeyof, 'KeyofType'),

src/core/index.ts

@@ -1 +1 @@
-export { coreFuzzers } from './core';
+export { coreFuzzers, arrayFuzzer } from './core';

src/registry.ts

@@ -1,6 +1,6 @@
 import { Fuzzer, ExampleGenerator, exampleGenerator } from './fuzzer';
 import * as t from 'io-ts';
-import { coreFuzzers } from './core/';
+import { coreFuzzers, arrayFuzzer } from './core/';
 
 export interface Registry {
   register<T, U extends t.Decoder<unknown, T>>(v0: Fuzzer<T, U>): Registry;
@@ -11,6 +11,40 @@ export interface Registry {
   getFuzzer<T>(a: t.Decoder<unknown, T>): Fuzzer<T> | null;
 }
 
+export interface FluentRegistry extends Registry {
+  withArrayFuzzer(maxLength: number): FluentRegistry;
+}
+
+class FluentifiedRegistry implements FluentRegistry {
+  private readonly pimpl: Registry;
+  constructor(pimpl: Registry) {
+    this.pimpl = pimpl;
+  }
+
+  register<T, U extends t.Decoder<unknown, T>>(v0: Fuzzer<T, U>): Registry;
+  register(...vv: Fuzzer[]): FluentRegistry {
+    this.pimpl.register(...vv);
+    return this;
+  }
+
+  exampleGenerator<T>(d: t.Decoder<unknown, T>): ExampleGenerator<T> {
+    return this.pimpl.exampleGenerator(d);
+  }
+
+  getFuzzer<T>(a: t.Decoder<unknown, T>): Fuzzer<T> | null {
+    return this.pimpl.getFuzzer(a);
+  }
+
+  withArrayFuzzer(maxLength: number): FluentRegistry {
+    this.register(arrayFuzzer(maxLength));
+    return this;
+  }
+}
+
+export function fluent(r: Registry): FluentRegistry {
+  return new FluentifiedRegistry(r);
+}
+
 type Key = string;
 
 function fuzzerKey(f: Fuzzer): Key {
@@ -41,7 +75,6 @@ class RegistryC implements Registry {
     ) => ExampleGenerator<T>;
   }
 
-  register<T, U extends t.Decoder<unknown, T>>(v0: Fuzzer<T, U>): Registry;
   register(...vv: Fuzzer[]) {
     for (const v of vv) {
       this.fuzzers.set(fuzzerKey(v), v);

test/test-registry.ts

@@ -127,4 +127,62 @@ describe('registry', () => {
       }
     });
   });
+
+  describe('#fluent', () => {
+    describe('#getFuzzer', () => {
+      describe('on the core registry', () => {
+        for (const b of types) {
+          it(`has a fuzzer for \`${b.name}\` type`, () => {
+            const r = lib.fluent(lib.createCoreRegistry()).getFuzzer(b);
+            assert.ok(r);
+            const x = r!;
+            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);
+            }
+          });
+        }
+      });
+
+      describe('#exampleGenerator', () => {
+        describe('on the core registry', () => {
+          for (const b of types) {
+            it(`can create an example generator for \`${b.name}\` type`, () => {
+              const r = lib
+                .fluent(lib.createCoreRegistry())
+                .exampleGenerator(b);
+              assert.ok(r);
+            });
+          }
+        });
+      });
+
+      describe('#withArrayFuzzer', () => {
+        describe('on the core registry', () => {
+          const b = t.array(t.number);
+          it(`overrides the array fuzzer max length`, () => {
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withArrayFuzzer(3)
+              .exampleGenerator(b);
+            for (let i = 0; i < 100; i++) {
+              assert.ok(r.encode(i).length <= 3);
+            }
+          });
+
+          it(`overrides the array fuzzer max length on the underlying registry`, () => {
+            const r0 = lib.createCoreRegistry();
+            lib.fluent(r0).withArrayFuzzer(3);
+            const r = r0.exampleGenerator(b);
+            for (let i = 0; i < 100; i++) {
+              assert.ok(r.encode(i).length <= 3);
+            }
+          });
+        });
+      });
+    });
+  });
 });

tslint.json

@@ -13,6 +13,7 @@
       "allow-leading-underscore",
       "allow-trailing-underscore",
       "require-const-for-all-caps"
-    ]
+    ],
+    "no-unused-variable": true
   }
-}
+}