@natlibfi/ekirjasto-opds-feed-parser 1.0.0

package/test/link_parser_test.ts

@@ -0,0 +1,324 @@
+import PrefixMap from "../src/prefix_map";
+import LinkParser from "../src/link_parser";
+import NamespaceParser from "../src/namespace_parser";
+import OPDSCatalogRootLink from "../src/opds_catalog_root_link";
+import OPDSFacetLink from "../src/opds_facet_link";
+import SearchLink from "../src/search_link";
+import AlternateLink from "../src/alternate_link";
+import CompleteEntryLink from "../src/complete_entry_link";
+import OPDSAcquisitionLink from "../src/opds_acquisition_link";
+import OPDSArtworkLink from "../src/opds_artwork_link";
+import OPDSCrawlableLink from "../src/opds_crawlable_link";
+import OPDSCollectionLink from "../src/opds_collection_link";
+import OPDSShelfLink from "../src/opds_shelf_link";
+import AvailabilityParser from "../src/availability_parser";
+import HoldsParser from "../src/holds_parser";
+import CopiesParser from "../src/copies_parser";
+import chai = require("chai");
+let expect = chai.expect;
+
+describe("LinkParser", () => {
+  let parser: LinkParser;
+  let prefixes: PrefixMap;
+
+  beforeEach(() => {
+    prefixes = {
+      [NamespaceParser.OPDS_URI]: "opds:",
+      [NamespaceParser.THR_URI]: "thr:"
+    };
+    parser = new LinkParser(prefixes);
+  });
+
+  describe("#parse", () => {
+    it("extracts link attributes", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel":  {"value": "test rel"},
+          "type": {"value": "test type"},
+          "title": {"value": "test title"},
+          "role": {"value": "test role"}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals("test rel");
+      expect(parsedLink.type).to.equals("test type");
+      expect(parsedLink.title).to.equals("test title");
+      expect(parsedLink.role).to.equals("test role");
+    });
+
+    it("allows no type, title, and role", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel":  {"value": "test rel"},
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals("test rel");
+      expect(parsedLink.type).to.be.undefined;
+      expect(parsedLink.title).to.be.undefined;
+      expect(parsedLink.role).to.be.undefined;
+    });
+
+    it("extracts catalog root link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSCatalogRootLink.REL}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSCatalogRootLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(OPDSCatalogRootLink.REL);
+    });
+
+    it("extracts facet link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSFacetLink.REL},
+          "opds:facetGroup": {"value": "test facet group"},
+          "opds:activeFacet": {"value": "false"},
+          "thr:count": {"value": "57"}
+        }
+      };
+      let parsedLink = <OPDSFacetLink>parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSFacetLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(OPDSFacetLink.REL);
+      expect(parsedLink.facetGroup).to.equals("test facet group");
+      expect(parsedLink.activeFacet).to.be.false;
+      expect(parsedLink.count).to.equals(57);
+    });
+
+    it("extracts search link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": SearchLink.REL},
+        }
+      };
+      let parsedLink = <SearchLink>parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(SearchLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(SearchLink.REL);
+    });
+
+    it("extracts acquisition link", () => {
+      OPDSAcquisitionLink.RELS.forEach(rel => {
+        let link = {
+          "$": {
+            "href": {"value": "test href"},
+            "rel": {"value": rel}
+          }
+        };
+        let parsedLink = parser.parse(link);
+        expect(parsedLink).to.be.an.instanceof(OPDSAcquisitionLink);
+        expect(parsedLink.href).to.equals("test href");
+        expect(parsedLink.rel).to.equals(rel);
+      });
+    });
+
+    it("extracts prices for acquisition link", () => {
+      let value =  "1000.00";
+      let currencyCode = "USD";
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSAcquisitionLink.BUY_REL}
+        },
+        "opds:price": [
+          {
+            "$": {
+              "currencyCode": { "value": currencyCode }
+            },
+            "_": value
+          }
+        ]
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSAcquisitionLink);
+      let castParsedLink = <OPDSAcquisitionLink>parsedLink;
+      expect(castParsedLink.prices.length).to.equals(1);
+    });
+
+    it("extracts nested indirect acquisition for acquisition link", () => {
+      let type1 = "vnd.adobe/adept+xml";
+      let type2 = "application/epub+zip";
+      let type3 = "application/zip";
+      let type4 = "application/pdf";
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSAcquisitionLink.BUY_REL}
+        },
+        "opds:indirectAcquisition": [
+          {
+            "$": {
+              "type": { "value": type1 }
+            },
+            "opds:indirectAcquisition": [
+              {
+                "$": {
+                  "type": { "value": type2 }
+                }
+              }
+            ]
+          },
+          {
+            "$": {
+              "type": { "value": type3 }
+            },
+            "opds:indirectAcquisition": [
+              {
+                "$": {
+                  "type": { "value": type4 }
+                }
+              }
+            ]
+          }
+        ]
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSAcquisitionLink);
+      let castParsedLink = <OPDSAcquisitionLink>parsedLink;
+      expect(castParsedLink.indirectAcquisitions[0].type).to.equals(type1);
+      expect(castParsedLink.indirectAcquisitions[0].indirectAcquisitions[0].type).to.equals(type2);
+      expect(castParsedLink.indirectAcquisitions[1].type).to.equals(type3);
+      expect(castParsedLink.indirectAcquisitions[1].indirectAcquisitions[0].type).to.equals(type4);
+    });
+
+    it("extracts availability, holds, copies for acquisition link", () => {
+      let link = {
+        $: {
+          href: { value: "test href" },
+          rel: { value: OPDSAcquisitionLink.BORROW_REL }
+        },
+        "opds:availability": [
+          {
+            $: {
+              status: { value: "unavailable" },
+              until: { value: "2016-11-02T19:46:27Z" }
+            }
+          }
+        ],
+        "opds:holds": [
+          {
+            $: {
+              total: { value: "29" },
+              position: { value: "11" }
+            }
+          }
+        ],
+        "opds:copies": [
+          {
+            $: {
+              total: { value: "7" },
+              available: { value: "0" }
+            }
+          }
+        ]
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSAcquisitionLink);
+      let castParsedLink = <OPDSAcquisitionLink>parsedLink;
+      expect(castParsedLink.availability).to.deep.equal(
+        new AvailabilityParser(prefixes).parse(link["opds:availability"][0])
+      );
+      expect(castParsedLink.holds).to.deep.equal(
+        new HoldsParser(prefixes).parse(link["opds:holds"][0])
+      );
+      expect(castParsedLink.copies).to.deep.equal(
+        new CopiesParser(prefixes).parse(link["opds:copies"][0])
+      );
+    });
+
+    it("extracts artwork link", () => {
+      OPDSArtworkLink.RELS.forEach(rel => {
+        let link = {
+          "$": {
+            "href": {"value": "test href"},
+            "rel": {"value": rel}
+          }
+        };
+        let parsedLink = parser.parse(link);
+        expect(parsedLink).to.be.an.instanceof(OPDSArtworkLink);
+        expect(parsedLink.href).to.equals("test href");
+        expect(parsedLink.rel).to.equals(rel);
+      });
+    });
+
+    it("extracts alternate link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": AlternateLink.REL}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(AlternateLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(AlternateLink.REL);
+    });
+
+    it("extracts complete entry link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": AlternateLink.REL},
+          "type": {"value": CompleteEntryLink.TYPE}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(CompleteEntryLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(AlternateLink.REL);
+      expect(parsedLink.type).to.equals(CompleteEntryLink.TYPE);
+    });
+
+    it("extracts crawlable link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSCrawlableLink.REL}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSCrawlableLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(OPDSCrawlableLink.REL);
+    });
+
+    it("extracts collection link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSCollectionLink.REL},
+          "title": {"value": "test title"}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSCollectionLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.title).to.equals("test title");
+      expect(parsedLink.rel).to.equals(OPDSCollectionLink.REL);
+    });
+
+    it("extracts shelf link", () => {
+      let link = {
+        "$": {
+          "href": {"value": "test href"},
+          "rel": {"value": OPDSShelfLink.REL}
+        }
+      };
+      let parsedLink = parser.parse(link);
+      expect(parsedLink).to.be.an.instanceof(OPDSShelfLink);
+      expect(parsedLink.href).to.equals("test href");
+      expect(parsedLink.rel).to.equals(OPDSShelfLink.REL);
+    });
+  });
+});

