Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-02-12 14:54
📄 bloodhound_spec.js describe('Bloodhound', function() { function build(o) { return new Bloodhound(_.mixin({ datumTokenizer: datumTokenizer, queryTokenizer: queryTokenizer }, o \|\| {})); } beforeEach(function() { jasmine.Remote.useMock(); jasmine.Prefetch.useMock(); jasmine.Transport.useMock(); jasmine.PersistentStorage.useMock(); }); afterEach(function() { clearAjaxRequests(); }); describe('#initialize', function() { beforeEach(function() { this.bloodhound = build({ initialize: false }); spyOn(this.bloodhound, '_initialize').andCallThrough(); }); it('should not initialize if intialize option is false', function() { expect(this.bloodhound._initialize).not.toHaveBeenCalled(); }); it('should not support reinitialization by default', function() { var p1, p2; p1 = this.bloodhound.initialize(); p2 = this.bloodhound.initialize(); expect(p1).toBe(p2); expect(this.bloodhound._initialize.callCount).toBe(1); }); it('should reinitialize if reintialize flag is true', function() { var p1, p2; p1 = this.bloodhound.initialize(); p2 = this.bloodhound.initialize(true); expect(p1).not.toBe(p2); expect(this.bloodhound._initialize.callCount).toBe(2); }); it('should clear the index', function() { this.bloodhound = build({ initialize: false, prefetch: '/prefetch' }); spyOn(this.bloodhound, 'clear'); this.bloodhound.initialize(); expect(this.bloodhound.clear).toHaveBeenCalled(); }); it('should load data from prefetch cache if available', function() { this.bloodhound = build({ initialize: false, prefetch: '/prefetch' }); this.bloodhound.prefetch.fromCache.andReturn(fixtures.serialized.simple); this.bloodhound.initialize(); expect(this.bloodhound.all()).toEqual(fixtures.data.simple); expect(this.bloodhound.prefetch.fromNetwork).not.toHaveBeenCalled(); }); it('should load data from prefetch network as fallback', function() { this.bloodhound = build({ initialize: false, prefetch: '/prefetch' }); this.bloodhound.prefetch.fromCache.andReturn(null); this.bloodhound.prefetch.fromNetwork.andCallFake(fakeFromNetwork); this.bloodhound.initialize(); expect(this.bloodhound.all()).toEqual(fixtures.data.simple); function fakeFromNetwork(cb) { cb(null, fixtures.data.simple); } }); it('should store prefetch network data in the prefetch cache', function() { this.bloodhound = build({ initialize: false, prefetch: '/prefetch' }); this.bloodhound.prefetch.fromCache.andReturn(null); this.bloodhound.prefetch.fromNetwork.andCallFake(fakeFromNetwork); this.bloodhound.initialize(); expect(this.bloodhound.prefetch.store) .toHaveBeenCalledWith(fixtures.serialized.simple); function fakeFromNetwork(cb) { cb(null, fixtures.data.simple); } }); it('should add local after prefetch is loaded', function() { this.bloodhound = build({ initialize: false, local: [{ foo: 'bar' }], prefetch: '/prefetch' }); this.bloodhound.prefetch.fromNetwork.andCallFake(fakeFromNetwork); expect(this.bloodhound.all()).toEqual([]); this.bloodhound.initialize(); expect(this.bloodhound.all()).toEqual([{ foo: 'bar' }]); function fakeFromNetwork(cb) { cb(null, []); } }); }); describe('#add', function() { it('should add datums to search index', function() { var spy = jasmine.createSpy(); this.bloodhound = build().add(fixtures.data.simple); this.bloodhound.search('big', spy); expect(spy).toHaveBeenCalledWith([ { value: 'big' }, { value: 'bigger' }, { value: 'biggest' } ]); }); }); describe('#get', function() { beforeEach(function() { this.bloodhound = build({ identify: function(d) { return d.value; }, local: fixtures.data.simple }); }); it('should support array signature', function() { expect(this.bloodhound.get(['big', 'bigger'])).toEqual([ { value: 'big' }, { value: 'bigger' } ]); }); it('should support splat signature', function() { expect(this.bloodhound.get('big', 'bigger')).toEqual([ { value: 'big' }, { value: 'bigger' } ]); }); it('should return nothing for unknown ids', function() { expect(this.bloodhound.get('big', 'foo', 'bigger')).toEqual([ { value: 'big' }, { value: 'bigger' } ]); }); }); describe('#clear', function() { it('should remove all datums to search index', function() { var spy = jasmine.createSpy(); this.bloodhound = build({ local: fixtures.data.simple }).clear(); this.bloodhound.search('big', spy); expect(spy).toHaveBeenCalledWith([]); }); }); describe('#clearPrefetchCache', function() { it('should clear persistent storage', function() { this.bloodhound = build({ prefetch: '/prefetch' }).clearPrefetchCache(); expect(this.bloodhound.prefetch.clear).toHaveBeenCalled(); }); }); describe('#clearRemoteCache', function() { it('should clear remote request cache', function() { spyOn(Transport, 'resetCache'); this.bloodhound = build({ remote: '/remote' }).clearRemoteCache(); expect(Transport.resetCache).toHaveBeenCalled(); }); }); describe('#all', function() { it('should return all local results', function() { this.bloodhound = build({ local: fixtures.data.simple }); expect(this.bloodhound.all()).toEqual(fixtures.data.simple); }); }); describe('#search – local', function() { it('should return sync matches', function() { var spy = jasmine.createSpy(); this.bloodhound = build({ local: fixtures.data.simple }); this.bloodhound.search('big', spy); expect(spy).toHaveBeenCalledWith([ { value: 'big' }, { value: 'bigger' }, { value: 'biggest' } ]); }); }); describe('#search – prefetch', function() { it('should return sync matches', function() { var spy = jasmine.createSpy(); this.bloodhound = build({ initialize: false, prefetch: '/prefetch' }); this.bloodhound.prefetch.fromCache.andReturn(fixtures.serialized.simple); this.bloodhound.initialize(); this.bloodhound.search('big', spy); expect(spy).toHaveBeenCalledWith([ { value: 'big' }, { value: 'bigger' }, { value: 'biggest' } ]); }); }); describe('#search – remote', function() { it('should return async matches', function() { var spy = jasmine.createSpy(); this.bloodhound = build({ remote: '/remote' }); this.bloodhound.remote.get.andCallFake(fakeGet); this.bloodhound.search('dog', $.noop, spy); expect(spy.callCount).toBe(1); function fakeGet(o, cb) { cb(fixtures.data.animals); } }); }); describe('#search – integration', function() { it('should backfill when local/prefetch is not sufficient', function() { var syncSpy, asyncSpy; syncSpy = jasmine.createSpy(); asyncSpy = jasmine.createSpy(); this.bloodhound = build({ sufficient: 3, local: fixtures.data.simple, remote: '/remote' }); this.bloodhound.remote.get.andCallFake(fakeGet); this.bloodhound.search('big', syncSpy, asyncSpy); expect(syncSpy).toHaveBeenCalledWith([ { value: 'big' }, { value: 'bigger' }, { value: 'biggest' } ]); expect(asyncSpy).not.toHaveBeenCalled(); this.bloodhound.search('bigg', syncSpy, asyncSpy); expect(syncSpy).toHaveBeenCalledWith([ { value: 'bigger' }, { value: 'biggest' } ]); expect(asyncSpy).toHaveBeenCalledWith(fixtures.data.animals); function fakeGet(o, cb) { cb(fixtures.data.animals); } }); it('should remove duplicates from backfill', function() { var syncSpy, asyncSpy; syncSpy = jasmine.createSpy(); asyncSpy = jasmine.createSpy(); this.bloodhound = build({ identify: function(d) { return d.value; }, local: fixtures.data.animals, remote: '/remote' }); this.bloodhound.remote.get.andCallFake(fakeGet); this.bloodhound.search('dog', syncSpy, asyncSpy); expect(syncSpy).toHaveBeenCalledWith([{ value: 'dog' }]); expect(asyncSpy).toHaveBeenCalledWith([ { value: 'cat' }, { value: 'moose' } ]); function fakeGet(o, cb) { cb(fixtures.data.animals); } }); }); // helper functions // ---------------- function datumTokenizer(d) { return $.trim(d.value).split(/\s+/); } function queryTokenizer(s) { return $.trim(s).split(/\s+/); } });	8.67 KB	2026-02-12 14:54
📄 lru_cache_spec.js describe('LruCache', function() { beforeEach(function() { this.cache = new LruCache(3); }); it('should make entries retrievable by their keys', function() { var key = 'key', val = 42; this.cache.set(key, val); expect(this.cache.get(key)).toBe(val); }); it('should return undefined if key has not been set', function() { expect(this.cache.get('wat?')).toBeUndefined(); }); it('should hold up to maxSize entries', function() { this.cache.set('one', 1); this.cache.set('two', 2); this.cache.set('three', 3); this.cache.set('four', 4); expect(this.cache.get('one')).toBeUndefined(); expect(this.cache.get('two')).toBe(2); expect(this.cache.get('three')).toBe(3); expect(this.cache.get('four')).toBe(4); }); it('should evict lru entry if cache is full', function() { this.cache.set('one', 1); this.cache.set('two', 2); this.cache.set('three', 3); this.cache.get('one'); this.cache.set('four', 4); expect(this.cache.get('one')).toBe(1); expect(this.cache.get('two')).toBeUndefined(); expect(this.cache.get('three')).toBe(3); expect(this.cache.get('four')).toBe(4); expect(this.cache.size).toBe(3); }); });	1.19 KB	2026-02-12 14:54
📄 options_parser_spec.js describe('options parser', function() { function build(o) { return oParser(_.mixin({ datumTokenizer: $.noop, queryTokenizer: $.noop }, o \|\| {})); } function prefetch(o) { return oParser({ datumTokenizer: $.noop, queryTokenizer: $.noop, prefetch: _.mixin({ url: '/example' }, o \|\| {}) }); } function remote(o) { return oParser({ datumTokenizer: $.noop, queryTokenizer: $.noop, remote: _.mixin({ url: '/example' }, o \|\| {}) }); } it('should throw exception if datumTokenizer is not set', function() { expect(parse).toThrow(); function parse() { build({ datumTokenizer: null }); } }); it('should throw exception if queryTokenizer is not set', function() { expect(parse).toThrow(); function parse() { build({ queryTokenizer: null }); } }); it('should wrap sorter', function() { var o = build({ sorter: function(a, b) { return a -b; } }); expect(o.sorter([2, 1, 3])).toEqual([1, 2, 3]); }); it('should default sorter to identity function', function() { var o = build(); expect(o.sorter([2, 1, 3])).toEqual([2, 1, 3]); }); describe('local', function() { it('should default to empty array', function() { var o = build(); expect(o.local).toEqual([]); }); it('should support function', function() { var o = build({ local: function() { return [1]; } }); expect(o.local).toEqual([1]); }); it('should support arrays', function() { var o = build({ local: [1] }); expect(o.local).toEqual([1]); }); }); describe('prefetch', function() { it('should throw exception if url is not set', function() { expect(parse).toThrow(); function parse() { prefetch({ url: null }); } }); it('should support simple string format', function() { expect(build({ prefetch: '/prefetch' }).prefetch).toBeDefined(); }); it('should default ttl to 1 day', function() { var o = prefetch(); expect(o.prefetch.ttl).toBe(86400000); }); it('should default cache to true', function() { var o = prefetch(); expect(o.prefetch.cache).toBe(true); }); it('should default transform to identiy function', function() { var o = prefetch(); expect(o.prefetch.transform('foo')).toBe('foo'); }); it('should default cacheKey to url', function() { var o = prefetch(); expect(o.prefetch.cacheKey).toBe(o.prefetch.url); }); it('should default transport to jQuery.ajax', function() { var o = prefetch(); expect(o.prefetch.transport).toBe($.ajax); }); it('should prepend verison to thumbprint', function() { var o = prefetch(); expect(o.prefetch.thumbprint).toBe('%VERSION%'); o = prefetch({ thumbprint: 'foo' }); expect(o.prefetch.thumbprint).toBe('%VERSION%foo'); }); it('should wrap custom transport to be deferred compatible', function() { var o, errDeferred, successDeferred; o = prefetch({ transport: errTransport }); errDeferred = o.prefetch.transport('q'); o = prefetch({ transport: successTransport }); successDeferred = o.prefetch.transport('q'); waits(0); runs(function() { expect(errDeferred.isRejected()).toBe(true); expect(successDeferred.isResolved()).toBe(true); }); function errTransport(q, success, error) { error(); } function successTransport(q, success, error) { success(); } }); }); describe('remote', function() { it('should throw exception if url is not set', function() { expect(parse).toThrow(); function parse() { remote({ url: null }); } }); it('should support simple string format', function() { expect(build({ remote: '/remote' }).remote).toBeDefined(); }); it('should default transform to identiy function', function() { var o = remote(); expect(o.remote.transform('foo')).toBe('foo'); }); it('should default transport to jQuery.ajax', function() { var o = remote(); expect(o.remote.transport).toBe($.ajax); }); it('should default limiter to debouce', function() { var o = remote(); expect(o.remote.limiter.name).toBe('debounce'); }); it('should default prepare to identity function', function() { var o = remote(); expect(o.remote.prepare('q', { url: '/foo' })).toEqual({ url: '/foo' }); }); it('should support wildcard for prepare', function() { var o = remote({ wildcard: '%FOO' }); expect(o.remote.prepare('=', { url: '/%FOO' })).toEqual({ url: '/%3D' }); }); it('should support replace for prepare', function() { var o = remote({ replace: function() { return '/bar'; } }); expect(o.remote.prepare('q', { url: '/foo' })).toEqual({ url: '/bar' }); }); it('should should rateLimitBy for limiter', function() { var o = remote({ rateLimitBy: 'throttle' }); expect(o.remote.limiter.name).toBe('throttle'); }); it('should wrap custom transport to be deferred compatible', function() { var o, errDeferred, successDeferred; o = remote({ transport: errTransport }); errDeferred = o.remote.transport('q'); o = remote({ transport: successTransport }); successDeferred = o.remote.transport('q'); waits(0); runs(function() { expect(errDeferred.isRejected()).toBe(true); expect(successDeferred.isResolved()).toBe(true); }); function errTransport(q, success, error) { error(); } function successTransport(q, success, error) { success(); } }); }); });	5.55 KB	2026-02-12 14:54
📄 persistent_storage_spec.js describe('PersistentStorage', function() { var engine, ls; // test suite is dependent on localStorage being available if (!window.localStorage) { console.warn('no localStorage support – skipping PersistentStorage suite'); return; } // for good measure! localStorage.clear(); beforeEach(function() { ls = { get length() { return localStorage.length; }, key: spyThrough('key'), clear: spyThrough('clear'), getItem: spyThrough('getItem'), setItem: spyThrough('setItem'), removeItem: spyThrough('removeItem') }; engine = new PersistentStorage('ns', ls); spyOn(Date.prototype, 'getTime').andReturn(0); }); afterEach(function() { localStorage.clear(); }); // public methods // -------------- describe('#get', function() { it('should access localStorage with prefixed key', function() { engine.get('key'); expect(ls.getItem).toHaveBeenCalledWith('__ns__key'); }); it('should return undefined when key does not exist', function() { expect(engine.get('does not exist')).toEqual(undefined); }); it('should return value as correct type', function() { engine.set('string', 'i am a string'); engine.set('number', 42); engine.set('boolean', true); engine.set('null', null); engine.set('object', { obj: true }); expect(engine.get('string')).toEqual('i am a string'); expect(engine.get('number')).toEqual(42); expect(engine.get('boolean')).toEqual(true); expect(engine.get('null')).toBeNull(); expect(engine.get('object')).toEqual({ obj: true }); }); it('should expire stale keys', function() { engine.set('key', 'value', -1); expect(engine.get('key')).toBeNull(); expect(ls.getItem('__ns__key__ttl')).toBeNull(); }); }); describe('#set', function() { it('should access localStorage with prefixed key', function() { engine.set('key', 'val'); expect(ls.setItem.mostRecentCall.args[0]).toEqual('__ns__key'); }); it('should JSON.stringify value before storing', function() { engine.set('key', 'val'); expect(ls.setItem.mostRecentCall.args[1]).toEqual(JSON.stringify('val')); }); it('should store ttl if provided', function() { var ttl = 1; engine.set('key', 'value', ttl); expect(ls.setItem.argsForCall[0]) .toEqual(['__ns__key__ttl__', ttl.toString()]); }); it('should call clear if the localStorage limit has been reached', function() { var spy; ls.setItem.andCallFake(function() { var err = new Error(); err.name = 'QuotaExceededError'; throw err; }); engine.clear = spy = jasmine.createSpy(); engine.set('key', 'value', 1); expect(spy).toHaveBeenCalled(); }); it('should noop if the localStorage limit has been reached', function() { var get, set, remove, clear, isExpired; ls.setItem.andCallFake(function() { var err = new Error(); err.name = 'QuotaExceededError'; throw err; }); get = engine.get; set = engine.set; remove = engine.remove; clear = engine.clear; isExpired = engine.isExpired; engine.set('key', 'value', 1); expect(engine.get).not.toBe(get); expect(engine.set).not.toBe(set); expect(engine.remove).not.toBe(remove); expect(engine.clear).not.toBe(clear); expect(engine.isExpired).not.toBe(isExpired); }); }); describe('#remove', function() { it('should remove key from storage', function() { engine.set('key', 'val'); engine.remove('key'); expect(engine.get('key')).toBeNull(); }); }); describe('#clear', function() { it('should work with namespaces that contain regex characters', function() { engine = new PersistentStorage('ns?()'); engine.set('key1', 'val1'); engine.set('key2', 'val2'); engine.clear(); expect(engine.get('key1')).toEqual(undefined); expect(engine.get('key2')).toEqual(undefined); }); it('should remove all keys that exist in namespace of engine', function() { engine.set('key1', 'val1'); engine.set('key2', 'val2'); engine.set('key3', 'val3'); engine.set('key4', 'val4', 0); engine.clear(); expect(engine.get('key1')).toEqual(undefined); expect(engine.get('key2')).toEqual(undefined); expect(engine.get('key3')).toEqual(undefined); expect(engine.get('key4')).toEqual(undefined); }); it('should not affect keys with different namespace', function() { ls.setItem('diff_namespace', 'val'); engine.clear(); expect(ls.getItem('diff_namespace')).toEqual('val'); }); }); describe('#isExpired', function() { it('should be false for keys without ttl', function() { engine.set('key', 'value'); expect(engine.isExpired('key')).toBe(false); }); it('should be false for fresh keys', function() { engine.set('key', 'value', 1); expect(engine.isExpired('key')).toBe(false); }); it('should be true for stale keys', function() { engine.set('key', 'value', -1); expect(engine.isExpired('key')).toBe(true); }); }); // compatible across browsers function spyThrough(method) { return jasmine.createSpy().andCallFake(fake); function fake() { return localStorage[method].apply(localStorage, arguments); } } });	5.36 KB	2026-02-12 14:54
📄 prefetch_spec.js describe('Prefetch', function() { function build(o) { return new Prefetch(_.mixin({ url: '/prefetch', ttl: 3600, cache: true, thumbprint: '', cacheKey: 'cachekey', prepare: function(x) { return x; }, transform: function(x) { return x; }, transport: $.ajax }, o \|\| {})); } beforeEach(function() { jasmine.PersistentStorage.useMock(); this.prefetch = build(); this.storage = this.prefetch.storage; this.thumbprint = this.prefetch.thumbprint; }); describe('#clear', function() { it('should clear cache storage', function() { this.prefetch.clear(); expect(this.storage.clear).toHaveBeenCalled(); }); }); describe('#store', function() { it('should store data in the storage cache', function() { this.prefetch.store({ foo: 'bar' }); expect(this.storage.set) .toHaveBeenCalledWith('data', { foo: 'bar' }, 3600); }); it('should store thumbprint in the storage cache', function() { this.prefetch.store({ foo: 'bar' }); expect(this.storage.set) .toHaveBeenCalledWith('thumbprint', jasmine.any(String), 3600); }); it('should store protocol in the storage cache', function() { this.prefetch.store({ foo: 'bar' }); expect(this.storage.set) .toHaveBeenCalledWith('protocol', location.protocol, 3600); }); it('should be noop if cache option is false', function() { this.prefetch = build({ cache: false }); this.prefetch.store({ foo: 'bar' }); expect(this.storage.set).not.toHaveBeenCalled(); }); }); describe('#fromCache', function() { it('should return data if available', function() { this.storage.get .andCallFake(fakeStorageGet({ foo: 'bar' }, this.thumbprint)); expect(this.prefetch.fromCache()).toEqual({ foo: 'bar' }); }); it('should return null if data is expired', function() { this.storage.get .andCallFake(fakeStorageGet({ foo: 'bar' }, 'foo')); expect(this.prefetch.fromCache()).toBeNull(); }); it('should return null if data does not exist', function() { this.storage.get .andCallFake(fakeStorageGet(null, this.thumbprint)); expect(this.prefetch.fromCache()).toBeNull(); }); it('should return null if cache option is false', function() { this.prefetch = build({ cache: false }); this.storage.get .andCallFake(fakeStorageGet({ foo: 'bar' }, this.thumbprint)); expect(this.prefetch.fromCache()).toBeNull(); expect(this.storage.get).not.toHaveBeenCalled(); }); }); describe('#fromNetwork', function() { it('should have sensible default request settings', function() { var spy; spy = jasmine.createSpy(); spyOn(this.prefetch, 'transport').andReturn($.Deferred()); this.prefetch.fromNetwork(spy); expect(this.prefetch.transport).toHaveBeenCalledWith({ url: '/prefetch', type: 'GET', dataType: 'json' }); }); it('should transform request settings with prepare', function() { var spy; spy = jasmine.createSpy(); spyOn(this.prefetch, 'prepare').andReturn({ foo: 'bar' }); spyOn(this.prefetch, 'transport').andReturn($.Deferred()); this.prefetch.fromNetwork(spy); expect(this.prefetch.transport).toHaveBeenCalledWith({ foo: 'bar' }); }); it('should transform the response using transform', function() { var spy; this.prefetch = build({ transform: function() { return { bar: 'foo' }; } }); spy = jasmine.createSpy(); spyOn(this.prefetch, 'transport') .andReturn($.Deferred().resolve({ foo: 'bar' })); this.prefetch.fromNetwork(spy); expect(spy).toHaveBeenCalledWith(null, { bar: 'foo' }); }); it('should invoke callback with data if success', function() { var spy; spy = jasmine.createSpy(); spyOn(this.prefetch, 'transport') .andReturn($.Deferred().resolve({ foo: 'bar' })); this.prefetch.fromNetwork(spy); expect(spy).toHaveBeenCalledWith(null, { foo: 'bar' }); }); it('should invoke callback with err argument true if failure', function() { var spy; spy = jasmine.createSpy(); spyOn(this.prefetch, 'transport').andReturn($.Deferred().reject()); this.prefetch.fromNetwork(spy); expect(spy).toHaveBeenCalledWith(true); }); }); function fakeStorageGet(data, thumbprint, protocol) { return function(key) { var val; switch (key) { case 'data': val = data; break; case 'protocol': val = protocol \|\| location.protocol; break; case 'thumbprint': val = thumbprint; break; } return val; }; } });	4.72 KB	2026-02-12 14:54
📄 remote_spec.js describe('Remote', function() { beforeEach(function() { jasmine.Transport.useMock(); this.remote = new Remote({ url: '/test?q=%QUERY', prepare: function(x) { return x; }, transform: function(x) { return x; } }); this.transport = this.remote.transport; }); describe('#cancelLastRequest', function() { it('should cancel last request', function() { this.remote.cancelLastRequest(); expect(this.transport.cancel).toHaveBeenCalled(); }); }); describe('#get', function() { it('should have sensible default request settings', function() { var spy; spy = jasmine.createSpy(); spyOn(this.remote, 'prepare'); this.remote.get('foo', spy); expect(this.remote.prepare).toHaveBeenCalledWith('foo', { url: '/test?q=%QUERY', type: 'GET', dataType: 'json' }); }); it('should transform request settings with prepare', function() { var spy; spy = jasmine.createSpy(); spyOn(this.remote, 'prepare').andReturn([{ foo: 'bar' }]); this.remote.get('foo', spy); expect(this.transport.get) .toHaveBeenCalledWith([{ foo: 'bar' }], jasmine.any(Function)); }); it('should transform response with transform', function() { var spy; spy = jasmine.createSpy(); spyOn(this.remote, 'transform').andReturn([{ foo: 'bar' }]); this.transport.get.andCallFake(function(_, cb) { cb(null, {}); }); this.remote.get('foo', spy); expect(spy).toHaveBeenCalledWith([{ foo: 'bar' }]); }); it('should return empty array on error', function() { var spy; spy = jasmine.createSpy(); this.transport.get.andCallFake(function(_, cb) { cb(true); }); this.remote.get('foo', spy); expect(spy).toHaveBeenCalledWith([]); }); }); });	1.81 KB	2026-02-12 14:54
📄 search_index_spec.js describe('SearchIndex', function() { function build(o) { return new SearchIndex(_.mixin({ datumTokenizer: Bloodhound.tokenizers.obj.whitespace('value'), queryTokenizer: Bloodhound.tokenizers.whitespace }, o \|\| {})); } beforeEach(function() { this.index = build(); this.index.add(fixtures.data.simple); }); it('should support serialization/deserialization', function() { var serialized = this.index.serialize(); this.index.bootstrap(serialized); expect(this.index.search('smaller')).toEqual([{ value: 'smaller' }]); }); it('should be able to add data on the fly', function() { this.index.add({ value: 'new' }); expect(this.index.search('new')).toEqual([{ value: 'new' }]); }); it('#get should return datums by id', function() { this.index = build({ identify: function(d) { return d.value; } }); this.index.add(fixtures.data.simple); expect(this.index.get(['big', 'bigger'])).toEqual([ { value: 'big' }, { value: 'bigger' } ]); }); it('#search should return datums that match the given query', function() { expect(this.index.search('big')).toEqual([ { value: 'big' }, { value: 'bigger' }, { value: 'biggest' } ]); expect(this.index.search('small')).toEqual([ { value: 'small' }, { value: 'smaller' }, { value: 'smallest' } ]); }); it('#search should return an empty array of there are no matches', function() { expect(this.index.search('wtf')).toEqual([]); }); it('#serach should handle multi-token queries', function() { this.index.add({ value: 'foo bar' }); expect(this.index.search('foo b')).toEqual([{ value: 'foo bar' }]); }); it('#all should return all datums', function() { expect(this.index.all()).toEqual(fixtures.data.simple); }); it('#reset should empty the search index', function() { this.index.reset(); expect(this.index.datums).toEqual([]); expect(this.index.trie.i).toEqual([]); expect(this.index.trie.c).toEqual({}); }); });	2.01 KB	2026-02-12 14:54
📄 tokenizers_spec.js describe('tokenizers', function() { it('.whitespace should tokenize on whitespace', function() { var tokens = tokenizers.whitespace('big-deal ok'); expect(tokens).toEqual(['big-deal', 'ok']); }); it('.whitespace should treat null as empty string', function() { var tokens = tokenizers.whitespace(null); expect(tokens).toEqual([]); }); it('.whitespace should treat undefined as empty string', function() { var tokens = tokenizers.whitespace(undefined); expect(tokens).toEqual([]); }); it('.nonword should tokenize on non-word characters', function() { var tokens = tokenizers.nonword('big-deal ok'); expect(tokens).toEqual(['big', 'deal', 'ok']); }); it('.nonword should treat null as empty string', function() { var tokens = tokenizers.nonword(null); expect(tokens).toEqual([]); }); it('.nonword should treat undefined as empty string', function() { var tokens = tokenizers.nonword(undefined); expect(tokens).toEqual([]); }); it('.obj.whitespace should tokenize on whitespace', function() { var t = tokenizers.obj.whitespace('val'); var tokens = t({ val: 'big-deal ok' }); expect(tokens).toEqual(['big-deal', 'ok']); }); it('.obj.whitespace should accept multiple properties', function() { var t = tokenizers.obj.whitespace('one', 'two'); var tokens = t({ one: 'big-deal ok', two: 'buzz' }); expect(tokens).toEqual(['big-deal', 'ok', 'buzz']); }); it('.obj.whitespace should accept array', function() { var t = tokenizers.obj.whitespace(['one', 'two']); var tokens = t({ one: 'big-deal ok', two: 'buzz' }); expect(tokens).toEqual(['big-deal', 'ok', 'buzz']); }); it('.obj.nonword should tokenize on non-word characters', function() { var t = tokenizers.obj.nonword('val'); var tokens = t({ val: 'big-deal ok' }); expect(tokens).toEqual(['big', 'deal', 'ok']); }); it('.obj.nonword should accept multiple properties', function() { var t = tokenizers.obj.nonword('one', 'two'); var tokens = t({ one: 'big-deal ok', two: 'buzz' }); expect(tokens).toEqual(['big', 'deal', 'ok', 'buzz']); }); it('.obj.nonword should accept array', function() { var t = tokenizers.obj.nonword(['one', 'two']); var tokens = t({ one: 'big-deal ok', two: 'buzz' }); expect(tokens).toEqual(['big', 'deal', 'ok', 'buzz']); }); });	2.33 KB	2026-02-12 14:54
📄 transport_spec.js describe('Transport', function() { beforeEach(function() { jasmine.Ajax.useMock(); jasmine.Clock.useMock(); this.transport = new Transport({ transport: $.ajax }); }); afterEach(function() { // run twice to flush out on-deck requests $.each(ajaxRequests, drop); $.each(ajaxRequests, drop); clearAjaxRequests(); Transport.resetCache(); function drop(i, req) { req.readyState !== 4 && req.response(fixtures.ajaxResps.ok); } }); it('should use jQuery.ajax as the default transport mechanism', function() { var req, resp = fixtures.ajaxResps.ok, spy = jasmine.createSpy(); this.transport.get('/test', spy); req = mostRecentAjaxRequest(); req.response(resp); expect(req.url).toBe('/test'); expect(spy).toHaveBeenCalledWith(null, resp.parsed); }); it('should respect maxPendingRequests configuration', function() { for (var i = 0; i < 10; i++) { this.transport.get('/test' + i, $.noop); } expect(ajaxRequests.length).toBe(6); }); it('should support rate limiting', function() { this.transport = new Transport({ transport: $.ajax, limiter: limiter }); for (var i = 0; i < 5; i++) { this.transport.get('/test' + i, $.noop); } jasmine.Clock.tick(100); expect(ajaxRequests.length).toBe(1); function limiter(fn) { return _.debounce(fn, 20); } }); it('should cache most recent requests', function() { var spy1 = jasmine.createSpy(), spy2 = jasmine.createSpy(); this.transport.get('/test1', $.noop); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); this.transport.get('/test2', $.noop); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok1); expect(ajaxRequests.length).toBe(2); this.transport.get('/test1', spy1); this.transport.get('/test2', spy2); jasmine.Clock.tick(0); // no ajax requests were made on subsequent requests expect(ajaxRequests.length).toBe(2); expect(spy1).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed); expect(spy2).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok1.parsed); }); it('should not cache requests if cache option is false', function() { this.transport = new Transport({ transport: $.ajax, cache: false }); this.transport.get('/test1', $.noop); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); this.transport.get('/test1', $.noop); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); expect(ajaxRequests.length).toBe(2); }); it('should prevent dog pile', function() { var spy1 = jasmine.createSpy(), spy2 = jasmine.createSpy(); this.transport.get('/test1', spy1); this.transport.get('/test1', spy2); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); expect(ajaxRequests.length).toBe(1); waitsFor(function() { return spy1.callCount && spy2.callCount; }); runs(function() { expect(spy1).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed); expect(spy2).toHaveBeenCalledWith(null, fixtures.ajaxResps.ok.parsed); }); }); it('should always make a request for the last call to #get', function() { var spy = jasmine.createSpy(); for (var i = 0; i < 6; i++) { this.transport.get('/test' + i, $.noop); } this.transport.get('/test' + i, spy); expect(ajaxRequests.length).toBe(6); _.each(ajaxRequests, function(req) { req.response(fixtures.ajaxResps.ok); }); expect(ajaxRequests.length).toBe(7); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); expect(spy).toHaveBeenCalled(); }); it('should invoke the callback with err set to true on failure', function() { var req, resp = fixtures.ajaxResps.err, spy = jasmine.createSpy(); this.transport.get('/test', spy); req = mostRecentAjaxRequest(); req.response(resp); expect(req.url).toBe('/test'); expect(spy).toHaveBeenCalledWith(true); }); it('should not send cancelled requests', function() { this.transport = new Transport({ transport: $.ajax, limiter: limiter }); this.transport.get('/test', $.noop); this.transport.cancel(); jasmine.Clock.tick(100); expect(ajaxRequests.length).toBe(0); function limiter(fn) { return _.debounce(fn, 20); } }); it('should not send outdated requests', function() { this.transport = new Transport({ transport: $.ajax, limiter: limiter }); // warm cache this.transport.get('/test1', $.noop); jasmine.Clock.tick(100); mostRecentAjaxRequest().response(fixtures.ajaxResps.ok); expect(mostRecentAjaxRequest().url).toBe('/test1'); expect(ajaxRequests.length).toBe(1); // within the same rate-limit cycle, request test2 and test1. test2 becomes // outdated after test1 is requested and no request is sent for test1 // because it's a cache hit this.transport.get('/test2', $.noop); this.transport.get('/test1', $.noop); jasmine.Clock.tick(100); expect(ajaxRequests.length).toBe(1); function limiter(fn) { return _.debounce(fn, 20); } }); });	4.96 KB	2026-02-12 14:54

Terminal