Merge lp:~jjacobs/methanal/util-tests into lp:methanal

[Jonathan Jacobs]

[Tristan Seligmann (mithrandi)]

review: Approve

=== removed file 'methanal/js/Methanal/Tests/DOMUtil.js'
--- methanal/js/Methanal/Tests/DOMUtil.js	2009-10-10 10:28:01 +0000
+++ methanal/js/Methanal/Tests/DOMUtil.js	1970-01-01 00:00:00 +0000
@@ -1,75 +0,0 @@
-// import Divmod.MockBrowser
-
-
-
-/**
- * HTMLSelectElement mock implementation.
- */
-Divmod.MockBrowser.Element.subclass(
-    Methanal.Tests.DOMUtil, 'MockHTMLSelectElement').methods(
-    function __init__(self) {
-        Methanal.Tests.DOMUtil.MockHTMLSelectElement.upcall(
-            self, '__init__', 'select');
-        self.options = [];
-    },
-
-
-    /**
-     * Add a new element to the collection of OPTION elements for this SELECT.
-     */
-    function add(self, element, before) {
-        var index = Methanal.Util.arrayIndexOf(self.options, before);
-        if (index == -1) {
-            index = self.options.length;
-            self.options.push(element);
-        } else {
-            self.options.splice(index, 0, element);
-        }
-        element.index = index;
-    });
-
-
-
-/**
- * HTMLDocument mock implementation.
- */
-Divmod.MockBrowser.Document.subclass(
-    Methanal.Tests.DOMUtil, 'Document').methods(
-    function __init__(self) {
-        self._elementTags = {};
-        Methanal.Tests.DOMUtil.Document.upcall(self, '__init__');
-    },
-
-
-    /**
-     * Register a new type for a tag name.
-     */
-    function registerElementTag(self, tagName, type) {
-        var old = self._elementTags[tagName];
-        self._elementTags[tagName] = type;
-        return old;
-    },
-
-
-    function createElement(self, tagName) {
-        var el;
-        if (self._elementTags[tagName]) {
-            el = self._elementTags[tagName]();
-        } else {
-            el = Divmod.MockBrowser.Element(tagName);
-        }
-        el._setOwnerDocument(self);
-        self._allElements.push(el);
-        return el;
-    });
-
-
-
-// Only override Divmod's mock document.
-if (document instanceof Divmod.MockBrowser.Document) {
-    if (!(document instanceof Methanal.Tests.DOMUtil.Document)) {
-        document = Methanal.Tests.DOMUtil.Document();
-        document.registerElementTag(
-            'select', Methanal.Tests.DOMUtil.MockHTMLSelectElement);
-    }
-}

