Move tests to test for easier Mocha usage

1 files changed, 159 insertions, 0 deletions

diff --git a/test/style-reader.tests.js b/test/style-reader.tests.js
new file mode 100644
index 0000000..0a4dccb
--- /dev/null
+++ b/test/style-reader.tests.js
@@ -0,0 +1,159 @@
+var assert = require("assert");
+var htmlPaths = require("../lib/html-paths");
+var documentMatchers = require("../lib/document-matchers");
+var styleReader = require("../lib/style-reader");
+var results = require("../lib/results");
+var test = require("./testing").test;
+
+
+var readHtmlPath = styleReader.readHtmlPath;
+var readDocumentMatcher = styleReader.readDocumentMatcher;
+var readStyle = styleReader.readStyle;
+
+
+describe('styleReader.readHtmlPath', function() {
+    test('reads empty path', function() {
+        assertHtmlPath("", htmlPaths.empty);
+    });
+    
+    test('reads single element', function() {
+        assertHtmlPath("p", htmlPaths.elements(["p"]));
+    });
+    
+    test('reads choice of elements', function() {
+        assertHtmlPath(
+            "ul|ol",
+            htmlPaths.elements([
+                htmlPaths.element(["ul", "ol"])
+            ])
+        );
+    });
+    
+    test('reads nested elements', function() {
+        assertHtmlPath("ul > li", htmlPaths.elements(["ul", "li"]));
+    });
+    
+    test('reads class on element', function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {"class": "tip"})
+        ]);
+        assertHtmlPath("p.tip", expected);
+    });
+    
+    test('reads multiple classes on element', function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {"class": "tip help"})
+        ]);
+        assertHtmlPath("p.tip.help", expected);
+    });
+    
+    test('reads when element must be fresh', function() {
+        var expected = htmlPaths.elements([
+            htmlPaths.element("p", {}, {"fresh": true})
+        ]);
+        assertHtmlPath("p:fresh", expected);
+    });
+    
+    function assertHtmlPath(input, expected) {
+        assert.deepEqual(readHtmlPath(input), results.success(expected));
+    }
+});
+
+describe("styleReader.readDocumentMatcher", function() {
+    test("reads plain paragraph", function() {
+        assertDocumentMatcher("p", documentMatchers.paragraph());
+    });
+    
+    test("reads paragraph with style ID", function() {
+        assertDocumentMatcher(
+            "p.Heading1",
+            documentMatchers.paragraph({styleId: "Heading1"})
+        );
+    });
+    
+    test("reads paragraph with style name", function() {
+        assertDocumentMatcher(
+            "p[style-name='Heading 1']",
+            documentMatchers.paragraph({styleName: "Heading 1"})
+        );
+    });
+    
+    test("reads p:ordered-list(1) as ordered list with index of 0", function() {
+        assertDocumentMatcher(
+            "p:ordered-list(1)",
+            documentMatchers.paragraph({list: {isOrdered: true, levelIndex: 0}})
+        );
+    });
+    
+    test("reads p:unordered-list(1) as unordered list with index of 0", function() {
+        assertDocumentMatcher(
+            "p:unordered-list(1)",
+            documentMatchers.paragraph({list: {isOrdered: false, levelIndex: 0}})
+        );
+    });
+    
+    test("reads plain run", function() {
+        assertDocumentMatcher(
+            "r",
+            documentMatchers.run()
+        );
+    });
+    
+    test("reads bold", function() {
+        assertDocumentMatcher(
+            "b",
+            documentMatchers.bold
+        );
+    });
+    
+    test("reads italic", function() {
+        assertDocumentMatcher(
+            "i",
+            documentMatchers.italic
+        );
+    });
+    
+    test("reads underline", function() {
+        assertDocumentMatcher(
+            "u",
+            documentMatchers.underline
+        );
+    });
+    
+    test("reads strikethrough", function() {
+        assertDocumentMatcher(
+            "strike",
+            documentMatchers.strikethrough
+        );
+    });
+    
+    function assertDocumentMatcher(input, expected) {
+        assert.deepEqual(readDocumentMatcher(input), results.success(expected));
+    }
+});
+
+describe("styleReader.read", function() {
+    test("document matcher is mapped to HTML path using arrow", function() {
+        assertStyleMapping(
+            "p => h1",
+            {
+                from: documentMatchers.paragraph(),
+                to: htmlPaths.elements(["h1"])
+            }
+        );
+    });
+    
+    test("reads style mapping with no HTML path", function() {
+        assertStyleMapping(
+            "r =>",
+            {
+                from: documentMatchers.run(),
+                to: htmlPaths.empty
+            }
+        );
+    });
+    
+    function assertStyleMapping(input, expected) {
+        assert.deepEqual(readStyle(input), results.success(expected));
+    }
+});