extjs-rails 4.1.0.alpha1

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

@@ -0,0 +1,277 @@
+describe("Ext.Error", function() { 
+    var global;
+
+    beforeEach(function() {
+        global = Ext.global;
+
+        // mock the console to avoid logging to the real console during the tests
+        Ext.global = {
+            console: {
+                dir: function(s) {
+                    return s;
+                },
+                log: function(s) {
+                    return s;
+                },                
+                error: function(s) {
+                    return s;
+                },
+                warn: function(s) {
+                    return s;
+                }
+            }
+        };
+    });
+
+    afterEach(function() {
+        Ext.global = global;
+    });
+
+    describe("raising an error via Ext.Error.raise", function() {
+
+        describe("passing a string", function() {
+    
+            it("should throw an error with a msg property", function() {
+                var error;
+                try {
+                    Ext.Error.raise('foo');
+                }
+                catch (err) {
+                    error = err;
+                }
+                expect(error.msg).toEqual('foo');
+            });
+        
+            it("should log an error to the console", function() {
+                spyOn(Ext.global.console, 'error');
+                try {
+                    Ext.Error.raise('foo');
+                } 
+                catch (err) {}
+                expect(Ext.global.console.error).toHaveBeenCalledWith('[E] foo');
+            });
+        
+            it("should log the error object to the console", function() {
+                spyOn(Ext.global.console, 'dir').andCallFake(function(err){
+                    expect(err.msg).toEqual('foo');
+                });
+                try {
+                    Ext.Error.raise('foo');
+                } 
+                catch (err) {}
+            });
+        
+            it("should do nothing when Ext.Error.ignore = true", function() {
+                spyOn(Ext.global.console, 'warn');
+            
+                Ext.Error.ignore = true;
+                try {
+                    Ext.Error.raise('foo');
+                } 
+                catch (err) {
+                    expect('Error should not have been caught').toBe(true);
+                }
+                expect(Ext.global.console.warn).not.toHaveBeenCalled();
+                Ext.Error.ignore = false;
+            });
+        
+            it("should not throw an error if handled by Ext.Error.handle", function() {
+                spyOn(Ext.global.console, 'warn');
+            
+                var origHandle = Ext.Error.handle;
+                Ext.Error.handle = function(err) {
+                    expect(err.msg).toEqual('foo');
+                    return true;
+                }
+                try {
+                    Ext.Error.raise('foo');
+                } 
+                catch (err) {
+                    expect('Error should not have been caught').toBe(true);
+                }
+                expect(Ext.global.console.warn).not.toHaveBeenCalled();
+                Ext.Error.handle = origHandle;
+            });
+        });
+    
+        describe("passing an object with a msg property", function() {
+    
+            it("should throw an error with a msg property", function() {
+                var error;
+                try {
+                    Ext.Error.raise({msg: 'foo'});
+                }
+                catch (err) {
+                    error = err;
+                }
+                expect(error.msg).toEqual('foo');
+            });
+        
+            it("should log an error to the console", function() {
+                spyOn(Ext.global.console, 'error');
+                try {
+                    Ext.Error.raise({msg: 'foo'});
+                } 
+                catch (err) {}
+                expect(Ext.global.console.error).toHaveBeenCalledWith('[E] foo');
+            });
+        
+            it("should log the error object to the console", function() {
+                spyOn(Ext.global.console, 'dir').andCallFake(function(err){
+                    expect(err.msg).toEqual('foo');
+                });
+                try {
+                    Ext.Error.raise({msg: 'foo'});
+                } 
+                catch (err) {}
+            });
+                            
+            it("should do nothing when Ext.Error.ignore = true", function() {
+                spyOn(Ext.global.console, 'warn');
+            
+                Ext.Error.ignore = true;
+                try {
+                    Ext.Error.raise({msg: 'foo'});
+                } 
+                catch (err) {
+                    expect('Error should not have been caught').toBe(true);
+                }
+                expect(Ext.global.console.warn).not.toHaveBeenCalled();
+                Ext.Error.ignore = false;
+            });
+        
+            it("should not throw an error if handled by Ext.Error.handle", function() {
+                spyOn(Ext.global.console, 'warn');
+            
+                var origHandle = Ext.Error.handle;
+                Ext.Error.handle = function(err) {
+                    expect(err.msg).toEqual('foo');
+                    return true;
+                }
+                try {
+                    Ext.Error.raise({msg: 'foo'});
+                } 
+                catch (err) {
+                    expect('Error should not have been caught').toBe(true);
+                }
+                expect(Ext.global.console.warn).not.toHaveBeenCalled();
+                Ext.Error.handle = origHandle;
+            });
+        });
+    
+        describe("passing an object with custom metadata", function() {
+    
+            it("should throw an error with matching metadata", function() {
+                var error;
+                try {
+                    Ext.Error.raise({
+                        msg: 'Custom error',
+                        data: {
+                            foo: 'bar'
+                        }
+                    });
+                }
+                catch (err) {
+                    error = err;
+                }
+                expect(error.msg).toEqual('Custom error');
+                expect(error.data).not.toBe(null);
+                expect(error.data.foo).toEqual('bar');
+            });
+        
+            it("should log the complete metadata to the console", function() {
+                spyOn(Ext.global.console, 'dir').andCallFake(function(err){
+                    expect(err.msg).toEqual('Custom error');
+                    expect(err.data).not.toBe(null);
+                    expect(err.data.foo).toEqual('bar');
+                });
+                try {
+                    Ext.Error.raise({
+                        msg: 'Custom error',
+                        data: {
+                            foo: 'bar'
+                        }
+                    });
+                } 
+                catch (err) {}
+            });
+        });
+    
+        describe("originating from within a class defined by Ext", function() {
+    
+            Ext.define('CustomClass', {
+                doSomething: function(o){
+                    Ext.Error.raise({
+                        msg: 'Custom error',
+                        data: o,
+                        foo: 'bar'
+                    });
+                }
+            });
+            var customObj = Ext.create('CustomClass');
+        
+            it("should throw an error containing the source class and method", function() {
+                var error;
+                try {
+                    customObj.doSomething({
+                        extraData: 'extra'
+                    });
+                }
+                catch (err) {
+                    error = err;
+                }
+                expect(error.msg).toEqual('Custom error');
+                expect(error.sourceClass).toEqual('CustomClass');
+                expect(error.sourceMethod).toEqual('doSomething');
+                expect(error.toString()).toBe('CustomClass.doSomething(): Custom error');
+            });
+        
+            it("should log the complete metadata to the console", function() {
+                spyOn(Ext.global.console, 'dir').andCallFake(function(err){
+                    expect(err.msg).toEqual('Custom error');
+                    expect(err.sourceClass).toEqual('CustomClass');
+                    expect(err.sourceMethod).toEqual('doSomething');
+                    expect(err.data).not.toBe(null);
+                    expect(err.data.extraData).not.toBe(null);
+                    expect(err.data.extraData).toEqual('extra');
+                    expect(err.foo).toEqual('bar');
+                });
+                try {
+                    customObj.doSomething({
+                        extraData: 'extra'
+                    });
+                } 
+                catch (err) {
+                }
+            });
+        });
+    });
+    
+    describe("Throwing an an Ext.Error directly intantiated", function() {
+        describe("Passing an string as constructor argument", function() {
+           it("should contain a msg property with the given string as value", function() {
+              expect(function() {
+                  throw new Ext.Error("expected message");
+              }).toRaiseExtError("expected message");
+           });
+        });
+     });
+    
+    xdescribe("Ext.deprecated", function() {
+       // failing only on CI
+       it("should return a function that raises an error with the given suggestion", function() {
+          Ext.ClassManager.enableNamespaceParseCache = false;
+          Ext.define("Test.ThisClassContainsADeprecatedMethod", {
+             deprecatedMethod : Ext.deprecated("use another function")
+          });
+          expect(function() {
+              new Test.ThisClassContainsADeprecatedMethod().deprecatedMethod();
+          }).toThrow('The method "Test.ThisClassContainsADeprecatedMethod.deprecatedMethod" has been removed. use another function');
+          
+          try {
+              delete Test;
+          } catch(e) { }
+          Ext.ClassManager.enableNamespaceParseCache = true;
+       });
+    });
+});

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

