Move tests to respective folders as .spec

This is to keep to standards

ts/docx/document/body/body.spec.ts

@@ -0,0 +1,50 @@
+import { assert } from "chai";
+
+import { Utility } from "../../../tests/utility";
+import { Body } from "./";
+import { Columns } from "./columns";
+import { DocumentGrid } from "./doc-grid";
+import { PageMargin } from "./page-margin";
+import { PageSize } from "./page-size";
+import { SectionProperties } from "./section-properties";
+
+describe("Body", () => {
+    let body: Body;
+
+    beforeEach(() => {
+        body = new Body();
+        body.push(new SectionProperties());
+        body.push(new PageSize());
+        body.push(new PageMargin());
+        body.push(new Columns());
+        body.push(new DocumentGrid());
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create the Section Properties", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[0].rootKey, "w:sectPr");
+        });
+
+        it("should create the Page Size", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[1].rootKey, "w:pgSz");
+        });
+
+        it("should create the Page Margin", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[2].rootKey, "w:pgMar");
+        });
+
+        it("should create the Columns", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[3].rootKey, "w:cols");
+        });
+
+        it("should create the Document Grid", () => {
+            const newJson = Utility.jsonify(body);
+            assert.equal(newJson.root[4].rootKey, "w:docGrid");
+        });
+    });
+});

ts/docx/document/document.spec.ts

@@ -0,0 +1,74 @@
+import { assert, expect } from "chai";
+
+import * as docx from "../../";
+import { Formatter } from "../../export/formatter";
+
+describe("Document", () => {
+    let document: docx.Document;
+
+    beforeEach(() => {
+        document = new docx.Document();
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create valid JSON", () => {
+            const stringifiedJson = JSON.stringify(document);
+            let newJson;
+
+            try {
+                newJson = JSON.parse(stringifiedJson);
+            } catch (e) {
+                assert.isTrue(false);
+            }
+            assert.isTrue(true);
+        });
+    });
+
+    describe("#createParagraph", () => {
+        it("should create a new paragraph and append it to body", () => {
+            const para = document.createParagraph();
+            expect(para).to.be.an.instanceof(docx.Paragraph);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:p");
+        });
+
+        it("should use the text given to create a run in the paragraph", () => {
+            const para = document.createParagraph("sample paragraph text");
+            expect(para).to.be.an.instanceof(docx.Paragraph);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:p").which.includes({
+                "w:r": [
+                    {"w:rPr": []},
+                    {"w:t": [{_attr: {"xml:space": "preserve"}}, "sample paragraph text"]},
+                ],
+            });
+        });
+    });
+
+    describe("#createTable", () => {
+        it("should create a new table and append it to body", () => {
+            const table = document.createTable(2, 3);
+            expect(table).to.be.an.instanceof(docx.Table);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:tbl");
+        });
+
+        it("should create a table with the correct dimensions", () => {
+            document.createTable(2, 3);
+            const body = new Formatter().format(document)["w:document"][1]["w:body"];
+            expect(body).to.be.an("array").which.has.length.at.least(1);
+            expect(body[0]).to.have.property("w:tbl").which.includes({
+                "w:tblGrid": [
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                ],
+            });
+            expect(body[0]["w:tbl"].filter((x) => x["w:tr"])).to.have.length(2);
+        });
+    });
+});

ts/docx/paragraph/border.spec.ts

@@ -0,0 +1,29 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { ThematicBreak } from "./border";
+
+describe("Border", () => {
+    // TODO: Need tests here
+});
+
+describe("ThematicBreak", () => {
+    let thematicBreak: ThematicBreak;
+
+    beforeEach(() => {
+        thematicBreak = new ThematicBreak();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Thematic Break with correct border properties", () => {
+            const newJson = Utility.jsonify(thematicBreak);
+            const attributes = {
+                color: "auto",
+                space: "1",
+                val: "single",
+                sz: "6",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+    });
+});

ts/docx/paragraph/page-break.spec.ts

@@ -0,0 +1,32 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { PageBreak } from "./page-break";
+
+describe("PageBreak", () => {
+    let pageBreak: PageBreak;
+
+    beforeEach(() => {
+        pageBreak = new PageBreak();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Page Break with correct attributes", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            const attributes = {
+                type: "page",
+            };
+            assert.equal(JSON.stringify(newJson.root[1].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Page Break with w:r", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            assert.equal(newJson.rootKey, "w:r");
+        });
+
+        it("should create a Page Break with a Break inside", () => {
+            const newJson = Utility.jsonify(pageBreak);
+            assert.equal(newJson.root[1].rootKey, "w:br");
+        });
+    });
+});

