extjs-rails 4.1.0.alpha1

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/Support.js

@@ -0,0 +1,250 @@
+describe("Ext.Support", function() {
+	describe("Ext.is", function() {
+
+		var platform     = {
+			detect: function(navigatorObject) {
+				var result     = [];
+
+				Ext.is.init(navigatorObject);
+
+				if (Ext.is.Desktop) {
+					result.push('Desktop');
+				}
+				if (Ext.is.Tablet) {
+					result.push('Tablet');
+				}
+				if (Ext.is.Phone) {
+					result.push('Phone');
+				}
+
+				if (Ext.is.iPad) {
+					result.push('iPad');
+				}
+				if (Ext.is.iPhone) {
+					result.push('iPhone');
+				}
+				if (Ext.is.iPod) {
+					result.push('iPod');
+				}
+
+				if (Ext.is.Mac) {
+					result.push('Mac');
+				}
+				if (Ext.is.Windows) {
+					result.push('Windows');
+				}
+				if (Ext.is.Linux) {
+					result.push('Linux');
+				}
+				if (Ext.is.Android) {
+					result.push('Android');
+				}
+				if (Ext.is.iOS) {
+					result.push('iOS');
+				}
+				if (Ext.is.Blackberry) {
+					result.push('BlackBerry');
+				}
+
+				// Reset back to use actual navigator host object
+				Ext.is.init(window.navigator);
+
+				return result.join(' ');
+			},
+
+			data: {
+				'Desktop Mac': {
+					Safari_502_Mac: {
+						platform: 'MacIntel',
+						userAgent: 'Safari_5533.18.5Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_4; en-us) AppleWebKit/533.18.1 (KHTML, like Gecko) Version/5.0.2 Safari/533.18.5'
+					},
+
+					Chrome_70517_Mac: {
+						platform: 'MacIntel',
+						userAgent: 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_4; en-US) AppleWebKit/534.7 (KHTML, like Gecko) Chrome/7.0.517.44 Safari/534.7'
+					},
+
+					Opera_1063_Mac: {
+						platform: 'MacIntel',
+						userAgent: 'Opera/9.80 (Macintosh; Intel Mac OS X; U; en) Presto/2.6.30 Version/10.63'
+					}
+				},
+				'Desktop Windows': {
+					IE_9Beta_Win7: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; .NET4.0C; Media Center PC 6.0)'
+					},
+
+					IE_8_Win7: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; .NET CLR 3.5.30729)'
+					},
+
+					IE_7_WinVista: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; en-US)'
+					},
+
+					IE_61_WinXP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/4.0 (compatible; MSIE 6.1; Windows XP)'
+					},
+
+					Firefox_36_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.2.13) Gecko/20101203 Firefox/3.6.13'
+					},
+
+					Firefox_35_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.1.15) Gecko/20101026 Firefox/3.5.15'
+					},
+
+					Firefox_3_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.19) Gecko/2010031422 Firefox/3.0.19'
+					},
+
+					Opera_1054_XP: {
+						platform: 'Win32',
+						userAgent: 'Opera/9.80 (Windows NT 5.1; U; en) Presto/2.5.24 Version/10.54'
+					},
+
+					Opera_964_XP: {
+						platform: 'Win32',
+						userAgent: 'Opera/9.64 (Windows NT 5.1; U; en) Presto/2.1.1'
+					},
+
+					Safari_5_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/533.19.4 (KHTML, like Gecko) Version/5.0.3 Safari/533.19.4'
+					},
+
+					Safari_4_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.28.3 (KHTML, like Gecko) Version/3.2.3 Safari/525.29'
+					},
+
+					Safari_3_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/525.28.3 (KHTML, like Gecko) Version/3.2.3 Safari/525.29'
+					},
+
+					Chrome_8_Win7: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/534.10 (KHTML, like Gecko) Chrome/8.0.552.215 Safari/534.10'
+					},
+
+					Chrome_7_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.7 (KHTML, like Gecko) Chrome/7.0.517.44 Safari/534.7'
+					},
+
+					Chrome_6_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/534.2 (KHTML, like Gecko) Chrome/6.0.453.1 Safari/534.2'
+					},
+
+					Chrome_5_XP: {
+						platform: 'Win32',
+						userAgent: 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.126 Safari/533.4'
+					}
+				},
+				'Tablet iPad iOS': {
+					iPad_32: {
+						platform: 'iPad',
+						userAgent: 'Mozilla/5.0(iPad; U; CPU iPhone OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B314 Safari/531.21.10'
+					}
+				},
+				'Phone iPhone iOS': {
+					iPhone_31: {
+						platform: 'iPhone',
+						userAgent: 'Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_1_3 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7E18 Safari/528.16'
+					}
+				},
+				'Phone iPod iOS': {
+					iPod_41: {
+						platform: 'iPod',
+						userAgent: 'Mozilla/5.0 (iPod; U; CPU iPhone OS 4_1 like Mac OS X; en-us) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B118 Safari/6531.22.7'
+					},
+
+					iPod_31: {
+						platform: 'iPod',
+						userAgent: 'Mozilla/5.0 (iPod; U; CPU iPhone OS 3_1_3 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7E18 Safari/528.16'
+					}
+				},
+				'Phone Linux Android': {
+					Android_22_G2: {
+						platform: 'Linux armv7l',
+						userAgent: ' Mozilla/5.0 (Linux; U; Android 2.2; en-us; T-Mobile G2 Build/ FRF91) AppleWebKit/533.1(KHTML, like Gecko) Version/4.0 Mobile Safari/533.1'
+					},
+
+					Android_22_Desire: {
+						platform: 'Linux armv7l',
+						userAgent: 'Mozilla/5.0 (Linux; U; Android 2.2; en-vn; Desire_A8181 Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1'
+					},
+
+					Android_22_NexusOne: {
+						platform: 'Linux armv7l',
+						userAgent: 'Mozilla/5.0 (Linux; U; Android 2.2; en-us; Nexus One Build/ FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1'
+					},
+
+					Android_21_GalaxyS: {
+						platform: 'Linux armv7l',
+						userAgent: 'Mozilla/5.0 (Linux; U; Android 2.1-update1; fr-fr; GT-I9000 Build/ECLAIR) AppleWebKit/530.17 (KHTML, like Gecko) Version/4.0 Mobile Safari/530.17'
+					},
+
+					Android_21_Evo: {
+						platform: 'Linux armv7l',
+						userAgent: 'Mozilla/5.0 (Linux; U; Android 2.1-update1; en-us; Sprint APA9292KT Build/ERE27) AppleWebKit/530.17 (KHTML, like Gecko)'
+					}
+				},
+				'Phone BlackBerry': {
+					BlackBerry_Torch: {
+						platform: 'BlackBerry',
+						userAgent: 'Mozilla/5.0 (BlackBerry; U; BlackBerry 9800; en-US) AppleWebKit/534.1+ (KHTML, like Gecko) Version/6.0.0.246 Mobile Safari/534.1+'
+					}
+				}
+			}
+		},
+		generateSpecsFor = function(type) {
+			for (var data in platform.data[type]) {
+				if (platform.data.hasOwnProperty(type)) {
+					it("should detect " + data + " as " + type, function() {
+						expect(platform.detect(platform.data[type][data])).toEqual(type);
+					});
+				}
+			}
+		};
+
+		generateSpecsFor('Desktop Mac');
+		generateSpecsFor('Desktop Windows');
+		generateSpecsFor('Tablet iPad iOS');
+		generateSpecsFor('Phone iPhone iOS');
+		generateSpecsFor('Phone iPod iOS');
+		generateSpecsFor('Phone Linux Android');
+		generateSpecsFor('Phone BlackBerry');
+	});
+
+	describe("Ext.supports", function() {
+
+		describe("OrientationChange", function() {
+			it("should return true when supported", function() {
+				expect(Ext.supports.OrientationChange).toBe((typeof window.orientation != 'undefined') && ('onorientationchange' in window));
+			});
+		});
+
+		describe("DeviceMotion", function() {
+			it("should return true when supported", function() {
+				expect(Ext.supports.DeviceMotion).toBe('ondevicemotion' in window);
+			});
+		});
+
+		describe("Touch", function() {
+			it("should return true when supported", function() {
+				expect(Ext.supports.Touch).toBe(('ontouchstart' in window) && (!Ext.is.Desktop));
+			});
+		});
+
+	});
+});

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/class/Base.js

