DUITests.js

YUI({ useBrowserConsole: false }).use('console', 'test', function(Y) {
    var suite = new Y.Test.Suite({
        name: "DUI",
        
        setUp: function() {
            this.dyn = new DUI.Class({
                init: function(arg) {
                    this.quux = arg;
                },
                foo: 1,
                bar: function(){},
                baz: null
            });
            
            this.stat = new DUI.Class({
                foo: 1,
                bar: function(){},
                baz: null
            }, true);
        },
        
        tearDown: function() {
            delete this.dyn;
            delete this.stat;
        }
    });
    
    suite.add(new Y.Test.Case({
        name: "Create Dynamic Class",
        
        testConstructor: function() {
            var c = new suite.dyn(4);
            Y.Assert.areSame(4, c.quux, "Constructor should set member 'quux' to 4");
        },
        
        testNumericalMember: function() {
            Y.Assert.areSame(1, suite.dyn.prototype.foo, "Member 'foo' should be 1");
        },
        
        testFunctionMember: function() {
            Y.Assert.isTypeOf('function', suite.dyn.prototype.bar, "Member 'bar' should be a Function");
        },
        
        testNullMember: function() {
            Y.Assert.areSame(null, suite.dyn.prototype.baz, "Member 'baz' should be null");
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "Create Static Class",
        
        testNumericalMember: function() {
            Y.Assert.areSame(1, suite.stat.foo, "Member 'foo' should be 1");
        },
        
        testFunctionMember: function() {
            Y.Assert.isTypeOf('function', suite.stat.bar, "Member 'bar' should be a Function");
        },
        
        testNullMember: function() {
            Y.Assert.areSame(null, suite.stat.baz, "Member 'baz' should be null");
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "Utils: DUI.isClass",
        
        testDynNoFlag: function() {
            Y.Assert.isTrue(DUI.isClass(suite.dyn), "DUI.isClass -> Dynamic class -> No flag");
        },
        
        testDynDynFlag: function() {
            Y.Assert.isTrue(DUI.isClass(suite.dyn, false), "DUI.isClass -> Dynamic class -> Dynamic flag");
        },
        
        testDynStatFlag: function() {
            Y.Assert.isFalse(DUI.isClass(suite.dyn, true), "DUI.isClass -> Dynamic class -> Static flag");
        },
        
        testStatNoFlag: function() {
            Y.Assert.isTrue(DUI.isClass(suite.stat), "DUI.isClass -> Static class -> No flag");
        },
        
        testStatStatFlag: function() {
            Y.Assert.isTrue(DUI.isClass(suite.stat, true), "DUI.isClass -> Static class -> Static flag");
        },
        
        testStatDynFlag: function() {
            Y.Assert.isFalse(DUI.isClass(suite.stat, false), "DUI.isClass -> Static class -> Dynamic flag");
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "Utils: DUI.global",
        
        setUp: function() {
            globalTestObj = {
                foo: {
                    bar: 'bananas'
                }
            };
            
            this.scopedTestObj = {
                baz: {
                    quux: 'nanners'
                }
            };
        },
        
        tearDown: function() {
            delete globalTestObj;
            delete this.scopedTestObj;
        },
        
        testUndefinedGlobal: function() {
            Y.Assert.isUndefined(DUI.global('hntdnthdy.tshdxbwmxbxy.nhtdgip'), "DUI.global -> Undefined NS === undefined");
        },
        
        testGetGlobal: function() {
            Y.Assert.areSame('bananas', DUI.global('globalTestObj.foo.bar'), "DUI.global -> Get property of global object");
        },
        
        testGetScopedGlobal: function() {
            Y.Assert.areSame('nanners', DUI.global(['scopedTestObj.baz.quux', this]), "DUI.global -> Get property of scoped object");
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "DUI iterators",
        
        _should: {
            error: {
                testEachError: new Error('DUI.Class.each must be called with a function as its first argument.')
            }
        },
        
        setUp: function() {
            this.eachClass = new DUI.Class({
                foo: 1,
                bar: 2,
                baz: 3,
            }, true);
            
            this.dontEnumClass = new DUI.Class({
                foo: 1,
                bar: 2,
                baz: 3,
                dontEnum: ['bar']
            }, true);
        },
        
        tearDown: function() {
            delete this.eachClass;
            delete this.dontEnumClass;
        },
        
        testEach: function() {
            var result = '';
            
            this.eachClass.each(function(key, value) {
                result += key + value;
            });
            
            Y.Assert.areSame('foo1bar2baz3', result, "DUI each should call its arg on every iterable member of a class");
        },
        
        testEachError: function() {
            this.eachClass.each();
        },
        
        testDontEnum: function() {
            var result = '';
            
            this.dontEnumClass.each(function(key) {
                result += key;
            });
            
            Y.Assert.areSame('foobaz', result, "DUI each should omit key 'bar' passed into donEnum");
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "DUI namespaces",
        
        setUp: function() {
            this.nsClass = new DUI.Class(true);
        },
        
        tearDown: function() {
            delete this.nsClass;
        },
        
        testUndefinedNamespace: function() {
            Y.Assert.isUndefined(this.nsClass.ns('foo'), "Undefined namespace should return undefined");
        },
        
        testTopLevelNamespace: function() {
            this.nsClass.ns('foo', 1);
            
            Y.Assert.areSame(1, this.nsClass.ns('foo'), "Set a top level namespace and return it.");
            
            delete this.nsClass.foo;
        },
        
        testDeepNamespace: function() {
            this.nsClass.ns('foo.bar', 1);
            
            Y.Assert.areSame(1, this.nsClass.ns('foo.bar'), "Set a second level namespace and return it.");
            
            Y.Assert.isTrue(DUI.isClass(this.nsClass.ns('foo')), "Check to make sure a top level namespace was created to hold the nested one.");
            
            delete this.nsClass.foo;
        },
        
        testObjectNamespace: function() {
            this.nsClass.ns({
                foo: 1,
                bar: 2,
                baz: 3
            });
            
            Y.Assert.areSame(1, this.nsClass.ns('foo'), "Prop 'foo' should be 1");
            Y.Assert.areSame(2, this.nsClass.ns('bar'), "Prop 'bar' should be 2");
            Y.Assert.areSame(3, this.nsClass.ns('baz'), "Prop 'baz' should be 3");
            
            delete this.nsClass.foo;
            delete this.nsClass.bar;
            delete this.nsClass.baz;
        }
    }));
    
    suite.add(new Y.Test.Case({
        name: "DUI create",
        
        setUp: function() {
            this.createClass = new DUI.Class(true);
            
            this.createClass.create('foo', {
                bar: 1
            }, true);
        },
        
        tearDown: function() {
            delete this.createClass;
        },
        
        testNestedClass: function() {
            Y.Assert.areSame(1, this.createClass.foo.bar, "Nested class foo's prop bar should be 1");
        }
    }));
    
    var console = new Y.Console({
        newestOnTop: false,
    }).render();
    
    Y.Test.Runner.add(suite);
    Y.Test.Runner.run();
});