ts/docx/paragraph/paragraph.spec.ts

@@ -0,0 +1,293 @@
+import { assert, expect } from "chai";
+
+import * as docx from "../../docx";
+import { Formatter } from "../../export/formatter";
+import { Numbering } from "../../numbering";
+
+describe("Paragraph", () => {
+    let paragraph: docx.Paragraph;
+
+    beforeEach(() => {
+        paragraph = new docx.Paragraph();
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create valid JSON", () => {
+            const stringifiedJson = JSON.stringify(paragraph);
+            let newJson;
+
+            try {
+                newJson = JSON.parse(stringifiedJson);
+            } catch (e) {
+                assert.isTrue(false);
+            }
+            assert.isTrue(true);
+        });
+
+        it("should create have valid properties", () => {
+            const stringifiedJson = JSON.stringify(paragraph);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root[0].rootKey, "w:pPr");
+        });
+    });
+
+    describe("#createTextRun", () => {
+        it("should add a new run to the paragraph and return it", () => {
+            const run = paragraph.createTextRun("this is a test run");
+            expect(run).to.be.instanceof(docx.TextRun);
+            const tree = new Formatter().format(paragraph)["w:p"];
+            expect(tree).to.be.an("array").which.includes({
+                "w:r": [
+                    {"w:rPr": []},
+                    {"w:t": [{_attr: {"xml:space": "preserve"}}, "this is a test run"]},
+                ],
+            });
+        });
+    });
+
+    describe("#heading1()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading1();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading1"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#heading2()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading2();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading2"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#heading3()", () => {
+        it("should add heading style to JSON", () => {
+            paragraph.heading3();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading3"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#title()", () => {
+        it("should add title style to JSON", () => {
+            paragraph.title();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Title"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#center()", () => {
+        it("should add center alignment to JSON", () => {
+            paragraph.center();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:jc": [{_attr: {"w:val": "center"}}]}],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#thematicBreak()", () => {
+        it("should add thematic break to JSON", () => {
+            paragraph.thematicBreak();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{
+                    "w:pPr": [{
+                        "w:pBdr": [{
+                            "w:bottom": [{
+                                _attr: {
+                                    "w:val": "single",
+                                    "w:color": "auto",
+                                    "w:space": "1",
+                                    "w:sz": "6",
+                                },
+                            }],
+                        }],
+                    }],
+                }],
+            });
+        });
+    });
+
+    describe("#pageBreak()", () => {
+        it("should add page break to JSON", () => {
+            paragraph.pageBreak();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{
+                    "w:pPr": [],
+                }, {
+                    "w:r": [
+                        {"w:rPr": []},
+                        {"w:br": [{_attr: {"w:type": "page"}}]},
+                    ],
+                }],
+            });
+        });
+    });
+
+    describe("#bullet()", () => {
+        it("should add list paragraph style to JSON", () => {
+            paragraph.bullet();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
+        });
+
+        it("it should add numbered properties", () => {
+            paragraph.bullet();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(2);
+            expect(tree["w:p"][0]["w:pPr"][1]).to.deep.equal({
+                "w:numPr": [
+                    {"w:ilvl": [{_attr: {"w:val": 0}}]},
+                    {"w:numId": [{_attr: {"w:val": 1}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#setNumbering", () => {
+        it("should add list paragraph style to JSON", () => {
+            const numbering = new Numbering();
+            const numberedAbstract = numbering.createAbstractNumbering();
+            numberedAbstract.createLevel(0, "lowerLetter", "%1)", "start");
+            const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
+
+            paragraph.setNumbering(letterNumbering, 0);
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
+        });
+
+        it("it should add numbered properties", () => {
+            const numbering = new Numbering();
+            const numberedAbstract = numbering.createAbstractNumbering();
+            numberedAbstract.createLevel(0, "lowerLetter", "%1)", "start");
+            const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
+
+            paragraph.setNumbering(letterNumbering, 0);
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:pStyle": [{_attr: {"w:val": "ListParagraph"}}]},
+                            {
+                                "w:numPr": [
+                                    {"w:ilvl": [{_attr: {"w:val": 0}}]},
+                                    {"w:numId": [{_attr: {"w:val": letterNumbering.id}}]},
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#style", () => {
+        it("should set the paragraph style to the given styleId", () => {
+            paragraph.style("myFancyStyle");
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:pStyle": [{_attr: {"w:val": "myFancyStyle"}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#indent", () => {
+        it("should set the paragraph indent to the given values", () => {
+            paragraph.indent(720);
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:ind": [{_attr: {"w:left": 720}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#spacing", () => {
+        it("should set the paragraph spacing to the given values", () => {
+            paragraph.spacing({before: 90, line: 50});
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [
+                            {"w:spacing": [{_attr: {"w:before": 90, "w:line": 50}}]},
+                        ],
+                    },
+                ],
+            });
+        });
+    });
+
+    describe("#keepLines", () => {
+        it("should set the paragraph keepLines sub-component", () => {
+            paragraph.keepLines();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{"w:pPr": [{"w:keepLines": []}]}],
+            });
+        });
+    });
+
+    describe("#keepNext", () => {
+        it("should set the paragraph keepNext sub-component", () => {
+            paragraph.keepNext();
+            const tree = new Formatter().format(paragraph);
+            expect(tree).to.deep.equal({
+                "w:p": [{"w:pPr": [{"w:keepNext": []}]}],
+            });
+        });
+    });
+});

ts/docx/paragraph/spacing.spec.ts

@@ -0,0 +1,24 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Spacing } from "./spacing";
+
+describe("Spacing", () => {
+    describe("#constructor", () => {
+        it("should set the properties given", () => {
+            const spacing = new Spacing({before: 100, after: 120, line: 150});
+            const tree = new Formatter().format(spacing);
+            expect(tree).to.deep.equal({
+                "w:spacing": [{_attr: {"w:after": 120, "w:before": 100, "w:line": 150}}],
+            });
+        });
+
+        it("should only set the given properties", () => {
+            const spacing = new Spacing({before: 100});
+            const tree = new Formatter().format(spacing);
+            expect(tree).to.deep.equal({
+                "w:spacing": [{_attr: {"w:before": 100}}],
+            });
+        });
+    });
+});

ts/docx/paragraph/style.spec.ts

@@ -0,0 +1,22 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { Style } from "./style";
+
+describe("ParagraphStyle", () => {
+    let style: Style;
+
+    describe("#constructor()", () => {
+        it("should create a style with given value", () => {
+            style = new Style("test");
+            const newJson = Utility.jsonify(style);
+            assert.equal(newJson.root[0].root.val, "test");
+        });
+
+        it("should create a style with blank val", () => {
+            style = new Style("");
+            const newJson = Utility.jsonify(style);
+            assert.equal(newJson.root[0].root.val, "");
+        });
+    });
+});

ts/docx/paragraph/tab-stop.spec.ts

@@ -0,0 +1,57 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { LeftTabStop, MaxRightTabStop } from "./tab-stop";
+
+describe("LeftTabStop", () => {
+    let tabStop: LeftTabStop;
+
+    beforeEach(() => {
+        tabStop = new LeftTabStop(100);
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab Stop with correct attributes", () => {
+            const newJson = Utility.jsonify(tabStop);
+            const attributes = {
+                val: "left",
+                pos: 100,
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Tab Stop with w:tab", () => {
+            const newJson = Utility.jsonify(tabStop);
+            assert.equal(newJson.root[0].rootKey, "w:tab");
+        });
+    });
+});
+
+describe("RightTabStop", () => {
+    // TODO
+});
+
+describe("MaxRightTabStop", () => {
+    let tabStop: MaxRightTabStop;
+
+    beforeEach(() => {
+        tabStop = new MaxRightTabStop();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab Stop with correct attributes", () => {
+            const newJson = Utility.jsonify(tabStop);
+
+            const attributes = {
+                val: "right",
+                pos: 9026,
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Tab Stop with w:tab", () => {
+            const newJson = Utility.jsonify(tabStop);
+            assert.equal(newJson.root[0].rootKey, "w:tab");
+        });
+    });
+});

ts/docx/paragraph/unordered-list.spec.ts

@@ -0,0 +1,31 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { NumberProperties } from "./unordered-list";
+
+describe("NumberProperties", () => {
+    let numberProperties: NumberProperties;
+
+    beforeEach(() => {
+        numberProperties = new NumberProperties(5, 10);
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Number Properties with correct root key", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.rootKey, "w:numPr");
+        });
+
+        it("should create a Page Break with a Indent Level inside", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.root[0].rootKey, "w:ilvl");
+            assert.equal(newJson.root[0].root[0].root.val, 10);
+        });
+
+        it("should create a Page Break with a Number Id inside", () => {
+            const newJson = Utility.jsonify(numberProperties);
+            assert.equal(newJson.root[1].rootKey, "w:numId");
+            assert.equal(newJson.root[1].root[0].root.val, 5);
+        });
+    });
+});

ts/docx/run/break.spec.ts

@@ -0,0 +1,19 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { Break } from "./break";
+
+describe("Break", () => {
+    let currentBreak: Break;
+
+    beforeEach(() => {
+        currentBreak = new Break();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Break with correct root key", () => {
+            const newJson = Utility.jsonify(currentBreak);
+            assert.equal(newJson.rootKey, "w:br");
+        });
+    });
+});

ts/docx/run/run-components/drawing/drawing.spec.ts

@@ -0,0 +1,27 @@
+import { assert } from "chai";
+import * as fs from "fs";
+
+import { Utility } from "../../../../tests/utility";
+import { Drawing } from "./";
+
+describe("Drawing", () => {
+    let currentBreak: Drawing;
+
+    beforeEach(() => {
+        const path = "./demo/penguins.jpg";
+        currentBreak = new Drawing({
+            fileName: "test.jpg",
+            referenceId: 1,
+            stream: fs.createReadStream(path),
+            path: path,
+        });
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Drawing with correct root key", () => {
+            const newJson = Utility.jsonify(currentBreak);
+            assert.equal(newJson.rootKey, "w:drawing");
+            // console.log(JSON.stringify(newJson, null, 2));
+        });
+    });
+});

