toArray isolated tests

Author: hoichi

src/index.test.ts

@@ -1,6 +1,6 @@
 import { isNumber, isString } from "lodash";
 
-import { be, beTrue, decode } from "./index";
+import { be, beArray, beTrue, decode } from "./index";
 
 test("be", () => {
   const numError = "Not a number!";
@@ -17,7 +17,7 @@ test("beTrue", () => {
   expect(() => beTrue(5.7, eq(5.5), fiverError)).toThrow(fiverError);
 });
 
-test("orBe: validation ok", () => {
+test("decode: validation ok", () => {
   expect(
     decode(
       ["foo", "bar"],
@@ -33,7 +33,7 @@ test("orBe: validation ok", () => {
   });
 });
 
-test("orBe: falling back", () => {
+test("decode: falling back", () => {
   const logger = jest.fn();
 
   expect(
@@ -50,3 +50,69 @@ test("orBe: falling back", () => {
 
   expect(logger).toBeCalledWith(expect.objectContaining({ message: "Failed" }));
 });
+
+test("beArray: happy path", () => {
+  expect(beArray([1, false, "Bob"], el => el)).toStrictEqual([1, false, "Bob"]);
+});
+
+test("beArray: filtering", () => {
+  expect(
+    beArray(["a", 0, "b", 1, "c"], s => {
+      if (typeof s !== "string") throw Error("!");
+      return { s };
+    })
+  ).toStrictEqual([{ s: "a" }, { s: "b" }, { s: "c" }]);
+});
+
+test("beArray: invalidate all", () => {
+  expect(() =>
+    beArray(
+      ["a", 0, "b", 1, "c"],
+      x => {
+        if (typeof x !== "string") throw Error("!!!");
+        return x;
+      },
+      { invalidateAll: true }
+    )
+  ).toThrow("!!!");
+});
+
+test("beArray: not an array", () => {
+  expect(() => {
+    beArray("[]", x => x);
+  }).toThrow("“[]” (string) is not an array");
+
+  expect(() => {
+    beArray(3.14, x => x);
+  }).toThrow("3.14 (number) is not an array");
+
+  expect(() => {
+    beArray("[]", x => x, {
+      notAnArrayError: "Not quite an array one would expect"
+    });
+  }).toThrow("Not quite an array one would expect");
+});
+
+test("beArray: checkLength", () => {
+  expect(() =>
+    beArray(
+      [false, false, false, false, true],
+      x => {
+        if (!x) throw Error("!!!");
+        return x;
+      },
+      { minLength: 2, minLengthError: "Way too short!" }
+    )
+  ).toThrow("Way too short!");
+
+  expect(() =>
+    beArray(
+      [false, false, false, false, true],
+      x => {
+        if (!x) throw Error("!!!");
+        return x;
+      },
+      { minLength: 2 }
+    )
+  ).toThrow("Array length (1) less than specified (2)");
+});

src/index.ts

@@ -73,36 +73,51 @@ export function decode<In, Out, Fb>(
   }
 }
 
-// todo: fallback()
-// something like orNull, simpler than the whole decode
-
 type ArrayOptions = {
   invalidateAll?: boolean;
   minLength?: number;
+  minLengthError?: string;
+  notAnArrayError?: string;
 };
 
 export function beArray<Out>(
   input: unknown,
-  elDecoder: (el: unknown) => Out,
-  { invalidateAll, minLength = Infinity }: ArrayOptions = {}
+  elementDecoder: (el: unknown) => Out,
+  {
+    invalidateAll,
+    minLength = 0,
+    minLengthError,
+    notAnArrayError
+  }: ArrayOptions = {}
 ): Out[] | null {
-  if (!isArray(input)) return null; // todo: customize
+  if (!isArray(input))
+    throw TypeError(
+      notAnArrayError || `${printValueInfo(input)} is not an array`
+    );
 
   const result = [];
   for (const el of input) {
     try {
-      result.push(elDecoder(el));
+      result.push(elementDecoder(el));
     } catch (e) {
       if (invalidateAll) throw e;
       // otherwise, don’t push the result, but swallow the exception,
-      // effectively invalidating the single element, but not the whole array
-		// todo: but shouldn’t `decode` log those errors? then every
-		//  `orNull` and `fallback` should rethrow or smth
-		//  Or, we should introduce verbosity/severity
-		//  Or, decode should be a logging point, but fallback should mean it’s
-		//  ok to fall back
+      // effectively invalidating a single element, but not the whole array
     }
   }
 
-  return result.length < minLength ? result : null;
+  if (result.length < minLength) {
+    throw Error(
+      minLengthError ||
+        `Array length (${result.length}) less than specified (${minLength})`
+    );
+  }
+  return result;
+}
+
+function printValueInfo(value: any) {
+  const valType = typeof value;
+  const lq = valType === 'string' ? '“' : '';
+  const rq = valType === 'string' ? '”' : '';
+  return `${lq + value + rq} (${typeof value})`
 }

tsconfig.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
     "moduleResolution": "node",
     "target": "es5",
     "lib": [
@@ -25,4 +26,4 @@
     "node_modules",
     "**/*.test.ts"
   ]
-}
+}