[MERGE] JS test framework + python runner

bzr revid: xmo@openerp.com-20121116111513-kddq4tohsgaj3hub

1 files changed, 239 insertions, 92 deletions

diff --git a/addons/web/static/test/testing.js b/addons/web/static/test/testing.js
index 1be8e94e74b..5bd008ad7ec 100644
--- a/addons/web/static/test/testing.js
+++ b/addons/web/static/test/testing.js
@@ -1,97 +1,244 @@
-// Test support structures and methods for OpenERP
-openerp.testing = (function () {
-    var xhr = QWeb2.Engine.prototype.get_xhr();
-    xhr.open('GET', '/web/static/src/xml/base.xml', false);
-    xhr.send(null);
-    var doc = xhr.responseXML;
-
-    var dependencies = {
-        corelib: [],
-        coresetup: ['corelib'],
-        data: ['corelib', 'coresetup'],
-        dates: [],
-        formats: ['coresetup', 'dates'],
-        chrome: ['corelib', 'coresetup'],
-        views: ['corelib', 'coresetup', 'data', 'chrome'],
-        search: ['data', 'coresetup', 'formats'],
-        list: ['views', 'data'],
-        form: ['data', 'views', 'list', 'formats'],
-        list_editable: ['list', 'form', 'data'],
+openerp.testing.section('testing.stack', function (test) {
+    // I heard you like tests, so I put tests in your testing infrastructure,
+    // so you can test what you test
+    var reject = function () {
+        // utility function, rejects a success
+        var args = _.toArray(arguments);
+        return $.Deferred(function (d) {
+            d.reject.apply(d, ["unexpected success"].concat(args));
+        });
     };
+    test('direct, value, success', {asserts: 1}, function () {
+        var s = openerp.testing.Stack();
+        return s.execute(function () {
+            return 42;
+        }).then(function (val) {
+            strictEqual(val, 42, "should return the handler value");
+        });
+    });
+    test('direct, deferred, success', {asserts: 1}, function () {
+        var s = openerp.testing.Stack();
+        return s.execute(function () {
+            return $.when(42);
+        }).then(function (val) {
+            strictEqual(val, 42, "should return the handler value")
+        });
+    });
+    test('direct, deferred, failure', {asserts: 1}, function () {
+        var s = openerp.testing.Stack();
+        return s.execute(function () {
+            return $.Deferred(function (d) {
+                d.reject("failed");
+            });
+        }).then(reject, function (f) {
+            strictEqual(f, "failed", "should propagate failure");
+            return $.when();
+        });
+    });
+
+    test('successful setup', {asserts: 2}, function () {
+        var setup_done = false;
+        var s = openerp.testing.Stack();
+        return s.push(function () {
+            return $.Deferred(function (d) {
+                setTimeout(function () {
+                    setup_done = true;
+                    d.resolve(2);
+                }, 50);
+            });
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            ok(setup_done, "should have executed setup");
+            strictEqual(val, 42, "should return executed function value (not setup)");
+        });
+    });
+    test('successful teardown', {asserts: 2}, function () {
+        var teardown = false;
+        var s = openerp.testing.Stack();
+        return s.push(null, function () {
+            return $.Deferred(function (d) {
+                setTimeout(function () {
+                    teardown = true;
+                    d.resolve(2);
+                }, 50);
+            });
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            ok(teardown, "should have executed teardown");
+            strictEqual(val, 42, "should return executed function value (not setup)");
+        });
+    });
+    test('successful setup and teardown', {asserts: 3}, function () {
+        var setup = false, teardown = false;
+        var s = openerp.testing.Stack();
+        return s.push(function () {
+            return $.Deferred(function (d) {
+                setTimeout(function () {
+                    setup = true;
+                    d.resolve(2);
+                }, 50);
+            });
+        }, function () {
+            return $.Deferred(function (d) {
+                setTimeout(function () {
+                    teardown = true;
+                    d.resolve(2);
+                }, 50);
+            });
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            ok(setup, "should have executed setup");
+            ok(teardown, "should have executed teardown");
+            strictEqual(val, 42, "should return executed function value (not setup)");
+        });
+    });
+
+    test('multiple setups', {asserts: 2}, function () {
+        var setups = 0;
+        var s = openerp.testing.Stack();
+        return s.push(function () {
+            setups++;
+        }).push(function () {
+            setups++;
+        }).push(function () {
+            setups++;
+        }).push(function () {
+            setups++;
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            strictEqual(setups, 4, "should have executed all setups of stack");
+            strictEqual(val, 42);
+        });
+    });
+    test('multiple teardowns', {asserts: 2}, function () {
+        var teardowns = 0;
+        var s = openerp.testing.Stack();
+        return s.push(null, function () {
+            teardowns++;
+        }).push(null, function () {
+            teardowns++;
+        }).push(null, function () {
+            teardowns++;
+        }).push(null, function () {
+            teardowns++;
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            strictEqual(teardowns, 4, "should have executed all teardowns of stack");
+            strictEqual(val, 42);
+        });
+    });
+    test('holes in setups', {asserts: 2}, function () {
+        var setups = [];
+        var s = openerp.testing.Stack();
+        return s.push(function () {
+            setups.push(0);
+        }).push().push().push(function () {
+            setups.push(3);
+        }).push(function () {
+            setups.push(4);
+        }).push().push(function () {
+            setups.push(6);
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            deepEqual(setups, [0, 3, 4, 6],
+                "should have executed setups in correct order");
+            strictEqual(val, 42);
+        });
+    });
+    test('holes in teardowns', {asserts: 2}, function () {
+        var teardowns = [];
+        var s = openerp.testing.Stack();
+        return s.push(null, function () {
+            teardowns.push(0);
+        }).push().push().push(null, function () {
+            teardowns.push(3);
+        }).push(null, function () {
+            teardowns.push(4);
+        }).push().push(null, function () {
+            teardowns.push(6);
+        }).execute(function () {
+            return 42;
+        }).then(function (val) {
+            deepEqual(teardowns, [6, 4, 3, 0],
+                "should have executed teardowns in correct order");
+            strictEqual(val, 42);
+        });
 
-    return {
-        /**
-         * Function which does not do anything
-         */
-        noop: function () { },
-        /**
-         * Loads 'base.xml' template file into qweb for the provided instance
-         *
-         * @param instance openerp instance being initialized, to load the template file in
-         */
-        loadTemplate: function (instance) {
-            instance.web.qweb.add_template(doc);
-        },
-        /**
-         * Alter provided instance's ``session`` attribute to make response
-         * mockable:
-         *
-         * * The ``responses`` parameter can be used to provide a map of (RPC)
-         *   paths (e.g. ``/web/view/load``) to a function returning a response
-         *   to the query.
-         * * ``instance.session`` grows a ``responses`` attribute which is
-         *   a map of the same (and is in fact initialized to the ``responses``
-         *   parameter if one is provided)
-         *
-         * Note that RPC requests to un-mocked URLs will be rejected with an
-         * error message: only explicitly specified urls will get a response.
-         *
-         * Mocked sessions will *never* perform an actual RPC connection.
-         *
-         * @param instance openerp instance being initialized
-         * @param {Object} [responses]
-         */
-        mockifyRPC: function (instance, responses) {
-            var session = instance.session;
-            session.responses = responses || {};
-            session.rpc_function = function (url, payload) {
-                var fn = this.responses[url.url + ':' + payload.params.method]
-                      || this.responses[url.url];
+    });
 
-                if (!fn) {
-                    return $.Deferred().reject({}, 'failed',
-                        _.str.sprintf("Url %s not found in mock responses, with arguments %s",
-                                      url.url, JSON.stringify(payload.params))
-                    ).promise();
-                }
-                return $.when(fn(payload));
-            };
-        },
-        /**
-         * Creates an openerp web instance loading the specified module after
-         * all of its dependencies.
-         *
-         * @param {String} module
-         * @returns OpenERP Web instance
-         */
-        instanceFor: function (module) {
-            var instance = openerp.init([]);
-            this._load(instance, module);
-            return instance;
-        },
-        _load: function (instance, module, loaded) {
-            if (!loaded) { loaded = []; }
+    test('failed setup', {asserts: 5}, function () {
+        var setup, teardown, teardown2, code;
+        return openerp.testing.Stack().push(function () {
+            setup = true;
+        }, function () {
+            teardown = true;
+        }).push(function () {
+            return $.Deferred().reject("Fail!");
+        }, function () {
+            teardown2 = true;
+        }).execute(function () {
+            code = true;
+            return 42;
+        }).then(reject, function (m) {
+            ok(setup, "should have executed first setup function");
+            ok(teardown, "should have executed first teardown function");
+            ok(!teardown2, "should not have executed second teardown function");
+            strictEqual(m, "Fail!", "should return setup failure message");
+            ok(!code, "should not have executed callback");
+            return $.when();
+        });
+    });
+    test('failed teardown', {asserts: 2}, function () {
+        var teardowns = 0;
+        return openerp.testing.Stack().push(null, function () {
+            teardowns++;
+            return $.Deferred().reject('Fail 1');
+        }).push(null, function () {
+            teardowns++;
+        }).push(null, function () {
+            teardowns++;
+            return $.Deferred().reject('Fail 3');
+        }).execute(function () {
+            return 42;
+        }).then(reject, function (m) {
+            strictEqual(teardowns, 3,
+                "should have tried executing all teardowns");
+            strictEqual(m, "Fail 3", "should return first failure message");
+                    return $.when();
+        });
+    });
+    test('failed call + teardown', {asserts: 2}, function () {
+        var teardowns = 0;
+        return openerp.testing.Stack().push(null, function () {
+            teardowns++;
+        }).push(null, function () {
+            teardowns++;
+            return $.Deferred().reject('Fail 2');
+        }).execute(function () {
+            return $.Deferred().reject("code");
+        }).then(reject, function (m) {
+            strictEqual(teardowns, 2,
+                "should have tried executing all teardowns");
+            strictEqual(m, "code", "should return first failure message");
+                    return $.when();
+        });
+    });
 
-            var deps = dependencies[module];
-            if (!deps) { throw new Error("Unknown dependencies for " + module); }
+    test('arguments passing', {asserts: 9}, function () {
+        var asserter = function (a, b, c) {
+            strictEqual(a, 1);
+            strictEqual(b, "foo");
+            deepEqual(c, {bar: "baz", qux: 42});
+        };
 
-            var to_load = _.difference(deps, loaded);
-            while (!_.isEmpty(to_load)) {
-                this._load(instance, to_load[0], loaded);
-                to_load = _.difference(deps, loaded);
-            }
-            openerp.web[module](instance);
-            loaded.push(module);
-        }
-    }
-})();
+        return openerp.testing.Stack()
+            .push(asserter, asserter)
+            .execute(asserter, 1, "foo", {bar: 'baz', qux: 42});
+    });
+});