ts/docx/run/run-components/text.spec.ts

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../../export/formatter";
+import { Text } from "./text";
+
+describe("Text", () => {
+    describe("#constructor", () => {
+        it("creates an empty text run if no text is given", () => {
+            const t = new Text("");
+            const f = new Formatter().format(t);
+            expect(f).to.deep.equal({"w:t": [{_attr: {"xml:space": "preserve"}}]});
+        });
+
+        it("adds the passed in text to the component", () => {
+            const t = new Text(" this is\n text");
+            const f = new Formatter().format(t);
+            expect(f).to.deep.equal({"w:t": [
+                {_attr: {"xml:space": "preserve"}},
+                " this is\n text",
+            ]});
+        });
+    });
+});

ts/docx/run/run-fonts.spec.ts

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { RunFonts } from "./run-fonts";
+
+describe("RunFonts", () => {
+
+    describe("#constructor()", () => {
+        it("uses the font name for both ascii and hAnsi", () => {
+            const tree = new Formatter().format(new RunFonts("Times"));
+            expect(tree).to.deep.equal({
+                "w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}],
+            });
+        });
+
+        it("uses hint if given", () => {
+            const tree = new Formatter().format(new RunFonts("Times", "default"));
+            expect(tree).to.deep.equal({
+                "w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times", "w:hint": "default"}}],
+            });
+        });
+    });
+});

