QUnit unit tests for ServiceKernel.js (https://gist.github.com/4089076)

ServiceKernel.Tests.js

// unit tests for ServiceKernel.js (https://gist.github.com/4089076)
// 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);
});