All new

alle new

node_modules/mammoth/test/transforms.tests.js

@@ -0,0 +1,125 @@
+var assert = require("assert");
+
+var _ = require("underscore");
+
+var documents = require("../lib/documents");
+var transforms = require("../lib/transforms");
+var test = require("./test")(module);
+
+
+test("paragraph()", {
+    "paragraph is transformed": function() {
+        var paragraph = documents.paragraph([]);
+        var result = transforms.paragraph(function() {
+            return documents.tab();
+        })(paragraph);
+        assert.deepEqual(result, documents.tab());
+    },
+    
+    "non-paragraph elements are not transformed": function() {
+        var run = documents.run([]);
+        var result = transforms.paragraph(function() {
+            return documents.tab();
+        })(run);
+        assert.deepEqual(result, documents.run([]));
+    }
+});
+
+
+test("run()", {
+    "run is transformed": function() {
+        var run = documents.run([]);
+        var result = transforms.run(function() {
+            return documents.tab();
+        })(run);
+        assert.deepEqual(result, documents.tab());
+    },
+    
+    "non-run elements are not transformed": function() {
+        var paragraph = documents.paragraph([]);
+        var result = transforms.run(function() {
+            return documents.tab();
+        })(paragraph);
+        assert.deepEqual(result, documents.paragraph([]));
+    }
+});
+
+
+test("elements()", {
+    "all descendants are transformed": function() {
+        var root = {
+            children: [
+                {
+                    children: [
+                        {}
+                    ]
+                }
+            ]
+        };
+        var currentCount = 0;
+        function setCount(node) {
+            currentCount++;
+            return _.extend(node, {count: currentCount});
+        }
+        
+        var result = transforms._elements(setCount)(root);
+        
+        assert.deepEqual(result, {
+            count: 3,
+            children: [
+                {
+                    count: 2,
+                    children: [
+                        {count: 1}
+                    ]
+                }
+            ]
+        });
+    }
+});
+
+
+test("getDescendants()", {
+    "returns nothing if element has no children property": function() {
+        assert.deepEqual(transforms.getDescendants({}), []);
+    },
+    
+    "returns nothing if element has empty children": function() {
+        assert.deepEqual(transforms.getDescendants({children: []}), []);
+    },
+    
+    "includes children": function() {
+        var element = {
+            children: [{name: "child 1"}, {name: "child 2"}]
+        };
+        assert.deepEqual(
+            transforms.getDescendants(element),
+            [{name: "child 1"}, {name: "child 2"}]
+        );
+    },
+    
+    "includes indirect descendants": function() {
+        var grandchild = {name: "grandchild"};
+        var child = {name: "child", children: [grandchild]};
+        var element = {children: [child]};
+        assert.deepEqual(
+            transforms.getDescendants(element),
+            [grandchild, child]
+        );
+    }
+});
+
+
+test("getDescendantsOfType()", {
+    "filters descendants to type": function() {
+        var paragraph = {type: "paragraph"};
+        var run = {type: "run"};
+        var element = {
+            children: [paragraph, run]
+        };
+        assert.deepEqual(
+            transforms.getDescendantsOfType(element, "run"),
+            [run]
+        );
+    }
+});