ts/docx/run/run.spec.ts

@@ -0,0 +1,157 @@
+import { assert, expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Utility } from "../../tests/utility";
+import { Run } from "./";
+
+describe("Run", () => {
+    let run: Run;
+
+    beforeEach(() => {
+        run = new Run();
+    });
+
+    describe("#bold()", () => {
+        it("it should add bold to the properties", () => {
+            run.bold();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:b");
+        });
+    });
+
+    describe("#italic()", () => {
+        it("it should add italics to the properties", () => {
+            run.italic();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:i");
+        });
+    });
+
+    describe("#underline()", () => {
+        it("it should add underline to the properties", () => {
+            run.underline();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:u");
+        });
+
+        it("should default to 'single' and no color", () => {
+            run.underline();
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:u": [{_attr: {"w:val": "single"}}]}]},
+                ],
+            });
+        });
+
+        it("should set the style type and color if given", () => {
+            run.underline("double", "990011");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:u": [{_attr: {"w:val": "double", "w:color": "990011"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#smallCaps()", () => {
+        it("it should add smallCaps to the properties", () => {
+            run.smallCaps();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:smallCaps");
+        });
+    });
+
+    describe("#caps()", () => {
+        it("it should add caps to the properties", () => {
+            run.allCaps();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:caps");
+        });
+    });
+
+    describe("#strike()", () => {
+        it("it should add strike to the properties", () => {
+            run.strike();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:strike");
+        });
+    });
+
+    describe("#doubleStrike()", () => {
+        it("it should add caps to the properties", () => {
+            run.doubleStrike();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[0].root[0].rootKey, "w:dstrike");
+        });
+    });
+
+    describe("#break()", () => {
+        it("it should add break to the run", () => {
+            run.break();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[1].rootKey, "w:br");
+        });
+    });
+
+    describe("#tab()", () => {
+        it("it should add break to the run", () => {
+            run.tab();
+            const newJson = Utility.jsonify(run);
+            assert.equal(newJson.root[1].rootKey, "w:tab");
+        });
+    });
+
+    describe("#font()", () => {
+        it("should allow chaining calls", () => {
+            expect(run.font("Times")).to.equal(run);
+        });
+
+        it("should set the font as named", () => {
+            run.font("Times");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#color", () => {
+        it("should set the run to the color given", () => {
+            run.color("001122");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:color": [{_attr: {"w:val": "001122"}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#size", () => {
+        it("should set the run to the given size", () => {
+            run.size(24);
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:sz": [{_attr: {"w:val": 24}}]}]},
+                ],
+            });
+        });
+    });
+
+    describe("#style", () => {
+        it("should set the style to the given styleId", () => {
+            run.style("myRunStyle");
+            const tree = new Formatter().format(run);
+            expect(tree).to.deep.equal({
+                "w:r": [
+                    {"w:rPr": [{"w:rStyle": [{_attr: {"w:val": "myRunStyle"}}]}]},
+                ],
+            });
+        });
+    });
+});

