2017-02-15 21:52:29 +00:00
|
|
|
import 'typings-test'
|
|
|
|
import taskbuffer = require('../dist/index')
|
|
|
|
import { expect } from 'smartchai'
|
|
|
|
import * as q from 'smartq'
|
2016-05-06 00:05:45 +00:00
|
|
|
|
2016-05-15 01:16:50 +00:00
|
|
|
// setup some testData to work with
|
2017-02-15 21:52:29 +00:00
|
|
|
let testTask: taskbuffer.Task
|
2016-08-01 14:10:00 +00:00
|
|
|
let testTaskFunction = function () {
|
2017-02-15 21:52:29 +00:00
|
|
|
let done = q.defer()
|
|
|
|
console.log('main function executed!')
|
|
|
|
done.resolve()
|
|
|
|
return done.promise
|
|
|
|
}
|
2016-08-01 14:10:00 +00:00
|
|
|
|
|
|
|
let testTaskFunctionTimeout = function () {
|
2017-02-15 21:52:29 +00:00
|
|
|
let done = q.defer()
|
|
|
|
console.log('main function started!')
|
|
|
|
setTimeout(() => {
|
|
|
|
console.log('main function ended!')
|
|
|
|
done.resolve()
|
|
|
|
}, 2000)
|
|
|
|
return done.promise
|
|
|
|
}
|
2016-08-01 14:10:00 +00:00
|
|
|
|
2016-05-06 00:05:45 +00:00
|
|
|
let testPreTask = new taskbuffer.Task({
|
2017-02-15 21:52:29 +00:00
|
|
|
taskFunction: function () {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('preTask executed')
|
|
|
|
done.resolve()
|
|
|
|
return done.promise
|
|
|
|
},
|
|
|
|
preTask: testTask
|
|
|
|
})
|
2016-05-06 00:05:45 +00:00
|
|
|
|
2016-08-01 14:10:00 +00:00
|
|
|
|
|
|
|
// some more tasks to wirj with
|
|
|
|
let task1 = new taskbuffer.Task({
|
2017-02-15 21:52:29 +00:00
|
|
|
name: 'Task 1',
|
|
|
|
taskFunction: () => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('Task1 started')
|
|
|
|
setTimeout(() => {
|
|
|
|
console.log('Task1 executed')
|
|
|
|
done.resolve()
|
|
|
|
}, 5000)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
})
|
2016-08-01 14:10:00 +00:00
|
|
|
let task2 = new taskbuffer.Task({
|
2017-02-15 21:52:29 +00:00
|
|
|
name: 'Task 1',
|
|
|
|
taskFunction: () => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('Task2 started')
|
|
|
|
setTimeout(() => {
|
|
|
|
console.log('Task2 executed')
|
|
|
|
done.resolve()
|
|
|
|
}, 5000)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
})
|
2016-08-01 14:10:00 +00:00
|
|
|
let task3 = new taskbuffer.Task({
|
2017-02-15 21:52:29 +00:00
|
|
|
name: 'Task 3',
|
|
|
|
taskFunction: () => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('Task3 started')
|
|
|
|
setTimeout(() => {
|
|
|
|
console.log('Task3 executed')
|
|
|
|
done.resolve()
|
|
|
|
}, 5000)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
})
|
2016-08-01 14:10:00 +00:00
|
|
|
|
|
|
|
// the actual tests
|
2017-02-15 21:52:29 +00:00
|
|
|
describe('taskbuffer', function () {
|
|
|
|
describe('.Task', function () {
|
|
|
|
it('new Task() should return a new task', function () {
|
|
|
|
testTask = new taskbuffer.Task({ taskFunction: testTaskFunction, preTask: testPreTask })
|
|
|
|
})
|
|
|
|
it('testTask should be and instance of Task', function () {
|
|
|
|
expect(testTask).to.be.instanceof(taskbuffer.Task)
|
|
|
|
})
|
|
|
|
it('testTask.idle is true', function () {
|
|
|
|
if (!testTask.idle) {
|
|
|
|
throw new Error('testTask.idle is not true')
|
|
|
|
}
|
2016-08-01 14:10:00 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
})
|
|
|
|
it('testTask.running is type boolean and initially false', function () {
|
|
|
|
expect(testTask.running).to.be.a('boolean')
|
|
|
|
expect(testTask.running).to.be.false
|
|
|
|
})
|
|
|
|
it('testTask.trigger() expect return Promise', function () {
|
|
|
|
expect(testTask.trigger()).to.be.instanceof(Promise)
|
|
|
|
})
|
|
|
|
it('testTask.trigger() returned Promise expect be fullfilled', function (done) {
|
|
|
|
testTask.trigger()
|
|
|
|
.then(done)
|
|
|
|
})
|
|
|
|
it('expect run a task without pre and afterTask', function (done) {
|
|
|
|
let localTestTask = new taskbuffer.Task({ taskFunction: testTaskFunction })
|
|
|
|
localTestTask.trigger().then(done)
|
|
|
|
})
|
2016-08-01 14:10:00 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
it('expect run buffered', function (done) {
|
|
|
|
this.timeout(10000)
|
|
|
|
let localTestTask = new taskbuffer.Task({
|
|
|
|
taskFunction: testTaskFunctionTimeout,
|
|
|
|
buffered: true,
|
|
|
|
bufferMax: 2
|
|
|
|
})
|
|
|
|
localTestTask.trigger()
|
|
|
|
localTestTask.trigger()
|
|
|
|
localTestTask.trigger()
|
|
|
|
localTestTask.trigger().then(() => {
|
|
|
|
done()
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
describe('Taskchain', function () {
|
|
|
|
let testTaskchain
|
|
|
|
let testTaskArray = [
|
|
|
|
new taskbuffer.Task({
|
|
|
|
name: 'task1',
|
|
|
|
taskFunction: function () {
|
|
|
|
let done = q.defer()
|
|
|
|
setTimeout(done.resolve, 2000)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
}),
|
|
|
|
new taskbuffer.Task({
|
|
|
|
name: 'task2',
|
|
|
|
taskFunction: function () {
|
|
|
|
let done = q.defer()
|
|
|
|
setTimeout(done.resolve, 2000)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
})
|
|
|
|
]
|
|
|
|
it('expect run tasks in sequence', function (done) {
|
|
|
|
this.timeout(5000)
|
|
|
|
testTaskchain = new taskbuffer.Taskchain({
|
|
|
|
name: 'Taskchain1',
|
|
|
|
taskArray: testTaskArray
|
|
|
|
})
|
|
|
|
testTaskchain.trigger().then(done)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
describe('taskparallel', function () {
|
|
|
|
it('expect run in Parallel', function (done) {
|
|
|
|
this.timeout(7000)
|
|
|
|
let testTaskparallel = new taskbuffer.Taskparallel({
|
|
|
|
taskArray: [ task1, task2, task3 ]
|
|
|
|
})
|
|
|
|
testTaskparallel.trigger().then(() => {
|
|
|
|
done()
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
describe('some flowtests', function () {
|
|
|
|
let flowTask1 = new taskbuffer.Task({
|
|
|
|
taskFunction: (x: number) => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('flowTask1')
|
|
|
|
console.log(x)
|
|
|
|
done.resolve(x)
|
|
|
|
return done.promise
|
|
|
|
}
|
|
|
|
})
|
2016-08-03 12:51:43 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
let flowTaskBuffered = new taskbuffer.Task({
|
|
|
|
taskFunction: (x: number) => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('flowTask1')
|
|
|
|
console.log(x)
|
|
|
|
done.resolve(x)
|
|
|
|
return done.promise
|
|
|
|
},
|
|
|
|
buffered: true,
|
|
|
|
bufferMax: 1
|
|
|
|
})
|
2016-08-03 12:51:43 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
let flowTask2 = new taskbuffer.Task({
|
|
|
|
taskFunction: (x: number) => {
|
|
|
|
let done = q.defer()
|
|
|
|
console.log('flowTask2')
|
|
|
|
console.log(x)
|
|
|
|
done.resolve(x)
|
|
|
|
return done.promise
|
|
|
|
},
|
|
|
|
preTask: flowTask1
|
|
|
|
})
|
|
|
|
let flowTask3 = new taskbuffer.Taskchain({
|
|
|
|
taskArray: [ flowTask1, flowTask2 ]
|
|
|
|
})
|
|
|
|
it('should let a value flow through a task', function (done) {
|
|
|
|
flowTask1.trigger(12).then((x) => {
|
|
|
|
expect(x).to.equal(12)
|
|
|
|
done()
|
|
|
|
}).catch(done)
|
|
|
|
})
|
|
|
|
it('should let a values flow between tasks', function (done) {
|
|
|
|
flowTask2.trigger(12).then((x) => {
|
|
|
|
expect(x).to.equal(12)
|
|
|
|
done()
|
|
|
|
}).catch(done)
|
|
|
|
})
|
2016-08-03 12:51:43 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
it('expect let a values flow between tasks when buffered', function (done) {
|
|
|
|
flowTaskBuffered.trigger(12).then((x) => {
|
|
|
|
expect(x).to.equal(12)
|
|
|
|
done()
|
|
|
|
}).catch(done)
|
|
|
|
})
|
2016-08-03 12:51:43 +00:00
|
|
|
|
2017-02-15 21:52:29 +00:00
|
|
|
it('should let a values flow between tasks in Taskchain', function (done) {
|
|
|
|
flowTask3.trigger(12).then((x) => {
|
|
|
|
expect(x).to.equal(12)
|
|
|
|
done()
|
|
|
|
}).catch(done)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|