akond · August 29, 2015 14:07 · Dec 12, 2012 · Dec 12, 2012
diff --git a/ServiceKernel.Tests.js b/ServiceKernel.Tests.js
@@ -1,3 +1,4 @@
+// unit tests for ServiceKernel.js (https://gist.github.com/4089076)
 // requires QUnit test framework
 
 module("ServiceKernelTests");

diff --git a/ServiceKernel.Tests.js b/ServiceKernel.Tests.js
@@ -0,0 +1,255 @@
+// requires QUnit test framework
+
+module("ServiceKernelTests");
+
+if (typeof throws === "undefined") throws = raises;
+
+test("require unregistered service throws", function () {
+    var kernel = new ServiceKernel();
+
+    throws(function () {
+        kernel.require("a", function (a) {
+            ok(false, "should not get here.");
+        });
+    }, Error);
+});
+
+test("require 'require' service succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    var requireCallbackInvoked = false;
+    kernel.require("require", function (require) {
+        ok(typeof require === "function");
+        require("require", function (require2) {
+            deepEqual(require, require2);
+            requireCallbackInvoked = true;
+        });
+    });
+
+    ok(requireCallbackInvoked);
+});
+
+test("require 'kernel' service succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    var requireCallbackInvoked = false;
+    kernel.require("kernel", function (kernel2) {
+        deepEqual(kernel, kernel2);
+        requireCallbackInvoked = true;
+    });
+
+    ok(requireCallbackInvoked);
+});
+
+test("undefine existing service returns true", function () {
+    var kernel = new ServiceKernel();
+    ok(kernel.undefine("require"));
+    ok(kernel.undefine("kernel"));
+});
+
+test("require undefined service throws", function () {
+    var kernel = new ServiceKernel();
+
+    kernel.undefine("require");
+    throws(function () {
+        kernel.require("require", function () {
+            ok(false, "should not get here.");
+        });
+    }, Error);
+
+    kernel.undefine("kernel");
+    throws(function () {
+        kernel.require("kernel", function () {
+            ok(false, "should not get here.");
+        });
+    }, Error);
+});
+
+test("undefine non-existent service returns false", function () {
+    var kernel = new ServiceKernel();
+    ok(!kernel.undefine("foo"));
+});
+
+test("define existing service throws", function () {
+    var kernel = new ServiceKernel();
+
+    throws(function () {
+        kernel.define("require", function () {
+        });
+    }, Error);
+    throws(function () {
+        kernel.define("kernel", function () {
+        });
+    }, Error);
+
+    var service = defineService(function () {
+        return this;
+    });
+
+    throws(function () {
+        kernel.define("require", service);
+    }, Error);
+    throws(function () {
+        kernel.define("kernel", service);
+    }, Error);
+});
+
+test("require service instance succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    var a = {
+        foo: 0
+    };
+    kernel.defineInstance("a", a);
+
+    var requireCallbackInvoked = false;
+    kernel.require("a", function (a2) {
+        deepEqual(a, a2);
+        requireCallbackInvoked = true;
+    });
+
+    ok(requireCallbackInvoked);
+});
+
+test("require service succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    kernel.define("a", function () {
+        return function () {
+            return "a";
+        }
+    });
+
+    var requireCallbackInvoked = false;
+    kernel.require("a", function (a) {
+        equal("a", a());
+        requireCallbackInvoked = true;
+    });
+
+    ok(requireCallbackInvoked);
+});
+
+test("require service with dependency succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    kernel.define("a", function () {
+        return {
+            foo: function () {
+                return "afoo";
+            }
+        };
+    });
+
+    var bServiceInitialized = false;
+    kernel.define("b", ["a"], function (a) {
+        bServiceInitialized = true;
+        return {
+            a_foo: function () {
+                return a.foo();
+            }
+        };
+    });
+
+    var requireCallbackInvoked = false;
+    kernel.require("b", function (b) {
+        equal("afoo", b.a_foo());
+        requireCallbackInvoked = true;
+    });
+
+    ok(requireCallbackInvoked);
+    ok(bServiceInitialized);
+});
+
+test("require service with circular dependency succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    var aServiceInitialized = false;
+    kernel.define("a", [
+        "require",
+        "b"
+    ], function (require, b) {
+        strictEqual("undefined", typeof b);
+        aServiceInitialized = true;
+        return {
+            foo: function () {
+                return require("b").foo();
+            }
+        };
+    });
+
+    var bServiceInitialized = false;
+    kernel.define("b", ["a"], function (a) {
+        bServiceInitialized = true;
+        return {
+            foo: function () {
+                return "bfoo";
+            },
+            a_foo: function () {
+                return a.foo();
+            }
+        };
+    });
+
+    var requireCallbackInvoked = false;
+    kernel.require("b", function (b) {
+        equal("bfoo", b.foo());
+        equal("bfoo", b.a_foo());
+        requireCallbackInvoked = true;
+    });
+
+    ok(requireCallbackInvoked);
+    ok(bServiceInitialized);
+    ok(aServiceInitialized);
+});
+
+test("require service with circular dependency and dependent deferred require succeeds", function () {
+    var kernel = new ServiceKernel();
+
+    var aServiceInitialized = false;
+    var bRequireCallbackInvoked = false;
+    kernel.define("a", ["require", "b"], function (require, b) {
+
+        strictEqual("undefined", typeof b);
+        require(["b"], function(b) {
+
+            bRequireCallbackInvoked = true;
+            equal("bfoo", b.foo());
+
+        });
+
+        // above require callback can't be invoked until b finished being defined
+        ok(!bRequireCallbackInvoked);
+
+        aServiceInitialized = true;
+        return {
+            foo: function () {
+                return require("b").foo();
+            }
+        };
+    });
+
+    var bServiceInitialized = false;
+    kernel.define("b", ["a"], function (a) {
+        bServiceInitialized = true;
+        return {
+            foo: function () {
+                return "bfoo";
+            },
+            a_foo: function () {
+                return a.foo();
+            }
+        };
+    });
+
+    var requireCallbackInvoked = false;
+    kernel.require("b", function (b) {
+        equal("bfoo", b.foo());
+        equal("bfoo", b.a_foo());
+        requireCallbackInvoked = true;
+    });
+
+    ok(bRequireCallbackInvoked);
+    ok(requireCallbackInvoked);
+    ok(bServiceInitialized);
+    ok(aServiceInitialized);
+});