ts/docx/run/script.spec.ts

@@ -0,0 +1,50 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { SubScript, SuperScript } from "./script";
+
+describe("SubScript", () => {
+    let subScript: SubScript;
+
+    beforeEach(() => {
+        subScript = new SubScript();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Sub Script with correct attributes", () => {
+            const newJson = Utility.jsonify(subScript);
+            const attributes = {
+                val: "subscript",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Sub Script with correct root key", () => {
+            const newJson = Utility.jsonify(subScript);
+            assert.equal(newJson.rootKey, "w:vertAlign");
+        });
+    });
+});
+
+describe("SuperScript", () => {
+    let superScript: SuperScript;
+
+    beforeEach(() => {
+        superScript = new SuperScript();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Super Script with correct attributes", () => {
+            const newJson = Utility.jsonify(superScript);
+            const attributes = {
+                val: "superscript",
+            };
+            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
+        });
+
+        it("should create a Super Script with correct root key", () => {
+            const newJson = Utility.jsonify(superScript);
+            assert.equal(newJson.rootKey, "w:vertAlign");
+        });
+    });
+});

ts/docx/run/strike.spec.ts

@@ -0,0 +1,34 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { DoubleStrike, Strike } from "./formatting";
+
+describe("Strike", () => {
+    let strike: Strike;
+
+    beforeEach(() => {
+        strike = new Strike();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Strike with correct root key", () => {
+            const newJson = Utility.jsonify(strike);
+            assert.equal(newJson.rootKey, "w:strike");
+        });
+    });
+});
+
+describe("DoubleStrike", () => {
+    let strike: DoubleStrike;
+
+    beforeEach(() => {
+        strike = new DoubleStrike();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Double Strike with correct root key", () => {
+            const newJson = Utility.jsonify(strike);
+            assert.equal(newJson.rootKey, "w:dstrike");
+        });
+    });
+});

