added a few of tests

Author: Code-Hex

src/base64.test.ts

@@ -0,0 +1,46 @@
+import { decodeBase64Url, encodeBase64Url } from "./base64";
+
+const urlRef = (s: string): string =>
+  s.replace(/\+|\//g, (m) => ({ "+": "-", "/": "_" }[m]!))
+
+describe("base64", () => {
+  describe.each([
+    // basic
+    ["Hello, 世界", "SGVsbG8sIOS4lueVjA=="],
+
+    // RFC 3548 examples (TODO(codehex): clear)
+    // ["\x14\xfb\x9c\x03\xd9\x7e", "FPucA9l+"],
+    // ["\x14\xfb\x9c\x03\xd9", "FPucA9k="],
+    // ["\x14\xfb\x9c\x03", "FPucAw=="],
+
+    // RFC 4648 examples
+    ["", ""],
+    ["f", "Zg=="],
+    ["fo", "Zm8="],
+    ["foo", "Zm9v"],
+    ["foob", "Zm9vYg=="],
+    ["fooba", "Zm9vYmE="],
+    ["foobar", "Zm9vYmFy"],
+
+    // Wikipedia examples
+    ["sure.", "c3VyZS4="],
+    ["sure", "c3VyZQ=="],
+    ["sur", "c3Vy"],
+    ["su", "c3U="],
+    ["leasure.", "bGVhc3VyZS4="],
+    ["easure.", "ZWFzdXJlLg=="],
+    ["asure.", "YXN1cmUu"],
+    ["sure.", "c3VyZS4="],
+  ])('%s, %s', (decoded, encoded) => {
+    it("encode", () => {
+      const got = encodeBase64Url(decoded)
+      const want = urlRef(encoded)
+      expect(got).toBe(want)
+    })
+    it("decode", () => {
+      const got = decodeBase64Url(urlRef(encoded))
+      const want = decoded
+      expect(got).toBe(want)
+    })
+  })
+})

src/base64.ts

@@ -1,16 +1,5 @@
 export const decodeBase64Url = (str: string): string => {
-  const pad = (s: string): string => {
-    switch (s.length % 4) {
-      case 2:
-        return `${s}==`;
-      case 3:
-        return `${s}=`;
-      default:
-        return s;
-    }
-  };
-  pad(str).replace(/_|-/g, (m) => ({ _: "/", "-": "+" }[m]!));
-  return atob(str);
+  return decodeBase64(str).replace(/_|-/g, (m) => ({ _: "/", "-": "+" }[m]!));;
 };
 
 export const decodeBase64UrlBytes = (str: string): Uint8Array =>
@@ -21,4 +10,36 @@ export const encodeBase64UrlBytes = (buf: ArrayBufferLike) => {
 };
 
 export const encodeBase64Url = (str: string): string =>
-  btoa(str).replace(/\/|\+|=/g, (m) => ({ "/": "_", "+": "-", "=": "" }[m]!));
+  encodeBase64(str).replace(/\/|\+/g, (m) => ({ "/": "_", "+": "-" }[m]!));
+
+const pad = (s: string): string => {
+  switch (s.length % 4) {
+    case 2:
+      return `${s}==`;
+    case 3:
+      return `${s}=`;
+    default:
+      return s;
+  }
+};
+
+// This approach is written in MDN.
+// btoa does not support utf-8 characters. So we need a little bit hack.
+const encodeBase64 = (str: string): string => {
+  const binary = []
+  const encoded = new TextEncoder().encode(str)
+  for (let i = 0; i < encoded.byteLength; i++) {
+    binary.push(String.fromCharCode(encoded[i]))
+  }
+  return pad(btoa(binary.join('')))
+}
+
+// atob does not support utf-8 characters. So we need a little bit hack.
+const decodeBase64 = (str: string): string => {
+  const binary = atob(pad(str))
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes)
+}

src/validator.test.ts

