| // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| // use this file except in compliance with the License. You may obtain a copy of |
| // the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| // License for the specific language governing permissions and limitations under |
| // the License. |
| define([ |
| 'api', |
| 'addons/activetasks/resources', |
| 'addons/activetasks/stores', |
| 'addons/activetasks/tests/fakeActiveTaskResponse', |
| 'react', |
| 'testUtils' |
| ], function (FauxtonAPI, ActiveTasks, Stores, fakedResponse, React, utils) { |
| var assert = utils.assert; |
| var restore = utils.restore; |
| var TestUtils = React.addons.TestUtils; |
| |
| var activeTasksStore = Stores.activeTasksStore; |
| var activeTasksCollection = new ActiveTasks.AllTasks(); |
| activeTasksCollection.parse(fakedResponse); |
| |
| describe('Active Tasks -- Stores', function () { |
| var spy, clock; |
| |
| beforeEach(function () { |
| activeTasksStore.initAfterFetching(activeTasksCollection.table, activeTasksCollection); |
| clock = sinon.useFakeTimers(); |
| }); |
| |
| afterEach(function () { |
| restore(spy); |
| restore(clock); |
| }); |
| |
| describe('Active Task Stores - Polling', function () { |
| var pollingWidgetDiv, pollingWidget; |
| |
| beforeEach(function () { |
| activeTasksStore.initAfterFetching(activeTasksCollection.table, activeTasksCollection); |
| clock = sinon.useFakeTimers(); |
| }); |
| |
| afterEach(function () { |
| restore(activeTasksStore.getPollingInterval); |
| restore(window.clearInterval); |
| restore(clock); |
| }); |
| |
| it('should poll at the min time', function () { |
| spy = sinon.spy(activeTasksStore, 'getPollingInterval'); |
| var minTime = 1; |
| activeTasksStore.setPollingInterval(minTime); |
| activeTasksStore.setPolling(); |
| assert.ok(spy.calledOnce); |
| |
| setInterval(spy, minTime * 1000); |
| clock.tick(minTime * 1000); |
| assert.ok(spy.calledTwice); |
| |
| clock.tick(minTime * 1000); |
| assert.ok(spy.calledThrice); |
| }); |
| |
| it('should poll at the max time', function () { |
| spy = sinon.spy(activeTasksStore, 'getPollingInterval'); |
| |
| var maxTime = 30; |
| activeTasksStore.setPollingInterval(maxTime); |
| activeTasksStore.setPolling(); |
| assert.ok(spy.calledOnce); |
| |
| setInterval(spy, maxTime * 1000); |
| clock.tick(maxTime * 1000); |
| assert.ok(spy.calledTwice); |
| |
| clock.tick(maxTime * 1000); |
| assert.ok(spy.calledThrice); |
| }); |
| |
| it('should poll at a mid time', function () { |
| spy = sinon.spy(activeTasksStore, 'getPollingInterval'); |
| |
| var midtime = 15; |
| activeTasksStore.setPollingInterval(midtime); |
| activeTasksStore.setPolling(); |
| assert.ok(spy.calledOnce); |
| |
| setInterval(spy, midtime * 1000); |
| clock.tick(midtime * 1000); |
| assert.ok(spy.calledTwice); |
| |
| clock.tick(midtime * 1000); |
| assert.ok(spy.calledThrice); |
| }); |
| |
| it('should clear interval each time', function () { |
| var spy = sinon.spy(window, 'clearInterval'); |
| activeTasksStore.setPolling(); |
| assert.ok(spy.calledOnce); |
| }); |
| |
| it('should set the isLoading variable so that the loading lines show up', function () { |
| spy = sinon.spy(activeTasksStore, 'setIsLoading'); |
| var date = new Date(); |
| |
| activeTasksCollection.pollingFetch(); |
| assert.ok(spy.withArgs(true, date).calledOnce); |
| |
| activeTasksCollection.parse(fakedResponse); |
| assert.ok(spy.withArgs(false, date).calledOnce); |
| |
| restore(activeTasksStore.setIsLoading); |
| }); |
| }); |
| |
| describe('Active Task Stores - Filter Tab Tray', function () { |
| var fakeFilteredTable, storeFilteredtable; |
| function sort (a, b, sortBy) { //sorts array by objects with key 'sortBy', with default started_on |
| if (_.isUndefined(sortBy)) { |
| sortBy = 'started-on'; |
| } |
| return b[sortBy] - a[sortBy]; |
| } |
| |
| afterEach(function () { |
| fakeFilteredTable = []; |
| }); |
| |
| it('should filter the table correctly, by radio -- All Tasks', function () { |
| activeTasksStore.setSelectedRadio('all_tasks'); |
| //parse table and check that it only contains objects any type |
| var table = activeTasksStore.getFilteredTable(activeTasksStore._collection); |
| assert.ok(activeTasksStore._collection.length, table.length); |
| }); |
| |
| it('should filter the table correctly, by radio', function () { |
| activeTasksStore.setSelectedRadio('replication'); |
| var storeFilteredtable = activeTasksStore.getFilteredTable(activeTasksStore._collection); |
| |
| //parse table and check that it only contains objects with type: Replication |
| _.each(storeFilteredtable, function (activeTask) { |
| assert.ok(activeTasksStore.passesRadioFilter(activeTask)); |
| assert.deepEqual(activeTask.type, activeTasksStore.getSelectedRadio()); |
| }); |
| }); |
| |
| it('should search the table correctly', function () { |
| activeTasksStore.setSelectedRadio('all_tasks'); |
| var searchTerm = 'base'; |
| activeTasksStore.setSearchTerm(searchTerm); |
| var storeGeneratedTable = activeTasksStore.getFilteredTable(activeTasksStore._collection); |
| var regEx = new RegExp(searchTerm); |
| |
| fakeFilteredTable = [ |
| { user: 'information'}, |
| { user: 'ooo'} |
| ]; |
| |
| assert.equal(fakeFilteredTable[0].user, storeGeneratedTable[0].user); |
| assert.equal(fakeFilteredTable[1].user, storeGeneratedTable[1].user); |
| }); |
| }); |
| |
| describe('Active Task Stores - Table Header Sort - Select Ascending/Descending', function () { |
| |
| it('should set header as ascending, on default', function () { |
| activeTasksStore.setSelectedRadio('all-tasks'); |
| activeTasksStore._headerIsAscending = true; |
| assert.ok(activeTasksStore.getHeaderIsAscending()); |
| }); |
| |
| it('should set header as descending, if same header is selected again', function () { |
| activeTasksStore._prevSortbyHeader = 'sameHeader'; |
| activeTasksStore._sortByHeader = 'sameHeader'; |
| activeTasksStore.toggleHeaderIsAscending(); |
| assert.notOk(activeTasksStore.getHeaderIsAscending()); |
| }); |
| |
| it('should set header as ascending, if different header is selected', function () { |
| activeTasksStore._sortByHeader = 'differentHeader'; |
| activeTasksStore.toggleHeaderIsAscending(); |
| assert.ok(activeTasksStore.getHeaderIsAscending()); |
| }); |
| }); |
| }); |
| }); |