@depup/mammoth 1.12.0-depup.54

package/test/docx/comments-reader.tests.js

@@ -0,0 +1,53 @@
+var assert = require("assert");
+
+var createCommentsReader = require("../../lib/docx/comments-reader").createCommentsReader;
+var createBodyReader = require("../../lib/docx/body-reader").createBodyReader;
+var stylesReader = require("../../lib/docx/styles-reader");
+var documents = require("../../lib/documents");
+var xml = require("../../lib/xml");
+var test = require("../test")(module);
+
+
+function readComment(element) {
+    var bodyReader = createBodyReader({styles: stylesReader.defaultStyles});
+    var commentsReader = createCommentsReader(bodyReader);
+    var comments = commentsReader(element);
+    assert.equal(comments.value.length, 1);
+    return comments.value[0];
+}
+
+test('ID and body of comment are read', function() {
+    var body = [xml.element("w:p")];
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1"}, body)
+    ]));
+    assert.deepEqual(comment.body, [new documents.Paragraph([])]);
+    assert.deepEqual(comment.commentId, "1");
+});
+
+
+test('when optional attributes of comment are missing then they are read as null', function() {
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1"})
+    ]));
+    assert.strictEqual(comment.authorName, null);
+    assert.strictEqual(comment.authorInitials, null);
+});
+
+
+test('when optional attributes of comment are blank then they are read as null', function() {
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1", "w:author": " ", "w:initials": " "})
+    ]));
+    assert.strictEqual(comment.authorName, null);
+    assert.strictEqual(comment.authorInitials, null);
+});
+
+
+test('when optional attributes of comment are not blank then they are read', function() {
+    var comment = readComment(xml.element("w:comments", {}, [
+        xml.element("w:comment", {"w:id": "1", "w:author": "The Piemaker", "w:initials": "TP"})
+    ]));
+    assert.strictEqual(comment.authorName, "The Piemaker");
+    assert.strictEqual(comment.authorInitials, "TP");
+});

package/test/docx/content-types-reader.tests.js

@@ -0,0 +1,45 @@
+var assert = require("assert");
+
+var readContentTypesFromXml = require("../../lib/docx/content-types-reader").readContentTypesFromXml;
+var XmlElement = require("../../lib/xml").Element;
+var test = require("../test")(module);
+
+
+test('reads default-per-extension from XML', function() {
+    var contentTypes = readContentTypesFromXml(
+        new XmlElement("content-types:Types", {}, [
+            new XmlElement("content-types:Default", {Extension: "png", ContentType: "image/png"})
+        ])
+    );
+    assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/png");
+});
+
+test('reads overrides in preference to defaults', function() {
+    var contentTypes = readContentTypesFromXml(
+        new XmlElement("content-types:Types", {}, [
+            new XmlElement("content-types:Default", {Extension: "png", ContentType: "image/png"}),
+            new XmlElement("content-types:Override", {PartName: "/word/media/hat.png", ContentType: "image/hat"})
+        ])
+    );
+    assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/hat");
+});
+
+test('fallback content types have common image types', function() {
+    var contentTypes = readContentTypesFromXml(
+        new XmlElement("content-types:Types", {}, [])
+    );
+    assert.equal(contentTypes.findContentType("word/media/hat.png"), "image/png");
+    assert.equal(contentTypes.findContentType("word/media/hat.gif"), "image/gif");
+    assert.equal(contentTypes.findContentType("word/media/hat.jpg"), "image/jpeg");
+    assert.equal(contentTypes.findContentType("word/media/hat.jpeg"), "image/jpeg");
+    assert.equal(contentTypes.findContentType("word/media/hat.bmp"), "image/bmp");
+    assert.equal(contentTypes.findContentType("word/media/hat.tif"), "image/tiff");
+    assert.equal(contentTypes.findContentType("word/media/hat.tiff"), "image/tiff");
+});
+
+test('fallback content types are case insensitive on extension', function() {
+    var contentTypes = readContentTypesFromXml(
+        new XmlElement("content-types:Types", {}, [])
+    );
+    assert.equal(contentTypes.findContentType("word/media/hat.PnG"), "image/png");
+});

package/test/docx/document-matchers.js