ts/docx/run/tab.spec.ts

@@ -0,0 +1,19 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { Tab } from "./tab";
+
+describe("Tab", () => {
+    let tab: Tab;
+
+    beforeEach(() => {
+        tab = new Tab();
+    });
+
+    describe("#constructor()", () => {
+        it("should create a Tab with correct root key", () => {
+            const newJson = Utility.jsonify(tab);
+            assert.equal(newJson.rootKey, "w:tab");
+        });
+    });
+});

ts/docx/run/text-run.spec.ts

@@ -0,0 +1,20 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { TextRun } from "./text-run";
+
+describe("TextRun", () => {
+    let run: TextRun;
+
+    describe("#constructor()", () => {
+
+        it("should add text into run", () => {
+            run = new TextRun("test");
+            const f = new Formatter().format(run);
+            expect(f).to.deep.equal({"w:r": [
+                {"w:rPr": []},
+                {"w:t": [{_attr: {"xml:space": "preserve"}}, "test"]},
+            ]});
+        });
+    });
+});

ts/docx/run/underline.spec.ts

@@ -0,0 +1,215 @@
+import { assert, expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Utility } from "../../tests/utility";
+import * as u from "./underline";
+
+describe("Underline", () => {
+
+    describe("#constructor()", () => {
+
+        it("should create a new Underline object with u:u as the rootKey", () => {
+            const underline = new u.Underline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.rootKey, "w:u");
+        });
+
+        it("should default to 'single' and no color", () => {
+            const underline = new u.Underline();
+            const tree = new Formatter().format(underline);
+            expect(tree).to.deep.equal({
+                "w:u": [{_attr: {"w:val": "single"}}],
+            });
+        });
+
+        it("should use the given style type and color", () => {
+            const underline = new u.Underline("double", "FF00CC");
+            const tree = new Formatter().format(underline);
+            expect(tree).to.deep.equal({
+                "w:u": [{_attr: {"w:val": "double", "w:color": "FF00CC"}}],
+            });
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should have u:u as the rootKey", () => {
+            const underline = new u.DashDotDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.rootKey, "w:u");
+        });
+
+        it("should put value in attribute", () => {
+            const underline = new u.DashDotDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashDotDotHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashDotHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashDotHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashLongHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashLongHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashLongUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dashLong");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DotDashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotDash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DotDotDashUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotDotDash");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DottedHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dottedHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DottedUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "dotted");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.DoubleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "double");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.SingleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "single");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.ThickUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "thick");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WaveUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wave");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WavyDoubleUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wavyDouble");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WavyHeavyUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "wavyHeavy");
+        });
+    });
+});
+
+describe("DashDotDotHeavyUnderline", () => {
+
+    describe("#constructor()", () => {
+        it("should put value in attribute", () => {
+            const underline = new u.WordsUnderline();
+            const newJson = Utility.jsonify(underline);
+            assert.equal(newJson.root[0].root.val, "words");
+        });
+    });
+});

ts/docx/table/grid.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { GridCol, TableGrid } from "./grid";
+
+describe("GridCol", () => {
+    describe("#constructor", () => {
+        it("sets the width attribute to the value given", () => {
+            const grid = new GridCol(1234);
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({
+                "w:gridCol": [{_attr: {"w:w": 1234}}],
+            });
+        });
+
+        it("does not set a width attribute if not given", () => {
+            const grid = new GridCol();
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({"w:gridCol": []});
+        });
+    });
+});
+
+describe("TableGrid", () => {
+    describe("#constructor", () => {
+        it("creates a column for each width given", () => {
+            const grid = new TableGrid([1234, 321, 123]);
+            const tree = new Formatter().format(grid);
+            expect(tree).to.deep.equal({
+                "w:tblGrid": [
+                    {"w:gridCol": [{_attr: {"w:w": 1234}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 321}}]},
+                    {"w:gridCol": [{_attr: {"w:w": 123}}]},
+                ],
+            });
+        });
+    });
+});

