Test framework for Web UI.

Test framework for Web UI has been created using qUnit. The test files
are located in install/static/test. The main page is index.html which
contains links to all test suites (xxx_tests.html). The test cases are
stored in xxx_tests.js. All test suites can be executed at once using
all_tests.html. The test data is stored in data folder. This patch
includes test suites for ipa.js and entity.js.

Some variables and functions in ipa.js have been modified to accomodate
testing (e.g. JSON URL, error handler, synchronous operation). The
sampledata has been moved to test/data. The develop.js and webui.js also
have been modified accordingly.

43 files changed, 1785 insertions, 36 deletions

diff --git a/install/static/develop.js b/install/static/develop.js
index 1a80e94a..f161f782 100644
--- a/install/static/develop.js
+++ b/install/static/develop.js
@@ -1,2 +1,4 @@
-ipa_use_sampledata = (window.location.protocol == 'file:');
-
+if (window.location.protocol == 'file:') {
+    ipa_json_url = "test/data";
+    ipa_use_static_files = true;
+}
diff --git a/install/static/ipa.js b/install/static/ipa.js
index 8110f3bf..b7f98e8d 100644
--- a/install/static/ipa.js
+++ b/install/static/ipa.js
@@ -21,9 +21,17 @@
 /* IPA JSON-RPC helper */
 
 var IPA_DEFAULT_JSON_URL = '/ipa/json';
-var IPA_SAMPLEDATA_URL = 'sampledata';
 
-var ipa_use_sampledata = false;
+var ipa_json_url;
+var ipa_use_static_files;
+
+var ipa_ajax_options = {
+    type: 'POST',
+    contentType: 'application/json',
+    dataType: 'json',
+    async: true,
+    processData: false,
+};
 
 /* JSON-RPC ID counter */
 var ipa_jsonrpc_id = 0;
@@ -31,42 +39,27 @@ var ipa_jsonrpc_id = 0;
 /* IPA objects data in JSON format */
 var ipa_objs = {};
 
-var _ipa_init_on_win_callback = null;
 
 /* initialize the IPA JSON-RPC helper
  * arguments:
  *   url - JSON-RPC URL to use (optional) */
-function ipa_init(url, on_win, use_sampledata)
+function ipa_init(url, use_static_files, on_win, on_error)
 {
     if (url)
         ipa_json_url = url;
-    else
-        ipa_json_url = IPA_DEFAULT_JSON_URL;
-    if (use_sampledata)
-        ipa_use_sampledata = use_sampledata;
-
-    _ipa_init_on_win_callback = on_win;
 
-    var options = {
-        type: 'POST',
-        contentType: 'application/json',
-        dataType: 'json',
-        processData: false,
-    };
-
-    $.ajaxSetup(options);
+    if (use_static_files)
+        ipa_use_static_files = use_static_files;
 
-    ipa_cmd('json_metadata', [], {}, _ipa_load_objs,
-            function(response){
-                alert('init failed');
-            });
-}
+    $.ajaxSetup(ipa_ajax_options);
 
