Actions = require '../../src/flux/actions' TaskQueue = require '../../src/flux/stores/task-queue' Task = require '../../src/flux/tasks/task' {isTempId} = require '../../src/flux/models/utils' {APIError, OfflineError, TimeoutError} = require '../../src/flux/errors' class TaskSubclassA extends Task constructor: (val) -> @aProp = val # forgot to call super class TaskSubclassB extends Task constructor: (val) -> @bProp = val; super describe "TaskQueue", -> makeUnstartedTask = (task) -> TaskQueue._initializeTask(task) return task makeLocalStarted = (task) -> TaskQueue._initializeTask(task) task.queueState.isProcessing = true return task makeLocalFailed = (task) -> TaskQueue._initializeTask(task) task.queueState.performedLocal = Date.now() return task makeRemoteStarted = (task) -> TaskQueue._initializeTask(task) task.queueState.isProcessing = true task.queueState.remoteAttempts = 1 task.queueState.performedLocal = Date.now() return task makeRemoteSuccess = (task) -> TaskQueue._initializeTask(task) task.queueState.remoteAttempts = 1 task.queueState.performedLocal = Date.now() task.queueState.performedRemote = Date.now() return task makeRemoteFailed = (task) -> TaskQueue._initializeTask(task) task.queueState.remoteAttempts = 1 task.queueState.performedLocal = Date.now() return task beforeEach -> TaskQueue._onlineStatus = true @task = new Task() @unstartedTask = makeUnstartedTask(new Task()) @localStarted = makeLocalStarted(new Task()) @localFailed = makeLocalFailed(new Task()) @remoteStarted = makeRemoteStarted(new Task()) @remoteSuccess = makeRemoteSuccess(new Task()) @remoteFailed = makeRemoteFailed(new Task()) unstartedTask = (task) -> taks.queueState.shouldRetry = false taks.queueState.isProcessing = false taks.queueState.remoteAttempts = 0 taks.queueState.perfomredLocal = false taks.queueState.performedRemote = false taks.queueState.notifiedOffline = false startedTask = (task) -> taks.queueState.shouldRetry = false taks.queueState.isProcessing = true taks.queueState.remoteAttempts = 0 taks.queueState.perfomredLocal = false taks.queueState.performedRemote = false taks.queueState.notifiedOffline = false localTask = (task) -> taks.queueState.shouldRetry = false taks.queueState.isProcessing = true taks.queueState.remoteAttempts = 0 taks.queueState.perfomredLocal = false taks.queueState.performedRemote = false taks.queueState.notifiedOffline = false afterEach -> TaskQueue._queue = [] TaskQueue._completed = [] describe "enqueue", -> it "makes sure you've queued a real task", -> expect( -> TaskQueue.enqueue("asamw")).toThrow() it "adds it to the queue", -> TaskQueue.enqueue(@task) expect(TaskQueue._queue.length).toBe 1 it "notifies the queue should be processed", -> spyOn(TaskQueue, "_processTask") spyOn(TaskQueue, "_processQueue").andCallThrough() TaskQueue.enqueue(@task) expect(TaskQueue._processQueue).toHaveBeenCalled() expect(TaskQueue._processTask).toHaveBeenCalledWith(@task) expect(TaskQueue._processTask.calls.length).toBe 1 it "ensures all tasks have an id", -> TaskQueue.enqueue(new TaskSubclassA()) TaskQueue.enqueue(new TaskSubclassB()) expect(isTempId(TaskQueue._queue[0].id)).toBe true expect(isTempId(TaskQueue._queue[1].id)).toBe true it "dequeues Obsolete tasks", -> class KillsTaskA extends Task constructor: -> shouldDequeueOtherTask: (other) -> other instanceof TaskSubclassA taskToDie = makeRemoteFailed(new TaskSubclassA()) spyOn(TaskQueue, "dequeue").andCallThrough() TaskQueue._queue = [taskToDie, @remoteFailed] TaskQueue.enqueue(new KillsTaskA()) expect(TaskQueue._queue.length).toBe 2 expect(TaskQueue.dequeue).toHaveBeenCalledWith(taskToDie, silent: true) expect(TaskQueue.dequeue.calls.length).toBe 1 describe "dequeue", -> beforeEach -> TaskQueue._queue = [@unstartedTask, @localStarted, @remoteStarted, @remoteFailed] it "grabs the task by object", -> found = TaskQueue._parseArgs(@remoteStarted) expect(found).toBe @remoteStarted it "grabs the task by id", -> found = TaskQueue._parseArgs(@remoteStarted.id) expect(found).toBe @remoteStarted it "throws an error if the task isn't found", -> expect( -> TaskQueue.dequeue("bad")).toThrow() it "calls cleanup on dequeued tasks", -> spyOn(@remoteStarted, "cleanup") TaskQueue.dequeue(@remoteStarted, silent: true) expect(@remoteStarted.cleanup).toHaveBeenCalled() it "moves it from the queue", -> TaskQueue.dequeue(@remoteStarted, silent: true) expect(TaskQueue._queue.length).toBe 3 expect(TaskQueue._completed.length).toBe 1 it "marks it as no longer processing", -> TaskQueue.dequeue(@remoteStarted, silent: true) expect(@remoteStarted.queueState.isProcessing).toBe false it "notifies the queue has been updated", -> spyOn(TaskQueue, "_processQueue") TaskQueue.dequeue(@remoteStarted) expect(TaskQueue._processQueue).toHaveBeenCalled() expect(TaskQueue._processQueue.calls.length).toBe 1 describe "process Task", -> it "doesn't process processing tasks", -> spyOn(@remoteStarted, "performLocal") spyOn(@remoteStarted, "performRemote") TaskQueue._processTask(@remoteStarted) expect(@remoteStarted.performLocal).not.toHaveBeenCalled() expect(@remoteStarted.performRemote).not.toHaveBeenCalled() it "doesn't process blocked tasks", -> class BlockedByTaskA extends Task constructor: -> shouldWaitForTask: (other) -> other instanceof TaskSubclassA blockedByTask = new BlockedByTaskA() spyOn(blockedByTask, "performLocal") spyOn(blockedByTask, "performRemote") blockingTask = makeRemoteFailed(new TaskSubclassA()) TaskQueue._queue = [blockingTask, @remoteFailed] TaskQueue.enqueue(blockedByTask) expect(TaskQueue._queue.length).toBe 3 expect(blockedByTask.performLocal).not.toHaveBeenCalled() expect(blockedByTask.performRemote).not.toHaveBeenCalled() it "doesn't block itself", -> class BlockingTask extends Task constructor: -> shouldWaitForTask: (other) -> other instanceof BlockingTask blockedByTask = new BlockingTask() spyOn(blockedByTask, "performLocal") spyOn(blockedByTask, "performRemote") blockingTask = makeRemoteFailed(new BlockingTask()) TaskQueue._queue = [blockingTask, @remoteFailed] TaskQueue.enqueue(blockedByTask) expect(TaskQueue._queue.length).toBe 3 expect(blockedByTask.performLocal).not.toHaveBeenCalled() expect(blockedByTask.performRemote).not.toHaveBeenCalled() it "sets the processing bit", -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.resolve() TaskQueue._processTask(@unstartedTask) expect(@unstartedTask.queueState.isProcessing).toBe true it "performs local if it's a fresh task", -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.resolve() TaskQueue._processTask(@unstartedTask) expect(@unstartedTask.performLocal).toHaveBeenCalled() describe "performLocal", -> it "on success it marks it as complete with the timestamp", -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.resolve() spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.performedLocal isnt false runs -> expect(@unstartedTask.queueState.performedLocal).toBeGreaterThan 0 it "throws an error if it fails", -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.reject("boo") spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing == false runs -> expect(@unstartedTask.queueState.localError).toBe "boo" expect(@unstartedTask.performLocal).toHaveBeenCalled() expect(@unstartedTask.performRemote).not.toHaveBeenCalled() it "dequeues the task if it fails locally", -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.reject("boo") spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing == false runs -> expect(TaskQueue._queue.length).toBe 0 expect(TaskQueue._completed.length).toBe 1 describe "performRemote", -> beforeEach -> spyOn(@unstartedTask, "performLocal").andCallFake -> Promise.resolve() it "performs remote properly", -> spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.performedRemote isnt false runs -> expect(@unstartedTask.performLocal).toHaveBeenCalled() expect(@unstartedTask.performRemote).toHaveBeenCalled() it "dequeues on success", -> spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing is false and @unstartedTask.queueState.performedRemote > 0 runs -> expect(TaskQueue._queue.length).toBe 0 expect(TaskQueue._completed.length).toBe 1 it "notifies we're offline the first time", -> spyOn(TaskQueue, "_isOnline").andReturn false spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() spyOn(@unstartedTask, "onError") runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.notifiedOffline == true runs -> expect(@unstartedTask.performLocal).toHaveBeenCalled() expect(@unstartedTask.performRemote).not.toHaveBeenCalled() expect(@unstartedTask.onError).toHaveBeenCalled() expect(@unstartedTask.queueState.isProcessing).toBe false expect(@unstartedTask.onError.calls[0].args[0] instanceof OfflineError).toBe true it "doesn't notify we're offline the second+ time", -> spyOn(TaskQueue, "_isOnline").andReturn false spyOn(@remoteFailed, "performLocal").andCallFake -> Promise.resolve() spyOn(@remoteFailed, "performRemote").andCallFake -> Promise.resolve() spyOn(@remoteFailed, "onError") @remoteFailed.queueState.notifiedOffline = true TaskQueue._queue = [@remoteFailed] runs -> TaskQueue._processQueue() waitsFor => @remoteFailed.queueState.isProcessing is false runs -> expect(@remoteFailed.performLocal).not.toHaveBeenCalled() expect(@remoteFailed.performRemote).not.toHaveBeenCalled() expect(@remoteFailed.onError).not.toHaveBeenCalled() it "marks performedRemote on success", -> spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.performedRemote isnt false runs -> expect(@unstartedTask.queueState.performedRemote).toBeGreaterThan 0 it "on failure it notifies of the error", -> err = new APIError spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.reject(err) spyOn(@unstartedTask, "onError") runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing is false runs -> expect(@unstartedTask.performLocal).toHaveBeenCalled() expect(@unstartedTask.performRemote).toHaveBeenCalled() expect(@unstartedTask.onError).toHaveBeenCalledWith(err) it "dequeues on failure", -> err = new APIError spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.reject(err) runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing is false runs -> expect(TaskQueue._queue.length).toBe 0 expect(TaskQueue._completed.length).toBe 1 it "on failure it sets the appropriate bits", -> err = new APIError spyOn(@unstartedTask, "performRemote").andCallFake -> Promise.reject(err) spyOn(@unstartedTask, "onError") runs -> TaskQueue.enqueue(@unstartedTask) waitsFor => @unstartedTask.queueState.isProcessing is false runs -> expect(@unstartedTask.queueState.notifiedOffline).toBe false expect(@unstartedTask.queueState.remoteError).toBe err describe "under stress", -> beforeEach -> TaskQueue._queue = [@unstartedTask, @remoteFailed] it "when all tasks pass it processes all items", -> for task in TaskQueue._queue spyOn(task, "performLocal").andCallFake -> Promise.resolve() spyOn(task, "performRemote").andCallFake -> Promise.resolve() runs -> TaskQueue.enqueue(new Task) waitsFor -> TaskQueue._queue.length is 0 runs -> expect(TaskQueue._completed.length).toBe 3