source: Dev/trunk/src/client/dojo/tests/aspect.js

define(["dojo/aspect"], function(aspect){

doh.register("tests.aspect",
        [
                function before(t){
                        var order = [];
                        var obj = {
                                method: function(a){
                                        order.push(a);
                                }
                        };
                        var signal = aspect.before(obj, "method", function(a){
                                order.push(a);
                                return [a+1];
                        });
                        obj.method(0);
                        obj.method(2);
                        var signal2 = aspect.before(obj, "method", function(a){
                                order.push(a);
                                return [a+1];
                        });
                        obj.method(4);
                        signal.remove();
                        obj.method(7);
                        signal2.remove();
                        obj.method(9);
                        t.is(order, [0,1,2,3,4,5,6,7,8,9]);
                },

                function after(t){
                        var order = [];
                        var obj = {
                                method: function(a){
                                        order.push(a);
                                        return a+1;
                                }
                        };
                        var signal = aspect.after(obj, "method", function(a){
                                order.push(0);
                                return a+1;
                        });
                        obj.method(0); // 0, 0
                        var signal2 = aspect.after(obj, "method", function(a){
                                order.push(a);
                        });
                        obj.method(3); // 3, 0, 5
                        var signal3 = aspect.after(obj, "method", function(a){
                                order.push(3);
                        }, true);
                        obj.method(3); // 3, 0, 5, 3
                        signal2.remove();
                        obj.method(6); // 6, 0, 3
                        signal3.remove();
                        var signal4 = aspect.after(obj, "method", function(a){
                                order.push(4);
                        }, true);
                        signal.remove();
                        obj.method(7); // 7, 4
                        signal4.remove();
                        var signal5 = aspect.after(obj, "method", function(a){
                                order.push(a);
                                aspect.after(obj, "method", function(a){
                                        order.push(a);
                                });
                                aspect.after(obj, "method", function(a){
                                        order.push(a);
                                }).remove();
                                return a+1;
                        });
                        var signal6 = aspect.after(obj, "method", function(a){
                                order.push(a);
                                return a+2;
                        });
                        obj.method(8); // 8, 9, 10
                        obj.method(8); // 8, 9, 10, 12
                        t.is([0, 0, 3, 0, 5, 3, 0, 5, 3, 6, 0, 3, 7, 4, 8, 9, 10, 8, 9, 10, 12], order);
                        obj = {method: function(){}};
                        aspect.after(obj, "method", function(){
                                return false;
                        }, true);
                        t.t(obj.method() === false);
                },
                function afterMultiple(t){
                        var order = [];
                        obj = {
                                foo: function(){}
                        };
                        aspect.after(obj, "foo", function(){order.push(1)});
                        aspect.after(obj, "foo", function(){order.push(2)});
                        aspect.after(obj, "foo", function(){order.push(3)});
                        obj.foo();
                        t.is([1,2,3], order);
                },
                function around(t){
                        var order = [];
                        var obj = {
                                method: function(a){
                                        order.push(a);
                                        return a+1;
                                }
                        };
                        var beforeSignal = aspect.before(obj, "method", function(a){
                                order.push(a);
                        });
                        var signal = aspect.around(obj, "method", function(original){
                                return function(a){
                                        a= a + 1;
                                        a = original(a);
                                        order.push(a);
                                        return a+1;
                                };
                        });
                        order.push(obj.method(0));
                        obj.method(4);
                        t.is(order, [0,1,2,3,4,5,6]);
                },
                function around2(t){
                        var order = [];
                        var obj = {
                                method: function(a){
                                        order.push(1);
                                }
                        };
                        var signal1 = aspect.around(obj, "method", function(original){
                                return function(a){
                                        original();
                                        order.push(2);
                                };
                        });
                        var signal2 = aspect.around(obj, "method", function(original){
                                return function(a){
                                        original();
                                        order.push(3);
                                };
                        });
                        var signal3 = aspect.around(obj, "method", function(original){
                                return function(a){
                                        original();
                                        order.push(4);
                                };
                        });
                        signal2.remove();
                        obj.method();
                        t.is(order, [1,2,4]);
                },
                function multipleRemove(t){
                        var foo = {bar: function(){}};
                        var order = [];
                        var signal1 = aspect.after(foo, "bar", function() {
                        order.push(1);
                        });

                        var signal2 = aspect.after(foo, "bar", function() {
                                order.push(2);
                        });

                        var signal3 = aspect.after(foo, "bar", function() {
                                order.push(3);
                        });

                        // This should execute all 3 callbacks
                        foo.bar();
                        
                        signal2.remove();
                        signal3.remove();

                        // Ideally signal2 should not be removed again, but can happen if the app
                        // fails to clear its state.
                        signal2.remove();
                        
                        // This should execute only the first callback, but notice that the third callback
                        // is executed as well
                        foo.bar();
                        t.is(order, [1,2,3,1]);
                },
                function delegation(t){
                        var order = [];
                        var proto = {
                                foo: function(x){
                                        order.push(x);
                                        return x;
                                },
                                bar: function(){
                                }
                        };
                        aspect.after(proto, "foo", function(x){
                                order.push(x + 1);
                                return x;
                        });
                        aspect.after(proto, "bar", function(x){
                                t.t(this.isInstance);
                        });
                        proto.foo(0);
                        function Class(){
                        }
                        Class.prototype = proto;
                        var instance = new Class();
                        instance.isInstance = true;
                        aspect.after(instance, "foo", function(x){
                                order.push(x + 2);
                                return x;
                        });
                        instance.bar();
                        instance.foo(2);
                        proto.foo(5);
                        t.is(order, [0,1,2,3,4,5,6]);
                }
        ]
);

});