parse-domain 2.3.0 → 2.3.4

package/test/tries/parsePubSuffixList.test.js

@@ -1,129 +0,0 @@
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const chai = require("chai");
-const parsePubSuffixList = require("../../lib/tries/parsePubSuffixList");
-
-const expect = chai.expect;
-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()", () => {
-    it("returns an object with empty lists by default", () => {
-        const str = [icannStart, icannEnd, privateStart, privateEnd].join("\n");
-
-        expect(parsePubSuffixList(str)).to.eql({
-            icann: [],
-            private: [],
-        });
-    });
-
-    it("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)).to.eql({
-            icann: ["a.b.c", "a", "b"],
-            private: ["a.b.c", "a", "b"],
-        });
-    });
-
-    it("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)).to.eql({
-            icann: ["a.b.c", "a", "b"],
-            private: ["a.b.c", "a", "b"],
-        });
-    });
-
-    it("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)).to.eql({
-            icann: ["a.b.c", "a", "b"],
-            private: ["a.b.c", "a", "b"],
-        });
-    });
-
-    it("throws when the ICANN start marker is missing ", () => {
-        const str = [""].join("\n");
-
-        expect(() => parsePubSuffixList(str)).to.throw("Missing start marker of icann list");
-    });
-
-    it("throws when the ICANN end marker is missing ", () => {
-        const str = [icannStart].join("\n");
-
-        expect(() => parsePubSuffixList(str)).to.throw("Missing end marker of icann list");
-    });
-
-    it("throws when the PRIVATE start marker is missing ", () => {
-        const str = [icannStart, icannEnd].join("\n");
-
-        expect(() => parsePubSuffixList(str)).to.throw("Missing start marker of private list");
-    });
-
-    it("throws when the PRIVATE end marker is missing ", () => {
-        const str = [icannStart, icannEnd, privateStart].join("\n");
-
-        expect(() => parsePubSuffixList(str)).to.throw("Missing end marker of private list");
-    });
-
-    describe("with fixtures", () => {
-        const pubSuffixList = fs.readFileSync(path.resolve(pathToFixtures, "pubSuffixList.txt"), "utf8");
-
-        it("returns the expected result (based on samples)", () => {
-            const parsedList = parsePubSuffixList(pubSuffixList);
-
-            expect(parsedList.icann).to.be.an("array");
-            expect(parsedList.private).to.be.an("array");
-            expect(parsedList.icann).to.contain("com");
-            expect(parsedList.icann).to.contain("co.uk");
-            expect(parsedList.private).to.contain("herokuapp.com");
-        });
-    });
-});

package/test/tries/parseTrie.test.js

@@ -1,162 +0,0 @@
-"use strict";
-
-const chai = require("chai");
-const parseTrie = require("../../lib/tries/parseTrie");
-
-const expect = chai.expect;
-
-describe("parseTrie()", () => {
-    describe("basic cases", () => {
-        it("returns a map", () => {
-            expect(parseTrie("")).to.be.instanceOf(Map);
-        });
-
-        it("returns an empty map when an empty string is given", () => {
-            const trie = parseTrie("");
-
-            expect(trie.size).to.equal(0);
-        });
-
-        it("returns a map with the given domain as key and true as value", () => {
-            const trie = parseTrie("some-domain");
-            const someDomain = trie.get("some-domain");
-
-            expect(someDomain).to.equal(true);
-        });
-    });
-
-    describe("with SAME separator", () => {
-        it("returns a map with the given domains as key and true as value", () => {
-            const trie = parseTrie("a,b,c");
-            const a = trie.get("a");
-            const b = trie.get("b");
-            const c = trie.get("c");
-
-            expect(a).to.equal(true);
-            expect(b).to.equal(true);
-            expect(c).to.equal(true);
-        });
-    });
-
-    describe("and with DOWN separator", () => {
-        it("returns a nested map", () => {
-            const trie = parseTrie("a>a");
-            const a = trie.get("a");
-            const aa = a.get("a");
-
-            expect(aa).to.equal(true);
-        });
-
-        it("returns a deeply nested map", () => {
-            const trie = parseTrie("a>a>a");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-
-            expect(aa).to.be.instanceOf(Map);
-            expect(aaa).to.equal(true);
-        });
-
-        it("returns a nested map with the given domains as key and true as value", () => {
-            const trie = parseTrie("a>a,b,c");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const ab = a.get("b");
-            const ac = a.get("c");
-
-            expect(aa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ac).to.equal(true);
-        });
-    });
-
-    describe("and with UP separator", () => {
-        it("returns a map with maps", () => {
-            const trie = parseTrie("a>a,b<b>a,b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const ab = a.get("a");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const bb = b.get("b");
-
-            expect(aa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ba).to.equal(true);
-            expect(bb).to.equal(true);
-        });
-
-        it("goes up multiple levels", () => {
-            const trie = parseTrie("a>a>a>a<<<b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const aaaa = aaa.get("a");
-            const b = trie.get("b");
-
-            expect(aaaa).to.equal(true);
-            expect(b).to.equal(true);
-        });
-    });
-
-    describe("and with RESET separator", () => {
-        it("resets the domain level", () => {
-            const trie = parseTrie("a>a|b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const b = trie.get("b");
-
-            expect(aa).to.equal(true);
-            expect(b).to.equal(true);
-        });
-
-        it("works also on the top-level", () => {
-            const trie = parseTrie("a|b");
-            const a = trie.get("a");
-            const b = trie.get("b");
-
-            expect(a).to.equal(true);
-            expect(b).to.equal(true);
-        });
-
-        it("returns the expected trie", () => {
-            const trie = parseTrie("a>a>a|b>a|c");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const c = trie.get("c");
-
-            expect(aaa).to.equal(true);
-            expect(ba).to.equal(true);
-            expect(c).to.equal(true);
-        });
-    });
-
-    describe("complex cases", () => {
-        it("parses 'a>a>a>a<<b,c|b>a>a<b>a>a,b' without errors", () => {
-            const trie = parseTrie("a>a>a>a<<b,c|b>a>a<b>a>a,b");
-            const a = trie.get("a");
-            const aa = a.get("a");
-            const aaa = aa.get("a");
-            const aaaa = aaa.get("a");
-            const ab = a.get("b");
-            const ac = a.get("c");
-            const b = trie.get("b");
-            const ba = b.get("a");
-            const baa = ba.get("a");
-            const bb = b.get("b");
-            const bba = bb.get("a");
-            const bbaa = bba.get("a");
-            const bbab = bba.get("b");
-
-            expect(aaaa).to.equal(true);
-            expect(ab).to.equal(true);
-            expect(ac).to.equal(true);
-            expect(baa).to.equal(true);
-            expect(bbaa).to.equal(true);
-            expect(bbab).to.equal(true);
-        });
-    });
-});