feat: support UnknownArray

Author: holvonixAdvay

README.md

@@ -53,6 +53,7 @@ Currently supports (and their nested closure):
 * `t.undefined`
 * `t.union`
 * `t.unknown`
+* `t.UnknownArray`
 * `t.void`
 
 ## Use Cases

src/core/core.ts

@@ -3,6 +3,7 @@ import { Fuzzer, ConcreteFuzzer, fuzzGenerator } from '../fuzzer';
 import { isLeft, isRight } from 'fp-ts/lib/Either';
 
 export type BasicType =
+  | t.AnyArrayType
   | t.ArrayType<t.Mixed>
   | t.BooleanType
   | t.ExactType<t.Mixed>
@@ -22,7 +23,6 @@ export type BasicType =
   | t.UnknownType
   | t.VoidType
   // not yet supported:
-  | t.AnyArrayType
   | t.AnyDictionaryType
   | t.DictionaryType<t.Mixed, t.Mixed>
   | t.RecursiveType<t.Mixed>
@@ -183,20 +183,24 @@ export function fuzzReadonly(
   };
 }
 
+function arrayFuzzFunc(maxLength: number) {
+  return (n: number, h0: t.Encoder<number, unknown>) => {
+    const ret = [];
+    for (let index = 0; index < n % maxLength; index++) {
+      ret.push(h0.encode(n + index));
+    }
+    return ret;
+  };
+}
+
 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 % maxLength; index++) {
-        ret.push(h0.encode(n + index));
-      }
-      return ret;
-    },
+    func: arrayFuzzFunc(maxLength),
   };
 };
 
@@ -228,6 +232,19 @@ export function readonlyArrayFuzzer(maxLength: number = defaultMaxArrayLength) {
   return gen(fuzzReadonlyArrayWithMaxLength(maxLength), 'ReadonlyArrayType');
 }
 
+const fuzzAnyArrayWithMaxLength = (maxLength: number) => (
+  b: t.AnyArrayType
+): ConcreteFuzzer<unknown[]> => {
+  return {
+    children: [t.unknown],
+    func: arrayFuzzFunc(maxLength),
+  };
+};
+
+export function anyArrayFuzzer(maxLength: number = defaultMaxArrayLength) {
+  return gen(fuzzAnyArrayWithMaxLength(maxLength), 'AnyArrayType');
+}
+
 export const defaultExtraProps = { ___0000_extra_: t.number };
 
 const fuzzPartialWithExtraCodec = (extra: t.Props = defaultExtraProps) => (
@@ -347,6 +364,7 @@ export const coreFuzzers = [
   interfaceFuzzer(),
   partialFuzzer(),
   arrayFuzzer(),
+  anyArrayFuzzer(),
   gen(fuzzExact, 'ExactType'),
   gen(fuzzReadonly, 'ReadonlyType'),
   readonlyArrayFuzzer(),

src/registry.ts

@@ -5,6 +5,7 @@ import {
   partialFuzzer,
   interfaceFuzzer,
   readonlyArrayFuzzer,
+  anyArrayFuzzer,
 } from './core/core';
 
 export interface Registry {
@@ -18,6 +19,7 @@ export interface Registry {
 
 export interface FluentRegistry extends Registry {
   withArrayFuzzer(maxLength?: number): FluentRegistry;
+  withAnyArrayFuzzer(maxLength?: number): FluentRegistry;
   withReadonlyArrayFuzzer(maxLength?: number): FluentRegistry;
   withPartialFuzzer(extra?: t.Props): FluentRegistry;
   withInterfaceFuzzer(extra?: t.Props): FluentRegistry;
@@ -48,6 +50,11 @@ class FluentifiedRegistry implements FluentRegistry {
     return this;
   }
 
+  withAnyArrayFuzzer(maxLength?: number): FluentRegistry {
+    this.register(anyArrayFuzzer(maxLength));
+    return this;
+  }
+
   withReadonlyArrayFuzzer(maxLength?: number): FluentRegistry {
     this.register(readonlyArrayFuzzer(maxLength));
     return this;

test/helpers.ts

@@ -21,6 +21,7 @@ export const types = [
   t.unknown,
   t.array(t.string),
   t.readonlyArray(t.string),
+  t.UnknownArray,
   t.array(t.partial({ s: t.string, m: t.number })),
   t.readonlyArray(t.partial({ s: t.string, m: t.number })),
   t.Int,

test/test-registry.ts

@@ -199,6 +199,50 @@ describe('registry', () => {
         });
       });
 
+      describe('#withAnyArrayFuzzer', () => {
+        describe('on the core registry', () => {
+          it(`overrides the any array fuzzer max length`, () => {
+            const b = t.UnknownArray;
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withAnyArrayFuzzer(3)
+              .exampleGenerator(b);
+            for (let i = 0; i < 100; i++) {
+              assert.ok(r.encode(i).length <= 3);
+            }
+          });
+
+          it(`does not affect specific arrays`, () => {
+            const b = t.array(t.number);
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withAnyArrayFuzzer(3)
+              .exampleGenerator(b);
+            let ml = 0;
+            for (let i = 0; i < 100; i++) {
+              ml = Math.max(r.encode(i).length, ml);
+            }
+            assert.ok(ml > 3);
+          });
+
+          it(`does not affect readonly arrays`, () => {
+            const b = t.readonlyArray(t.number);
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withAnyArrayFuzzer(3)
+              .exampleGenerator(b);
+            let ml = 0;
+            for (let i = 0; i < 100; i++) {
+              ml = Math.max(r.encode(i).length, ml);
+            }
+            assert.ok(ml > 3);
+          });
+        });
+      });
+
       describe('#withReadonlyArrayFuzzer', () => {
         describe('on the core registry', () => {
           it(`overrides the array fuzzer max length`, () => {