@@ -0,0 +1,42 @@
+var hamjest = require("hamjest");
+var _ = require("underscore");
+
+var documents = require("../../lib/documents");
+
+
+exports.isEmptyRun = isRun({children: []});
+exports.isRun = isRun;
+exports.isText = isText;
+exports.isCheckbox = isCheckbox;
+exports.isHyperlink = isHyperlink;
+exports.isTable = isTable;
+exports.isRow = isRow;
+
+
+function isRun(properties) {
+    return isDocumentElement(documents.types.run, properties);
+}
+
+function isText(text) {
+    return isDocumentElement(documents.types.text, {value: text});
+}
+
+function isCheckbox(properties) {
+    return isDocumentElement(documents.types.checkbox, properties);
+}
+
+function isHyperlink(properties) {
+    return isDocumentElement(documents.types.hyperlink, properties);
+}
+
+function isTable(options) {
+    return isDocumentElement(documents.types.table, options);
+}
+
+function isRow(options) {
+    return isDocumentElement(documents.types.tableRow, options);
+}
+
+function isDocumentElement(type, properties) {
+    return hamjest.hasProperties(_.extend({type: hamjest.equalTo(type)}, properties));
+}

package/test/docx/document-xml-reader.tests.js

@@ -0,0 +1,41 @@
+var assert = require("assert");
+
+var documents = require("../../lib/documents");
+var DocumentXmlReader = require("../../lib/docx/document-xml-reader").DocumentXmlReader;
+var xml = require("../../lib/xml");
+var test = require("../test")(module);
+var createBodyReaderForTests = require("./testing").createBodyReaderForTests;
+
+test("when body element is present then body is read", function() {
+    var bodyReader = createBodyReaderForTests({});
+    var documentXmlReader = new DocumentXmlReader({
+        bodyReader: bodyReader
+    });
+    var textXml = xml.element("w:t", {}, [xml.text("Hello!")]);
+    var runXml = xml.element("w:r", {}, [textXml]);
+    var paragraphXml = xml.element("w:p", {}, [runXml]);
+    var bodyXml = xml.element("w:body", {}, [paragraphXml]);
+    var documentXml = xml.element("w:document", {}, [bodyXml]);
+
+    var result = documentXmlReader.convertXmlToDocument(documentXml);
+
+    assert.deepEqual(result.messages, []);
+    assert.deepEqual(result.value, documents.document(
+        [documents.paragraph([documents.run([documents.text("Hello!")])])],
+        {}
+    ));
+});
+
+test("when body element is not present then error is thrown", function() {
+    var bodyReader = createBodyReaderForTests({});
+    var documentXmlReader = new DocumentXmlReader({
+        bodyReader: bodyReader
+    });
+    var paragraphXml = xml.element("w:p", {}, []);
+    var bodyXml = xml.element("w:body2", {}, [paragraphXml]);
+    var documentXml = xml.element("w:document", {}, [bodyXml]);
+
+    assert.throws(function() {
+        documentXmlReader.convertXmlToDocument(documentXml);
+    }, /Could not find the body element: are you sure this is a docx file?/);
+});

package/test/docx/docx-reader.tests.js