package/test/namespace_parser_test.ts

@@ -0,0 +1,41 @@
+import NamespaceParser from "../src/namespace_parser";
+import chai = require("chai");
+let expect = chai.expect;
+
+describe("NamespaceParser", () => {
+  let parser: NamespaceParser;
+
+  beforeEach(() => {
+    parser = new NamespaceParser();
+  });
+
+  describe("#prefixes", () => {
+    it("returns empty string for no prefix", () => {
+      let namespaces = {
+        "$": {
+          "xmlns": {
+            "value": NamespaceParser.ATOM_URI,
+            "local": ""
+          }
+        }
+      };
+      let prefixes = parser.prefixes(namespaces);
+      let atomPrefix = prefixes[NamespaceParser.ATOM_URI];
+      expect(atomPrefix).to.equals("");
+    });
+
+    it("returns prefix with colon", () => {
+      let namespaces = {
+        "$": {
+          "xmlns:atom": {
+            "value": NamespaceParser.ATOM_URI,
+            "local": "atom"
+          }
+        }
+      };
+      let prefixes = parser.prefixes(namespaces);
+      let atomPrefix = prefixes[NamespaceParser.ATOM_URI];
+      expect(atomPrefix).to.equals("atom:");
+    });
+  });
+});

package/test/opds_parser_test.ts