@@ -0,0 +1,536 @@
+describe("Ext.Function", function() {
+    
+    var _setTimeout,
+        _clearTimeout,
+        timeouts,
+        timeoutIds,
+        clearedTimeoutIds,
+        runAfterInvocation = function(spyedFunction, callback, invocationCount) {
+            invocationCount = invocationCount || 1;
+            waitsFor(function() { return spyedFunction.calls.length >= invocationCount; });
+            runs(callback);
+        },
+        mockTimeout = function() {
+            timeouts = [];
+            timeoutIds = [];
+            clearedTimeoutIds = [];
+            
+            _setTimeout = window.setTimeout;
+            window.setTimeout = function(fn, timeout) {
+                timeouts.push(timeout);
+                var timeoutId = _setTimeout.apply(this, arguments);
+                timeoutIds.push(timeoutId);
+                return timeoutId;
+            };
+            
+            _clearTimeout = window.clearTimeout;
+            window.clearTimeout = function(timeoutId) {
+                clearedTimeoutIds.push(timeoutId);
+                _clearTimeout.apply(this, arguments);
+            };
+        },
+        unmockTimeout = function() {
+            timeouts = undefined;
+            timeoutIds = undefined;
+            clearedTimeoutIds = undefined;
+            window.setTimeout = _setTimeout;
+            window.clearTimeout = _clearTimeout;
+        };
+
+    
+    describe("bind", function() {
+        var fn,
+            bind;
+
+        beforeEach(function() {
+            fn = jasmine.createSpy("bindSpy");
+        });
+
+        it("should return a function if a function is passed as first argument", function() {
+            bind = Ext.Function.bind(fn, this);
+
+            expect(typeof bind === "function").toBe(true);
+        });
+
+        it("should use the correct scope", function() {
+            bind = Ext.Function.bind(fn, fakeScope);
+
+            bind();
+
+            expect(fn.calls[0].object).toBe(fakeScope);
+        });
+
+        it("should call the first function when it is executed", function() {
+            bind = Ext.Function.bind(fn, this);
+
+            bind();
+
+            expect(fn).toHaveBeenCalled();
+        });
+
+        describe("argument passing", function() {
+
+            it("should use default args if none are passed", function() {
+                bind = Ext.Function.bind(fn, this, ['a', 'b']);
+
+                bind();
+
+                expect(fn).toHaveBeenCalledWith('a', 'b');
+            });
+
+            it("should use passed args if they are present", function() {
+                bind = Ext.Function.bind(fn, this);
+
+                bind('c', 'd');
+
+                expect(fn).toHaveBeenCalledWith('c', 'd');
+            });
+
+            it("should append args", function() {
+                bind = Ext.Function.bind(fn, this, ['a', 'b'], true);
+
+                bind('c', 'd');
+
+                expect(fn).toHaveBeenCalledWith('c', 'd', 'a', 'b');
+            });
+
+            it("should append args at the given index", function() {
+                bind = Ext.Function.bind(fn, this, ['a', 'b'], 0);
+
+                bind('c', 'd');
+
+                expect(fn).toHaveBeenCalledWith('a', 'b', 'c', 'd');
+            });
+        });
+    });
+    
+    describe("pass", function() {
+        it("should pass the specified array of arguments as the first arguments to the given function", function() {
+            var fn = jasmine.createSpy(),
+                args = [0, 1, 2],
+                callback = Ext.Function.pass(fn, args);
+            callback(3, 4, 5);
+            expect(fn).toHaveBeenCalledWith(0, 1, 2, 3, 4, 5);
+        });
+        it("should pass the specified string argument as the first argument to the given function", function() {
+            var fn = jasmine.createSpy(),
+                args = 'a',
+                callback = Ext.Function.pass(fn, args);
+            callback('b', 'c');
+            expect(fn).toHaveBeenCalledWith('a', 'b', 'c');
+        });
+        it("should pass the specified numeric argument as the first argument to the given function", function() {
+            var fn = jasmine.createSpy(),
+                args = 0,
+                callback = Ext.Function.pass(fn, args);
+            callback(1);
+            expect(fn).toHaveBeenCalledWith(0, 1);
+        });
+        it("should pass the specified 'arguments' argument as the first argument to the given funciton", function() {
+            var testFunction = function () {
+                    var fn = jasmine.createSpy(),
+                        args = arguments,
+                        callback = Ext.Function.pass(fn, args);
+                    callback(3, 4, 5);
+                    expect(fn).toHaveBeenCalledWith(0, 1, 2, 3, 4, 5);
+                };
+            testFunction(0, 1, 2);
+        });
+        it("should discard the argument if it's undefined", function() {
+            var fn = jasmine.createSpy(),
+                args = undefined,
+                callback = Ext.Function.pass(fn, args);
+                callback(1);
+            expect(fn).toHaveBeenCalledWith(1);
+        });
+        it("should use 'this' as default scope", function() {
+           var foo = 'a',
+               fn = jasmine.createSpy().andCallFake(function() {
+                   foo = this.foo;
+               }),
+               callback = Ext.Function.pass(fn, 'c');
+           callback('d');
+           expect(fn).toHaveBeenCalledWith('c', 'd');
+           expect(foo).toBeUndefined();
+        });
+        it("should override 'this' with the specified scope", function() {
+            var foo = 'a',
+                scope = { foo: 'b' },
+                fn = jasmine.createSpy().andCallFake(function() {
+                    foo = this.foo;
+                }),
+                callback = Ext.Function.pass(fn, 'c', scope);
+            callback('d');
+            expect(fn).toHaveBeenCalledWith('c', 'd');
+            expect(foo).toBe('b');
+        });
+    });
+    
+    describe("clone", function() {
+        it("should clone the given function", function() {
+            var fn = jasmine.createSpy().andCallFake(function(arg) { return 'bar'; }),
+                clonedFn = Ext.Function.clone(fn),
+                result = clonedFn('foo');
+            expect(result).toBe('bar');
+            expect(fn).toHaveBeenCalledWith('foo');
+        });
+    });
+
+    describe("createInterceptor", function() {
+        var interceptor,
+            interceptorFn,
+            interceptedFn,
+            interceptorIsRunFirst,
+            interceptedIsRunAfter;
+
+        beforeEach(function() {
+            interceptorIsRunFirst = false;
+            interceptedIsRunAfter = false;
+
+            interceptorFn = jasmine.createSpy("interceptorSpy").andCallFake(function() {
+                interceptorIsRunFirst = true;
+            });
+            interceptedFn = jasmine.createSpy("interceptedSpy").andCallFake(function() {
+                interceptedIsRunAfter = interceptorIsRunFirst;
+            });
+        });
+
+        describe("if no function is passed", function() {
+            it("should return the same function", function() {
+                expect(Ext.Function.createInterceptor(interceptedFn)).toEqual(interceptedFn);
+            });
+        });
+
+        describe("if a function is passed", function() {
+            beforeEach(function() {
+                interceptor = Ext.Function.createInterceptor(interceptedFn, interceptorFn, fakeScope);
+                interceptor();
+            });
+
+            it("should return a new function", function() {
+                expect(typeof interceptor === "function").toBe(true);
+                expect(interceptor).not.toEqual(interceptedFn);
+            });
+
+            it("should set the correct scope for the interceptor function", function() {
+                expect(interceptorFn.calls[0].object).toBe(fakeScope);
+            });
+
+            it("should call the interceptor function first", function() {
+                expect(interceptedIsRunAfter).toBe(true);
+            });
+
+        });
+
+        describe("if the interceptor function returns false", function() {
+            it("should not execute the original function", function() {
+                interceptor = Ext.Function.createInterceptor(interceptedFn, function() {
+                    return false;
+                });
+
+                interceptor();
+                expect(interceptedFn).not.toHaveBeenCalled();
+            });
+        });
+    });
+    
+    describe("createDelayed", function() {
+       it("should create bind to the given function to be called after x milliseconds", function() {
+           mockTimeout();
+           var fn = jasmine.createSpy(),
+               delayedFn = Ext.Function.createDelayed(fn, 2);
+           
+           delayedFn('foo');
+           expect(timeouts.shift()).toBe(2);
+           
+           expect(fn).not.toHaveBeenCalled();
+           
+           runAfterInvocation(fn, function() {
+               expect(fn).toHaveBeenCalledWith('foo');
+           });
+           unmockTimeout();
+       });
+       it("should use the specified scope as 'this'", function() {
+           var scope = { x: 'foo' },
+               fn = jasmine.createSpy().andCallFake(function() { this.x = 'bar' }),
+               delayedFn = Ext.Function.createDelayed(fn, 2, scope);
+           delayedFn();
+           expect(fn).not.toHaveBeenCalled();
+           expect(scope.x).toBe('foo');
+           
+           runAfterInvocation(fn, function() {
+               expect(scope.x).toBe('bar');
+           });
+       });
+       it("should override the call arguments with the specified arguments", function() {
+           var scope = {},
+               args = [0, 1, 2],
+               fn = jasmine.createSpy(),
+               delayedFn = Ext.Function.createDelayed(fn, 2, scope, args);
+           delayedFn(3, 4, 5);
+           expect(fn).not.toHaveBeenCalled();
+           runAfterInvocation(fn, function() {
+               expect(fn).toHaveBeenCalledWith(0, 1, 2); 
+           });
+       });
+       it("should append the specified arguments to the call arguments when appendArgs is true", function() {
+           var scope = {},
+               args = [0, 1, 2],
+               fn = jasmine.createSpy(),
+               delayedFn = Ext.Function.createDelayed(fn, 2, scope, args, true);
+           delayedFn(3, 4, 5);
+           expect(fn).not.toHaveBeenCalled();
+           runAfterInvocation(fn, function() {
+               expect(fn).toHaveBeenCalledWith(3, 4, 5, 0, 1, 2); 
+           });
+       });
+       it("should insert the specified arguments into the call arguments at the position specified by appendArgs", function() {
+           var scope = {},
+           args = [0, 1, 2],
+           fn = jasmine.createSpy(),
+           delayedFn = Ext.Function.createDelayed(fn, 2, scope, args, 2);
+           delayedFn(3, 4, 5);
+           expect(fn).not.toHaveBeenCalled();
+           runAfterInvocation(fn, function() {
+               expect(fn).toHaveBeenCalledWith(3, 4, 0, 1, 2, 5); 
+           });
+       });
+    });
+
+    describe("defer", function() {
+        var fn;
+
+        beforeEach(function(){
+            fn = jasmine.createSpy("deferSpy");
+        });
+
+        it("should execute the function after the specified number of milliseconds", function() {
+            Ext.defer(fn, 10);
+
+            waitsFor(function(){
+                return fn.calls.length === 1;
+            }, "fn was never called");
+
+            runs(function() {
+                expect(fn).toHaveBeenCalled();
+            });
+        });
+
+        it("should execute the function directly if the specified number of milliseconds is <= 0", function() {
+            Ext.defer(fn, 0);
+
+            expect(fn).toHaveBeenCalled();
+        });
+
+        it("should set the correct scope", function() {
+            Ext.defer(fn, 10, fakeScope);
+
+            waitsFor(function(){
+                return fn.calls.length === 1;
+            }, "fn was never called");
+
+            runs(function() {
+                expect(fn.calls[0].object).toBe(fakeScope);
+            });
+        });
+
+        it("should pass the correct arguments", function() {
+            Ext.defer(fn, 10, this, [1, 2, 3]);
+
+            waitsFor(function(){
+                return fn.calls.length === 1;
+            }, "fn was never called");
+
+            runs(function() {
+                expect(fn).toHaveBeenCalledWith(1,2,3);
+            });
+        });
+
+        it("should return a timeout number", function() {
+            expect(typeof Ext.defer(function() {}, 10) === 'number').toBe(true);
+        });
+    });
+
+    describe("createSequence", function() {
+        var sequence,
+            newFn,
+            origFn,
+            origFnIsRunFirst,
+            newFnIsRunAfter;
+
+        beforeEach(function() {
+            origFnIsRunFirst = false;
+            newFnIsRunAfter = false;
+
+            origFn = jasmine.createSpy("interceptedSpy").andCallFake(function() {
+                origFnIsRunFirst = true;
+            });
+
+            newFn = jasmine.createSpy("sequenceSpy").andCallFake(function() {
+                newFnIsRunAfter = origFnIsRunFirst;
+            });
+        });
+
+        describe("if no function is passed", function() {
+            it("should return the same function", function() {
+                expect(Ext.Function.createSequence(origFn)).toEqual(origFn);
+            });
+        });
+
+        describe("if a function is passed", function() {
+            beforeEach(function() {
+                sequence = Ext.Function.createSequence(origFn, newFn, fakeScope);
+                sequence();
+            });
+
+            it("should return a new function", function() {
+                expect(typeof sequence === "function").toBe(true);
+                expect(sequence).not.toEqual(origFn);
+            });
+
+            it("should set the correct scope for the sequence function", function() {
+                expect(newFn.calls[0].object).toBe(fakeScope);
+            });
+
+            it("should call the sequence function first", function() {
+                expect(newFnIsRunAfter).toBe(true);
+            });
+
+        });
+    });
+    
+    describe("createBuffered", function() {
+        it("should prevent the execution of multiple calls of the buffered function within the timeout period", function() {
+            mockTimeout();
+            var fn = jasmine.createSpy(),
+                bufferedFn = Ext.Function.createBuffered(fn, 2);
+           
+            bufferedFn();
+            expect(timeouts.shift()).toBe(2);
+           
+            bufferedFn();
+            expect(clearedTimeoutIds.shift()).toBe(timeoutIds.shift());
+            expect(timeouts.shift()).toBe(2);
+           
+            expect(fn).not.toHaveBeenCalled();
+            runAfterInvocation(fn, function() {
+                expect(fn.calls.length).toBe(1);
+            });
+            
+            unmockTimeout();
+        });
+        it("should use the specified scope as 'this'", function() {
+            var scope = { x: 1 },
+                fn = jasmine.createSpy().andCallFake(function() { this.x++; }),
+                bufferedFn = Ext.Function.createBuffered(fn, 20, scope);
+            bufferedFn();
+            expect(scope.x).toBe(1);
+            bufferedFn();
+            runAfterInvocation(fn, function() {
+                expect(scope.x).toBe(2);
+            });
+        });
+        it("should override the call arguments with the specified ones", function() {
+            var scope = {},
+                args = ['bar1', 'bar2'],
+                fn = jasmine.createSpy(),
+                bufferedFn = Ext.Function.createBuffered(fn, 20, scope, args);
+            bufferedFn('foo1', 'foo2');
+            expect(fn).not.toHaveBeenCalled();
+            runAfterInvocation(fn, function() {
+                expect(fn).toHaveBeenCalledWith('bar1', 'bar2');
+            });
+        });
+    });
+    
+    describe("createThrottled", function() {
+        it("should execute only once per each specified time interval", function() {
+            mockTimeout();
+            var fn = jasmine.createSpy(),
+                throttledFn = Ext.Function.createThrottled(fn, 10);
+           
+            expect(fn).not.toHaveBeenCalled();
+            throttledFn();
+            expect(clearedTimeoutIds.shift()).toBeUndefined();
+            expect(fn.calls.length).toBe(1);
+            
+            throttledFn();
+            expect(timeouts.shift()).not.toBeGreaterThan(10);
+            expect(clearedTimeoutIds.shift()).toBeUndefined();
+            throttledFn();
+            expect(timeouts.shift()).not.toBeGreaterThan(10);
+            expect(clearedTimeoutIds.shift()).toBe(timeoutIds.shift());
+            throttledFn();
+            expect(timeouts.shift()).not.toBeGreaterThan(10);
+            expect(clearedTimeoutIds.shift()).toBe(timeoutIds.shift());
+            
+            expect(fn.calls.length).toBe(1);
+            runAfterInvocation(fn, function() {
+                expect(fn.calls.length).toEqual(2);
+                throttledFn(); // elapsed may have been exceeded here, so this call may execute immediately
+                expect(fn.calls.length).not.toBeLessThan(2);
+                expect(fn.calls.length).not.toBeGreaterThan(3);
+            }, 2);
+            unmockTimeout();
+        });
+        
+        it("should use the specified scope as 'this'", function() {
+            var scope = {},
+                fn = jasmine.createSpy().andCallFake(function(value) { this.x = value; }),
+                throttledFn = Ext.Function.createThrottled(fn, 10, scope);
+            
+            throttledFn('foo');
+            throttledFn('bar');
+            throttledFn('baz');
+            throttledFn('qux');
+            
+            expect(fn).toHaveBeenCalledWith('foo');
+            expect(scope.x).toBe('foo');
+            expect(fn.calls.length).toBe(1);
+        });
+    });
+    
+    describe("interceptAfter", function() {
+        it("should execute interceptor after each method call", function() {
+            var monologue = {
+                    phrases: [],
+                    addPhrase: function(phrase) {
+                        this.phrases.push(phrase)
+                    }
+                },
+                addMeToo = jasmine.createSpy().andCallFake(function(phrase) {
+                    this.phrases.push(phrase + ' too');
+                });
+                
+            Ext.Function.interceptAfter(monologue, 'addPhrase', addMeToo);
+            monologue.addPhrase('I like you');
+            monologue.addPhrase('I love you');
+            expect(monologue.phrases).toEqual(['I like you', 'I like you too', 'I love you', 'I love you too']);
+            expect(addMeToo).toHaveBeenCalledWith('I like you');
+            expect(addMeToo).toHaveBeenCalledWith('I love you');
+        });
+        
+        it("should execute interceptor after each method call with the specified scope as 'this'", function() {
+            var monologue = {
+                    phrases: [],
+                    addPhrase: function(phrase) {
+                        this.phrases.push(phrase)
+                    }
+                },
+                transcription = {
+                    phrases: []
+                },
+                transcriptPhrase = jasmine.createSpy().andCallFake(function(phrase) {
+                    this.phrases.push("He said: " + phrase);
+                });
+            
+            Ext.Function.interceptAfter(monologue, 'addPhrase', transcriptPhrase, transcription);
+            monologue.addPhrase('I like you');
+            monologue.addPhrase('I love you');
+            expect(monologue.phrases).toEqual(['I like you', 'I love you']);
+            expect(transcription.phrases).toEqual(['He said: I like you', 'He said: I love you']);
+            expect(transcriptPhrase).toHaveBeenCalledWith('I like you');
+            expect(transcriptPhrase).toHaveBeenCalledWith('I love you');
+        });
+    });
+});