ts/docx/table/properties.spec.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { TableProperties } from "./properties";
+
+describe("TableProperties", () => {
+    describe("#constructor", () => {
+        it("creates an initially empty property object", () => {
+            const tp = new TableProperties();
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({"w:tblPr": []});
+        });
+    });
+
+    describe("#setWidth", () => {
+        it("adds a table width property", () => {
+            const tp = new TableProperties().setWidth("dxa", 1234);
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblW": [{_attr: {"w:type": "dxa", "w:w": 1234}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#fixedWidthLayout", () => {
+        it("sets the table to fixed width layout", () => {
+            const tp = new TableProperties().fixedWidthLayout();
+            const tree = new Formatter().format(tp);
+            expect(tree).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblLayout": [{_attr: {"w:type": "fixed"}}]},
+                ],
+            });
+        });
+    });
+});

ts/docx/table/table.spec.ts

@@ -0,0 +1,190 @@
+/* tslint:disable:no-unused-expression */
+import { expect } from "chai";
+
+import { Formatter } from "../../export/formatter";
+import { Paragraph } from "../paragraph";
+import { Table } from "./";
+
+describe("Table", () => {
+    describe("#constructor", () => {
+        it("creates a table with the correct number of rows and columns", () => {
+            const table = new Table(3, 2);
+            const tree = new Formatter().format(table);
+            const cell = {"w:tc": [{"w:tcPr": []}, {"w:p": [{"w:pPr": []}]}]};
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                    {"w:tr": [{"w:trPr": []}, cell, cell]},
+                ],
+            });
+        });
+    });
+
+    describe("#getRow and Row#getCell", () => {
+        it("returns the correct row", () => {
+            const table = new Table(2, 2);
+            table.getRow(0).getCell(0).addContent(new Paragraph("A1"));
+            table.getRow(0).getCell(1).addContent(new Paragraph("B1"));
+            table.getRow(1).getCell(0).addContent(new Paragraph("A2"));
+            table.getRow(1).getCell(1).addContent(new Paragraph("B2"));
+            const tree = new Formatter().format(table);
+            const cell = (c) => ({"w:tc": [
+                {"w:tcPr": []},
+                {"w:p": [
+                    {"w:pPr": []},
+                    {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, c]}]},
+                ]},
+            ]});
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell("A1"), cell("B1")]},
+                    {"w:tr": [{"w:trPr": []}, cell("A2"), cell("B2")]},
+                ],
+            });
+        });
+    });
+
+    describe("#getCell", () => {
+        it("returns the correct cell", () => {
+            const table = new Table(2, 2);
+            table.getCell(0, 0).addContent(new Paragraph("A1"));
+            table.getCell(0, 1).addContent(new Paragraph("B1"));
+            table.getCell(1, 0).addContent(new Paragraph("A2"));
+            table.getCell(1, 1).addContent(new Paragraph("B2"));
+            const tree = new Formatter().format(table);
+            const cell = (c) => ({"w:tc": [
+                {"w:tcPr": []},
+                {"w:p": [
+                    {"w:pPr": []},
+                    {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, c]}]},
+                ]},
+            ]});
+            expect(tree).to.deep.equal({
+                "w:tbl": [
+                    {"w:tblPr": []},
+                    {"w:tblGrid": [
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                        {"w:gridCol": [{_attr: {"w:w": 1}}]},
+                    ]},
+                    {"w:tr": [{"w:trPr": []}, cell("A1"), cell("B1")]},
+                    {"w:tr": [{"w:trPr": []}, cell("A2"), cell("B2")]},
+                ],
+            });
+        });
+    });
+
+    describe("#setWidth", () => {
+        it("sets the preferred width on the table", () => {
+            const table = new Table(2, 2).setWidth("pct", 1000);
+            const tree = new Formatter().format(table);
+            expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
+            expect(tree["w:tbl"][0]).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblW": [{_attr: {"w:type": "pct", "w:w": 1000}}]},
+                ],
+            });
+        });
+    });
+
+    describe("#fixedWidthLayout", () => {
+        it("sets the table to fixed width layout", () => {
+            const table = new Table(2, 2).fixedWidthLayout();
+            const tree = new Formatter().format(table);
+            expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
+            expect(tree["w:tbl"][0]).to.deep.equal({
+                "w:tblPr": [
+                    {"w:tblLayout": [{_attr: {"w:type": "fixed"}}]},
+                ],
+            });
+        });
+    });
+
+    describe("Cell", () => {
+        describe("#prepForXml", () => {
+            it("inserts a paragraph at the end of the cell if it is empty", () => {
+                const table = new Table(1, 1);
+                const tree = new Formatter().format(table);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [{"w:pPr": []}]},
+                    ],
+                });
+            });
+
+            it("inserts a paragraph at the end of the cell even if it has a child table", () => {
+                const parentTable = new Table(1, 1);
+                parentTable.getCell(0, 0).addContent(new Table(1, 1));
+                const tree = new Formatter().format(parentTable);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                const cell = row["w:tr"].find((x) => x["w:tc"]);
+                expect(cell).not.to.be.undefined;
+                expect(cell["w:tc"][cell["w:tc"].length - 1]).to.deep.equal({
+                    "w:p": [{"w:pPr": []}],
+                });
+            });
+
+            it("does not insert a paragraph if it already ends with one", () => {
+                const parentTable = new Table(1, 1);
+                parentTable.getCell(0, 0).addContent(new Paragraph("Hello"));
+                const tree = new Formatter().format(parentTable);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [
+                            {"w:pPr": []},
+                            {"w:r": [{"w:rPr": []}, {"w:t": [{_attr: {"xml:space": "preserve"}}, "Hello"]}]},
+                        ]},
+                    ],
+                });
+            });
+        });
+
+        describe("#createParagraph", () => {
+            it("inserts a new paragraph in the cell", () => {
+                const table = new Table(1, 1);
+                const para = table.getCell(0, 0).createParagraph("Test paragraph");
+                expect(para).to.be.an.instanceof(Paragraph);
+                const tree = new Formatter().format(table);
+                expect(tree).to.have.property("w:tbl").which.is.an("array");
+                const row = tree["w:tbl"].find((x) => x["w:tr"]);
+                expect(row).not.to.be.undefined;
+                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
+                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
+                    "w:tc": [
+                        {"w:tcPr": []},
+                        {"w:p": [
+                            {"w:pPr": []},
+                            {"w:r": [
+                                {"w:rPr": []},
+                                {"w:t": [{_attr: {"xml:space": "preserve"}}, "Test paragraph"]},
+                            ]},
+                        ]},
+                    ],
+                });
+            });
+        });
+    });
+});

