parse-domain 2.3.0 → 2.3.4

package/test/trie/parse.test.js

@@ -0,0 +1,140 @@
+"use strict";
+
+const parse = require("../../lib/trie/parse");
+
+describe("parse()", () => {
+    describe("when called with ''", () => {
+        test("returns a node with null as domain and no children", () => {
+            const root = parse("");
+
+            expect(root.domain).toBeNull();
+            expect(root.children.size).toBe(0);
+        });
+    });
+    describe("when called with 'a'", () => {
+        test("adds 'a' as child of root", () => {
+            const root = parse("a");
+
+            expect(root.children.has("a")).toBe(true);
+        });
+        test("initializes 'a' with the correct domain and parent", () => {
+            const root = parse("a");
+            const a = root.children.get("a");
+
+            expect(a.domain).toBe("a");
+            expect(a.parent).toBe(root);
+        });
+    });
+    describe("when called with 'a,b'", () => {
+        test("adds 'a' and 'b' as child of root", () => {
+            const root = parse("a,b");
+
+            expect(root.children.has("a")).toBe(true);
+            expect(root.children.has("b")).toBe(true);
+        });
+        test("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a,b");
+            const b = root.children.get("b");
+
+            expect(b.domain).toBe("b");
+            expect(b.parent).toBe(root);
+        });
+    });
+    describe("when called with 'a>b'", () => {
+        test("adds 'a' as child of root and 'b' as child of 'a'", () => {
+            const root = parse("a>b");
+
+            expect(root.children.has("a")).toBe(true);
+            expect(root.children.get("a").children.has("b")).toBe(true);
+        });
+        test("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a>b");
+            const a = root.children.get("a");
+            const b = a.children.get("b");
+
+            expect(b.domain).toBe("b");
+            expect(b.parent).toBe(a);
+        });
+    });
+    describe("when called with 'a>b,c'", () => {
+        test("adds 'b' and 'c' as child of 'a'", () => {
+            const root = parse("a>b,c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).toBe(true);
+            expect(a.children.has("c")).toBe(true);
+        });
+        test("initializes 'c' with the correct domain and parent", () => {
+            const root = parse("a>b,c");
+            const a = root.children.get("a");
+            const c = a.children.get("c");
+
+            expect(c.domain).toBe("c");
+            expect(c.parent).toBe(a);
+        });
+    });
+    describe("when called with 'a>b<c'", () => {
+        test("adds 'b' as child of 'a' and 'c' as child of root", () => {
+            const root = parse("a>b<c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).toBe(true);
+            expect(root.children.has("c")).toBe(true);
+        });
+        test("initializes 'c' with the correct domain and parent", () => {
+            const root = parse("a>b<c");
+            const c = root.children.get("c");
+
+            expect(c.domain).toBe("c");
+            expect(c.parent).toBe(root);
+        });
+    });
+    describe("when called with 'a|b'", () => {
+        test("adds 'a' and 'b' as child of root", () => {
+            const root = parse("a|b");
+
+            expect(root.children.has("a")).toBe(true);
+            expect(root.children.has("b")).toBe(true);
+        });
+        test("initializes 'b' with the correct domain and parent", () => {
+            const root = parse("a|b");
+            const b = root.children.get("b");
+
+            expect(b.domain).toBe("b");
+            expect(b.parent).toBe(root);
+        });
+    });
+    describe("when called with 'a>b|c'", () => {
+        test("adds 'b' as child of 'a' and 'c' as child of root", () => {
+            const root = parse("a>b|c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).toBe(true);
+            expect(root.children.has("c")).toBe(true);
+        });
+    });
+    describe("when called with 'a>b<a>d'", () => {
+        test("adds 'b' and 'd' as child of 'a'", () => {
+            const root = parse("a>b<a>c");
+            const a = root.children.get("a");
+
+            expect(a.children.has("b")).toBe(true);
+            expect(a.children.has("c")).toBe(true);
+        });
+    });
+    describe("when called with 'a>b>c'", () => {
+        test("adds 'c' as child of 'b'", () => {
+            const root = parse("a>b>c");
+            const b = root.children.get("a").children.get("b");
+
+            expect(b.children.has("c")).toBe(true);
+        });
+    });
+    describe("when called with 'a>b>c>d|e'", () => {
+        test("adds 'e' as child node of root", () => {
+            const node = parse("a>b>c>d|e");
+
+            expect(node.children.has("e")).toBe(true);
+        });
+    });
+});

package/test/trie/parsePubSuffixList.test.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const parsePubSuffixList = require("../../lib/trie/parsePubSuffixList");
+
+const pathToFixtures = path.resolve(__dirname, "..", "fixtures");
+const icannStart = "// ===BEGIN ICANN DOMAINS===";
+const icannEnd = "// ===END ICANN DOMAINS===";
+const privateStart = "// ===BEGIN PRIVATE DOMAINS===";
+const privateEnd = "// ===END PRIVATE DOMAINS===";
+
+describe("parsePubSuffixList()", () => {
+    test("returns an object with empty lists by default", () => {
+        const str = [icannStart, icannEnd, privateStart, privateEnd].join("\n");
+
+        expect(parsePubSuffixList(str)).toEqual({
+            icann: [],
+            private: [],
+        });
+    });
+
+    test(
+        "splits the list by the line break character \\n (ignoring \\r if present)",
+        () => {
+            const str = [
+                icannStart,
+                "a.b.c\r",
+                "a",
+                "b\r",
+                icannEnd + "\r",
+                privateStart,
+                "a.b.c",
+                "a",
+                "b",
+                privateEnd,
+            ].join("\n");
+
+            expect(parsePubSuffixList(str)).toEqual({
+                icann: ["a.b.c", "a", "b"],
+                private: ["a.b.c", "a", "b"],
+            });
+        }
+    );
+
+    test("removes lines that start with a // sequence", () => {
+        const str = [
+            icannStart,
+            "// comment",
+            "a.b.c",
+            "a",
+            "b",
+            "//another comment",
+            icannEnd,
+            privateStart,
+            "a.b.c",
+            "//",
+            "a",
+            " // ",
+            "b",
+            privateEnd,
+        ].join("\n");
+
+        expect(parsePubSuffixList(str)).toEqual({
+            icann: ["a.b.c", "a", "b"],
+            private: ["a.b.c", "a", "b"],
+        });
+    });
+
+    test("removes empty lines", () => {
+        const str = [
+            icannStart,
+            " ",
+            "a.b.c",
+            "a",
+            "b",
+            "\r",
+            icannEnd,
+            privateStart,
+            "a.b.c",
+            "\t",
+            "a",
+            "b",
+            privateEnd,
+        ].join("\n");
+
+        expect(parsePubSuffixList(str)).toEqual({
+            icann: ["a.b.c", "a", "b"],
+            private: ["a.b.c", "a", "b"],
+        });
+    });
+
+    test("throws when the ICANN start marker is missing ", () => {
+        const str = [""].join("\n");
+
+        expect(() => parsePubSuffixList(str)).toThrowError("Missing start marker of icann list");
+    });
+
+    test("throws when the ICANN end marker is missing ", () => {
+        const str = [icannStart].join("\n");
+
+        expect(() => parsePubSuffixList(str)).toThrowError("Missing end marker of icann list");
+    });
+
+    test("throws when the PRIVATE start marker is missing ", () => {
+        const str = [icannStart, icannEnd].join("\n");
+
+        expect(() => parsePubSuffixList(str)).toThrowError("Missing start marker of private list");
+    });
+
+    test("throws when the PRIVATE end marker is missing ", () => {
+        const str = [icannStart, icannEnd, privateStart].join("\n");
+
+        expect(() => parsePubSuffixList(str)).toThrowError("Missing end marker of private list");
+    });
+
+    describe("with fixtures", () => {
+        const pubSuffixList = fs.readFileSync(path.resolve(pathToFixtures, "pubSuffixList.txt"), "utf8");
+
+        test("returns the expected result (based on samples)", () => {
+            const parsedList = parsePubSuffixList(pubSuffixList);
+
+            expect(Array.isArray(parsedList.icann)).toBe(true);
+            expect(Array.isArray(parsedList.private)).toBe(true);
+            expect(parsedList.icann).toEqual(expect.arrayContaining(["com"]));
+            expect(parsedList.icann).toEqual(expect.arrayContaining(["co.uk"]));
+            expect(parsedList.private).toEqual(expect.arrayContaining(["herokuapp.com"]));
+        });
+    });
+});

package/test/{tries → trie}/serializeTrie.test.js

@@ -1,9 +1,6 @@
 "use strict";
 
-const chai = require("chai");
-const serializeTrie = require("../../lib/tries/serializeTrie");
-
-const expect = chai.expect;
+const serializeTrie = require("../../lib/trie/serializeTrie");
 
 describe("serializeTrie()", () => {
     [
@@ -36,9 +33,12 @@ describe("serializeTrie()", () => {
         const parsedList = args[0];
         const expectedString = args[1];
 
-        it(`maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`, () => {
-            expect(serializeTrie(parsedList)).to.equal(expectedString);
-        });
+        test(
+            `maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`,
+            () => {
+                expect(serializeTrie(parsedList)).toBe(expectedString);
+            }
+        );
     });
 
     describe(`type ${serializeTrie.TYPE_LIGHT}`, () => {
@@ -57,9 +57,12 @@ describe("serializeTrie()", () => {
             const parsedList = args[0];
             const expectedString = args[1];
 
-            it(`maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`, () => {
-                expect(serializeTrie(parsedList, type)).to.equal(expectedString);
-            });
+            test(
+                `maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`,
+                () => {
+                    expect(serializeTrie(parsedList, type)).toBe(expectedString);
+                }
+            );
         });
     });
 
@@ -84,16 +87,19 @@ describe("serializeTrie()", () => {
             const parsedList = args[0];
             const expectedString = args[1];
 
-            it(`maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`, () => {
-                expect(serializeTrie(parsedList, type)).to.equal(expectedString);
-            });
+            test(
+                `maps ${JSON.stringify(parsedList)} on ${JSON.stringify(expectedString)}`,
+                () => {
+                    expect(serializeTrie(parsedList, type)).toBe(expectedString);
+                }
+            );
         });
     });
 
     describe("wrong usage", () => {
         expect(() => {
             serializeTrie([], "unsupported type");
-        }).to.throw(
+        }).toThrowError(
             'Cannot serialize trie: Unknown trie type "unsupported type". Expected type to be one of complete, light'
         );
     });

package/lib/tries/lookUp.js

@@ -1,40 +0,0 @@
-"use strict";
-
-var WILDCARD = "*";
-var EXCEPTION = "!";
-
-function lookUp(trie, hostname) {
-  var domains = hostname.split(".").reverse();
-  var tlds = [];
-  var currentTrie = trie;
-
-  for (var i = 0; i < domains.length; i++) {
-    var domain = domains[i];
-    var isWildcardRule = currentTrie.has(WILDCARD);
-
-    if (isWildcardRule) {
-      if (currentTrie.has(EXCEPTION + domain) === false) {
-        tlds.push(domain);
-      }
-
-      break;
-    }
-
-    if (currentTrie.has(domain) === false) {
-      break;
-    }
-
-    tlds.push(domain);
-    var value = currentTrie.get(domain);
-
-    if (value === true) {
-      break;
-    }
-
-    currentTrie = value;
-  }
-
-  return tlds.length === 0 ? null : tlds.reverse().join(".");
-}
-
-module.exports = lookUp;

package/lib/tries/parseTrie.js

@@ -1,62 +0,0 @@
-"use strict";
-
-var SEPARATORS = require("./separators");
-
-function parseTrie(input) {
-  var map = new Map();
-  var parentMaps = [map];
-  var domain = "";
-
-  function setDomain(value) {
-    if (domain === "") {
-      return;
-    }
-
-    map.set(domain, value);
-    domain = "";
-  }
-
-  for (var i = 0; i < input.length; i++) {
-    var _char = input.charAt(i);
-
-    switch (_char) {
-      case SEPARATORS.SAME:
-        {
-          setDomain(true);
-          continue;
-        }
-
-      case SEPARATORS.DOWN:
-        {
-          var childMap = new Map();
-          setDomain(childMap);
-          parentMaps.push(map);
-          map = childMap;
-          continue;
-        }
-
-      case SEPARATORS.RESET:
-        {
-          setDomain(true); // Remove all parent maps but the top most
-
-          parentMaps.length = 1;
-          map = parentMaps[0];
-          continue;
-        }
-
-      case SEPARATORS.UP:
-        {
-          setDomain(true);
-          map = parentMaps.pop();
-          continue;
-        }
-    }
-
-    domain += _char;
-  }
-
-  setDomain(true);
-  return parentMaps[0];
-}
-
-module.exports = parseTrie;

package/lib/tries/separators.js

@@ -1,12 +0,0 @@
-"use strict";
-
-module.exports = {
-  UP: "<",
-  // one level up
-  SAME: ",",
-  // same level
-  DOWN: ">",
-  // one level down
-  RESET: "|" // reset level index and start new
-
-};

package/test/mocha.opts

@@ -1 +0,0 @@
---recursive

package/test/tries/lookUp.test.js

@@ -1,116 +0,0 @@
-"use strict";
-
-const chai = require("chai");
-const lookUp = require("../../lib/tries/lookUp");
-
-const expect = chai.expect;
-
-describe("lookUp()", () => {
-    it("returns null if the trie is empty", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        expect(lookUp(trie, hostname)).to.eql(null);
-    });
-    it("returns null if the trie contains no matching top-level domain", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        trie.set("cc", true);
-
-        expect(lookUp(trie, hostname)).to.eql(null);
-    });
-    it("returns the hostname if the hostname is a top-level domain", () => {
-        const trie = new Map();
-        const hostname = "a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain from the hostname (2 domains)", () => {
-        const trie = new Map();
-        const hostname = "b.a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain from the hostname (3 domains)", () => {
-        const trie = new Map();
-        const hostname = "c.b.a";
-
-        trie.set("a", true);
-        trie.set("b", true);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("returns the top-level domain (2 tlds) from the hostname (3 domains)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("b", true);
-        trie.set("a", trieA);
-        trie.set("b", new Map());
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-    it("returns the top-level domain (3 tlds) from the hostname (4 domains)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const trieAB = new Map();
-        const hostname = "d.c.b.a";
-
-        trieAB.set("c", true);
-        trieA.set("b", trieAB);
-        trieA.set("a", true);
-        trie.set("a", trieA);
-        trie.set("b", new Map());
-
-        expect(lookUp(trie, hostname)).to.eql("c.b.a");
-    });
-    it("interprets wildcards in the trie correctly (simple)", () => {
-        const trie = new Map();
-        const hostname = "a.b.c";
-
-        trie.set("*", true);
-
-        expect(lookUp(trie, hostname)).to.eql("c");
-    });
-    it("interprets wildcards in the trie correctly (nested)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-    it("interprets exceptions of wildcards in the trie correctly (simple)", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trieA.set("!b", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("a");
-    });
-    it("still handles wildcards correctly if there are non-matching exceptions", () => {
-        const trie = new Map();
-        const trieA = new Map();
-        const hostname = "c.b.a";
-
-        trieA.set("*", true);
-        trieA.set("!a", true);
-        trieA.set("!c", true);
-        trie.set("a", trieA);
-
-        expect(lookUp(trie, hostname)).to.eql("b.a");
-    });
-});