feat: support readonlyArray types

Author: holvonixAdvay

README.md

@@ -35,24 +35,25 @@ function fuzz() {
 
 Currently supports (and their nested closure):
 
-* `t.number`
-* `t.string`
+* `t.array`
 * `t.boolean`
-* `t.union`
-* `t.type` (interface)
-* `t.partial`
+* `t.exact`
+* `t.Int`
 * `t.intersection`
-* `t.array`
+* `t.keyof`
+* `t.literal`
 * `t.null`
+* `t.number`
+* `t.partial`
+* `t.readonly`
+* `t.readonlyArray`
+* `t.string`
+* `t.tuple`
+* `t.type` (interface)
 * `t.undefined`
-* `t.void`
+* `t.union`
 * `t.unknown`
-* `t.Int`
-* `t.literal`
-* `t.keyof`
-* `t.tuple`
-* `t.exact`
-* `t.readonly`
+* `t.void`
 
 ## Use Cases
 

src/core/core.ts

@@ -3,30 +3,30 @@ import { Fuzzer, ConcreteFuzzer, fuzzGenerator } from '../fuzzer';
 import { isLeft, isRight } from 'fp-ts/lib/Either';
 
 export type BasicType =
-  | t.NumberType
+  | t.ArrayType<t.Mixed>
   | t.BooleanType
-  | t.StringType
-  | t.NullType
-  | t.UndefinedType
-  | t.VoidType
-  | t.UnknownType
-  | t.UnionType<t.Mixed[]>
+  | t.ExactType<t.Mixed>
   | t.InterfaceType<unknown>
-  | t.PartialType<unknown>
-  | t.ArrayType<t.Mixed>
   | t.IntersectionType<t.Mixed[]>
-  | t.LiteralType<string | number | boolean>
   | t.KeyofType<{ [key: string]: unknown }>
-  | t.TupleType<t.Mixed[]>
-  | t.ExactType<t.Mixed>
+  | t.LiteralType<string | number | boolean>
+  | t.NullType
+  | t.NumberType
+  | t.PartialType<unknown>
+  | t.ReadonlyArrayType<t.Mixed>
   | t.ReadonlyType<t.Mixed>
+  | t.StringType
+  | t.TupleType<t.Mixed[]>
+  | t.UndefinedType
+  | t.UnionType<t.Mixed[]>
+  | t.UnknownType
+  | t.VoidType
   // not yet supported:
   | t.AnyArrayType
   | t.AnyDictionaryType
-  | t.RefinementType<t.Mixed>
-  | t.RecursiveType<t.Mixed>
   | t.DictionaryType<t.Mixed, t.Mixed>
-  | t.ReadonlyArrayType<t.Mixed>;
+  | t.RecursiveType<t.Mixed>
+  | t.RefinementType<t.Mixed>;
 
 export type basicFuzzGenerator<
   T,
@@ -209,6 +209,25 @@ export function arrayFuzzer(maxLength: number = defaultMaxArrayLength) {
  */
 export const fuzzArray = fuzzArrayWithMaxLength();
 
+const fuzzReadonlyArrayWithMaxLength = (maxLength: number) => (
+  b: t.ReadonlyArrayType<t.Mixed>
+): ConcreteFuzzer<unknown[]> => {
+  return {
+    children: [b.type],
+    func: (n, h0) => {
+      const ret = [];
+      for (let index = 0; index < n % maxLength; index++) {
+        ret.push(Object.freeze(h0.encode(n + index)));
+      }
+      return ret;
+    },
+  };
+};
+
+export function readonlyArrayFuzzer(maxLength: number = defaultMaxArrayLength) {
+  return gen(fuzzReadonlyArrayWithMaxLength(maxLength), 'ReadonlyArrayType');
+}
+
 export const defaultExtraProps = { ___0000_extra_: t.number };
 
 const fuzzPartialWithExtraCodec = (extra: t.Props = defaultExtraProps) => (
@@ -330,6 +349,7 @@ export const coreFuzzers = [
   arrayFuzzer(),
   gen(fuzzExact, 'ExactType'),
   gen(fuzzReadonly, 'ReadonlyType'),
+  readonlyArrayFuzzer(),
   gen(fuzzUnion, 'UnionType'),
   gen(fuzzIntersection, 'IntersectionType'),
   gen(fuzzLiteral, 'LiteralType'),

src/registry.ts

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

test/helpers.ts

@@ -20,6 +20,9 @@ export const types = [
   t.void,
   t.unknown,
   t.array(t.string),
+  t.readonlyArray(t.string),
+  t.array(t.partial({ s: t.string, m: t.number })),
+  t.readonlyArray(t.partial({ s: t.string, m: t.number })),
   t.Int,
   t.literal('hello'),
   t.literal(34.4),

test/test-registry.ts

@@ -173,6 +173,20 @@ describe('registry', () => {
             }
           });
 
+          it(`does not affect readonly arrays`, () => {
+            const b = t.readonlyArray(t.number);
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withArrayFuzzer(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(`overrides apply to the underlying registry`, () => {
             const b = t.array(t.number);
             const r0 = lib.createCoreRegistry();
@@ -185,6 +199,36 @@ describe('registry', () => {
         });
       });
 
+      describe('#withReadonlyArrayFuzzer', () => {
+        describe('on the core registry', () => {
+          it(`overrides the array fuzzer max length`, () => {
+            const b = t.readonlyArray(t.number);
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withReadonlyArrayFuzzer(3)
+              .exampleGenerator(b);
+            for (let i = 0; i < 100; i++) {
+              assert.ok(r.encode(i).length <= 3);
+            }
+          });
+
+          it(`does not affect non-readonly arrays`, () => {
+            const b = t.array(t.number);
+            const r0 = lib.createCoreRegistry();
+            const r = lib
+              .fluent(r0)
+              .withReadonlyArrayFuzzer(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('#withPartialFuzzer', () => {
         describe('on the core registry', () => {
           it(`overrides the partial object extra properties`, () => {