=== added file 'methanal/js/Methanal/Tests/MockBrowser.js'
--- methanal/js/Methanal/Tests/MockBrowser.js	1970-01-01 00:00:00 +0000
+++ methanal/js/Methanal/Tests/MockBrowser.js	2009-10-12 17:10:19 +0000
@@ -0,0 +1,102 @@
+// import Divmod.MockBrowser
+
+
+
+Divmod.MockBrowser.Element.subclass(
+    Methanal.Tests.MockBrowser, 'Element').methods(
+    function __init__(self, tagName) {
+        Methanal.Tests.MockBrowser.Element.upcall(self, '__init__', tagName);
+        self._updateChildProperties();
+    },
+
+
+    function _updateChildProperties(self) {
+        self.firstChild = self.childNodes[0] || null;
+        self.lastChild = self.childNodes[self.childNodes.length - 1] || null;
+    },
+
+
+    function appendChild(self, child) {
+        Methanal.Tests.MockBrowser.Element.upcall(self, 'appendChild', child);
+        self._updateChildProperties();
+    },
+
+
+    function removeChild(self, child) {
+        Methanal.Tests.MockBrowser.Element.upcall(self, 'removeChild', child);
+        self._updateChildProperties();
+    });
+
+
+
+/**
+ * HTMLSelectElement mock implementation.
+ */
+Methanal.Tests.MockBrowser.Element.subclass(
+    Methanal.Tests.MockBrowser, 'MockHTMLSelectElement').methods(
+    function __init__(self) {
+        Methanal.Tests.MockBrowser.MockHTMLSelectElement.upcall(
+            self, '__init__', 'select');
+        self.options = [];
+    },
+
+
+    /**
+     * Add a new element to the collection of OPTION elements for this SELECT.
+     */
+    function add(self, element, before) {
+        var index = Methanal.Util.arrayIndexOf(self.options, before);
+        if (index == -1) {
+            index = self.options.length;
+            self.options.push(element);
+        } else {
+            self.options.splice(index, 0, element);
+        }
+        element.index = index;
+    });
+
+
+
+/**
+ * HTMLDocument mock implementation.
+ */
+Divmod.MockBrowser.Document.subclass(
+    Methanal.Tests.MockBrowser, 'Document').methods(
+    function __init__(self) {
+        self._elementTags = {};
+        Methanal.Tests.MockBrowser.Document.upcall(self, '__init__');
+    },
+
+
+    /**
+     * Register a new type for a tag name.
+     */
+    function registerElementTag(self, tagName, type) {
+        var old = self._elementTags[tagName];
+        self._elementTags[tagName] = type;
+        return old;
+    },
+
+
+    function createElement(self, tagName) {
+        var el;
+        if (self._elementTags[tagName]) {
+            el = self._elementTags[tagName]();
+        } else {
+            el = Methanal.Tests.MockBrowser.Element(tagName);
+        }
+        el._setOwnerDocument(self);
+        self._allElements.push(el);
+        return el;
+    });
+
+
+
+// Only override Divmod's mock document.
+if (document instanceof Divmod.MockBrowser.Document) {
+    if (!(document instanceof Methanal.Tests.MockBrowser.Document)) {
+        document = Methanal.Tests.MockBrowser.Document();
+        document.registerElementTag(
+            'select', Methanal.Tests.MockBrowser.MockHTMLSelectElement);
+    }
+}

=== modified file 'methanal/js/Methanal/Tests/TestUtil.js'
--- methanal/js/Methanal/Tests/TestUtil.js	2009-10-10 10:28:01 +0000
+++ methanal/js/Methanal/Tests/TestUtil.js	2009-10-12 17:10:19 +0000
@@ -1,11 +1,184 @@
 // import Divmod.UnitTest
-// import Divmod.MockBrowser
 // import Methanal.Util
 // import Methanal.Tests.Util
