describe('app', function () {

    describe('induce', function () {

        it('enhances namespace with app', function () {
            var namespace = {};

            App.induce(namespace);

            assert.ok(namespace.app);
        });

        it('creates separated instances', function () {
            var namespace1 = {},
                namespace2 = {};

            App.induce(namespace1);
            App.induce(namespace2);

            namespace1.app.test = 23;

            assert.isUndefined(namespace2.app.test);
        });

        it('is already called on window', function () {
            assert.ok(window.app);
        })

    });

    describe('define', function () {
        var namespace;

        beforeEach(function () {
            namespace = {};
            App.induce(namespace);
        });

        it('is no evaluated initially', function () {
            var counter = 0;

            namespace.app.define('module.Object', function () {
                counter += 1;

                return {
                    attr: 12
                };
            });

            assert.equal(counter, 0);
        });

        it('can not be called twice with identical constant', function () {
            namespace.app.define('const', function () {});

            assert.throws(function () {
                namespace.app.define('const', function () {});
            }, /already defined/i)
        });

        it('accepts only a function', function () {
            assert.throws(function () {
                namespace.app.define('const', {});
            }, /definition has to be a function/i);
        })
    });

    describe('require', function () {
        var namespace;

        beforeEach(function () {
            namespace = {};
            App.induce(namespace);
        });

        it('invokes the definition', function () {
            var counter = 0,
                car;

            namespace.app.define('Car', function () {
                counter += 1;

                return {
                    hasTires: true
                };
            });

            assert.equal(counter, 0);

            car = namespace.app.require('Car');

            assert.equal(counter, 1);
            assert.ok(car.hasTires)
        });

        it('invokes the definition only the first time', function () {
            var counter = 0,
                car;

            namespace.app.define('Car', function () {
                counter += 1;

                return {
                    hasTires: true
                };
            });

            car = namespace.app.require('Car');

            assert.equal(counter, 1);
            assert.ok(car.hasTires)

            car = namespace.app.require('Car');

            assert.equal(counter, 1);
            assert.ok(car.hasTires)
        });

        it('throws if definition is not found', function () {
            assert.throws(function () {
                namespace.app.require('MyConst');
            }, /not defined/i);
        });

    });

    describe('overwrite', function () {
        var namespace;

        beforeEach(function () {
            namespace = {};
            App.induce(namespace);
        });

        it('temporarilly overwrites the Result of require', function () {
            namespace.app.define('test', function () {
                return 123
            });

            assert.equal(namespace.app.require('test'), 123)

            var count = 0;
            namespace.app.overwrite('test', function () {
                count += 1;
                return count;
            });


            assert.equal(namespace.app.require('test'), 1)
            assert.equal(namespace.app.require('test'), 2)
            assert.equal(namespace.app.require('test'), 3)

            namespace.app.reset('test')

            assert.equal(namespace.app.require('test'), 123)
        });
    });

});