@@ -0,0 +1,144 @@
+import { isArray, isNonEmptyString, isNonNullObject, isNumber, isObject, isString, isURL } from "./validator"
+
+describe("validator", () => {
+  describe("isURL", () => {
+    test.each([
+      ["http://example.com/", true],
+      ["http://example.com", true],
+      ["https://example.com/", true],
+      ["https://example.com", true],
+      ["https://www.example.com:8080", true],
+      ["http://localhost/path/name/", true],
+      ["https://www.example.com:8080/path/name/index.php?a=1&b=2&c=3#abcd", true],
+      ["http://www.example.com:8080/path/name/index.php?a=1&b=2&c=3#abcd", true],
+      ["http://localhost/path/name/index.php?a=1&b=2&c=3#abcd", true],
+      ["http://127.0.0.1/path/name/index.php?a=1&b=2&c=3#abcd", true],
+      ["http://a--b.c-c.co-uk/", true],
+      [null, false],
+      [undefined, false],
+      [["https://example.com"], false], // non-null string
+      ["ftp://www.example.com:8080/path/name/file.png", false],
+      ["http://-abc.com", false],
+      ["http://www._abc.com", false],
+      ["http://.com", false],
+      ["123456789", false]
+    ])("%p", (param, want) => {
+      expect(isURL(param)).toBe(want)
+    })
+  })
+
+  describe("isNumber", () => {
+    describe("non-number", () => {
+      const nonNumbers = [undefined, null, true, false, '', 'a', [], ['a'], {}, { a: 1 }]
+      nonNumbers.forEach((v) => {
+        it(`${v}`, () => expect(isNumber(v)).toBeFalsy())
+      })
+    })
+
+    describe("number", () => {
+      const numbers = [NaN, 0, -1, 1, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, Infinity, -Infinity]
+      numbers.forEach((v) => {
+        it(`${v}`, () => expect(isNumber(v)).toBeTruthy())
+      })
+    })
+  })
+
+  describe("isString", () => {
+    describe("non-string", () => {
+      const nonStrings = [undefined, null, NaN, 0, 1, true, false, [], ['a'], {}, { a: 1 }]
+      nonStrings.forEach((v) => {
+        it(`${v}`, () => expect(isString(v)).toBeFalsy())
+      })
+    })
+
+    describe("string", () => {
+      const strings = [
+        "",
+        " ",
+        "foo"
+      ]
+      strings.forEach((v) => {
+        it(`${v}`, () => expect(isString(v)).toBeTruthy())
+      })
+    })
+  })
+
+  describe("isNonEmptyString", () => {
+    describe("non-non-empty-string", () => {
+      const nonStrings = [undefined, null, NaN, 0, 1, true, false, [], ['a'], {}, { a: 1 }, ""]
+      nonStrings.forEach((v) => {
+        it(`${v}`, () => expect(isNonEmptyString(v)).toBeFalsy())
+      })
+    })
+
+    describe("non-empty-string", () => {
+      const strings = [
+        " ",
+        "foo"
+      ]
+      strings.forEach((v) => {
+        it(`${v}`, () => expect(isNonEmptyString(v)).toBeTruthy())
+      })
+    })
+  })
+
+  describe("isArray", () => {
+    describe("non-array", () => {
+      const nonArrays = [undefined, null, NaN, 0, 1, '', 'a', true, false, {}, { a: 1 }]
+      nonArrays.forEach((v) => {
+        it(`${v}`, () => expect(isArray(v)).toBeFalsy())
+      })
+    })
+
+    describe("array", () => {
+      const arrays = [
+        [],
+        [1,2,3],
+        new Array(),
+        new Array(1, 2, 3),
+      ]
+      arrays.forEach((v) => {
+        it(`${v}`, () => expect(isArray(v)).toBeTruthy())
+      })
+    })
+  })
+
+  describe("isObject", () => {
+    describe("non-object", () => {
+      const nonObjects = [undefined, NaN, 0, 1, true, false, '', 'a', [], ['a']]
+      nonObjects.forEach((v) => {
+        it(`${v}`, () => expect(isObject(v)).toBeFalsy())
+      })
+    })
+
+    describe("object", () => {
+      const objects = [
+        null,
+        {},
+        {a: 1}
+      ]
+      objects.forEach((v) => {
+        it(`${v}`, () => expect(isObject(v)).toBeTruthy())
+      })
+    })
+  })
+
+  describe("isNonNullObject", () => {
+    describe("non-non-null-object", () => {
+      const nonNonNullObjects = [undefined, NaN, 0, 1, true, false, '', 'a', [], ['a'], null]
+      nonNonNullObjects.forEach((v) => {
+        it(`${v}`, () => expect(isNonNullObject(v)).toBeFalsy())
+      })
+    })
+
+    describe("object", () => {
+      const nonNullObjects = [
+        {},
+        {a: 1}
+      ]
+      nonNullObjects.forEach((v) => {
+        it(`${v}`, () => expect(isNonNullObject(v)).toBeTruthy())
+      })
+    })
+  })
+})