-function _ipa_load_objs(data, textStatus, xhr)
-{
-    ipa_objs = data.result.result;
-    if (_ipa_init_on_win_callback)
-        _ipa_init_on_win_callback(data, textStatus, xhr);
+    ipa_cmd('json_metadata', [], {},
+        function(data, status, xhr) {
+            ipa_objs = data.result.result;
+            if (on_win) on_win(data, status, xhr);
+        },
+        on_error
+    );
 }
 
 /* call an IPA command over JSON-RPC
@@ -84,8 +77,12 @@ function ipa_cmd(name, args, options, win_callback, fail_callback, objname)
         name = objname + '_' + name;
 
     var url = ipa_json_url;
-    if (ipa_use_sampledata && IPA_SAMPLEDATA_URL)
-        url = IPA_SAMPLEDATA_URL + '/' + name + '.json';
+
+    if (!url)
+        url = IPA_DEFAULT_JSON_URL;
+
+    if (ipa_use_static_files)
+        url += '/' + name + '.json';
 
     var data = {
         method: name,
@@ -132,7 +129,10 @@ function ipa_parse_qs(qs)
 /* helper function used to retrieve information about an attribute */
 function ipa_get_param_info(obj_name, attr)
 {
-    var takes_params = ipa_objs[obj_name].takes_params;
+    var ipa_obj = ipa_objs[obj_name];
+    if (!ipa_obj) return null;
+
+    var takes_params = ipa_obj.takes_params;
     if (!takes_params)
         return (null);
 
@@ -147,7 +147,10 @@ function ipa_get_param_info(obj_name, attr)
 /* helper function used to retrieve attr name with members of type `member` */
 function ipa_get_member_attribute(obj_name, member)
 {
-    var attribute_members = ipa_objs[obj_name].attribute_members
+    var ipa_obj = ipa_objs[obj_name];
+    if (!ipa_obj) return null;
+
+    var attribute_members = ipa_obj.attribute_members
     for (var a in attribute_members) {
         var objs = attribute_members[a];
         for (var i = 0; i < objs.length; ++i) {
@@ -155,5 +158,7 @@ function ipa_get_member_attribute(obj_name, member)
                 return a;
         }
     }
+
+    return null;
 }
 
diff --git a/install/static/test/all_tests.html b/install/static/test/all_tests.html
new file mode 100644
index 00000000..7185f53e
--- /dev/null
+++ b/install/static/test/all_tests.html
@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Complete Test Suite</title>
+    <link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
+    <script type="text/javascript" src="qunit.js"></script>
+    <script type="text/javascript" src="../jquery.js"></script>
+    <script type="text/javascript" src="../ipa.js"></script>
+    <script type="text/javascript" src="../details.js"></script>
+    <script type="text/javascript" src="../search.js"></script>
+    <script type="text/javascript" src="../add.js"></script>
+    <script type="text/javascript" src="../entity.js"></script>
+    <script type="text/javascript" src="ipa_tests.js"></script>
+    <script type="text/javascript" src="entity_tests.js"></script>
+</head>
+<body>
+    <h1 id="qunit-header">Complete Test Suite</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+    <div id="qunit-fixture">test markup</div>
+</body>
+</html>
diff --git a/install/static/sampledata/group_add.json b/install/static/test/data/group_add.json
index 180f5f11..180f5f11 100644
--- a/install/static/sampledata/group_add.json
+++ b/install/static/test/data/group_add.json
diff --git a/install/static/sampledata/group_add_member.json b/install/static/test/data/group_add_member.json
index 7f10d105..7f10d105 100644
--- a/install/static/sampledata/group_add_member.json
+++ b/install/static/test/data/group_add_member.json
diff --git a/install/static/sampledata/group_find.json b/install/static/test/data/group_find.json
index 902689a0..902689a0 100644
--- a/install/static/sampledata/group_find.json
+++ b/install/static/test/data/group_find.json
diff --git a/install/static/sampledata/group_show.json b/install/static/test/data/group_show.json
index 536b120c..536b120c 100644
--- a/install/static/sampledata/group_show.json
+++ b/install/static/test/data/group_show.json
diff --git a/install/static/sampledata/host_add.json b/install/static/test/data/host_add.json
index 8b4d8b93..8b4d8b93 100644
--- a/install/static/sampledata/host_add.json
+++ b/install/static/test/data/host_add.json
diff --git a/install/static/sampledata/host_find.json b/install/static/test/data/host_find.json
index 83a65d1b..83a65d1b 100644
--- a/install/static/sampledata/host_find.json
+++ b/install/static/test/data/host_find.json
diff --git a/install/static/sampledata/host_show.json b/install/static/test/data/host_show.json
index 64a7fb31..64a7fb31 100644
--- a/install/static/sampledata/host_show.json
+++ b/install/static/test/data/host_show.json
diff --git a/install/static/sampledata/hostgroup_add.json b/install/static/test/data/hostgroup_add.json
index bc41ee7d..bc41ee7d 100644
--- a/install/static/sampledata/hostgroup_add.json
+++ b/install/static/test/data/hostgroup_add.json
diff --git a/install/static/sampledata/hostgroup_add_member.json b/install/static/test/data/hostgroup_add_member.json
index a9220175..a9220175 100644
--- a/install/static/sampledata/hostgroup_add_member.json
+++ b/install/static/test/data/hostgroup_add_member.json
diff --git a/install/static/sampledata/hostgroup_find.json b/install/static/test/data/hostgroup_find.json
index 6732910c..6732910c 100644
--- a/install/static/sampledata/hostgroup_find.json
+++ b/install/static/test/data/hostgroup_find.json
diff --git a/install/static/sampledata/hostgroup_show.json b/install/static/test/data/hostgroup_show.json
index 776d446d..776d446d 100644
--- a/install/static/sampledata/hostgroup_show.json
+++ b/install/static/test/data/hostgroup_show.json
diff --git a/install/static/sampledata/json_metadata.json b/install/static/test/data/json_metadata.json
index 07acb3e4..07acb3e4 100644
--- a/install/static/sampledata/json_metadata.json
+++ b/install/static/test/data/json_metadata.json
diff --git a/install/static/sampledata/netgroup_add.json b/install/static/test/data/netgroup_add.json
index 989bb5db..989bb5db 100644
--- a/install/static/sampledata/netgroup_add.json
+++ b/install/static/test/data/netgroup_add.json
diff --git a/install/static/sampledata/netgroup_add_member.json b/install/static/test/data/netgroup_add_member.json
index 5fbae9e1..5fbae9e1 100644
--- a/install/static/sampledata/netgroup_add_member.json
+++ b/install/static/test/data/netgroup_add_member.json
diff --git a/install/static/sampledata/netgroup_find.json b/install/static/test/data/netgroup_find.json
index 15626e0b..15626e0b 100644
--- a/install/static/sampledata/netgroup_find.json
+++ b/install/static/test/data/netgroup_find.json
diff --git a/install/static/sampledata/netgroup_show.json b/install/static/test/data/netgroup_show.json
index aa77e888..aa77e888 100644
--- a/install/static/sampledata/netgroup_show.json
+++ b/install/static/test/data/netgroup_show.json
diff --git a/install/static/sampledata/rolegroup_add.json b/install/static/test/data/rolegroup_add.json
index 54e2c283..54e2c283 100644
--- a/install/static/sampledata/rolegroup_add.json
+++ b/install/static/test/data/rolegroup_add.json
diff --git a/install/static/sampledata/rolegroup_add_member.json b/install/static/test/data/rolegroup_add_member.json
index e68ecc28..e68ecc28 100644
--- a/install/static/sampledata/rolegroup_add_member.json
+++ b/install/static/test/data/rolegroup_add_member.json
diff --git a/install/static/sampledata/rolegroup_del.json b/install/static/test/data/rolegroup_del.json
index 8af1e630..8af1e630 100644
--- a/install/static/sampledata/rolegroup_del.json
+++ b/install/static/test/data/rolegroup_del.json
diff --git a/install/static/sampledata/rolegroup_find.json b/install/static/test/data/rolegroup_find.json
index 8ed2a76b..8ed2a76b 100644
--- a/install/static/sampledata/rolegroup_find.json
+++ b/install/static/test/data/rolegroup_find.json
diff --git a/install/static/sampledata/rolegroup_remove_member.json b/install/static/test/data/rolegroup_remove_member.json
index d42bb601..d42bb601 100644
--- a/install/static/sampledata/rolegroup_remove_member.json
+++ b/install/static/test/data/rolegroup_remove_member.json
diff --git a/install/static/sampledata/rolegroup_show.json b/install/static/test/data/rolegroup_show.json
index 4652fb2c..4652fb2c 100644
--- a/install/static/sampledata/rolegroup_show.json
+++ b/install/static/test/data/rolegroup_show.json
diff --git a/install/static/sampledata/service_add.json b/install/static/test/data/service_add.json
index 4275d9bb..4275d9bb 100644
--- a/install/static/sampledata/service_add.json
+++ b/install/static/test/data/service_add.json
diff --git a/install/static/sampledata/service_add_host.json b/install/static/test/data/service_add_host.json
index cb199e31..cb199e31 100644
--- a/install/static/sampledata/service_add_host.json
+++ b/install/static/test/data/service_add_host.json
diff --git a/install/static/sampledata/service_del.json b/install/static/test/data/service_del.json
index 053b0ad9..053b0ad9 100644
--- a/install/static/sampledata/service_del.json
+++ b/install/static/test/data/service_del.json
diff --git a/install/static/sampledata/service_find.json b/install/static/test/data/service_find.json
index b71ea9e3..b71ea9e3 100644
--- a/install/static/sampledata/service_find.json
+++ b/install/static/test/data/service_find.json
diff --git a/install/static/sampledata/service_remove_host.sh b/install/static/test/data/service_remove_host.sh
index 15234f4d..15234f4d 100644
--- a/install/static/sampledata/service_remove_host.sh
+++ b/install/static/test/data/service_remove_host.sh
diff --git a/install/static/sampledata/service_show.json b/install/static/test/data/service_show.json
index 30025eb7..30025eb7 100644
--- a/install/static/sampledata/service_show.json
+++ b/install/static/test/data/service_show.json
diff --git a/install/static/sampledata/user_add.json b/install/static/test/data/user_add.json
index b2ede8d1..b2ede8d1 100644
--- a/install/static/sampledata/user_add.json
+++ b/install/static/test/data/user_add.json
diff --git a/install/static/sampledata/user_find.json b/install/static/test/data/user_find.json
index c8ead0ff..c8ead0ff 100644
--- a/install/static/sampledata/user_find.json
+++ b/install/static/test/data/user_find.json
diff --git a/install/static/sampledata/user_show.json b/install/static/test/data/user_show.json
index 149b24f6..149b24f6 100644
--- a/install/static/sampledata/user_show.json
+++ b/install/static/test/data/user_show.json
diff --git a/install/static/sampledata/whoami.json b/install/static/test/data/whoami.json
index a922d372..a922d372 100644
--- a/install/static/sampledata/whoami.json
+++ b/install/static/test/data/whoami.json
diff --git a/install/static/test/entity_tests.html b/install/static/test/entity_tests.html
new file mode 100644
index 00000000..224bb23d
--- /dev/null
+++ b/install/static/test/entity_tests.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Entity Test Suite</title>
+    <link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
+    <script type="text/javascript" src="qunit.js"></script>
+    <script type="text/javascript" src="../jquery.js"></script>
+    <script type="text/javascript" src="../ipa.js"></script>
+    <script type="text/javascript" src="../details.js"></script>
+    <script type="text/javascript" src="../search.js"></script>
+    <script type="text/javascript" src="../add.js"></script>
+    <script type="text/javascript" src="../entity.js"></script>
+    <script type="text/javascript" src="entity_tests.js"></script>
+</head>
+<body>
+    <h1 id="qunit-header">Entity Test Suite</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+    <div id="qunit-fixture">test markup</div>
+</body>
+</html>
diff --git a/install/static/test/entity_tests.js b/install/static/test/entity_tests.js
new file mode 100644
index 00000000..297928ba
--- /dev/null
+++ b/install/static/test/entity_tests.js
@@ -0,0 +1,120 @@
+/*  Authors:
+ *    Endi Sukma Dewata <edewata@redhat.com>
+ *
+ * Copyright (C) 2010 Red Hat
+ * see file 'COPYING' for use and warranty information
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; version 2 only
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+test("Testing ipa_entity_set_search_definition().", function() {
+
+    var uid_callback = function() {
+        return true;
+    };
+
+    ipa_entity_set_search_definition("user", [
+        ["uid", "Login", uid_callback],
+    ]);
+
+    var list = ipa_entity_search_list["user"];
+    ok(
+        list,
+        "ipa_entity_search_list[\"user\"] is not null"
+    );
+
+    var attr = list[0];
+    ok(
+        attr,
+        "ipa_entity_search_list[\"user\"][0] is not null"
+    );
+
+    equals(
+        attr[0], "uid",
+        "ipa_entity_search_list[\"user\"][0][0]"
+    );
+
+    equals(
+        attr[1], "Login",
+        "ipa_entity_search_list[\"user\"][0][1]"
+    );
+
+    var callback = attr[2];
+    ok(
+        callback,
+        "ipa_entity_search_list[\"user\"][0][2] not null"
+    );
+
+    ok(
+        callback(),
+        "ipa_entity_search_list[\"user\"][0][2]() works"
+    );
+});
+
+test("Testing ipa_entity_generate_views().", function() {
+
+    ipa_ajax_options["async"] = false;
+
+    ipa_init(
+        "data",
+        true,
+        function(data, status, xhr) {
+            ok(true, "ipa_init() succeeded.");
+        },
+        function(xhr, options, thrownError) {
+            ok(false, "ipa_init() failed: "+thrownError);
+        }
+    );
+
+    var container = $("<div/>");
+    ipa_entity_generate_views("user", container);
+
+    var list = container.children();
+    var facets = list.children();
+
+    equals(
+        facets.length, 6,
+        "Checking number of facets"
+    )
+
+    var search = facets.first();
+
+    equals(
+        search.attr("title"), "search",
+        "Checking the first facet"
+    )
+
+    var details = search.next();
+
+    equals(
+        details.attr("title"), "details",
+        "Checking the second facet"
+    )
+
+    var facet = details.next();
+    var attribute_members = ipa_objs["user"].attribute_members;
+    for (attribute_member in attribute_members) {
+        var objects = attribute_members[attribute_member];
+        for (var i = 0; i < objects.length; i++) {
+            var object = objects[i];
+
+            equals(
+                facet.attr("title"), object,
+                "Checking the next facet"
+            );
+
+            facet = facet.next();
+        }
+    }
+});
diff --git a/install/static/test/index.html b/install/static/test/index.html
new file mode 100644
index 00000000..c6d22950
--- /dev/null
+++ b/install/static/test/index.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>IPA Test Suite</title>
+    <link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
+    <style type="text/css">
+#content {
+    font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+    font-size: smaller;
+
+    border-bottom: 1px solid #fff;
+    padding: 0.5em 0.5em 0.5em 2.5em;
+
+    color: #2b81af;
+    background-color: #D2E0E6;
+}
+    </style>
+</head>
+<body>
+    <h1 id="qunit-header">IPA Test Suite</h1>
+
+    <h2 id="qunit-banner" class="qunit-pass"></h2>
+
+    <div id="content">
+        <a href="all_tests.html">Complete Test Suite</a>
+        <ul>
+        <li><a href="ipa_tests.html">Core Test Suite</a>
+        <li><a href="entity_tests.html">Entity Test Suite</a>
+        </ul>
+    </div>
+
+    <div id="qunit-testresult">
+        <br>
+    </div>
+
+</body>
+</html>
diff --git a/install/static/test/ipa_tests.html b/install/static/test/ipa_tests.html
new file mode 100644
index 00000000..3031f231
--- /dev/null
+++ b/install/static/test/ipa_tests.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Core Test Suite</title>
+    <link rel="stylesheet" href="qunit.css" type="text/css" media="screen">
+    <script type="text/javascript" src="qunit.js"></script>
+    <script type="text/javascript" src="../jquery.js"></script>
+    <script type="text/javascript" src="../ipa.js"></script>
+    <script type="text/javascript" src="ipa_tests.js"></script>
+</head>
+<body>
+    <h1 id="qunit-header">Core Test Suite</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+    <div id="qunit-fixture">test markup</div>
+</body>
+</html>
diff --git a/install/static/test/ipa_tests.js b/install/static/test/ipa_tests.js
new file mode 100644
index 00000000..8dbdd62d
--- /dev/null
+++ b/install/static/test/ipa_tests.js
@@ -0,0 +1,94 @@
+/*  Authors:
+ *    Endi Sukma Dewata <edewata@redhat.com>
+ *
+ * Copyright (C) 2010 Red Hat
+ * see file 'COPYING' for use and warranty information
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; version 2 only
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+test("Testing ipa_init().", function() {
+
+    expect(1);
+
+    ipa_ajax_options["async"] = false;
+
+    ipa_init(
+        "data",
+        true,
+        function(data, status, xhr) {
+            ok(true, "ipa_init() succeeded.");
+        },
+        function(xhr, options, thrownError) {
+            ok(false, "ipa_init() failed: "+thrownError);
+        }
+    );
+});
+
+test("Testing ipa_get_param_info().", function() {
+
+    var param_info = ipa_get_param_info("user", "uid");
+    ok(
+        param_info,
+        "ipa_get_param_info(\"user\", \"uid\") not null"
+    );
+
+    equals(
+        param_info["label"], "User login",
+        "ipa_get_param_info(\"user\", \"uid\")[\"label\"]"
+    );
+
+    equals(
+        ipa_get_param_info("user", "wrong_attribute"), null,
+        "ipa_get_param_info(\"user\", \"wrong_attribute\")"
+    );
+
+    equals(
+        ipa_get_param_info("user", null), null,
+        "ipa_get_param_info(\"user\", null)"
+    );
+
+    equals(
+        ipa_get_param_info("wrong_entity", "uid"), null,
+        "ipa_get_param_info(\"wrong_entity\", \"uid\")"
+    );
+
+    equals(
+        ipa_get_param_info(null, "uid"), null,
+        "ipa_get_param_info(null, \"uid\")"
+    );
+});
+
+test("Testing ipa_get_member_attribute().", function() {
+
+    equals(
+        ipa_get_member_attribute("user", "group"), "memberof",
+        "ipa_get_member_attribute(\"user\", \"group\")"
+    );
+
+    equals(
+        ipa_get_member_attribute("user", "host"), null,
+        "ipa_get_member_attribute(\"user\", \"host\")"
+    );
+
+    equals(
+        ipa_get_member_attribute("user", null), null,
+        "ipa_get_member_attribute(\"user\", null)"
+    );
+
+    equals(
+        ipa_get_member_attribute(null, "group"), null,
+        "ipa_get_member_attribute(null, \"group\")"
+    );
+});
diff --git a/install/static/test/qunit.css b/install/static/test/qunit.css
new file mode 100644
index 00000000..e9404f59
--- /dev/null
+++ b/install/static/test/qunit.css
@@ -0,0 +1,155 @@
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+	
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 4px 4px 1px;
+	background-color: #0d3349;
+	
+	border-radius: 15px 15px 0 0;
+	-moz-border-radius: 15px 15px 0 0;
+	-webkit-border-top-right-radius: 15px;
+	-webkit-border-top-left-radius: 15px;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: white;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0em 0 0.5em 2em;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests ol {
+	margin-top: 0.5em;
+	padding: 0.5em;
+	
+	background-color: #fff;
+	
+	border-radius: 15px;
+	-moz-border-radius: 15px;
+	-webkit-border-radius: 15px;
+	
+	box-shadow: inset 0px 2px 13px #999;
+	-moz-box-shadow: inset 0px 2px 13px #999;
+	-webkit-box-shadow: inset 0px 2px 13px #999;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	margin: 0.5em;
+	padding: 0.4em 0.5em 0.4em 0.5em;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #5E740B;
+	background-color: #fff;
+	border-left: 26px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+ 
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 26px solid #EE5757;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail, 
+#qunit-testrunner-toolbar                   { background-color: #EE5757; }
+
+
+/** Footer */
+
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+
+	color: #2b81af;
+	background-color: #D2E0E6;
+
+	border-radius: 0 0 15px 15px;
+	-moz-border-radius: 0 0 15px 15px;
+	-webkit-border-bottom-right-radius: 15px;
+	-webkit-border-bottom-left-radius: 15px;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+}
diff --git a/install/static/test/qunit.js b/install/static/test/qunit.js
new file mode 100644
index 00000000..0b8173a8
--- /dev/null
+++ b/install/static/test/qunit.js
@@ -0,0 +1,1261 @@
+/*
+ * QUnit - A JavaScript Unit Testing Framework
+ * 
+ * http://docs.jquery.com/QUnit
+ *
+ * Copyright (c) 2009 John Resig, Jörn Zaefferer
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * and GPL (GPL-LICENSE.txt) licenses.
+ */
+
+(function(window) {
+
+var QUnit = {
+
+	// call on start of module test to prepend name to all tests
+	module: function(name, testEnvironment) {
+		config.currentModule = name;
+
+		synchronize(function() {
+			if ( config.currentModule ) {
+				QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );
+			}
+
+			config.currentModule = name;
+			config.moduleTestEnvironment = testEnvironment;
+			config.moduleStats = { all: 0, bad: 0 };
+
+			QUnit.moduleStart( name, testEnvironment );
+		});
+	},
+
+	asyncTest: function(testName, expected, callback) {
+		if ( arguments.length === 2 ) {
+			callback = expected;
+			expected = 0;
+		}
+
+		QUnit.test(testName, expected, callback, true);
+	},
+	
+	test: function(testName, expected, callback, async) {
+		var name = '<span class="test-name">' + testName + '</span>', testEnvironment, testEnvironmentArg;
+
+		if ( arguments.length === 2 ) {
+			callback = expected;
+			expected = null;
+		}
+		// is 2nd argument a testEnvironment?
+		if ( expected && typeof expected === 'object') {
+			testEnvironmentArg =  expected;
+			expected = null;
+		}
+
+		if ( config.currentModule ) {
+			name = '<span class="module-name">' + config.currentModule + "</span>: " + name;
+		}
+
+		if ( !validTest(config.currentModule + ": " + testName) ) {
+			return;
+		}
+
+		synchronize(function() {
+
+			testEnvironment = extend({
+				setup: function() {},
+				teardown: function() {}
+			}, config.moduleTestEnvironment);
+			if (testEnvironmentArg) {
+				extend(testEnvironment,testEnvironmentArg);
+			}
+
+			QUnit.testStart( testName, testEnvironment );
+
+			// allow utility functions to access the current test environment
+			QUnit.current_testEnvironment = testEnvironment;
+			
+			config.assertions = [];
+			config.expected = expected;
+			
+			var tests = id("qunit-tests");
+			if (tests) {
+				var b = document.createElement("strong");
+					b.innerHTML = "Running " + name;
+				var li = document.createElement("li");
+					li.appendChild( b );
+					li.id = "current-test-output";
+				tests.appendChild( li )
+			}
+
+			try {
+				if ( !config.pollution ) {
+					saveGlobal();
+				}
+
+				testEnvironment.setup.call(testEnvironment);
+			} catch(e) {
+				QUnit.ok( false, "Setup failed on " + name + ": " + e.message );
+			}
+	    });
+	
+	    synchronize(function() {
+			if ( async ) {
+				QUnit.stop();
+			}
+
+			try {
+				callback.call(testEnvironment);
+			} catch(e) {
+				fail("Test " + name + " died, exception and test follows", e, callback);
+				QUnit.ok( false, "Died on test #" + (config.assertions.length + 1) + ": " + e.message );
+				// else next test will carry the responsibility
+				saveGlobal();
+
+				// Restart the tests if they're blocking
+				if ( config.blocking ) {
+					start();
+				}
+			}
+		});
+
+		synchronize(function() {
+			try {
+				checkPollution();
+				testEnvironment.teardown.call(testEnvironment);
+			} catch(e) {
+				QUnit.ok( false, "Teardown failed on " + name + ": " + e.message );
+			}
+	    });
+	
+	    synchronize(function() {
+			try {
+				QUnit.reset();
+			} catch(e) {
+				fail("reset() failed, following Test " + name + ", exception and reset fn follows", e, reset);
+			}
+
+			if ( config.expected && config.expected != config.assertions.length ) {
+				QUnit.ok( false, "Expected " + config.expected + " assertions, but " + config.assertions.length + " were run" );
+			}
+
+			var good = 0, bad = 0,
+				tests = id("qunit-tests");
+
+			config.stats.all += config.assertions.length;
+			config.moduleStats.all += config.assertions.length;
+
+			if ( tests ) {
+				var ol  = document.createElement("ol");
+
+				for ( var i = 0; i < config.assertions.length; i++ ) {
+					var assertion = config.assertions[i];
+
+					var li = document.createElement("li");
+					li.className = assertion.result ? "pass" : "fail";
+					li.innerHTML = assertion.message || "(no message)";
+					ol.appendChild( li );
+
+					if ( assertion.result ) {
+						good++;
+					} else {
+						bad++;
+						config.stats.bad++;
+						config.moduleStats.bad++;
+					}
+				}
+				if (bad == 0) {
+					ol.style.display = "none";
+				}
+
+				var b = document.createElement("strong");
+				b.innerHTML = name + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + config.assertions.length + ")</b>";
+				
+				addEvent(b, "click", function() {
+					var next = b.nextSibling, display = next.style.display;
+					next.style.display = display === "none" ? "block" : "none";
+				});
+				
+				addEvent(b, "dblclick", function(e) {
+					var target = e && e.target ? e.target : window.event.srcElement;
+					if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
+						target = target.parentNode;
+					}
+					if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
+						window.location.search = "?" + encodeURIComponent(getText([target]).replace(/\(.+\)$/, "").replace(/(^\s*|\s*$)/g, ""));
+					}
+				});
+
+				var li = id("current-test-output");
+				li.id = "";
+				li.className = bad ? "fail" : "pass";
+				li.removeChild( li.firstChild );
+				li.appendChild( b );
+				li.appendChild( ol );
+
+				if ( bad ) {
+					var toolbar = id("qunit-testrunner-toolbar");
+					if ( toolbar ) {
+						toolbar.style.display = "block";
+						id("qunit-filter-pass").disabled = null;
+						id("qunit-filter-missing").disabled = null;
+					}
+				}
+
+			} else {
+				for ( var i = 0; i < config.assertions.length; i++ ) {
+					if ( !config.assertions[i].result ) {
+						bad++;
+						config.stats.bad++;
+						config.moduleStats.bad++;
+					}
+				}
+			}
+
+			QUnit.testDone( testName, bad, config.assertions.length );
+
+			if ( !window.setTimeout && !config.queue.length ) {
+				done();
+			}
+		});
+
+		synchronize( done );
+	},
+	
+	/**
+	 * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
+	 */
+	expect: function(asserts) {
+		config.expected = asserts;
+	},
+
+	/**
+	 * Asserts true.
+	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
+	 */
+	ok: function(a, msg) {
+		msg = escapeHtml(msg);
+		QUnit.log(a, msg);
+
+		config.assertions.push({
+			result: !!a,
+			message: msg
+		});
+	},
+
+	/**
+	 * Checks that the first two arguments are equal, with an optional message.
+	 * Prints out both actual and expected values.
+	 *
+	 * Prefered to ok( actual == expected, message )
+	 *
+	 * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );
+	 *
+	 * @param Object actual
+	 * @param Object expected
+	 * @param String message (optional)
+	 */
+	equal: function(actual, expected, message) {
+		push(expected == actual, actual, expected, message);
+	},
+
+	notEqual: function(actual, expected, message) {
+		push(expected != actual, actual, expected, message);
+	},
+	
+	deepEqual: function(actual, expected, message) {
+		push(QUnit.equiv(actual, expected), actual, expected, message);
+	},
+
+	notDeepEqual: function(actual, expected, message) {
+		push(!QUnit.equiv(actual, expected), actual, expected, message);
+	},
+
+	strictEqual: function(actual, expected, message) {
+		push(expected === actual, actual, expected, message);
+	},
+
+	notStrictEqual: function(actual, expected, message) {
+		push(expected !== actual, actual, expected, message);
+	},
+
+	raises: function(fn,  message) {
+		try {
+			fn();
+			ok( false, message );
+		}
+		catch (e) {
+			ok( true, message );
+		}
+	},
+
+	start: function() {
+		// A slight delay, to avoid any current callbacks
+		if ( window.setTimeout ) {
+			window.setTimeout(function() {
+				if ( config.timeout ) {
+					clearTimeout(config.timeout);
+				}
+
+				config.blocking = false;
+				process();
+			}, 13);
+		} else {
+			config.blocking = false;
+			process();
+		}
+	},
+	
+	stop: function(timeout) {
+		config.blocking = true;
+
+		if ( timeout && window.setTimeout ) {
+			config.timeout = window.setTimeout(function() {
+				QUnit.ok( false, "Test timed out" );
+				QUnit.start();
+			}, timeout);
+		}
+	}
+
+};
+
+// Backwards compatibility, deprecated
+QUnit.equals = QUnit.equal;
+QUnit.same = QUnit.deepEqual;
+
+// Maintain internal state
+var config = {
+	// The queue of tests to run
+	queue: [],
+
+	// block until document ready
+	blocking: true
+};
+
+// Load paramaters
+(function() {
+	var location = window.location || { search: "", protocol: "file:" },
+		GETParams = location.search.slice(1).split('&');
+
+	for ( var i = 0; i < GETParams.length; i++ ) {
+		GETParams[i] = decodeURIComponent( GETParams[i] );
+		if ( GETParams[i] === "noglobals" ) {
+			GETParams.splice( i, 1 );
+			i--;
+			config.noglobals = true;
+		} else if ( GETParams[i].search('=') > -1 ) {
+			GETParams.splice( i, 1 );
+			i--;
+		}
+	}
+	
+	// restrict modules/tests by get parameters
+	config.filters = GETParams;
+	
+	// Figure out if we're running the tests from a server or not
+	QUnit.isLocal = !!(location.protocol === 'file:');
+})();
+
+// Expose the API as global variables, unless an 'exports'
+// object exists, in that case we assume we're in CommonJS
+if ( typeof exports === "undefined" || typeof require === "undefined" ) {
+	extend(window, QUnit);
+	window.QUnit = QUnit;
+} else {
+	extend(exports, QUnit);
+	exports.QUnit = QUnit;
+}
+
+// define these after exposing globals to keep them in these QUnit namespace only
+extend(QUnit, {
+	config: config,
+
+	// Initialize the configuration options
+	init: function() {
+		extend(config, {
+			stats: { all: 0, bad: 0 },
+			moduleStats: { all: 0, bad: 0 },
+			started: +new Date,
+			updateRate: 1000,
+			blocking: false,
+			autostart: true,
+			autorun: false,
+			assertions: [],
+			filters: [],
+			queue: []
+		});
+
+		var tests = id("qunit-tests"),
+			banner = id("qunit-banner"),
+			result = id("qunit-testresult");
+
+		if ( tests ) {
+			tests.innerHTML = "";
+		}
+
+		if ( banner ) {
+			banner.className = "";
+		}
+
+		if ( result ) {
+			result.parentNode.removeChild( result );
+		}
+	},
+	
+	/**
+	 * Resets the test setup. Useful for tests that modify the DOM.
+	 */
+	reset: function() {
+		if ( window.jQuery ) {
+			jQuery("#main, #qunit-fixture").html( config.fixture );
+		}
+	},
+	
+	/**
+	 * Trigger an event on an element.
+	 *
+	 * @example triggerEvent( document.body, "click" );
+	 *
+	 * @param DOMElement elem
+	 * @param String type
+	 */
+	triggerEvent: function( elem, type, event ) {
+		if ( document.createEvent ) {
+			event = document.createEvent("MouseEvents");
+			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
+				0, 0, 0, 0, 0, false, false, false, false, 0, null);
+			elem.dispatchEvent( event );
+
+		} else if ( elem.fireEvent ) {
+			elem.fireEvent("on"+type);
+		}
+	},
+	
+	// Safe object type checking
+	is: function( type, obj ) {
+		return QUnit.objectType( obj ) == type;
+	},
+	
+	objectType: function( obj ) {
+		if (typeof obj === "undefined") {
+				return "undefined";
+
+		// consider: typeof null === object
+		}
+		if (obj === null) {
+				return "null";
+		}
+
+		var type = Object.prototype.toString.call( obj )
+			.match(/^\[object\s(.*)\]$/)[1] || '';
+
+		switch (type) {
+				case 'Number':
+						if (isNaN(obj)) {
+								return "nan";
+						} else {
+								return "number";
+						}
+				case 'String':
+				case 'Boolean':
+				case 'Array':
+				case 'Date':
+				case 'RegExp':
+				case 'Function':
+						return type.toLowerCase();
+		}
+		if (typeof obj === "object") {
+				return "object";
+		}
+		return undefined;
+	},
+	
+	// Logging callbacks
+	begin: function() {},
+	done: function(failures, total) {},
+	log: function(result, message) {},
+	testStart: function(name, testEnvironment) {},
+	testDone: function(name, failures, total) {},
+	moduleStart: function(name, testEnvironment) {},
+	moduleDone: function(name, failures, total) {}
+});
+
+if ( typeof document === "undefined" || document.readyState === "complete" ) {
+	config.autorun = true;
+}
+
+addEvent(window, "load", function() {
+	QUnit.begin();
+	
+	// Initialize the config, saving the execution queue
+	var oldconfig = extend({}, config);
+	QUnit.init();
+	extend(config, oldconfig);
+
+	config.blocking = false;
+
+	var userAgent = id("qunit-userAgent");
+	if ( userAgent ) {
+		userAgent.innerHTML = navigator.userAgent;
+	}
+	var banner = id("qunit-header");
+	if ( banner ) {
+		banner.innerHTML = '<a href="' + location.href + '">' + banner.innerHTML + '</a>'; 
+	}
+	
+	var toolbar = id("qunit-testrunner-toolbar");
+	if ( toolbar ) {
+		toolbar.style.display = "none";
+		
+		var filter = document.createElement("input");
+		filter.type = "checkbox";
+		filter.id = "qunit-filter-pass";
+		filter.disabled = true;
+		addEvent( filter, "click", function() {
+			var li = document.getElementsByTagName("li");
+			for ( var i = 0; i < li.length; i++ ) {
+				if ( li[i].className.indexOf("pass") > -1 ) {
+					li[i].style.display = filter.checked ? "none" : "";
+				}
+			}
+		});
+		toolbar.appendChild( filter );
+
+		var label = document.createElement("label");
+		label.setAttribute("for", "qunit-filter-pass");
+		label.innerHTML = "Hide passed tests";
+		toolbar.appendChild( label );
+
+		var missing = document.createElement("input");
+		missing.type = "checkbox";
+		missing.id = "qunit-filter-missing";
+		missing.disabled = true;
+		addEvent( missing, "click", function() {
+			var li = document.getElementsByTagName("li");
+			for ( var i = 0; i < li.length; i++ ) {
+				if ( li[i].className.indexOf("fail") > -1 && li[i].innerHTML.indexOf('missing test - untested code is broken code') > - 1 ) {
+					li[i].parentNode.parentNode.style.display = missing.checked ? "none" : "block";
+				}
+			}
+		});
+		toolbar.appendChild( missing );
+
+		label = document.createElement("label");
+		label.setAttribute("for", "qunit-filter-missing");
+		label.innerHTML = "Hide missing tests (untested code is broken code)";
+		toolbar.appendChild( label );
+	}
+
+	var main = id('main') || id('qunit-fixture');
+	if ( main ) {
+		config.fixture = main.innerHTML;
+	}
+
+	if (config.autostart) {
+		QUnit.start();
+	}
+});
+
+function done() {
+	if ( config.doneTimer && window.clearTimeout ) {
+		window.clearTimeout( config.doneTimer );
+		config.doneTimer = null;
+	}
+
+	if ( config.queue.length ) {
+		config.doneTimer = window.setTimeout(function(){
+			if ( !config.queue.length ) {
+				done();
+			} else {
+				synchronize( done );
+			}
+		}, 13);
+
+		return;
+	}
+
+	config.autorun = true;
+
+	// Log the last module results
+	if ( config.currentModule ) {
+		QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );
+	}
+
+	var banner = id("qunit-banner"),
+		tests = id("qunit-tests"),
+		html = ['Tests completed in ',
+		+new Date - config.started, ' milliseconds.<br/>',
+		'<span class="passed">', config.stats.all - config.stats.bad, '</span> tests of <span class="total">', config.stats.all, '</span> passed, <span class="failed">', config.stats.bad,'</span> failed.'].join('');
+
+	if ( banner ) {
+		banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
+	}
+
+	if ( tests ) {	
+		var result = id("qunit-testresult");
+
+		if ( !result ) {
+			result = document.createElement("p");
+			result.id = "qunit-testresult";
+			result.className = "result";
+			tests.parentNode.insertBefore( result, tests.nextSibling );
+		}
+
+		result.innerHTML = html;
+	}
+
+	QUnit.done( config.stats.bad, config.stats.all );
+}
+
+function validTest( name ) {
+	var i = config.filters.length,
+		run = false;
+
+	if ( !i ) {
+		return true;
+	}
+	
+	while ( i-- ) {
+		var filter = config.filters[i],
+			not = filter.charAt(0) == '!';
+
+		if ( not ) {
+			filter = filter.slice(1);
+		}
+
+		if ( name.indexOf(filter) !== -1 ) {
+			return !not;
+		}
+
+		if ( not ) {
+			run = true;
+		}
+	}
+
+	return run;
+}
+
+function escapeHtml(s) {
+	s = s === null ? "" : s + "";
+	return s.replace(/[\&"<>\\]/g, function(s) {
+		switch(s) {
+			case "&": return "&amp;";
+			case "\\": return "\\\\";
+			case '"': return '\"';
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return s;
+		}
+	});
+}
+
+function push(result, actual, expected, message) {
+	message = escapeHtml(message) || (result ? "okay" : "failed");
+	message = '<span class="test-message">' + message + "</span>";
+	expected = escapeHtml(QUnit.jsDump.parse(expected));
+	actual = escapeHtml(QUnit.jsDump.parse(actual));
+	var output = message + ', expected: <span class="test-expected">' + expected + '</span>';
+	if (actual != expected) {
+		output += ' result: <span class="test-actual">' + actual + '</span>, diff: ' + QUnit.diff(expected, actual);
+	}
+	
+	// can't use ok, as that would double-escape messages
+	QUnit.log(result, output);
+	config.assertions.push({
+		result: !!result,
+		message: output
+	});
+}
+
+function synchronize( callback ) {
+	config.queue.push( callback );
+
+	if ( config.autorun && !config.blocking ) {
+		process();
+	}
+}
+
+function process() {
+	var start = (new Date()).getTime();
+
+	while ( config.queue.length && !config.blocking ) {
+		if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) {
+			config.queue.shift()();
+
+		} else {
+			setTimeout( process, 13 );
+			break;
+		}
+	}
+}
+
+function saveGlobal() {
+	config.pollution = [];
+	
+	if ( config.noglobals ) {
+		for ( var key in window ) {
+			config.pollution.push( key );
+		}
+	}
+}
+
+function checkPollution( name ) {
+	var old = config.pollution;
+	saveGlobal();
+	
+	var newGlobals = diff( old, config.pollution );
+	if ( newGlobals.length > 0 ) {
+		ok( false, "Introduced global variable(s): " + newGlobals.join(", ") );
+		config.expected++;
+	}
+
+	var deletedGlobals = diff( config.pollution, old );
+	if ( deletedGlobals.length > 0 ) {
+		ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") );
+		config.expected++;
+	}
+}
+
+// returns a new Array with the elements that are in a but not in b
+function diff( a, b ) {
+	var result = a.slice();
+	for ( var i = 0; i < result.length; i++ ) {
+		for ( var j = 0; j < b.length; j++ ) {
+			if ( result[i] === b[j] ) {
+				result.splice(i, 1);
+				i--;
+				break;
+			}
+		}
+	}
+	return result;
+}
+
+function fail(message, exception, callback) {
+	if ( typeof console !== "undefined" && console.error && console.warn ) {
+		console.error(message);
+		console.error(exception);
+		console.warn(callback.toString());
+
+	} else if ( window.opera && opera.postError ) {
+		opera.postError(message, exception, callback.toString);
+	}
+}
+
+function extend(a, b) {
+	for ( var prop in b ) {
+		a[prop] = b[prop];
+	}
+
+	return a;
+}
+
+function addEvent(elem, type, fn) {
+	if ( elem.addEventListener ) {
+		elem.addEventListener( type, fn, false );
+	} else if ( elem.attachEvent ) {
+		elem.attachEvent( "on" + type, fn );
+	} else {
+		fn();
+	}
+}
+
+function id(name) {
+	return !!(typeof document !== "undefined" && document && document.getElementById) &&
+		document.getElementById( name );
+}
+
+// Test for equality any JavaScript type.
+// Discussions and reference: http://philrathe.com/articles/equiv
+// Test suites: http://philrathe.com/tests/equiv
+// Author: Philippe Rathé <prathe@gmail.com>
+QUnit.equiv = function () {
+
+    var innerEquiv; // the real equiv function
+    var callers = []; // stack to decide between skip/abort functions
+    var parents = []; // stack to avoiding loops from circular referencing
+
+    // Call the o related callback with the given arguments.
+    function bindCallbacks(o, callbacks, args) {
+        var prop = QUnit.objectType(o);
+        if (prop) {
+            if (QUnit.objectType(callbacks[prop]) === "function") {
+                return callbacks[prop].apply(callbacks, args);
+            } else {
+                return callbacks[prop]; // or undefined
+            }
+        }
+    }
+    
+    var callbacks = function () {
+
+        // for string, boolean, number and null
+        function useStrictEquality(b, a) {
+            if (b instanceof a.constructor || a instanceof b.constructor) {
+                // to catch short annotaion VS 'new' annotation of a declaration
+                // e.g. var i = 1;
+                //      var j = new Number(1);
+                return a == b;
+            } else {
+                return a === b;
+            }
+        }
+
+        return {
+            "string": useStrictEquality,
+            "boolean": useStrictEquality,
+            "number": useStrictEquality,
+            "null": useStrictEquality,
+            "undefined": useStrictEquality,
+
+            "nan": function (b) {
+                return isNaN(b);
+            },
+
+            "date": function (b, a) {
+                return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf();
+            },
+
+            "regexp": function (b, a) {
+                return QUnit.objectType(b) === "regexp" &&
+                    a.source === b.source && // the regex itself
+                    a.global === b.global && // and its modifers (gmi) ...
+                    a.ignoreCase === b.ignoreCase &&
+                    a.multiline === b.multiline;
+            },
+
+            // - skip when the property is a method of an instance (OOP)
+            // - abort otherwise,
+            //   initial === would have catch identical references anyway
+            "function": function () {
+                var caller = callers[callers.length - 1];
+                return caller !== Object &&
+                        typeof caller !== "undefined";
+            },
+
+            "array": function (b, a) {
+                var i, j, loop;
+                var len;
+
+                // b could be an object literal here
+                if ( ! (QUnit.objectType(b) === "array")) {
+                    return false;
+                }   
+                
+                len = a.length;
+                if (len !== b.length) { // safe and faster
+                    return false;
+                }
+                
+                //track reference to avoid circular references
+                parents.push(a);
+                for (i = 0; i < len; i++) {
+                    loop = false;
+                    for(j=0;j<parents.length;j++){
+                        if(parents[j] === a[i]){
+                            loop = true;//dont rewalk array
+                        }
+                    }
+                    if (!loop && ! innerEquiv(a[i], b[i])) {
+                        parents.pop();
+                        return false;
+                    }
+                }
+                parents.pop();
+                return true;
+            },
+
+            "object": function (b, a) {
+                var i, j, loop;
+                var eq = true; // unless we can proove it
+                var aProperties = [], bProperties = []; // collection of strings
+
+                // comparing constructors is more strict than using instanceof
+                if ( a.constructor !== b.constructor) {
+                    return false;
+                }
+
+                // stack constructor before traversing properties
+                callers.push(a.constructor);
+                //track reference to avoid circular references
+                parents.push(a);
+                
+                for (i in a) { // be strict: don't ensures hasOwnProperty and go deep
+                    loop = false;
+                    for(j=0;j<parents.length;j++){
+                        if(parents[j] === a[i])
+                            loop = true; //don't go down the same path twice
+                    }
+                    aProperties.push(i); // collect a's properties
+
+                    if (!loop && ! innerEquiv(a[i], b[i])) {
+                        eq = false;
+                        break;
+                    }
+                }
+
+                callers.pop(); // unstack, we are done
+                parents.pop();
+
+                for (i in b) {
+                    bProperties.push(i); // collect b's properties
+                }
+
+                // Ensures identical properties name
+                return eq && innerEquiv(aProperties.sort(), bProperties.sort());
+            }
+        };
+    }();
+
+    innerEquiv = function () { // can take multiple arguments
+        var args = Array.prototype.slice.apply(arguments);
+        if (args.length < 2) {
+            return true; // end transition
+        }
+
+        return (function (a, b) {
+            if (a === b) {
+                return true; // catch the most you can
+            } else if (a === null || b === null || typeof a === "undefined" || typeof b === "undefined" || QUnit.objectType(a) !== QUnit.objectType(b)) {
+                return false; // don't lose time with error prone cases
+            } else {
+                return bindCallbacks(a, callbacks, [b, a]);
+            }
+
+        // apply transition with (1..n) arguments
+        })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1));
+    };
+
+    return innerEquiv;
+
+}();
+
+/**
+ * jsDump
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 5/15/2008
+ * @projectDescription Advanced and extensible data dumping for Javascript.
+ * @version 1.0.0
+ * @author Ariel Flesler
+ * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
+ */
+QUnit.jsDump = (function() {
+	function quote( str ) {
+		return '"' + str.toString().replace(/"/g, '\\"') + '"';
+	};
+	function literal( o ) {
+		return o + '';	
+	};
+	function join( pre, arr, post ) {
+		var s = jsDump.separator(),
+			base = jsDump.indent(),
+			inner = jsDump.indent(1);
+		if ( arr.join )
+			arr = arr.join( ',' + s + inner );
+		if ( !arr )
+			return pre + post;
+		return [ pre, inner + arr, base + post ].join(s);
+	};
+	function array( arr ) {
+		var i = arr.length,	ret = Array(i);					
+		this.up();
+		while ( i-- )
+			ret[i] = this.parse( arr[i] );				
+		this.down();
+		return join( '[', ret, ']' );
+	};
+	
+	var reName = /^function (\w+)/;
+	
+	var jsDump = {
+		parse:function( obj, type ) { //type is used mostly internally, you can fix a (custom)type in advance
+			var	parser = this.parsers[ type || this.typeOf(obj) ];
+			type = typeof parser;			
+			
+			return type == 'function' ? parser.call( this, obj ) :
+				   type == 'string' ? parser :
+				   this.parsers.error;
+		},
+		typeOf:function( obj ) {
+			var type;
+			if ( obj === null ) {
+				type = "null";
+			} else if (typeof obj === "undefined") {
+				type = "undefined";
+			} else if (QUnit.is("RegExp", obj)) {
+				type = "regexp";
+			} else if (QUnit.is("Date", obj)) {
+				type = "date";
+			} else if (QUnit.is("Function", obj)) {
+				type = "function";
+			} else if (obj.setInterval && obj.document && !obj.nodeType) {
+				type = "window";
+			} else if (obj.nodeType === 9) {
+				type = "document";
+			} else if (obj.nodeType) {
+				type = "node";
+			} else if (typeof obj === "object" && typeof obj.length === "number" && obj.length >= 0) {
+				type = "array";
+			} else {
+				type = typeof obj;
+			}
+			return type;
+		},
+		separator:function() {
+			return this.multiline ?	this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
+		},
+		indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing
+			if ( !this.multiline )
+				return '';
+			var chr = this.indentChar;
+			if ( this.HTML )
+				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
+			return Array( this._depth_ + (extra||0) ).join(chr);
+		},
+		up:function( a ) {
+			this._depth_ += a || 1;
+		},
+		down:function( a ) {
+			this._depth_ -= a || 1;
+		},
+		setParser:function( name, parser ) {
+			this.parsers[name] = parser;
+		},
+		// The next 3 are exposed so you can use them
+		quote:quote, 
+		literal:literal,
+		join:join,
+		//
+		_depth_: 1,
+		// This is the list of parsers, to modify them, use jsDump.setParser
+		parsers:{
+			window: '[Window]',
+			document: '[Document]',
+			error:'[ERROR]', //when no parser is found, shouldn't happen
+			unknown: '[Unknown]',
+			'null':'null',
+			undefined:'undefined',
+			'function':function( fn ) {
+				var ret = 'function',
+					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
+				if ( name )
+					ret += ' ' + name;
+				ret += '(';
+				
+				ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');
+				return join( ret, this.parse(fn,'functionCode'), '}' );
+			},
+			array: array,
+			nodelist: array,
+			arguments: array,
+			object:function( map ) {
+				var ret = [ ];
+				this.up();
+				for ( var key in map )
+					ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) );
+				this.down();
+				return join( '{', ret, '}' );
+			},
+			node:function( node ) {
+				var open = this.HTML ? '&lt;' : '<',
+					close = this.HTML ? '&gt;' : '>';
+					
+				var tag = node.nodeName.toLowerCase(),
+					ret = open + tag;
+					
+				for ( var a in this.DOMAttrs ) {
+					var val = node[this.DOMAttrs[a]];
+					if ( val )
+						ret += ' ' + a + '=' + this.parse( val, 'attribute' );
+				}
+				return ret + close + open + '/' + tag + close;
+			},
+			functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function
+				var l = fn.length;
+				if ( !l ) return '';				
+				
+				var args = Array(l);
+				while ( l-- )
+					args[l] = String.fromCharCode(97+l);//97 is 'a'
+				return ' ' + args.join(', ') + ' ';
+			},
+			key:quote, //object calls it internally, the key part of an item in a map
+			functionCode:'[code]', //function calls it internally, it's the content of the function
+			attribute:quote, //node calls it internally, it's an html attribute value
+			string:quote,
+			date:quote,
+			regexp:literal, //regex
+			number:literal,
+			'boolean':literal
+		},
+		DOMAttrs:{//attributes to dump from nodes, name=>realName
+			id:'id',
+			name:'name',
+			'class':'className'
+		},
+		HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )
+		indentChar:'   ',//indentation unit
+		multiline:false //if true, items in a collection, are separated by a \n, else just a space.
+	};
+
+	return jsDump;
+})();
+
+// from Sizzle.js
+function getText( elems ) {
+	var ret = "", elem;
+
+	for ( var i = 0; elems[i]; i++ ) {
+		elem = elems[i];
+
+		// Get the text from text nodes and CDATA nodes
+		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
+			ret += elem.nodeValue;
+
+		// Traverse everything else, except comment nodes
+		} else if ( elem.nodeType !== 8 ) {
+			ret += getText( elem.childNodes );
+		}
+	}
+
+	return ret;
+};
+
+/*
+ * Javascript Diff Algorithm
+ *  By John Resig (http://ejohn.org/)
+ *  Modified by Chu Alan "sprite"
+ *
+ * Released under the MIT license.
+ *
+ * More Info:
+ *  http://ejohn.org/projects/javascript-diff-algorithm/
+ *  
+ * Usage: QUnit.diff(expected, actual)
+ * 
+ * QUnit.diff("the quick brown fox jumped over", "the quick fox jumps over") == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
+ */
+QUnit.diff = (function() {
+	function diff(o, n){
+		var ns = new Object();
+		var os = new Object();
+		
+		for (var i = 0; i < n.length; i++) {
+			if (ns[n[i]] == null) 
+				ns[n[i]] = {
+					rows: new Array(),
+					o: null
+				};
+			ns[n[i]].rows.push(i);
+		}
+		
+		for (var i = 0; i < o.length; i++) {
+			if (os[o[i]] == null) 
+				os[o[i]] = {
+					rows: new Array(),
+					n: null
+				};
+			os[o[i]].rows.push(i);
+		}
+		
+		for (var i in ns) {
+			if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
+				n[ns[i].rows[0]] = {
+					text: n[ns[i].rows[0]],
+					row: os[i].rows[0]
+				};
+				o[os[i].rows[0]] = {
+					text: o[os[i].rows[0]],
+					row: ns[i].rows[0]
+				};
+			}
+		}
+		
+		for (var i = 0; i < n.length - 1; i++) {
+			if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null &&
+			n[i + 1] == o[n[i].row + 1]) {
+				n[i + 1] = {
+					text: n[i + 1],
+					row: n[i].row + 1
+				};
+				o[n[i].row + 1] = {
+					text: o[n[i].row + 1],
+					row: i + 1
+				};
+			}
+		}
+		
+		for (var i = n.length - 1; i > 0; i--) {
+			if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null &&
+			n[i - 1] == o[n[i].row - 1]) {
+				n[i - 1] = {
+					text: n[i - 1],
+					row: n[i].row - 1
+				};
+				o[n[i].row - 1] = {
+					text: o[n[i].row - 1],
+					row: i - 1
+				};
+			}
+		}
+		
+		return {
+			o: o,
+			n: n
+		};
+	}
+	
+	return function(o, n){
+		o = o.replace(/\s+$/, '');
+		n = n.replace(/\s+$/, '');
+		var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/));
+
+		var str = "";
+		
+		var oSpace = o.match(/\s+/g);
+		if (oSpace == null) {
+			oSpace = [" "];
+		}
+		else {
+			oSpace.push(" ");
+		}
+		var nSpace = n.match(/\s+/g);
+		if (nSpace == null) {
+			nSpace = [" "];
+		}
+		else {
+			nSpace.push(" ");
+		}
+		
+		if (out.n.length == 0) {
+			for (var i = 0; i < out.o.length; i++) {
+				str += '<del>' + out.o[i] + oSpace[i] + "</del>";
+			}
+		}
+		else {
+			if (out.n[0].text == null) {
+				for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
+					str += '<del>' + out.o[n] + oSpace[n] + "</del>";
+				}
+			}
+			
+			for (var i = 0; i < out.n.length; i++) {
+				if (out.n[i].text == null) {
+					str += '<ins>' + out.n[i] + nSpace[i] + "</ins>";
+				}
+				else {
+					var pre = "";
+					
+					for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) {
+						pre += '<del>' + out.o[n] + oSpace[n] + "</del>";
+					}
+					str += " " + out.n[i].text + nSpace[i] + pre;
+				}
+			}
+		}
+		
+		return str;
+	}
+})();
+
+})(this);
diff --git a/install/static/webui.js b/install/static/webui.js
index 153a6096..09ed7092 100644
--- a/install/static/webui.js
+++ b/install/static/webui.js
@@ -72,10 +72,19 @@ $(function() {
     };
 
     function init_on_win(data, text_status, xhr) {
-        ipa_cmd('user_find', [], {"whoami":"true","all":"true"}, whoami_on_win, null, null);
+        ipa_cmd('user_find', [], {"whoami":"true","all":"true"}, whoami_on_win,
+            function(xhr, options, thrownError) {
+                alert("Error: "+thrownError);
+            },
+            null
+        );
     };
 
-    ipa_init(null, init_on_win);
+    ipa_init(null, null, init_on_win,
+        function(xhr, options, thrownError) {
+            alert("Error: "+thrownError);
+        }
+    );
 });
 
 /* use this to track individual changes between two hashchange events */