merge taskdb into tasks.js

src/test/tasks-test.js

@@ -6,76 +6,137 @@
 
 'use strict';
 
-const common = require('./common.js'),
+const BoxError = require('../boxerror.js'),
+    common = require('./common.js'),
     expect = require('expect.js'),
     fs = require('fs'),
     paths = require('../paths.js'),
-    tasks = require('../tasks.js');
+    safe = require('safetydance'),
+    tasks = require('../tasks.js'),
+    _ = require('underscore');
 
 describe('task', function () {
-    before(common.setup);
-    after(common.cleanup);
+    const { setup, cleanup } = common;
 
-    it('can run valid task - success', function (done) {
-        tasks.add(tasks._TASK_IDENTITY, [ 'ping' ], function (error, taskId) {
-            if (error) return done(error);
+    before(setup);
+    after(cleanup);
 
+    let taskId;
+
+    let TASK = {
+        type: 'tasktype',
+        args: [ 1 ],
+        percent: 0,
+        message: 'Queued'
+    };
+
+    it('add succeeds', async function () {
+        const id = await tasks.add(TASK.type, TASK.args);
+        expect(id).to.be.ok();
+        taskId = id;
+    });
+
+    it('get succeeds', async function () {
+        const task = await tasks.get(taskId);
+        expect(_.pick(task, Object.keys(TASK))).to.eql(TASK);
+    });
+
+    it('get random task fails', async function () {
+        const task = await tasks.get('random');
+        expect(task).to.be(null);
+    });
+
+    it('update succeeds', async function () {
+        TASK.percent = 34;
+        TASK.message = 'almost ther';
+        await tasks.update(taskId, { percent: TASK.percent, message: TASK.message });
+        const task = await tasks.get(taskId);
+        expect(_.pick(task, Object.keys(TASK))).to.eql(TASK);
+    });
+
+    it('list succeeds - does not exist', async function () {
+        const result = await tasks.listByTypePaged('randomtask', 1, 1);
+        expect(result.length).to.be(0);
+    });
+
+    it('list succeeds - by type', async function () {
+        const result = await tasks.listByTypePaged(TASK.type, 1, 1);
+        expect(result.length).to.be(1);
+        expect(_.pick(result[0], Object.keys(TASK))).to.eql(TASK);
+    });
+
+    it('list succeeds - all', async function () {
+        const result = await tasks.listByTypePaged(null, 1, 1);
+        expect(result.length).to.be(1);
+        expect(_.pick(result[0], Object.keys(TASK))).to.eql(TASK);
+    });
+
+    it('del succeeds', async function () {
+        await tasks._del(taskId);
+        const task = await tasks.get(taskId);
+        expect(task).to.be(null);
+    });
+
+    it('del missing task fails', async function () {
+        const [error] = await safe(tasks._del('random'));
+        expect(error.reason).to.be(BoxError.NOT_FOUND);
+    });
+
+    it('can run valid task - success', async function () {
+        const taskId = await tasks.add(tasks._TASK_IDENTITY, [ 'ping' ]);
+
+        return new Promise((resolve, reject) => {
             tasks.startTask(taskId, {}, function (error, result) {
-                if (error) return done(error);
+                if (error) return reject(error);
                 expect(result).to.equal('ping');
-                expect(taskId).to.be.ok();
-                done();
+                resolve();
             });
         });
     });
 
-    it('can run valid task - error', function (done) {
-        tasks.add(tasks._TASK_ERROR, [ 'ping' ], function (error, taskId) {
-            if (error) return done(error);
+    it('can run valid task - error', async function () {
+        const taskId = await tasks.add(tasks._TASK_ERROR, [ 'ping' ]);
 
+        return new Promise((resolve, reject) => {
             tasks.startTask(taskId, {}, function (error, result) {
-                expect(error).to.be.ok();
+                if (!error) return reject(new Error('expecting task to fail'));
                 expect(error.message).to.be('Failed for arg: ping');
                 expect(result).to.be(null);
-                expect(taskId).to.be.ok();
-                done();
+                resolve();
             });
         });
     });
 
-    it('can get logs of crash', function (done) {
-        tasks.add(tasks._TASK_CRASH, [ 'ping' ], function (error, taskId) {
-            if (error) return done(error);
+    it('can get logs of crash', async function () {
+        const taskId = await tasks.add(tasks._TASK_CRASH, [ 'ping' ]);
 
+        return new Promise((resolve, reject) => {
             tasks.startTask(taskId, {}, function (error, result) {
-                expect(error).to.be.ok();
-
+                if (!error) return reject(new Error('expecting task to crash'));
                 expect(error.message).to.contain(`Task ${taskId} crashed`);
                 expect(result).to.be(null);
-                expect(taskId).to.be.ok();
 
-                let logs = fs.readFileSync(`${paths.TASKS_LOG_DIR}/${taskId}.log`, 'utf8');
+                const logs = fs.readFileSync(`${paths.TASKS_LOG_DIR}/${taskId}.log`, 'utf8');
                 expect(logs).to.contain('Crashing for arg: ping');
-                done();
+                resolve();
             });
         });
     });
 
-    it('can stop task', function (done) {
-        tasks.add(tasks._TASK_SLEEP, [ 10000 ], function (error, taskId) {
-            if (error) return done(error);
+    it('can stop task', async function () {
+        const taskId = await tasks.add(tasks._TASK_SLEEP, [ 10000 ]);
 
+        return new Promise((resolve, reject) => {
             tasks.startTask(taskId, {}, function (error, result) {
-                expect(error).to.be.ok();
+                if (!error) return reject(new Error('expecting task to stop'));
                 expect(error.message).to.contain('stopped');
                 expect(result).to.be(null);
-                expect(taskId).to.be.ok();
-                done();
+                resolve();
             });
 
-            setTimeout(() => {
-                tasks.stopTask(taskId, () => {});
-            }, 100);
+            setTimeout(async function () {
+                await tasks.stopTask(taskId);
+            }, 2000);
         });
     });
 });