Merge pull request #40 from sandstreamdev/improve_test_coverage

Improve test coverage

Author: przemyslawzalewski

README.md

@@ -87,6 +87,14 @@ any[]
 ```
 <!-- prettier-ignore-end -->
 
+## Examples
+
+<!-- prettier-ignore-start -->
+```javascript
+empty; // ⇒ []
+```
+<!-- prettier-ignore-end -->
+
 # exact
 
 Takes exactly the given count of elements.

array/README.md

@@ -5,7 +5,7 @@
   "examples": [
     {
       "language": "javascript",
-      "content": "empty(); // ⇒ TODO"
+      "content": "empty; // ⇒ []"
     }
   ],
   "questions": ["TODO: List questions that may this function answers."]

array/empty.json

@@ -9,3 +9,11 @@ Empty array.
 any[]
 ```
 <!-- prettier-ignore-end -->
+
+## Examples
+
+<!-- prettier-ignore-start -->
+```javascript
+empty; // ⇒ []
+```
+<!-- prettier-ignore-end -->

array/empty.md

@@ -41,10 +41,6 @@ const compareValues = (value1, value2) => {
 };
 
 const diff = (obj1, obj2) => {
-  if (isFunction(obj1) || isFunction(obj2)) {
-    throw "Invalid argument. Function given, object expected.";
-  }
-
   if (isValue(obj1) || isValue(obj2)) {
     const comparisonResult = compareValues(obj1, obj2);
 

debug/diff.js

@@ -36,20 +36,18 @@ describe("diff", () => {
   });
 
   it("supports dates", () => {
-    expect(
-      diff(
-        { a: new Date("2019-12-13T12:15:00.000Z") },
-        { a: new Date("2019-12-23T12:30:00.000Z") }
-      )
-    ).toEqual({
+    const a = new Date("2019-12-13T12:15:00.000Z");
+    const aClone = new Date("2019-12-13T12:15:00.000Z");
+    const b = new Date("2019-12-23T12:30:00.000Z");
+
+    expect(diff({ a }, { a: b })).toEqual({
       a: {
-        data: [
-          new Date("2019-12-13T12:15:00.000Z"),
-          new Date("2019-12-23T12:30:00.000Z")
-        ],
+        data: [a, b],
         type: VALUE_UPDATED
       }
     });
+
+    expect(diff({ a }, { a: aClone })).toEqual({});
   });
 
   it("supports arrays", () => {
@@ -72,7 +70,10 @@ describe("diff", () => {
   });
 
   it("ignores functions", () => {
-    expect(diff({ a: 1, f: x => x }, { a: 5, f: y => y + 3 })).toEqual({
+    const f = (x: number) => x;
+    const g = (y: number) => y + 3;
+
+    expect(diff({ a: 1, f }, { a: 5, f: g })).toEqual({
       a: { data: [1, 5], type: VALUE_UPDATED }
     });
   });

debug/diff.test.ts

@@ -41,10 +41,6 @@ const compareValues = (value1: any, value2: any) => {
 };
 
 const diff = (obj1: object, obj2: object) => {
-  if (isFunction(obj1) || isFunction(obj2)) {
-    throw "Invalid argument. Function given, object expected.";
-  }
-
   if (isValue(obj1) || isValue(obj2)) {
     const comparisonResult = compareValues(obj1, obj2);
 

debug/diff.ts

@@ -7,12 +7,44 @@ Provides a way to encode strings and bytes from and into Base64URL.
 <!-- prettier-ignore-start -->
 ```typescript
 {
-  decode: (text: string) => string;
-  decodeBytes: (text: string) => number[];
-  encode: (text: string) => string;
-  encodeBytes: (bytes: number[]) => string;
+  decode: (
+    text: string,
+    context?: {
+      atob: (byteString: string) => string;
+      TextDecoder: new (encoding: string) => {
+        decode: (input?: Uint8Array) => string;
+      };
+    }
+  ) => string;
+  decodeBytes: (
+    text: string,
+    context?: {
+      atob: (byteString: string) => string;
+      TextDecoder: new (encoding: string) => {
+        decode: (input?: Uint8Array) => string;
+      };
+    }
+  ) => number[];
+  encode: (
+    text: string,
+    context?: {
+      btoa: (byteString: string) => string;
+      TextEncoder: new () => {
+        encode: (input?: string) => Uint8Array;
+      };
+    }
+  ) => string;
+  encodeBytes: (
+    bytes: number[],
+    context?: {
+      btoa: (byteString: string) => string;
+      TextEncoder: new () => {
+        encode: (input?: string) => Uint8Array;
+      };
+    }
+  ) => string;
   fromByteString: (byteString: string) => number[];
-  toByteString: (bytes: any) => any;
+  toByteString: (bytes: number[]) => string;
 }
 ```
 <!-- prettier-ignore-end -->

encoding/README.md

@@ -1,4 +1,6 @@
 /* eslint-env browser, node */
+const toArray = typedArray => [...typedArray];
+
 export const toByteString = bytes =>
   bytes.map(_ => String.fromCharCode(_)).join("");
 
@@ -7,41 +9,49 @@ export const fromByteString = byteString =>
 
 const ENCODING = "utf-8";
 
-const btoaImplementation = text =>
-  typeof window !== "undefined"
-    ? btoa(toByteString([...new window.TextEncoder().encode(text)]))
+const btoaImplementation = (
+  text,
+  context = typeof window !== "undefined" ? window : undefined
+) =>
+  context
+    ? context.btoa(
+        toByteString(toArray(new context.TextEncoder().encode(text)))
+      )
     : Buffer.from(text, ENCODING).toString("base64");
 
-const atobImplementation = text =>
-  typeof window !== "undefined"
-    ? new window.TextDecoder(ENCODING).decode(
-        new Uint8Array(fromByteString(atob(text)))
+const atobImplementation = (
+  text,
+  context = typeof window !== "undefined" ? window : undefined
+) =>
+  context
+    ? new context.TextDecoder(ENCODING).decode(
+        new Uint8Array(fromByteString(context.atob(text)))
       )
     : Buffer.from(text, "base64").toString(ENCODING);
 
-export const encode = text =>
-  btoaImplementation(text)
+export const encode = (text, context) =>
+  btoaImplementation(text, context)
     .replace(/=/g, "")
     .replace(/\+/g, "-")
     .replace(/\//g, "_");
 
-export const decode = text =>
-  atobImplementation(text.replace(/-/g, "+").replace(/_/g, "/"));
+export const decode = (text, context) =>
+  atobImplementation(text.replace(/-/g, "+").replace(/_/g, "/"), context);
 
 export const toBase64Url = base64 =>
   base64.replace(/\+/g, "-").replace(/\//g, "_");
 
 export const fromBase64Url = base64 =>
   base64.replace(/-/g, "+").replace(/_/g, "/");
 
-export const encodeBytes = bytes => {
+export const encodeBytes = (bytes, context) => {
   const sourceText = toByteString(bytes);
 
-  return encode(sourceText);
+  return encode(sourceText, context);
 };
 
-export const decodeBytes = text => {
-  const decoded = decode(text);
+export const decodeBytes = (text, context) => {
+  const decoded = decode(text, context);
 
   return fromByteString(decoded);
 };

encoding/base64url.js

@@ -0,0 +1,138 @@
+/* eslint-env jest, node */
+import {
+  decode,
+  encode
+  // @ts-ignore ambiguous import
+} from "./base64url.ts";
+
+const unicodeText = "Zombies everywhere 🧟";
+
+describe("base64url", () => {
+  it("works in browsers using provided atob/btoa", () => {
+    const atob = (encodedString: string) => {
+      let data = encodedString.replace(/[ \t\n\f\r]/g, "");
+
+      if (data.length % 4 === 0) {
+        data = data.replace(/==?$/, "");
+      }
+
+      if (data.length % 4 === 1 || /[^+/0-9A-Za-z]/.test(data)) {
+        return null;
+      }
+
+      let output = "";
+
+      let buffer = 0;
+      let accumulatedBits = 0;
+
+      for (let i = 0; i < data.length; i++) {
+        buffer <<= 6;
+        buffer |= atobLookup(data[i]);
+        accumulatedBits += 6;
+
+        if (accumulatedBits === 24) {
+          output += String.fromCharCode((buffer & 0xff0000) >> 16);
+          output += String.fromCharCode((buffer & 0xff00) >> 8);
+          output += String.fromCharCode(buffer & 0xff);
+          buffer = accumulatedBits = 0;
+        }
+      }
+
+      if (accumulatedBits === 12) {
+        buffer >>= 4;
+        output += String.fromCharCode(buffer);
+      } else if (accumulatedBits === 18) {
+        buffer >>= 2;
+        output += String.fromCharCode((buffer & 0xff00) >> 8);
+        output += String.fromCharCode(buffer & 0xff);
+      }
+
+      return output;
+    };
+
+    const atobLookup = (character: string) => {
+      if (/[A-Z]/.test(character)) {
+        return character.charCodeAt(0) - "A".charCodeAt(0);
+      } else if (/[a-z]/.test(character)) {
+        return character.charCodeAt(0) - "a".charCodeAt(0) + 26;
+      } else if (/[0-9]/.test(character)) {
+        return character.charCodeAt(0) - "0".charCodeAt(0) + 52;
+      } else if (character === "+") {
+        return 62;
+      } else if (character === "/") {
+        return 63;
+      }
+
+      throw new RangeError("Character out of range.");
+    };
+
+    const btoa = (rawString: string) => {
+      const s = rawString;
+
+      for (let i = 0; i < s.length; i++) {
+        if (s.charCodeAt(i) > 255) {
+          return null;
+        }
+      }
+
+      let out = "";
+
+      for (let i = 0; i < s.length; i += 3) {
+        const groupsOfSix = [undefined, undefined, undefined, undefined];
+        groupsOfSix[0] = s.charCodeAt(i) >> 2;
+        groupsOfSix[1] = (s.charCodeAt(i) & 0x03) << 4;
+
+        if (s.length > i + 1) {
+          groupsOfSix[1] |= s.charCodeAt(i + 1) >> 4;
+          groupsOfSix[2] = (s.charCodeAt(i + 1) & 0x0f) << 2;
+        }
+
+        if (s.length > i + 2) {
+          groupsOfSix[2] |= s.charCodeAt(i + 2) >> 6;
+          groupsOfSix[3] = s.charCodeAt(i + 2) & 0x3f;
+        }
+
+        for (let j = 0; j < groupsOfSix.length; j++) {
+          if (typeof groupsOfSix[j] === "undefined") {
+            out += "=";
+          } else {
+            out += btoaLookup(groupsOfSix[j]);
+          }
+        }
+      }
+
+      return out;
+    };
+
+    const btoaLookup = (index: number) => {
+      if (index >= 0 && index < 26) {
+        return String.fromCharCode(index + "A".charCodeAt(0));
+      } else if (index < 52) {
+        return String.fromCharCode(index - 26 + "a".charCodeAt(0));
+      } else if (index < 62) {
+        return String.fromCharCode(index - 52 + "0".charCodeAt(0));
+      } else if (index === 62) {
+        return "+";
+      } else if (index === 63) {
+        return "/";
+      }
+
+      throw new RangeError("Index out of range.");
+    };
+
+    const context = {
+      atob,
+      btoa,
+      TextEncoder: global["TextEncoder"],
+      TextDecoder: global["TextDecoder"]
+    };
+
+    expect(decode(encode(unicodeText, context), context)).toEqual(unicodeText);
+
+    global["window"] = context;
+
+    expect(decode(encode(unicodeText))).toEqual(unicodeText);
+
+    delete global["window"];
+  });
+});