Move tests to test for easier Mocha usage

2 files changed, 159 insertions, 0 deletions

diff --git a/test/html/simplify.tests.js b/test/html/simplify.tests.js
new file mode 100644
index 0000000..ccc5610
--- /dev/null
+++ b/test/html/simplify.tests.js
@@ -0,0 +1,115 @@
+var assert = require("assert");
+
+var _ = require("underscore");
+
+var test = require("../testing").test;
+var html = require("../../lib/html");
+var htmlPaths = require("../../lib/html-paths");
+
+var nonFreshElement = html.nonFreshElement;
+var text = html.text;
+var pathToNodes = html.pathToNodes;
+
+describe("simplify", function() {
+    test("empty text nodes are removed", function() {
+        assert.deepEqual(
+            simplifyNode(text("")),
+            []
+        );
+    });
+    
+    test("elements with no children are removed", function() {
+        assert.deepEqual(
+            simplifyNode(nonFreshElement("p", {}, [])),
+            []
+        );
+    });
+    
+    test("elements only containing empty nodes are removed", function() {
+        assert.deepEqual(
+            simplifyNode(nonFreshElement("p", {}, [text("")])),
+            []
+        );
+    });
+    
+    test("empty children of element are removed", function() {
+        assert.deepEqual(
+            simplifyNode(nonFreshElement("p", {}, [text("Hello"), text("")])),
+            [nonFreshElement("p", {}, [text("Hello")])]
+        );
+    });
+    
+    test("successive fresh elements are not collapsed", function() {
+        var path = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: true})
+        ]);
+        var original = concat(
+            pathToNodes(path, [text("Hello")]),
+            pathToNodes(path, [text(" there")])
+        );
+        
+        assert.deepEqual(
+            html.simplify(original),
+            original);
+    });
+    
+    test("successive plain non-fresh elements are collapsed if they have the same tag name", function() {
+        var path = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: false})
+        ]);
+        assert.deepEqual(
+            html.simplify(concat(
+                pathToNodes(path, [text("Hello")]),
+                pathToNodes(path, [text(" there")])
+            )),
+            pathToNodes(path, [text("Hello"), text(" there")])
+        );
+    });
+    
+    test("non-fresh can collapse into preceding fresh element", function() {
+        var freshPath = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: true})]);
+        var nonFreshPath = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: false})]);
+        assert.deepEqual(
+            html.simplify(concat(
+                pathToNodes(freshPath, [text("Hello")]),
+                pathToNodes(nonFreshPath, [text(" there")])
+            )),
+            pathToNodes(freshPath, [text("Hello"), text(" there")])
+        );
+    });
+    
+    test("children of collapsed element can collapse with children of another collapsed element", function() {
+        assert.deepEqual(
+            html.simplify([
+                nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("Hello")])]),
+                nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("there")])])
+            ]),
+            [nonFreshElement("blockquote", {}, [nonFreshElement("p", {}, [text("Hello"), text("there")])])]
+        );
+    });
+    
+    test("empty elements are removed before collapsing", function() {
+        var freshPath = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: true})]);
+        var nonFreshPath = htmlPaths.elements([
+            htmlPaths.element("p", {}, {fresh: false})]);
+        assert.deepEqual(
+            html.simplify(concat(
+                pathToNodes(nonFreshPath, [text("Hello")]),
+                pathToNodes(freshPath, []),
+                pathToNodes(nonFreshPath, [text(" there")])
+            )),
+            pathToNodes(nonFreshPath, [text("Hello"), text(" there")])
+        );
+    });
+});
+
+function simplifyNode(node) {
+    return html.simplify([node]);
+}
+
+function concat() {
+    return _.flatten(arguments, true);
+}
diff --git a/test/html/write.tests.js b/test/html/write.tests.js
new file mode 100644
index 0000000..531995f
--- /dev/null
+++ b/test/html/write.tests.js
@@ -0,0 +1,44 @@
+var assert = require("assert");
+
+var test = require("../testing").test;
+var html = require("../../lib/html");
+var writers = require("../../lib/writers");
+
+
+describe("HTML write", function() {
+    test("text is HTML escaped", function() {
+        assert.equal(
+            generateString(html.text("<>&")),
+            "&lt;&gt;&amp;");
+    });
+    
+    test("double quotes outside of attributes are not escaped", function() {
+        assert.equal(
+            generateString(html.text('"')),
+            '"');
+    });
+    
+    test("element attributes are HTML escaped", function() {
+        assert.equal(
+            generateString(html.freshElement("p", {"x": "<"})),
+            '<p x="&lt;"></p>');
+    });
+    
+    test("double quotes inside attributes are escaped", function() {
+        assert.equal(
+            generateString(html.freshElement("p", {"x": '"'})),
+            '<p x="&quot;"></p>');
+    });
+    
+    test("element children are written", function() {
+        assert.equal(
+            generateString(html.freshElement("p", {}, [html.text("Hello")])),
+            '<p>Hello</p>');
+    });
+});
+
+function generateString(node) {
+    var writer = writers.writer();
+    html.write(writer, [node]);
+    return writer.asString();
+}