-
-
-
-Divmod.UnitTest.TestCase.subclass(Methanal.Tests.TestUtil, 'TestUtil').methods(
+// import Methanal.Tests.MockBrowser
+
+
+
+Methanal.Tests.Util.TestCase.subclass(
+    Methanal.Tests.TestUtil, 'TestUtil').methods(
+    /**
+     * L{Methanal.Util.addElementClass} and L{Methanal.Util.removeElementClass}
+     * add and remove values to an element's C{className} attribute.
+     */
+    function test_addRemoveElementClass(self) {
+        var node = document.createElement('div');
+        var addElementClass = Methanal.Util.addElementClass;
+        var removeElementClass = Methanal.Util.removeElementClass;
+
+        addElementClass(node, 'foo');
+        self.assertIdentical(node.className, 'foo');
+        addElementClass(node, 'foo');
+        self.assertIdentical(node.className, 'foo');
+
+        addElementClass(node, 'bar');
+        self.assertIdentical(node.className, 'foo bar');
+
+        removeElementClass(node, 'foo');
+        self.assertIdentical(node.className, 'bar');
+
+        removeElementClass(node, 'bar');
+        self.assertIdentical(node.className, '');
+
+        removeElementClass(node, 'bar');
+        self.assertIdentical(node.className, '');
+    },
+
+
+    /**
+     * Create a DOM node with some children.
+     */
+    function _makeNodeWithChildren(self) {
+        var T = Methanal.Util.DOMBuilder(document);
+        var node = T('div', {}, [
+            T('span', {}, ['hello ',
+                T('strong', {}, 'world')]),
+            T('em', {}, ['!'])]);
+        self.assertIdentical(node.childNodes.length, 2);
+        return node;
+    },
+
+
+    /**
+     * L{Methanal.Util.removeNodeContent} removes all of a node's children.
+     */
+    function test_removeNodeContent(self) {
+        var node = self._makeNodeWithChildren();
+        Methanal.Util.removeNodeContent(node);
+        self.assertIdentical(node.childNodes.length, 0);
+    },
+
+
+    /**
+     * L{Methanal.Util.replaceNodeContent} replaces a node's children with
+     * some other children.
+     */
+    function test_replaceNodeContent(self) {
+        var T = Methanal.Util.DOMBuilder(document);
+        var node = self._makeNodeWithChildren();
+        var children = [T('strong', {}, ['yay'])];
+        Methanal.Util.replaceNodeContent(node, children);
+        self.assertArraysEqual(node.childNodes, children);
+    },
+
+
+    /**
+     * L{Methanal.Util.replaceNodeText} replaces a node's content with a text
+     * node.
+     */
+    function test_replaceNodeText(self) {
+        var node = self._makeNodeWithChildren();
+        Methanal.Util.replaceNodeText(node, 'hey');
+        self.assertIdentical(node.childNodes.length, 1);
+        self.assertIsInstanceOf(node.firstChild, Divmod.MockBrowser.TextNode);
+    },
+
+
+    /**
+     * L{Methanal.Util.formatDecimal} pretty-prints a number with thousand
+     * separators.
+     */
+    function test_formatDecimal(self) {
+        var formatDecimal = Methanal.Util.formatDecimal;
+        self.assertIdentical(formatDecimal(1), '1');
+        self.assertIdentical(formatDecimal(100), '100');
+        self.assertIdentical(formatDecimal(1000), '1,000');
+        self.assertIdentical(formatDecimal(10000), '10,000');
+        self.assertIdentical(formatDecimal(1000000), '1,000,000');
+
+        self.assertIdentical(formatDecimal(1000.25), '1,000.25');
+        self.assertIdentical(formatDecimal(1000000.66), '1,000,000.66');
+    },
+
+
+    /**
+     * L{Methanal.Util.cycle} produces a callable that iterates through
+     * the original arguments indefinitely.
+     */
+    function test_cycle(self) {
+        var cycler = Methanal.Util.cycle(42, 5144, 'a');
+        self.assertIdentical(cycler(), 42);
+        self.assertIdentical(cycler(), 5144);
+        self.assertIdentical(cycler(), 'a');
+        self.assertIdentical(cycler(), 42);
+    },
+
+
+    /**
+     * L{Methanal.Util.arrayIndexOf} finds the first index of an element in an
+     * array, or C{-1} if no such element exists.
+     */
+    function test_arrayIndexOf(self) {
+        var arrayIndexOf = Methanal.Util.arrayIndexOf;
+        var a = ['x', 'y', 'z', 'x'];
+        self.assertIdentical(arrayIndexOf(a, 'x'), 0);
+        self.assertIdentical(arrayIndexOf(a, 'y'), 1);
+        self.assertIdentical(arrayIndexOf(a, 'z'), 2);
+        self.assertIdentical(arrayIndexOf(a, 'a'), -1);
+    },
+
+
+    /**
+     * L{Methanal.Util.nodeInserted} calls a widget's C{nodeInserted} method
+     * and the C{nodeInserted} method of each child widget.
+     */
+    function test_nodeInserted(self) {
+        function makeWidget(childWidgets) {
+            return {
+                'childWidgets': childWidgets,
+                'nodeInserted': function () {
+                    this.nodeInserted = true;
+                }};
+        };
+
+        var childWidgets = [];
+        for (var i = 0; i < 5; ++i) {
+            childWidgets.push(makeWidget([]));
+        }
+        var widget = makeWidget(childWidgets);
+
+        Methanal.Util.nodeInserted(widget);
+        self.assertIdentical(widget.nodeInserted, true);
+        for (var i = 0; i < childWidgets.length; ++i) {
+            self.assertIdentical(childWidgets[i].nodeInserted, true);
+        }
+    },
+
+
+    /**
+     * L{Methanal.Util.repr} converts an object to a human-readable string.
+     */
+    function test_repr(self) {
+        var repr = Methanal.Util.repr;
+        self.assertIdentical(repr('a'), '"a"');
+        self.assertIdentical(repr('a"b"c'), '"a\\"b\\"c"');
+        self.assertIdentical(repr(1), '1');
+        self.assertIdentical(repr(null), 'null');
+        self.assertIdentical(repr(undefined), 'undefined');
+        self.assertIdentical(repr(repr), '<function repr>');
+        var a = [1, 2, 3, 'a', ['b', '"c"']];
+        self.assertIdentical(repr(a), '[1, 2, 3, "a", ["b", "\\"c\\""]]');
+        var o = {a: 1};
+        self.assertIdentical(repr(o), '{"a": 1}');
+        var o2 = {a: 1, b: 2};
+        self.assertIdentical(repr(o2), '{"a": 1, "b": 2}');
+
+        var type = Divmod.Class.subclass('Foo');
+        var i = type();
+        self.assertIdentical(repr(i), i.toString());
+    },
+
+
     /**
      * L{Methanal.Util.strToInt} converts a base-10 integer value, represented
      * as a C{String}, to an C{Integer}.

=== modified file 'methanal/js/Methanal/Tests/TestView.js'
--- methanal/js/Methanal/Tests/TestView.js	2009-10-10 10:28:01 +0000
+++ methanal/js/Methanal/Tests/TestView.js	2009-10-12 17:10:19 +0000
@@ -3,7 +3,7 @@
 // import Methanal.View
 // import Methanal.Util
 // import Methanal.Tests.Util
-// import Methanal.Tests.DOMUtil
+// import Methanal.Tests.MockBrowser
 
 
 
@@ -374,7 +374,7 @@
 /**
  * Mimic Internet Explorer's broken C{HTMLSelectElement.add} behaviour.
  */
-Methanal.Tests.DOMUtil.MockHTMLSelectElement.subclass(
+Methanal.Tests.MockBrowser.MockHTMLSelectElement.subclass(
     Methanal.Tests.TestView, 'MockIEHTMLSelectElement').methods(
     function add(self, element, before) {
         if (before === null) {

=== modified file 'methanal/js/Methanal/Util.js'
--- methanal/js/Methanal/Util.js	2009-10-10 10:28:01 +0000
+++ methanal/js/Methanal/Util.js	2009-10-12 17:10:19 +0000
@@ -1,7 +1,3 @@
-// import Nevow.Athena
-
-
-
 /**
  * Add a class to an element's "className" attribute.
  *
@@ -95,7 +91,7 @@
  *
  * @type node: DOM node
  *
- * @type children: C{Array}
+ * @type children: C{Array} of C{DOM nodes}
  */
 Methanal.Util.replaceNodeContent = function replaceNodeContent(node, children) {
     Methanal.Util.removeNodeContent(node);
@@ -107,7 +103,7 @@
 
 
 /**
- * Replace a node's text node with new text.
+ * Replace all of a node's content with text.
  *
  * @type node: DOM node
  *
@@ -308,7 +304,20 @@
             return '<function ' + o.name + '>';
         }
     } else if (o instanceof Array) {
-        return o.toSource();
+        var names = Methanal.Util.map(Methanal.Util.repr, o);
+        return '[' + names.join(', ') + ']';
+    } else {
+        if (o.constructor !== undefined && o.constructor.name !== undefined) {
+            var typeName = o.constructor.name;
+            if (typeName == 'Object') {
+                var names = [];
+                var repr = Methanal.Util.repr;
+                for (var key in o) {
+                    names.push(repr(key) + ': ' + repr(o[key]));
+                }
+                return '{' + names.join(', ') + '}';
+            }
+        }
     }
     return o.toString();
 };