@@ -0,0 +1,47 @@
+describe("Ext.Base", function() {
+    
+    beforeEach(function() {
+        Ext.ClassManager.enableNamespaceParseCache = false;
+    });
+
+    afterEach(function() {
+        window.Test = undefined;
+
+        try {
+            delete window.Test;
+        } catch (e) {}
+        
+        Ext.ClassManager.enableNamespaceParseCache = true;
+    });
+
+    describe("borrow", function() {
+        beforeEach(function() {
+            Ext.define("Test.Foo", {
+                a: function() {
+                    return 'foo a';
+                },
+                b: function() {
+                    return 'foo b';
+                },
+                c: function() {
+                    return 'foo c';
+                }
+            });
+            Ext.define("Test.Bar", {
+                a: function() {
+                    return 'bar a';
+                }
+            });
+        });
+        
+        it("should borrow methods", function() {
+            Test.Bar.borrow(Test.Foo, ['b', 'c']);
+            
+            var bar = new Test.Bar();
+            expect(bar.a()).toEqual('bar a');
+            expect(bar.b()).toEqual('foo b');
+            expect(bar.c()).toEqual('foo c');
+        });
+    });
+    
+});

data/app/assets/javascripts/extjs-rails/src/core/test/unit/spec/class/Class.js

@@ -0,0 +1,561 @@
+describe("Ext.Class", function() {
+    var emptyFn = function(){},
+        cls;
+
+    beforeEach(function() {
+        window.My = {
+            awesome: {
+                Class: function(){},
+                Class1: function(){},
+                Class2: function(){}
+            },
+            cool: {
+                AnotherClass: function(){},
+                AnotherClass1: function(){},
+                AnotherClass2: function(){}
+            }
+        };
+    });
+
+    afterEach(function() {
+        if (window.My) {
+            window.My = undefined;
+        }
+
+        try {
+            delete window.My;
+        } catch (e) {}
+    });
+
+    // START PREPROCESSORS =================================================================== /
+    describe("preprocessors", function() {
+
+        beforeEach(function() {
+            cls = Ext.Class.create(null, {});
+        });
+
+        describe("extend", function() {
+
+            it("should extend from Base if no 'extend' property found", function() {
+                var data = {};
+
+                Ext.Class.preprocessors.extend.fn(cls, data, emptyFn, {}, emptyFn);
+
+                expect((new cls) instanceof Ext.Base).toBeTruthy();
+            });
+
+            it("should extend from given parent class", function() {
+                var data = {
+                    extend: My.awesome.Class
+                };
+
+                Ext.Class.preprocessors.extend.fn(cls, data, emptyFn, {}, emptyFn);
+
+                expect((new cls) instanceof My.awesome.Class).toBeTruthy();
+            });
+
+            it("should have superclass reference", function() {
+                var data = {
+                    extend: My.awesome.Class
+                };
+
+                var parentPrototype = My.awesome.Class.prototype;
+
+                Ext.Class.preprocessors.extend.fn(cls, data, emptyFn, {}, emptyFn);
+
+                expect(cls.superclass).toEqual(parentPrototype);
+                expect((new cls).superclass).toEqual(parentPrototype);
+            });
+        });
+
+        describe("other preprocessors", function() {
+            beforeEach(function() {
+                Ext.Class.preprocessors.extend.fn(cls, {}, emptyFn, {}, emptyFn);
+            });
+
+            describe("config", function() {
+
+                it("should create getter if not exists", function() {
+                    var data = {
+                        config: {
+                            someName: 'someValue'
+                        }
+                    };
+
+                    Ext.Class.preprocessors.config.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    expect(data.getSomeName).toBeDefined();
+                });
+
+                it("should NOT create getter if already exists", function() {
+                    var data = {
+                        config: {
+                            someName: 'someValue'
+                        }
+                    };
+
+                    var called = false;
+                    cls.prototype.getSomeName = function() {
+                        called = true;
+                    };
+
+                    Ext.Class.preprocessors.config.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    expect(data.getSomeName).not.toBeDefined();
+                });
+
+                it("should create setter if not exists", function() {
+                    var data = {
+                        config: {
+                            someName: 'someValue'
+                        }
+                    };
+
+                    Ext.Class.preprocessors.config.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    expect(data.setSomeName).toBeDefined();
+                });
+
+                it("should NOT create setter if already exists", function() {
+                    var data = {
+                        config: {
+                            someName: 'someValue'
+                        }
+                    };
+
+                    var called = false;
+
+                    cls.prototype.setSomeName = function() {
+                        called = true;
+                    };
+
+                    Ext.Class.preprocessors.config.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    expect(data.setSomeName).not.toBeDefined();
+                });
+            });
+
+            describe("statics", function() {
+                it("should copy static properties to the class", function() {
+                    var data = {
+                        statics: {
+                            someName: 'someValue',
+                            someMethod: Ext.emptyFn
+                        }
+                    };
+
+                    Ext.Class.preprocessors.statics.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    var obj = new cls;
+
+                    expect(data.statics).not.toBeDefined();
+                    expect(cls.someName).toBe('someValue');
+                    expect(cls.someMethod).toBe(Ext.emptyFn);
+                });
+            });
+
+            describe("inheritableStatics", function() {
+
+                it("should store names of inheritable static properties", function() {
+                    var data = {
+                        inheritableStatics: {
+                            someName: 'someValue',
+                            someMethod: Ext.emptyFn
+                        }
+                    };
+
+                    Ext.Class.preprocessors.inheritableStatics.fn(cls, data, emptyFn, {}, emptyFn);
+
+                    var obj = new cls;
+
+                    expect(obj.inheritableStatics).not.toBeDefined();
+                    expect(cls.someName).toBe('someValue');
+                    expect(cls.prototype.$inheritableStatics).toEqual(['someName', 'someMethod']);
+                    expect(cls.someMethod).toBe(Ext.emptyFn);
+                });
+
+                it("should inherit inheritable statics", function() {
+                    var data = {
+                        inheritableStatics: {
+                            someName: 'someValue',
+                            someMethod: Ext.emptyFn
+                        }
+                    }, cls2 = Ext.Class.create(null, {});
+
+                    Ext.Class.preprocessors.inheritableStatics.fn(cls, data, emptyFn, {}, emptyFn);
+                    Ext.Class.preprocessors.extend.fn(cls2, { extend: cls }, emptyFn, {}, emptyFn);
+
+                    expect(cls2.someName).toEqual('someValue');
+                    expect(cls2.someMethod).toBe(Ext.emptyFn);
+                });
+
+                it("should NOT inherit inheritable statics if the class already has it", function() {
+                    var data = {
+                        inheritableStatics: {
+                            someName: 'someValue',
+                            someMethod: Ext.emptyFn
+                        }
+                    }, cls2 = Ext.Class.create(null, {});
+
+                    cls2.someName = 'someOtherValue';
+                    cls2.someMethod = function(){};
+
+                    Ext.Class.preprocessors.inheritableStatics.fn(cls, data, emptyFn, {}, emptyFn);
+                    Ext.Class.preprocessors.extend.fn(cls2, { extend: cls }, emptyFn, {}, emptyFn);
+
+                    expect(cls2.someName).toEqual('someOtherValue');
+                    expect(cls2.someMethod).not.toBe(Ext.emptyFn);
+                });
+            });
+        });
+    });
+
+    // END PREPROCESSORS =================================================================== /
+
+    describe("Instantiation", function() {
+        var subClass, parentClass, mixinClass1, mixinClass2;
+
+        beforeEach(function() {
+            mixinClass1 = new Ext.Class({
+                config: {
+                    mixinConfig: 'mixinConfig'
+                },
+
+                constructor: function(config) {
+                    this.initConfig(config);
+
+                    this.mixinConstructor1Called = true;
+                },
+
+                mixinProperty1: 'mixinProperty1',
+
+                mixinMethod1: function() {
+                    this.mixinMethodCalled = true;
+                }
+            });
+
+            mixinClass2 = new Ext.Class({
+                constructor: function(config) {
+                    this.initConfig(config);
+
+                    this.mixinConstructor2Called = true;
+                },
+
+                mixinProperty2: 'mixinProperty2',
+
+                mixinMethod2: function() {
+                    this.mixinMethodCalled = true;
+                }
+            });
+
+            parentClass = new Ext.Class({
+                mixins: {
+                    mixin1: mixinClass1
+                },
+                config: {
+                    name: 'parentClass',
+                    isCool: false,
+                    members: {
+                        abe: 'Abraham Elias',
+                        ed: 'Ed Spencer'
+                    },
+                    hobbies: ['football', 'bowling']
+                },
+                constructor: function(config) {
+                    this.initConfig(config);
+
+                    this.parentConstructorCalled = true;
+
+                    this.mixins.mixin1.constructor.apply(this, arguments);
+                },
+
+                parentProperty: 'parentProperty',
+
+                parentMethod: function() {
+                    this.parentMethodCalled = true;
+                }
+            });
+
+            subClass = new Ext.Class({
+                extend: parentClass,
+                mixins: {
+                    mixin1: mixinClass1,
+                    mixin2: mixinClass2
+                },
+                config: {
+                    name: 'subClass',
+                    isCool: true,
+                    members: {
+                        jacky: 'Jacky Nguyen',
+                        tommy: 'Tommy Maintz'
+                    },
+                    hobbies: ['sleeping', 'eating', 'movies'],
+                    isSpecial: true
+                },
+                constructor: function(config) {
+                    this.initConfig(config);
+
+                    this.subConstrutorCalled = true;
+
+                    subClass.superclass.constructor.apply(this, arguments);
+
+                    this.mixins.mixin2.constructor.apply(this, arguments);
+                },
+                myOwnMethod: function() {
+                    this.myOwnMethodCalled = true;
+                }
+            });
+        });
+
+        describe("addStatics", function() {
+            it("single with name - value arguments", function() {
+                var called = false;
+
+                subClass.addStatics({
+                    staticMethod: function(){
+                        called = true;
+                    }
+                });
+
+                expect(subClass.staticMethod).toBeDefined();
+                subClass.staticMethod();
+
+                expect(called).toBeTruthy();
+            });
+
+            it("multiple with object map argument", function() {
+                subClass.addStatics({
+                    staticProperty: 'something',
+                    staticMethod: function(){}
+                });
+
+                expect(subClass.staticProperty).toEqual('something');
+                expect(subClass.staticMethod).toBeDefined();
+            });
+        });
+
+
+        describe("override", function() {
+            it("should override", function() {
+                subClass.override({
+                    myOwnMethod: function(){
+                        this.isOverridden = true;
+
+                        this.callOverridden(arguments);
+                    }
+                });
+
+                var obj = new subClass;
+                obj.myOwnMethod();
+
+                expect(obj.isOverridden).toBe(true);
+                expect(obj.myOwnMethodCalled).toBe(true);
+            });
+        });
+
+        describe("define override", function() {
+            var obj,
+                createFnsCalled;
+
+            beforeEach(function () {
+                createFnsCalled = [];
+                function onCreated () {
+                    createFnsCalled.push(this.$className);
+                }
+
+                Ext.define('Foo.UnusedOverride', {
+                    override: 'Foo.Nothing',
+
+                    foo: function (x) {
+                        return this.callParent([x*2]);
+                    }
+                }, onCreated);
+
+                // this override comes before its target:
+                Ext.define('Foo.SingletonOverride', {
+                    override: 'Foo.Singleton',
+
+                    foo: function (x) {
+                        return this.callParent([x*2]);
+                    }
+                }, onCreated);
+
+                Ext.define('Foo.Singleton', {
+                    singleton: true,
+                    foo: function (x) {
+                        return x;
+                    }
+                });
+
+                Ext.define('Foo.SomeClass', {
+                    method1: function(x) {
+                        return 'b' + x;
+                    },
+
+                    statics: {
+                        staticMethod: function (x) {
+                            return 'B' + x;
+                        }
+                    }
+                });
+
+                // this override comes after its target:
+                Ext.define('Foo.SomeClassOverride', {
+                    override: 'Foo.SomeClass',
+
+                    method1: function(x) {
+                        return 'a' + this.callParent([x*2]) + 'c';
+                    },
+
+                    method2: function() {
+                        return 'two';
+                    },
+
+                    statics: {
+                        newStatic: function () {
+                            return 'boo';
+                        },
+                        staticMethod: function (x) {
+                            return 'A' + this.callParent([x*2]) + 'C';
+                        }
+                    }
+                }, onCreated);
+
+                obj = Ext.create('Foo.SomeClass');
+            });
+
+            afterEach(function () {
+                var classes = Ext.ClassManager.classes,
+                    alternateToName = Ext.ClassManager.maps.alternateToName;
+                try {
+                    delete Ext.global.Foo;
+                } catch (e) {
+                    Ext.global.Foo = null;
+                }
+                obj = null;
+
+                Ext.each(['Foo.SingletonOverride', 'Foo.Singleton', 'Foo.SomeClassOverride', 'Foo.SomeClass'],
+                    function (className) {
+                        try {
+                            delete classes[className];
+                            delete alternateToName[className];
+                        } catch(e) {
+                            classes[className] = null;
+                            alternateToName[className] = null;
+                        }
+                    });
+            });
+
+            it("should call the createdFn", function () {
+                expect(createFnsCalled.length).toEqual(2);
+                expect(createFnsCalled[0]).toEqual('Foo.Singleton');
+                expect(createFnsCalled[1]).toEqual('Foo.SomeClass');
+            });
+
+            it("can add new methods", function() {
+                expect(obj.method2()).toEqual('two');
+            });
+
+            it("can add new static methods", function() {
+                expect(Foo.SomeClass.newStatic()).toEqual('boo');
+            });
+
+            it("callParent should work for instance methods", function() {
+                expect(obj.method1(21)).toEqual('ab42c');
+            });
+
+            it("callParent should work for static methods", function() {
+                expect(Foo.SomeClass.staticMethod(21)).toEqual('AB42C');
+            });
+
+            it('works with singletons', function () {
+                expect(Foo.Singleton.foo(21)).toEqual(42);
+            });
+        });
+
+        describe("mixin", function() {
+            it("should have all properties of mixins", function() {
+                var obj = new subClass;
+                expect(obj.mixinProperty1).toEqual('mixinProperty1');
+                expect(obj.mixinProperty2).toEqual('mixinProperty2');
+                expect(obj.mixinMethod1).toBeDefined();
+                expect(obj.mixinMethod2).toBeDefined();
+                expect(obj.config.mixinConfig).toEqual('mixinConfig');
+            });
+        });
+
+        describe("config", function() {
+            it("should merge properly", function() {
+                var obj = new subClass;
+                expect(obj.config).toEqual({
+                    mixinConfig: 'mixinConfig',
+                    name: 'subClass',
+                    isCool: true,
+                    members: {
+                        abe: 'Abraham Elias',
+                        ed: 'Ed Spencer',
+                        jacky: 'Jacky Nguyen',
+                        tommy: 'Tommy Maintz'
+                    },
+                    hobbies: ['sleeping', 'eating', 'movies'],
+                    isSpecial: true
+                });
+            });
+
+            it("should apply default config", function() {
+                var obj = new subClass;
+                expect(obj.getName()).toEqual('subClass');
+                expect(obj.getIsCool()).toEqual(true);
+                expect(obj.getHobbies()).toEqual(['sleeping', 'eating', 'movies']);
+            });
+
+            it("should apply with supplied config", function() {
+                var obj = new subClass({
+                    name: 'newName',
+                    isCool: false,
+                    members: {
+                        aaron: 'Aaron Conran'
+                    }
+                });
+
+                expect(obj.getName()).toEqual('newName');
+                expect(obj.getIsCool()).toEqual(false);
+                expect(obj.getMembers().aaron).toEqual('Aaron Conran');
+            });
+
+            it("should not share the same config", function() {
+                var obj1 = new subClass({
+                    name: 'newName',
+                    isCool: false,
+                    members: {
+                        aaron: 'Aaron Conran'
+                    }
+                });
+
+                var obj2 = new subClass();
+
+                expect(obj2.getName()).not.toEqual('newName');
+            });
+        });
+
+        describe("overriden methods", function() {
+            it("should call self constructor", function() {
+                var obj = new subClass;
+                expect(obj.subConstrutorCalled).toBeTruthy();
+            });
+
+            it("should call parent constructor", function() {
+                var obj = new subClass;
+                expect(obj.parentConstructorCalled).toBeTruthy();
+            });
+
+            it("should call mixins constructors", function() {
+                var obj = new subClass;
+                expect(obj.mixinConstructor1Called).toBeTruthy();
+                expect(obj.mixinConstructor2Called).toBeTruthy();
+            });
+        });
+
+    });
+
+});