@@ -0,0 +1,179 @@
+var assert = require("assert");
+
+var docxReader = require("../../lib/docx/docx-reader");
+var documents = require("../../lib/documents");
+var xml = require("../../lib/xml");
+
+var testing = require("../testing");
+var test = require("../test")(module);
+var testData = testing.testData;
+var createFakeDocxFile = testing.createFakeDocxFile;
+
+
+test("can read document with single paragraph with single run of text", function() {
+    var expectedDocument = documents.Document([
+        documents.Paragraph([
+            documents.Run([
+                documents.Text("Hello.")
+            ])
+        ])
+    ]);
+    var docxFile = createFakeDocxFile({
+        "word/document.xml": testData("simple/word/document.xml")
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        assert.deepEqual(expectedDocument, result.value);
+    });
+});
+
+test("hyperlink hrefs are read from relationships file", function() {
+    var docxFile = createFakeDocxFile({
+        "word/document.xml": testData("hyperlinks/word/document.xml"),
+        "word/_rels/document.xml.rels": testData("hyperlinks/word/_rels/document.xml.rels")
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        var paragraph = result.value.children[0];
+        assert.equal(1, paragraph.children.length);
+        var hyperlink = paragraph.children[0];
+        assert.equal(hyperlink.href, "http://www.example.com");
+        assert.equal(hyperlink.children.length, 1);
+    });
+});
+
+var relationshipNamespaces = {
+    "r": "http://schemas.openxmlformats.org/package/2006/relationships"
+};
+
+test("main document is found using _rels/.rels", function() {
+    var relationships = xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": "/word/document2.xml"
+        })
+    ]);
+    
+    var docxFile = createFakeDocxFile({
+        "word/document2.xml": testData("simple/word/document.xml"),
+        "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+    });
+    var expectedDocument = documents.Document([
+        documents.Paragraph([
+            documents.Run([
+                documents.Text("Hello.")
+            ])
+        ])
+    ]);
+    return docxReader.read(docxFile).then(function(result) {
+        assert.deepEqual(expectedDocument, result.value);
+    });
+});
+
+
+test("error is thrown when main document part does not exist", function() {
+    var relationships = xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": "/word/document2.xml"
+        })
+    ]);
+    
+    var docxFile = createFakeDocxFile({
+        "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+    });
+    return docxReader.read(docxFile).then(function(result) {
+        assert.ok(false, "Expected error");
+    }, function(error) {
+        assert.equal(error.message, "Could not find main document part. Are you sure this is a valid .docx file?");
+    });
+});
+
+
+test("part paths", {
+    "main document part is found using package relationships": function() {
+        var relationships = xml.element("r:Relationships", {}, [
+            xml.element("r:Relationship", {
+                "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+                "Target": "/word/document2.xml"
+            })
+        ]);
+        
+        var docxFile = createFakeDocxFile({
+            "word/document2.xml": " ",
+            "_rels/.rels": xml.writeString(relationships, relationshipNamespaces)
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths.mainDocument, "word/document2.xml");
+        });
+    },
+    
+    "word/document.xml is used as fallback location for main document part": function() {
+        var docxFile = createFakeDocxFile({
+            "word/document.xml": " "
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths.mainDocument, "word/document.xml");
+        });
+    }
+});
+
+[
+    {
+        name: "comments",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
+    },
+    {
+        name: "endnotes",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes"
+    },
+    {
+        name: "footnotes",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes"
+    },
+    {
+        name: "numbering",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering"
+    },
+    {
+        name: "styles",
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
+    }
+].forEach(function(options) {
+    test(options.name + " part is found using main document relationships", function() {
+        var docxFile = createFakeDocxFile({
+            "_rels/.rels": createPackageRelationships("word/document.xml"),
+            "word/document.xml": " ",
+            "word/_rels/document.xml.rels": xml.writeString(xml.element("r:Relationships", {}, [
+                xml.element("r:Relationship", {
+                    "Type": options.type,
+                    "Target": "target-path.xml"
+                })
+            ]), relationshipNamespaces),
+            "word/target-path.xml": " "
+        });
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths[options.name], "word/target-path.xml");
+        });
+    });
+
+    test("word/" + options.name + ".xml is used as fallback location for " + options.name + " part", function() {
+        var zipContents = {
+            "_rels/.rels": createPackageRelationships("word/document.xml"),
+            "word/document.xml": " "
+        };
+        zipContents["word/" + options.name + ".xml"] = " ";
+        var docxFile = createFakeDocxFile(zipContents);
+        return docxReader._findPartPaths(docxFile).then(function(partPaths) {
+            assert.equal(partPaths[options.name], "word/" + options.name + ".xml");
+        });
+    });
+});
+
+
+function createPackageRelationships(mainDocumentPath) {
+    return xml.writeString(xml.element("r:Relationships", {}, [
+        xml.element("r:Relationship", {
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            "Target": mainDocumentPath
+        })
+    ]), relationshipNamespaces);
+}

package/test/docx/files.tests.js

