add extjs 6.0.1 sources

[extjs.git] / extjs / packages / core / test / specs / lang / Function.js

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