ts/docx/xml-components/attribute.spec.ts

@@ -0,0 +1,26 @@
+import { assert } from "chai";
+
+import { Attributes } from "./";
+
+describe("Attribute", () => {
+    describe("#constructor()", () => {
+
+        it("should have val as defined with populated constructor", () => {
+            const newAttrs = new Attributes({
+                val: "test",
+            });
+            const stringifiedJson = JSON.stringify(newAttrs);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root.val, "test");
+        });
+
+        it("should have space value as defined with populated constructor", () => {
+            const newAttrs = new Attributes({
+                space: "spaceTest",
+            });
+            const stringifiedJson = JSON.stringify(newAttrs);
+            const newJson = JSON.parse(stringifiedJson);
+            assert.equal(newJson.root.space, "spaceTest");
+        });
+    });
+});

ts/docx/xml-components/xml-component.spec.ts

@@ -0,0 +1,24 @@
+import { assert } from "chai";
+
+import { Utility } from "../../tests/utility";
+import { XmlComponent } from "./";
+
+class TestComponent extends XmlComponent {
+
+}
+
+describe("XmlComponent", () => {
+    let xmlComponent: TestComponent;
+
+    beforeEach(() => {
+        xmlComponent = new TestComponent("w:test");
+    });
+
+    describe("#constructor()", () => {
+
+        it("should create an Xml Component which has the correct rootKey", () => {
+            const newJson = Utility.jsonify(xmlComponent);
+            assert.equal(newJson.rootKey, "w:test");
+        });
+    });
+});