@@ -0,0 +1,107 @@
+var path = require("path");
+var fs = require("fs");
+var assert = require("assert");
+
+var promises = require("../../lib/promises");
+var Files = require("../../lib/docx/files").Files;
+var uriToPath = require("../../lib/docx/files").uriToPath;
+
+var testing = require("../testing");
+var test = require("../test")(module);
+
+var readFile = promises.promisify(fs.readFile.bind(fs));
+
+
+test("Files", {
+    "when external file access is disabled then reading file raises error": function() {
+        var files = new Files({externalFileAccess: false});
+        return assertError(files.read("/tmp/image.png", "base64"), function(err) {
+            assert.strictEqual(err.message, "could not read external image '/tmp/image.png', external file access is disabled");
+        });
+    },
+
+    "can open files with file URI": function() {
+        var filePath = path.resolve(testing.testPath("tiny-picture.png"));
+        var files = new Files({externalFileAccess: true});
+        return files.read("file:///" + filePath.replace(/^\//, ""), "base64").then(function(contents) {
+            return readFile(filePath, "base64").then(function(expectedContents) {
+                assert.deepEqual(contents, expectedContents);
+            });
+        });
+    },
+
+    "can open files with relative URI": function() {
+        var filePath = path.resolve(testing.testPath("tiny-picture.png"));
+        var files = new Files({
+            externalFileAccess: true,
+            relativeToFile: testing.testPath("./document.docx")
+        });
+        return files.read("tiny-picture.png", "base64").then(function(contents) {
+            return readFile(filePath, "base64").then(function(expectedContents) {
+                assert.deepEqual(contents, expectedContents);
+            });
+        });
+    },
+
+    "given base is not set when opening relative uri then error is raised": function() {
+        var files = new Files({externalFileAccess: true});
+        return assertError(files.read("not-a-real-file.png", "base64"), function(err) {
+            assert.equal(err.message, "could not find external image 'not-a-real-file.png', path of input document is unknown");
+        });
+    },
+
+    "error if relative uri cannot be opened": function() {
+        var files = new Files({
+            externalFileAccess: true,
+            relativeToFile: "/tmp/document.docx"
+        });
+        return assertError(files.read("not-a-real-file.png", "base64"), function(err) {
+            assertRegex(err.message, /could not open external image: 'not-a-real-file.png' \(document directory: '\/tmp'\)\nENOENT.*\/tmp\/not-a-real-file.png.*/);
+        });
+    }
+});
+
+function assertError(promise, func) {
+    return promise.then(function() {
+        assert(false, "Expected error");
+    }, func);
+}
+
+function assertRegex(actual, expected) {
+    assert.ok(expected.test(actual), "Expected regex: " + expected + "\nbut was: " + actual);
+}
+
+
+test("uriToPath", {
+    "leading slash is retained on non-Windows file URIs": function() {
+        assert.equal(uriToPath("file:///a/b/c", "linux"), "/a/b/c");
+        assert.equal(uriToPath("file:///a/b/c", "win32"), "/a/b/c");
+    },
+
+    "URI is unquoted": function() {
+        assert.equal(uriToPath("file:///a%20b"), "/a b");
+    },
+
+    "when host is set to localhost then path can be found": function() {
+        assert.equal(uriToPath("file://localhost/a/b/c"), "/a/b/c");
+    },
+
+    "when host is set but not localhost then path cannot be found": function() {
+        assert.throws(function() {
+            uriToPath("file://example/a/b/c");
+        }, /Could not convert URI to path: file:\/\/example\/a\/b\/c/);
+    },
+
+    "leading slash is not dropped on Windows file URIs when platform is not Windows": function() {
+        assert.equal(uriToPath("file:///c:/a", "linux"), "/c:/a");
+    },
+
+    "leading slash is dropped on Windows file URIs when platform is Windows": function() {
+        assert.equal(uriToPath("file:///c:/a", "win32"), "c:/a");
+        assert.equal(uriToPath("file:///C:/a", "win32"), "C:/a");
+    },
+
+    "relative URI is unquoted": function() {
+        assert.equal(uriToPath("a%20b/c"), "a b/c");
+    }
+});

package/test/docx/notes-reader.tests.js

@@ -0,0 +1,36 @@
+var assert = require("assert");
+
+var createFootnotesReader = require("../../lib/docx/notes-reader").createFootnotesReader;
+var createBodyReader = require("../../lib/docx/body-reader").createBodyReader;
+var stylesReader = require("../../lib/docx/styles-reader");
+var documents = require("../../lib/documents");
+var XmlElement = require("../../lib/xml").Element;
+var test = require("../test")(module);
+
+
+test('ID and body of footnote are read', function() {
+    var bodyReader = new createBodyReader({styles: stylesReader.defaultStyles});
+    var footnoteBody = [new XmlElement("w:p", {}, [])];
+    var footnotes = createFootnotesReader(bodyReader)(
+        new XmlElement("w:footnotes", {}, [
+            new XmlElement("w:footnote", {"w:id": "1"}, footnoteBody)
+        ])
+    );
+    assert.equal(footnotes.value.length, 1);
+    assert.deepEqual(footnotes.value[0].body, [new documents.Paragraph([])]);
+    assert.deepEqual(footnotes.value[0].noteId, "1");
+});
+
+footnoteTypeIsIgnored('continuationSeparator');
+footnoteTypeIsIgnored('separator');
+
+function footnoteTypeIsIgnored(type) {
+    test('footnotes of type ' + type + ' are ignored', function() {
+        var footnotes = createFootnotesReader()(
+            new XmlElement("w:footnotes", {}, [
+                new XmlElement("w:footnote", {"w:id": "1", "w:type": type}, [])
+            ])
+        );
+        assert.equal(footnotes.value.length, 0);
+    });
+}