add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / test / specs / class / ClassManager.js

describe("Ext.ClassManager", function() {\r
    var manager = Ext.ClassManager,\r
        cls, emptyFn = function(){};\r
\r
\r
\r
    beforeEach(function() {\r
        manager.enableNamespaceParseCache = false;\r
        window.My = {\r
            awesome: {\r
                Class: function(){console.log(11);},\r
                Class1: function(){console.log(12);},\r
                Class2: function(){console.log(13);}\r
            },\r
            cool: {\r
                AnotherClass: function(){console.log(21);},\r
                AnotherClass1: function(){console.log(22);},\r
                AnotherClass2: function(){console.log(23);}\r
            }\r
        };\r
    });\r
\r
    afterEach(function() {\r
        try {\r
            delete window.Something;\r
            delete window.My;\r
            delete window.I;\r
            delete window.Test;\r
        } catch (e) {\r
            window.Something = undefined;\r
            window.My = undefined;\r
            window.I = undefined;\r
            window.Test = undefined;\r
        }\r
        manager.enableNamespaceParseCache = true;\r
    });\r
\r
    describe("exist", function() {\r
        it("should return whether a single class exists", function() {\r
            expect(manager.isCreated('My.notexisting.Class')).toBe(false);\r
            expect(manager.isCreated('My.awesome.Class')).toBe(true);\r
        });\r
    });\r
\r
    describe("loader preprocessor", function() {\r
        beforeEach(function() {\r
            cls = function(){};\r
        });\r
\r
        it("should load and replace string class names with objects", function() {\r
            var data = {\r
                    extend: 'My.awesome.Class',\r
                    mixins: {\r
                        name1: My.cool.AnotherClass,\r
                        name2: 'My.cool.AnotherClass1'\r
                    }\r
                },\r
                expected = {\r
                    extend: My.awesome.Class,\r
                    mixins: {\r
                        name1: My.cool.AnotherClass,\r
                        name2: My.cool.AnotherClass1\r
                    }\r
                },\r
                classNames;\r
\r
\r
            spyOn(Ext.Loader, 'require').andCallFake(function(classes, fn) {\r
                classNames = classes;\r
                fn();\r
            });\r
\r
            Ext.Class.getPreprocessor('loader').fn(cls, data, emptyFn, emptyFn);\r
\r
            expect(Ext.Loader.require).toHaveBeenCalled();\r
            expect(classNames).toEqual(['My.awesome.Class', 'My.cool.AnotherClass1']);\r
            expect(data).toEqual(expected);\r
        });\r
    });\r
\r
    describe("create", function() {\r
        var subClass, parentClass, mixinClass1, mixinClass2, subSubClass;\r
\r
        beforeEach(function() {\r
            mixinClass1 = manager.create('I.am.the.MixinClass1', {\r
                config: {\r
                    mixinConfig: 'mixinConfig'\r
                },\r
\r
                constructor: function() {\r
                    this.mixinConstructor1Called = true;\r
                },\r
\r
                mixinProperty1: 'mixinProperty1',\r
\r
                mixinMethod1: function() {\r
                    this.mixinMethodCalled = true;\r
                }\r
            });\r
\r
            mixinClass2 = manager.create('I.am.the.MixinClass2', {\r
                constructor: function() {\r
                    this.mixinConstructor2Called = true;\r
                },\r
\r
                mixinProperty2: 'mixinProperty2',\r
\r
                mixinMethod2: function() {\r
                    this.mixinMethodCalled = true;\r
                }\r
            });\r
\r
            parentClass = manager.create('I.am.the.ParentClass', {\r
                alias: ['parentclass', 'superclass'],\r
\r
                mixins: {\r
                    mixin1: 'I.am.the.MixinClass1'\r
                },\r
\r
                config: {\r
                    name: 'parentClass',\r
                    isCool: false,\r
                    members: {\r
                        abe: 'Abraham Elias',\r
                        ed: 'Ed Spencer'\r
                    },\r
                    hobbies: ['football', 'bowling']\r
                },\r
\r
                onClassExtended: function(subClass, data) {\r
                    subClass.onClassExtendedCalled = true;\r
                },\r
\r
                constructor: function(config) {\r
                    this.initConfig(config);\r
\r
                    this.parentConstructorCalled = true;\r
\r
                    this.mixins.mixin1.constructor.apply(this, arguments);\r
                },\r
\r
                parentProperty: 'parentProperty',\r
\r
                parentMethod: function() {\r
                    this.parentMethodCalled = true;\r
                }\r
            });\r
\r
            subClass = manager.create('I.am.the.SubClass', {\r
                alias: 'subclass',\r
\r
                extend: 'I.am.the.ParentClass',\r
\r
                mixins: {\r
                    mixin1: 'I.am.the.MixinClass1',\r
                    mixin2: 'I.am.the.MixinClass2'\r
                },\r
                config: {\r
                    name: 'subClass',\r
                    isCool: true,\r
                    members: {\r
                        jacky: 'Jacky Nguyen',\r
                        tommy: 'Tommy Maintz'\r
                    },\r
                    hobbies: ['sleeping', 'eating', 'movies'],\r
                    isSpecial: true\r
                },\r
                constructor: function() {\r
                    this.subConstrutorCalled = true;\r
\r
                    this.superclass.constructor.apply(this, arguments);\r
\r
                    this.mixins.mixin2.constructor.apply(this, arguments);\r
                },\r
                myOwnMethod: function() {\r
                    this.myOwnMethodCalled = true;\r
                }\r
            });\r
        });\r
        \r
        afterEach(function() {\r
            Ext.undefine('I.am.the.MixinClass1');\r
            Ext.undefine('I.am.the.MixinClass2');\r
            Ext.undefine('I.am.the.ParentClass');\r
            Ext.undefine('I.am.the.SubClass');\r
        });\r
\r
        it("should create the namespace", function() {\r
            expect(I).toBeDefined();\r
            expect(I.am).toBeDefined();\r
            expect(I.am.the).toBeDefined();\r
            expect(I.am.the.SubClass).toBeDefined();\r
        });\r
\r
        it("should get className", function() {\r
            expect(Ext.getClassName(subClass)).toEqual('I.am.the.SubClass');\r
        });\r
\r
        describe("addStatics", function() {\r
            it("single with name - value arguments", function() {\r
                var called = false;\r
\r
                subClass.addStatics({\r
                    staticMethod: function(){\r
                        called = true;\r
                    }\r
                });\r
\r
                expect(subClass.staticMethod).toBeDefined();\r
                subClass.staticMethod();\r
\r
                expect(called).toBeTruthy();\r
            });\r
\r
            it("multiple with object map argument", function() {\r
                subClass.addStatics({\r
                    staticProperty: 'something',\r
                    staticMethod: function(){}\r
                });\r
\r
                expect(subClass.staticProperty).toEqual('something');\r
                expect(subClass.staticMethod).toBeDefined();\r
            });\r
        });\r
\r
        describe("mixin", function() {\r
            it("should have all properties of mixins", function() {\r
                var obj = new subClass();\r
                expect(obj.mixinProperty1).toEqual('mixinProperty1');\r
                expect(obj.mixinProperty2).toEqual('mixinProperty2');\r
                expect(obj.mixinMethod1).toBeDefined();\r
                expect(obj.mixinMethod2).toBeDefined();\r
                expect(obj.config.mixinConfig).toEqual('mixinConfig');\r
            });\r
        });\r
\r
        describe("config", function() {\r
            it("should merge properly", function() {\r
                var obj = new subClass();\r
\r
                expect(obj.config).toEqual({\r
                    mixinConfig: 'mixinConfig',\r
                    name: 'subClass',\r
                    isCool: true,\r
                    members: {\r
                        abe: 'Abraham Elias',\r
                        ed: 'Ed Spencer',\r
                        jacky: 'Jacky Nguyen',\r
                        tommy: 'Tommy Maintz'\r
                    },\r
                    hobbies: ['sleeping', 'eating', 'movies'],\r
                    isSpecial: true\r
                });\r
            });\r
\r
            it("should apply default config", function() {\r
                var obj = new subClass();\r
\r
                expect(obj.getName()).toEqual('subClass');\r
                expect(obj.getIsCool()).toEqual(true);\r
                expect(obj.getHobbies()).toEqual(['sleeping', 'eating', 'movies']);\r
            });\r
\r
            it("should apply with supplied config", function() {\r
                var obj = new subClass({\r
                    name: 'newName',\r
                    isCool: false,\r
                    members: {\r
                        aaron: 'Aaron Conran'\r
                    }\r
                });\r
\r
                expect(obj.getName()).toEqual('newName');\r
                expect(obj.getIsCool()).toEqual(false);\r
                expect(obj.getMembers().aaron).toEqual('Aaron Conran');\r
            });\r
        });\r
\r
        describe("overriden methods", function() {\r
            it("should call self constructor", function() {\r
                var obj = new subClass();\r
                expect(obj.subConstrutorCalled).toBeTruthy();\r
            });\r
\r
            it("should call parent constructor", function() {\r
                var obj = new subClass();\r
                expect(obj.parentConstructorCalled).toBeTruthy();\r
            });\r
\r
            it("should call mixins constructors", function() {\r
                var obj = new subClass();\r
                expect(obj.mixinConstructor1Called).toBeTruthy();\r
                expect(obj.mixinConstructor2Called).toBeTruthy();\r
            });\r
        });\r
\r
        describe("alias", function() {\r
            it("should store alias", function() {\r
                expect(manager.getByAlias('subclass')).toBe(subClass);\r
            });\r
\r
            it("should store multiple aliases", function() {\r
                expect(manager.getByAlias('parentclass')).toBe(parentClass);\r
                expect(manager.getByAlias('superclass')).toBe(parentClass);\r
            });\r
        });\r
    });\r
\r
    describe('define', function () {\r
        it('should allow anonymous classes', function () {\r
            var T = Ext.define(null, function (Self) {\r
                return {\r
                    constructor: function () {\r
                        this.foo = 1;\r
                        this.T = Self;\r
                    }\r
                }\r
            });\r
            \r
            var obj = new T();\r
            \r
            expect(obj.foo).toBe(1);\r
            expect(T).toBe(obj.self);\r
            expect(obj.T).toBe(T);\r
            expect(obj.$className).toBeNull();\r
        })\r
    });\r
\r
    describe("instantiate", function() {\r
        beforeEach(function() {\r
            manager.create('Test.stuff.Person', {\r
                alias: 'person',\r
\r
                constructor: function(name, age, sex) {\r
                    this.name = name;\r
                    this.age = age;\r
                    this.sex = sex;\r
                },\r
\r
                eat: function(food) {\r
                    this.eatenFood = food;\r
                }\r
            });\r
\r
            manager.create('Test.stuff.Developer', {\r
                alias: 'developer',\r
\r
                extend: 'Test.stuff.Person',\r
\r
                constructor: function(isGeek, name, age, sex) {\r
                    this.isGeek = isGeek;\r
\r
                    return this.superclass.constructor.apply(this, arguments);\r
                },\r
\r
                code: function(language) {\r
                    this.languageCoded = language;\r
                    this.eat('bugs');\r
                }\r
            });\r
        });\r
\r
        afterEach(function() {\r
            Ext.undefine('Test.stuff.Person');\r
            Ext.undefine('Test.stuff.Developer');\r
        });\r
\r
        it("should create the instance by full class name", function() {\r
            var me = Ext.create('Test.stuff.Person', 'Jacky', 24, 'male');\r
            expect(me instanceof Test.stuff.Person).toBe(true);\r
        });\r
\r
        it("should create the instance by alias", function() {\r
            var me = manager.instantiateByAlias('person', 'Jacky', 24, 'male');\r
            expect(me instanceof Test.stuff.Person).toBe(true);\r
        });\r
\r
        it("should pass all arguments to the constructor", function() {\r
            var me = manager.instantiateByAlias('person', 'Jacky', 24, 'male');\r
            expect(me.name).toBe('Jacky');\r
            expect(me.age).toBe(24);\r
            expect(me.sex).toBe('male');\r
        });\r
\r
        it("should have all methods in prototype", function() {\r
            var me = manager.instantiateByAlias('person', 'Jacky', 24, 'male');\r
            me.eat('rice');\r
\r
            expect(me.eatenFood).toBe('rice');\r
        });\r
\r
        it("should works with inheritance", function() {\r
            var me = manager.instantiateByAlias('developer', true, 'Jacky', 24, 'male');\r
            me.code('javascript');\r
\r
            expect(me.languageCoded).toBe('javascript');\r
            expect(me.eatenFood).toBe('bugs');\r
        });\r
    });\r
\r
    describe("post-processors", function() {\r
        afterEach(function() {\r
            Ext.undefine('Something.Cool');\r
        });\r
\r
        xdescribe("uses", function() {\r
            //expect(Something.Cool).toBeDefined();\r
            //expect(Something.Cool instanceof test).toBeTruthy();\r
        });\r
\r
        describe("singleton", function() {\r
            it("should create the instance namespace and return the class", function() {\r
                var test = Ext.define('Something.Cool', {\r
                    singleton: true,\r
                    someMethod: function() {\r
                        this.someMethodCalled = true;\r
                    },\r
                    someProperty: 'something'\r
                });\r
\r
                expect(Something.Cool).toBeDefined();\r
                expect(Something.Cool instanceof test).toBeTruthy();\r
            });\r
        });\r
\r
        describe("alias xtype", function() {\r
            it("should set xtype as a static class property", function() {\r
                var test = Ext.define('Something.Cool', {\r
                    alias: 'widget.cool'\r
                });\r
\r
                expect(Something.Cool.xtype).toEqual('cool');\r
            });\r
        });\r
\r
        describe("alternate", function() {\r
            it("should create the alternate with a string for alternateClassName property", function() {\r
                Ext.define('Something.Cool', {\r
                    alternateClassName: 'Something.CoolAsWell',\r
\r
                    someMethod: function() {\r
                        this.someMethodCalled = true;\r
                    },\r
\r
                    someProperty: 'something'\r
                });\r
\r
                expect(Something.CoolAsWell).toBeDefined();\r
                expect(Something.CoolAsWell).toBe(Something.Cool);\r
            });\r
\r
            it("should create the alternate with an array for alternateClassName property", function() {\r
                Ext.define('Something.Cool', {\r
                    alternateClassName: ['Something.CoolAsWell', 'Something.AlsoCool']\r
                });\r
\r
                expect(Something.CoolAsWell).toBe(Something.Cool);\r
                expect(Something.AlsoCool).toBe(Something.Cool);\r
            });\r
        });\r
    });\r
\r
    describe("Ext.namespace", function() {\r
        var w = window;\r
\r
        function undo (name) {\r
            if (Ext.isIE8) {\r
                w[name] = undefined;\r
            } else {\r
                delete w[name];\r
            }\r
        }\r
\r
        it("should create a single top level namespace", function() {\r
            Ext.namespace('FooTest1');\r
\r
            expect(w.FooTest1).toBeDefined();\r
\r
            undo('FooTest1');\r
        });\r
\r
        it("should create multiple top level namespace", function() {\r
            Ext.namespace('FooTest2', 'FooTest3', 'FooTest4');\r
\r
            expect(w.FooTest2).toBeDefined();\r
            expect(w.FooTest3).toBeDefined();\r
            expect(w.FooTest4).toBeDefined();\r
\r
            undo('FooTest2');\r
            undo('FooTest3');\r
            undo('FooTest4');\r
        });\r
\r
        it("should create a chain of namespaces, starting from a top level", function() {\r
            Ext.namespace('FooTest5', 'FooTest5.ns1', 'FooTest5.ns1.ns2', 'FooTest5.ns1.ns2.ns3');\r
\r
            expect(w.FooTest5).toBeDefined();\r
            expect(w.FooTest5.ns1).toBeDefined();\r
            expect(w.FooTest5.ns1.ns2).toBeDefined();\r
            expect(w.FooTest5.ns1.ns2.ns3).toBeDefined();\r
\r
            undo('FooTest5');\r
        });\r
\r
        it("should create lower level namespaces without first defining the top level", function() {\r
            Ext.namespace('FooTest6.ns1', 'FooTest7.ns2');\r
\r
            expect(w.FooTest6).toBeDefined();\r
            expect(w.FooTest6.ns1).toBeDefined();\r
            expect(w.FooTest7).toBeDefined();\r
            expect(w.FooTest7.ns2).toBeDefined();\r
\r
            undo('FooTest6');\r
            undo('FooTest7');\r
        });\r
\r
        it("should create a lower level namespace without defining the middle level", function() {\r
            Ext.namespace('FooTest8', 'FooTest8.ns1.ns2');\r
\r
            expect(w.FooTest8).toBeDefined();\r
            expect(w.FooTest8.ns1).toBeDefined();\r
            expect(w.FooTest8.ns1.ns2).toBeDefined();\r
\r
            undo('FooTest8');\r
        });\r
\r
        it ("should not overwritte existing namespace", function() {\r
            Ext.namespace('FooTest9');\r
\r
            FooTest9.prop1 = 'foo';\r
\r
            Ext.namespace('FooTest9');\r
\r
            expect(FooTest9.prop1).toEqual("foo");\r
\r
            undo('FooTest9');\r
        });\r
    });\r
});\r