@@ -0,0 +1,147 @@
+import OPDSFeed from "../src/opds_feed";
+import {
+  NavigationFeed,
+  AcquisitionFeed,
+  OPDSEntry,
+  OPDSCatalogRootLink,
+  SearchLink,
+  AlternateLink,
+  OPDSAcquisitionLink,
+  OPDSArtworkLink
+} from "../src/index";
+import OPDSParser from "../src/opds_parser";
+import fs = require("fs");
+import chai = require("chai");
+let expect = chai.expect;
+
+describe("OPDSParser", () => {
+  let parser: OPDSParser;
+
+  beforeEach(() => {
+    parser = new OPDSParser();
+  });
+
+  describe("#parse", () => {
+    it("raises error when input has no feed or entry", (done) => {
+      let opds = "<test></test>";
+      parser.parse(opds).then(() => {
+        done("parser did not raise error for input with no feed");
+      }).catch((error) => {
+        done();
+      });
+    });
+
+    it("allows foreign markup", (done) => {
+      // http://opds-spec.org/specs/opds-catalog-1-1-20110627/#Document_Extensibility
+      let opds = "<feed><test /></feed>";
+      parser.parse(opds).then((result) => {
+        if (result) {
+          done();
+        } else {
+          done("parse did not return an OPDSFeed");
+        }
+      }).catch((error) => {
+        done(error);
+      });
+    });
+
+    it("parses navigation feed from OPDS test catalog", (done) => {
+      fs.readFile("test/files/navigation.xml", "utf8", (error, data) => {
+        if (error) {
+          done(error);
+        } else {
+          let promise: Promise<OPDSEntry | OPDSFeed> = parser.parse(data);
+          promise.then((result: OPDSFeed) => {
+            expect(result).to.be.an.instanceof(NavigationFeed);
+            expect(result).not.to.be.an.instanceof(AcquisitionFeed);
+            expect(result.id).to.equals("root.xml");
+            expect(result.title).to.equals("Test Catalog Root");
+            expect(result.updated).to.equals("2012-10-20T01:11:18Z");
+
+            expect(result.links.length).to.equals(5);
+            expect(result.links[0].href).to.equals("root.xml");
+            expect(result.links[1]).to.be.an.instanceof(OPDSCatalogRootLink);
+            expect(result.links[2]).to.be.an.instanceof(SearchLink);
+
+            expect(result.entries.length).to.equals(6);
+            expect(result.entries[0].title).to.equals("First Acquisition feed");
+            expect(result.entries[0].id).to.equals("main.xml");
+            expect(result.entries[0].updated).to.equals("2012-10-20T01:11:18Z");
+            expect(result.entries[0].summary.content).to.equals("Basic acquisition feed");
+            expect(result.entries[0].links.length).to.equals(1);
+            expect(result.entries[0].links[0].type).to.equals("application/atom+xml; profile=opds-catalog; kind=acquisition");
+            expect(result.entries[3].title).to.equals("Link: Recommended");
+            expect(result.entries[5].id).to.equals("popular.xml");
+          }).then(done, done);
+        }
+      });
+    });
+
+    it("parses acquisition feed from OPDS test catalog", (done) => {
+      fs.readFile("test/files/acquisition.xml", "utf8", (error, data) => {
+        if (error) {
+          done(error);
+        } else {
+          let promise: Promise<OPDSEntry | OPDSFeed> = parser.parse(data);
+          promise.then((result: OPDSFeed) => {
+            expect(result).to.be.an.instanceof(AcquisitionFeed);
+            expect(result).not.to.be.an.instanceof(NavigationFeed);
+            expect(result.id).to.equals("main.xml");
+            expect(result.title).to.equals("First Acquisition Feed");
+            expect(result.updated).to.equals("2012-10-20T01:11:18Z");
+            expect(result.search.totalResults).to.equals(18);
+
+            expect(result.links.length).to.equals(4);
+            expect(result.links[1].href).to.equals("../root.xml");
+            expect(result.links[1]).to.be.an.instanceof(OPDSCatalogRootLink);
+            expect(result.links[2]).to.be.an.instanceof(SearchLink);
+
+            expect(result.entries.length).to.equals(17);
+            expect(result.entries[0].title).to.equals("Pride and Prejudice");
+            expect(result.entries[0].id).to.equals("http://feedbooks.github.io/test/1");
+            expect(result.entries[0].authors.length).to.equals(1);
+            expect(result.entries[0].authors[0].name).to.equals("Jane Austen");
+            expect(result.entries[0].updated).to.equals("2012-10-12T17:43:18Z");
+            expect(result.entries[0].summary.content).to.contain("the story of Mrs. Bennet's attempts to marry off her five daughters");
+            expect(result.entries[0].categories.length).to.equals(2);
+            expect(result.entries[0].categories[0].term).to.equals("FBFIC000000");
+            expect(result.entries[0].categories[0].label).to.equals("Fiction");
+
+            expect(result.entries[0].links.length).to.equals(4);
+            expect(result.entries[0].links[0]).to.be.an.instanceof(OPDSAcquisitionLink);
+            expect(result.entries[0].links[0].href).to.equals("http://www.feedbooks.com/book/52.epub");
+            expect(result.entries[0].links[1]).to.be.an.instanceof(OPDSArtworkLink);
+          }).then(done, done);
+        }
+      });
+    });
+
+    it("parses example library simplified entry", (done) => {
+      fs.readFile("test/files/entry.xml", "utf8", (error, data) => {
+        if (error) {
+          done(error);
+        } else {
+          let promise: Promise<OPDSFeed | OPDSEntry> = parser.parse(data);
+          promise.then((result: OPDSEntry) => {
+            expect(result).to.be.an.instanceof(OPDSEntry);
+            expect(result).not.to.be.an.instanceof(OPDSFeed);
+            expect(result.id).to.equals("urn:librarysimplified.org/terms/id/Overdrive%20ID/135d0478-1ab9-4cc1-a1aa-2aa616b1218c");
+            expect(result.title).to.equals("The Frances Hodgson Burnett Megapack");
+            expect(result.updated).to.equals("2016-01-08T21:38:19Z");
+
+            expect(result.authors.length).to.equals(1);
+            expect(result.authors[0].name).to.equals("Frances Hodgson Burnett");
+
+            expect(result.links.length).to.equals(5);
+            expect(result.links[2]).to.be.an.instanceof(AlternateLink);
+            expect(result.links[4]).to.be.an.instanceof(OPDSAcquisitionLink);
+            expect((<OPDSAcquisitionLink>result.links[4]).indirectAcquisitions.length).to.equals(4);
+
+            expect(result.categories.length).to.equals(4);
+            expect(result.language).to.equals("en");
+          }).then(done, done);
+        }
+      });
+    });
+  });
+});

