fix: intersection fuzzer emits only examples consistent with each child type

Author: holvonixAdvay

src/core/core.ts

@@ -1,5 +1,6 @@
 import * as t from 'io-ts';
 import { Fuzzer, ConcreteFuzzer, fuzzGenerator } from '../fuzzer';
+import { isLeft } from 'fp-ts/lib/Either';
 
 export type BasicType =
   | t.NumberType
@@ -266,14 +267,23 @@ export function fuzzIntersection(
   return {
     children: b.types,
     func: (n, ...h) => {
+      let d = 0;
       let ret: unknown = undefined;
-      h.forEach((v, i) => {
-        if (ret === undefined) {
-          ret = v.encode(n + i);
-        } else {
-          ret = { ...ret, ...v.encode(n + i) };
-        }
-      });
+      do {
+        h.forEach((v, i) => {
+          let lp: unknown;
+          lp = v.encode(n + i + d);
+          if (typeof lp !== 'object') {
+            throw new Error('fuzzIntersection cannot support non-object types');
+          }
+          if (ret === undefined) {
+            ret = lp;
+          } else {
+            ret = { ...ret, ...lp };
+          }
+        });
+        d++;
+      } while (h.findIndex((_, i) => isLeft(b.types[i].decode(ret))) > -1);
       return ret;
     },
   };

test/helpers.ts

@@ -30,6 +30,38 @@ export const types = [
   }),
   t.tuple([t.number, t.string, t.boolean]),
   // Complex types
+  t.intersection([
+    t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.type({ s: t.string, j: t.boolean }),
+  ]),
+  t.intersection([
+    t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.type({ s2: t.string, j: t.boolean }),
+  ]),
+  t.union([
+    t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.type({ s: t.string, j: t.boolean }),
+  ]),
+  t.union([
+    t.type({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.type({ s2: t.string, j: t.boolean }),
+  ]),
+  t.intersection([
+    t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.partial({ s: t.string, j: t.boolean }),
+  ]),
+  t.intersection([
+    t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.partial({ s2: t.string, j: t.boolean }),
+  ]),
+  t.union([
+    t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.partial({ s: t.string, j: t.boolean }),
+  ]),
+  t.union([
+    t.partial({ s: t.string, m: t.number, ___0000_extra_: t.boolean }),
+    t.partial({ s2: t.string, j: t.boolean }),
+  ]),
   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 })]),
@@ -58,3 +90,8 @@ export const unknownTypes = [
   t.union([t.string, weirdString]),
   customStringDecoder,
 ];
+
+export const runtimeFailTypes = [
+  t.intersection([t.string, t.type({ m: t.number })]),
+  t.intersection([t.type({ m: t.number }), t.string]),
+];

test/test-fuzzer.ts

@@ -1,7 +1,7 @@
 import * as assert from 'assert';
 import * as lib from '../src/fuzzer';
 
-import { types, unknownTypes } from './helpers';
+import { types, unknownTypes, runtimeFailTypes } from './helpers';
 import { createCoreRegistry } from '../src/registry';
 import { isRight } from 'fp-ts/lib/Either';
 
@@ -13,6 +13,12 @@ describe('fuzzer', () => {
         assert.ok(lib.exampleGenerator(r, b));
       });
     }
+    for (const b of runtimeFailTypes) {
+      it(`can build a fuzzer for \`${b.name}\` type`, () => {
+        const r = createCoreRegistry();
+        assert.ok(lib.exampleGenerator(r, b));
+      });
+    }
     for (const b of unknownTypes) {
       it(`throws on unknown \`${b.name}\` type`, () => {
         const r = createCoreRegistry();
@@ -28,6 +34,12 @@ describe('fuzzer', () => {
         assert.ok(isRight(b.decode(lib.exampleOf(b, r, 0))));
       });
     }
+    for (const b of runtimeFailTypes) {
+      it(`throws on fuzzing \`${b.name}\` type`, () => {
+        const r = createCoreRegistry();
+        assert.throws(() => lib.exampleOf(b, r, 0));
+      });
+    }
     for (const b of unknownTypes) {
       it(`throws on unknown \`${b.name}\` type`, () => {
         const r = createCoreRegistry();