feat: support configuring extra properties for interface fuzzers

Author: holvonixAdvay

README.md

@@ -67,7 +67,7 @@ The `FluentRegistry` interface lets you easily change certain core
 fuzzers, currently:
 
 * maximum array length
-* extra properties inserted into `partial` objects
+* extra properties inserted into `partial` and `type` (interface) objects
 
 ### Fuzzing a Type (TODO)
 

src/core/core.ts

@@ -144,23 +144,6 @@ export function fuzzKeyof(
   };
 }
 
-export function fuzzInterface(
-  b: t.InterfaceType<t.Props>
-): ConcreteFuzzer<unknown> {
-  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 + i);
-      });
-      return ret;
-    },
-  };
-}
-
 export function fuzzTuple(
   b: t.TupleType<t.Mixed[]>
 ): ConcreteFuzzer<unknown[]> {
@@ -198,9 +181,11 @@ export function arrayFuzzer(maxLength: number = defaultMaxArrayLength) {
  */
 export const fuzzArray = fuzzArrayWithMaxLength();
 
-const fuzzPartialWithExtraCodec = (
-  extra: t.Props = { ___0000_extra_: t.number }
-) => (b: t.PartialType<t.Props>): ConcreteFuzzer<unknown> => {
+export const defaultExtraProps = { ___0000_extra_: t.number };
+
+const fuzzPartialWithExtraCodec = (extra: t.Props = defaultExtraProps) => (
+  b: t.PartialType<t.Props>
+): ConcreteFuzzer<unknown> => {
   const kk = Object.getOwnPropertyNames(b.props);
   const xx = Object.getOwnPropertyNames(extra);
   const keys = Object.getOwnPropertyNames(b.props).concat(
@@ -216,7 +201,7 @@ const fuzzPartialWithExtraCodec = (
       h.forEach((v, i) => {
         if (n & (2 ** i)) {
           // Only allow key indices from the original type
-          // or added keys without indices.
+          // or added keys not present in original type.
           if (i < kk.length || !kk.includes(keys[i])) {
             ret[keys[i]] = v.encode(n + i);
           }
@@ -227,7 +212,7 @@ const fuzzPartialWithExtraCodec = (
   };
 };
 
-export function partialFuzzer(extra: t.Props = { ___0000_extra_: t.number }) {
+export function partialFuzzer(extra: t.Props = defaultExtraProps) {
   return gen(fuzzPartialWithExtraCodec(extra), 'PartialType');
 }
 
@@ -236,6 +221,45 @@ export function partialFuzzer(extra: t.Props = { ___0000_extra_: t.number }) {
  */
 export const fuzzPartial = fuzzPartialWithExtraCodec();
 
+const fuzzInterfaceWithExtraCodec = (extra: t.Props = defaultExtraProps) => (
+  b: t.InterfaceType<t.Props>
+): ConcreteFuzzer<unknown> => {
+  const kk = Object.getOwnPropertyNames(b.props);
+  const xx = Object.getOwnPropertyNames(extra);
+  const keys = Object.getOwnPropertyNames(b.props).concat(
+    Object.getOwnPropertyNames(extra)
+  );
+  const vals = keys.map((k, i) =>
+    i < kk.length ? b.props[k] : extra[xx[i - kk.length]]
+  );
+  return {
+    children: vals,
+    func: (n, ...h) => {
+      const ret = Object.create(null);
+      h.forEach((v, i) => {
+        if (i < kk.length) {
+          ret[keys[i]] = v.encode(n + i);
+        } else if (n & (2 ** (i - kk.length))) {
+          // Only allow added keys not present in original type.
+          if (!kk.includes(keys[i])) {
+            ret[keys[i]] = v.encode(n + i);
+          }
+        }
+      });
+      return ret;
+    },
+  };
+};
+
+export function interfaceFuzzer(extra: t.Props = defaultExtraProps) {
+  return gen(fuzzInterfaceWithExtraCodec(extra), 'InterfaceType');
+}
+
+/**
+ * @deprecated
+ */
+export const fuzzInterface = fuzzInterfaceWithExtraCodec();
+
 export function fuzzIntersection(
   b: t.IntersectionType<t.Any[]>
 ): ConcreteFuzzer<unknown> {
@@ -264,7 +288,7 @@ export const coreFuzzers = [
   concrete(fuzzVoid, 'VoidType'),
   concrete(fuzzUnknown, 'UnknownType'),
   gen(fuzzUnion, 'UnionType'),
-  gen(fuzzInterface, 'InterfaceType'),
+  interfaceFuzzer(),
   partialFuzzer(),
   arrayFuzzer(),
   gen(fuzzIntersection, 'IntersectionType'),

src/registry.ts

@@ -1,7 +1,7 @@
 import { Fuzzer, ExampleGenerator, exampleGenerator } from './fuzzer';
 import * as t from 'io-ts';
 import { coreFuzzers, arrayFuzzer } from './core/';
-import { partialFuzzer } from './core/core';
+import { partialFuzzer, interfaceFuzzer } from './core/core';
 
 export interface Registry {
   register<T, U extends t.Decoder<unknown, T>>(v0: Fuzzer<T, U>): Registry;
@@ -15,6 +15,7 @@ export interface Registry {
 export interface FluentRegistry extends Registry {
   withArrayFuzzer(maxLength?: number): FluentRegistry;
   withPartialFuzzer(extra?: t.Props): FluentRegistry;
+  withInterfaceFuzzer(extra?: t.Props): FluentRegistry;
 }
 
 class FluentifiedRegistry implements FluentRegistry {
@@ -46,6 +47,11 @@ class FluentifiedRegistry implements FluentRegistry {
     this.register(partialFuzzer(extra));
     return this;
   }
+
+  withInterfaceFuzzer(extra?: t.Props): FluentRegistry {
+    this.register(interfaceFuzzer(extra));
+    return this;
+  }
 }
 
 export function fluent(r: Registry): FluentRegistry {

test/helpers.ts

@@ -8,6 +8,8 @@ export const types = [
   t.union([t.string, t.number, t.boolean]),
   t.intersection([t.type({ s: t.string }), t.type({ m: t.number })]),
   t.type({ s: t.string, m: t.number }),
+  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.null,
   t.undefined,

test/test-registry.ts

@@ -173,6 +173,20 @@ describe('registry', () => {
             }
           });
 
+          it(`overrides apply to the underlying registry`, () => {
+            const b = t.array(t.number);
+            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);
+            }
+          });
+        });
+      });
+
+      describe('#withPartialFuzzer', () => {
+        describe('on the core registry', () => {
           it(`overrides the partial object extra properties`, () => {
             const b = t.partial({ a: t.number });
             const r0 = lib.createCoreRegistry();
@@ -188,15 +202,29 @@ describe('registry', () => {
             assert.ok(keys.has('a'));
             assert.ok(keys.has('b'));
           });
+        });
+      });
 
-          it(`overrides apply to the underlying registry`, () => {
-            const b = t.array(t.number);
+      describe('#withInterfaceFuzzer', () => {
+        describe('on the core registry', () => {
+          it(`overrides the partial object extra properties`, () => {
+            const b = t.type({ a: t.number, j: t.boolean });
             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);
+            const r = lib
+              .fluent(r0)
+              .withInterfaceFuzzer({ b: t.string })
+              .exampleGenerator(b);
+            const keys = new Set<string>();
+            for (let i = 0; i < 10; i++) {
+              const ek = Object.keys(r.encode(i));
+              assert.ok(ek.includes('a'));
+              assert.ok(ek.includes('j'));
+              ek.map(x => keys.add(x));
             }
+            assert.deepStrictEqual(keys.size, 3);
+            assert.ok(keys.has('a'));
+            assert.ok(keys.has('j'));
+            assert.ok(keys.has('b'));
           });
         });
       });