package/test/price_parser_test.ts

@@ -0,0 +1,30 @@
+import PrefixMap from "../src/prefix_map";
+import OPDSPrice from "../src/opds_price";
+import PriceParser from "../src/price_parser";
+import chai = require("chai");
+let expect = chai.expect;
+
+describe("PriceParser", () => {
+  let parser: PriceParser;
+
+  beforeEach(() => {
+    let prefixes: PrefixMap = {};
+    parser = new PriceParser(prefixes);
+  });
+
+  describe("#parse", () => {
+    it("extracts attributes", () => {
+      let value =  "1000.00";
+      let currencyCode = "USD";
+      let price = {
+        "$": {
+          "currencyCode": { "value": currencyCode }
+        },
+        "_": value
+      };
+      let parsedPrice = parser.parse(price);
+      expect(parsedPrice.value).to.equals(value);
+      expect(parsedPrice.currencyCode).to.equals(currencyCode);
+    });
+ });
+});

package/test/series_parser_test.ts

@@ -0,0 +1,30 @@
+import PrefixMap from "../src/prefix_map";
+import Series from "../src/series";
+import SeriesParser from "../src/series_parser";
+import NamespaceParser from "../src/namespace_parser";
+import chai = require("chai");
+let expect = chai.expect;
+
+describe("SeriesParser", () => {
+  let parser: SeriesParser;
+
+  beforeEach(() => {
+    let prefixes: PrefixMap = {};
+    prefixes[NamespaceParser.SCHEMA_URI] = "schema:";
+    parser = new SeriesParser(prefixes);
+  });
+
+  describe("#parse", () => {
+    it("extracts attributes", () => {
+      let series = {
+        $: {
+          name: { value: "series name" },
+          "schema:position": { value: 5 }
+        }
+      };
+      let parsed = parser.parse(series);
+      expect(parsed.name).to.equals("series name");
+      expect(parsed.position).to.equals(5);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es5",
+    "noImplicitAny": false,
+    "outDir": "lib",
+    "sourceMap": false,
+    "declaration": true,
+    "types": ["mocha", "node"],
+    "lib": ["dom", "es2015"]
+  },
+  "exclude": [
+    "node_modules"
+  ]
+}

package/tslint.json

@@ -0,0 +1,54 @@
+{
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "spaces"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-internal-module": true,
+        "no-trailing-whitespace": true,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            true,
+            "double"
+        ],
+        "semicolon": true,
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    }
+}

package/typings.json

@@ -0,0 +1,8 @@
+{
+  "ambientDependencies": {
+    "chai": "github:DefinitelyTyped/DefinitelyTyped/chai/chai.d.ts#9c25433c84251bfe72bf0030a95edbbb2c81c9d5",
+    "mocha": "github:DefinitelyTyped/DefinitelyTyped/mocha/mocha.d.ts#d6dd320291705694ba8e1a79497a908e9f5e6617",
+    "node": "github:DefinitelyTyped/DefinitelyTyped/node/node.d.ts#1c56e368e17bb28ca57577250624ca5bd561aa81",
+    "xml2js": "github:DefinitelyTyped/DefinitelyTyped/xml2js/xml2js.d.ts#7304e0770d53762f89af7fcf14517d5f45a04cc2"
+  }
+}