push.rocks/taskbuffer
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(tests): now using tstest

Browse Source
This commit is contained in:
Philipp Kunz
2018-08-04 17:53:22 +02:00
parent df18aba4b5
commit f60deddadd
37 changed files with 1607 additions and 1659 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
test/test.1.task.ts
View File

@ -1,108 +1,118 @@
import { expect, tap } from 'tapbundle'
import taskbuffer = require('../dist/index')
import { expect, tap } from '@pushrocks/tapbundle';
import taskbuffer = require('../ts/index');
import * as q from 'smartq'
import * as smartdelay from 'smartdelay'
import * as smartpromise from '@pushrocks/smartpromise';
import * as smartdelay from '@pushrocks/smartdelay';
// setup some testData to work with
let testTask: taskbuffer.Task
let testTask: taskbuffer.Task;
let testPreTask = new taskbuffer.Task({
taskFunction: function () {
let done = q.defer()
console.log('preTask executed')
done.resolve()
return done.promise
taskFunction: function() {
let done = smartpromise.defer();
console.log('preTask executed');
done.resolve();
return done.promise;
},
preTask: testTask
})
});
// some more tasks to test with
let task1Counter = 0 // how often task 1 is being executed
let task1Counter = 0; // how often task 1 is being executed
let task1 = new taskbuffer.Task({
name: 'Task 1',
taskFunction: () => {
let done = q.defer()
console.log('Task1 started')
let done = smartpromise.defer();
console.log('Task1 started');
setTimeout(() => {
task1Counter++
console.log('Task1 executed')
done.resolve()
}, 5000)
return done.promise
task1Counter++;
console.log('Task1 executed');
done.resolve();
}, 5000);
return done.promise;
}
})
});
let task2 = new taskbuffer.Task({
name: 'Task 1',
taskFunction: () => {
let done = q.defer()
console.log('Task2 started')
let done = smartpromise.defer();
console.log('Task2 started');
setTimeout(() => {
console.log('Task2 executed')
done.resolve()
}, 5000)
return done.promise
console.log('Task2 executed');
done.resolve();
}, 5000);
return done.promise;
}
})
});
let task3 = new taskbuffer.Task({
name: 'Task 3',
taskFunction: () => {
let done = q.defer()
console.log('Task3 started')
let done = smartpromise.defer();
console.log('Task3 started');
setTimeout(() => {
console.log('Task3 executed')
done.resolve()
}, 5000)
return done.promise
console.log('Task3 executed');
done.resolve();
}, 5000);
return done.promise;
}
})
});
tap.test('new Task() should return a new task', async () => {
testTask = new taskbuffer.Task({ taskFunction: async () => { console.log('executed twice') }, preTask: testPreTask })
})
testTask = new taskbuffer.Task({
taskFunction: async () => {
console.log('executed twice');
},
preTask: testPreTask
});
});
tap.test('expect testTask to be an instance of Task', async () => {
expect(testTask).to.be.instanceof(taskbuffer.Task)
})
expect(testTask).to.be.instanceof(taskbuffer.Task);
});
tap.test('expect testTask.idle is true', async () => {
if (!testTask.idle) {
throw new Error('testTask.idle is not true')
throw new Error('testTask.idle is not true');
}
})
});
tap.test('testTask.running should be of type boolean and initially false', async () => {
expect(testTask.running).to.be.a('boolean')
expect(testTask.running).to.be.a('boolean');
// tslint:disable-next-line:no-unused-expression
expect(testTask.running).to.be.false
})
expect(testTask.running).to.be.false;
});
tap.test('testTask.trigger() should return Promise', async () => {
expect(testTask.trigger()).to.be.instanceof(Promise)
})
expect(testTask.trigger()).to.be.instanceof(Promise);
});
tap.test('testTask.trigger() returned Promise should be fullfilled', async () => {
await testTask.trigger()
})
await testTask.trigger();
});
tap.test('expect to run a task without pre and afterTask errorless', async () => {
let localTestTask = new taskbuffer.Task({ taskFunction: async () => { console.log('only once') } })
await localTestTask.trigger()
})
let localTestTask = new taskbuffer.Task({
taskFunction: async () => {
console.log('only once');
}
});
await localTestTask.trigger();
});
tap.test('expect task to run in buffered mode', async () => {
let localTestTask = new taskbuffer.Task({
taskFunction: async () => { await smartdelay.delayFor(3000) },
taskFunction: async () => {
await smartdelay.delayFor(3000);
},
buffered: true,
bufferMax: 2
})
localTestTask.trigger()
localTestTask.trigger()
localTestTask.trigger()
await localTestTask.trigger()
})
});
localTestTask.trigger();
localTestTask.trigger();
localTestTask.trigger();
await localTestTask.trigger();
});
tap.start()
tap.start();

54
test/test.2.taskchain.ts
View File

@ -1,48 +1,48 @@
import { expect, tap } from 'tapbundle'
import taskbuffer = require('../dist/index')
import { expect, tap } from '@pushrocks/tapbundle';
import taskbuffer = require('../ts/index');
import * as smartq from 'smartq'
import * as smartdelay from 'smartdelay'
import * as smartq from 'smartq';
import * as smartdelay from '@pushrocks/smartdelay';
let task1Executed = false
let task1Executed = false;
let task1 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task1Executed = true
await smartdelay.delayFor(2000);
task1Executed = true;
}
})
});
let task2Executed = false
let task2Executed = false;
let task2 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task2Executed = true
await smartdelay.delayFor(2000);
task2Executed = true;
}
})
});
let task3Executed = false
let task3Executed = false;
let task3 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task3Executed = true
await smartdelay.delayFor(2000);
task3Executed = true;
}
})
});
tap.test('expect run tasks in sequence', async () => {
let testTaskchain = new taskbuffer.Taskchain({
name: 'Taskchain1',
taskArray: [ task1, task2, task3 ]
})
let testPromise = testTaskchain.trigger()
await smartdelay.delayFor(2100)
taskArray: [task1, task2, task3]
});
let testPromise = testTaskchain.trigger();
await smartdelay.delayFor(2100);
// tslint:disable-next-line:no-unused-expression
expect(task1Executed).to.be.true
expect(task1Executed).to.be.true;
// tslint:disable-next-line:no-unused-expression
expect(task2Executed).to.be.false
await smartdelay.delayFor(2100)
expect(task2Executed).to.be.false;
await smartdelay.delayFor(2100);
// tslint:disable-next-line:no-unused-expression
expect(task2Executed).to.be.true
await testPromise
})
expect(task2Executed).to.be.true;
await testPromise;
});
tap.start()
tap.start();

42
test/test.3.taskparallel.ts
View File

@ -1,38 +1,38 @@
import { expect, tap } from 'tapbundle'
import taskbuffer = require('../dist/index')
import { expect, tap } from '@pushrocks/tapbundle';
import taskbuffer = require('../ts/index');
import * as smartq from 'smartq'
import * as smartdelay from 'smartdelay'
import * as smartq from 'smartq';
import * as smartdelay from '@pushrocks/smartdelay';
let task1Executed = false
let task1Executed = false;
let task1 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task1Executed = true
await smartdelay.delayFor(2000);
task1Executed = true;
}
})
});
let task2Executed = false
let task2Executed = false;
let task2 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task2Executed = true
await smartdelay.delayFor(2000);
task2Executed = true;
}
})
});
let task3Executed = false
let task3Executed = false;
let task3 = new taskbuffer.Task({
taskFunction: async () => {
await smartdelay.delayFor(2000)
task3Executed = true
await smartdelay.delayFor(2000);
task3Executed = true;
}
})
});
tap.test('expect run in Parallel', async () => {
let testTaskparallel = new taskbuffer.Taskparallel({
taskArray: [ task1, task2, task3 ]
})
await testTaskparallel.trigger()
})
taskArray: [task1, task2, task3]
});
await testTaskparallel.trigger();
});
tap.start()
tap.start();

60
test/test.4.taskmanager.ts
View File

@ -1,40 +1,42 @@
import { expect, tap } from 'tapbundle'
import taskbuffer = require('../dist/index')
import { expect, tap } from '@pushrocks/tapbundle';
import taskbuffer = require('../ts/index');
import * as smartq from 'smartq'
import * as smartdelay from 'smartdelay'
import * as smartpromise from '@pushrocks/smartpromise';
import * as smartdelay from '@pushrocks/smartdelay';
let myTaskManager: taskbuffer.TaskManager
let taskRunCounter = 0
let taskDone = smartq.defer()
let myTaskManager: taskbuffer.TaskManager;
let taskRunCounter = 0;
let taskDone = smartpromise.defer();
tap.test('should create an instance of TaskManager', async () => {
myTaskManager = new taskbuffer.TaskManager()
expect(myTaskManager).to.be.instanceof(taskbuffer.TaskManager)
})
myTaskManager = new taskbuffer.TaskManager();
expect(myTaskManager).to.be.instanceof(taskbuffer.TaskManager);
});
tap.test('should run the task as expected', async () => {
let referenceBoolean = false
myTaskManager.addTask(new taskbuffer.Task({
name: 'myTask',
taskFunction: async () => {
console.log('Task executed!')
referenceBoolean = true
taskRunCounter++
if (taskRunCounter === 10) {
taskDone.resolve()
let referenceBoolean = false;
myTaskManager.addTask(
new taskbuffer.Task({
name: 'myTask',
taskFunction: async () => {
console.log('Task executed!');
referenceBoolean = true;
taskRunCounter++;
if (taskRunCounter === 10) {
taskDone.resolve();
}
}
}
}))
await myTaskManager.triggerTaskByName('myTask')
})
);
await myTaskManager.triggerTaskByName('myTask');
// tslint:disable-next-line:no-unused-expression
expect(referenceBoolean).to.be.true
})
expect(referenceBoolean).to.be.true;
});
tap.test('should schedule task', async () => {
myTaskManager.scheduleTaskByName('myTask', '* * * * * *')
await taskDone.promise
myTaskManager.descheduleTaskByName('myTask')
})
myTaskManager.scheduleTaskByName('myTask', '* * * * * *');
await taskDone.promise;
myTaskManager.descheduleTaskByName('myTask');
});
tap.start()
tap.start();

74
test/test.5.task.paramflow.ts
View File

@ -1,64 +1,64 @@
import { expect, tap } from 'tapbundle'
import taskbuffer = require('../dist/index')
import { expect, tap } from '@pushrocks/tapbundle';
import taskbuffer = require('../ts/index');
import * as q from 'smartq'
import * as smartdelay from 'smartdelay'
import * as smartpromise from '@pushrocks/smartpromise';
import * as smartdelay from '@pushrocks/smartdelay';
let flowTask1 = new taskbuffer.Task({
taskFunction: (x: number) => {
let done = q.defer()
console.log('flowTask1')
console.log(x)
done.resolve(x)
return done.promise
let done = smartpromise.defer();
console.log('flowTask1');
console.log(x);
done.resolve(x);
return done.promise;
}
})
});
let flowTaskBuffered = new taskbuffer.Task({
taskFunction: (x: number) => {
let done = q.defer()
console.log('flowTask1')
console.log(x)
done.resolve(x)
return done.promise
let done = smartpromise.defer();
console.log('flowTask1');
console.log(x);
done.resolve(x);
return done.promise;
},
buffered: true,
bufferMax: 1
})
});
let flowTask2 = new taskbuffer.Task({
taskFunction: (x: number) => {
let done = q.defer()
console.log('flowTask2')
console.log(x)
done.resolve(x)
return done.promise
let done = smartpromise.defer();
console.log('flowTask2');
console.log(x);
done.resolve(x);
return done.promise;
},
preTask: flowTask1
})
});
let flowTask3 = new taskbuffer.Taskchain({
taskArray: [ flowTask1, flowTask2 ]
})
taskArray: [flowTask1, flowTask2]
});
tap.test('should let a value flow through a task', async () => {
let result = await flowTask1.trigger(12)
expect(result).to.equal(12)
})
let result = await flowTask1.trigger(12);
expect(result).to.equal(12);
});
tap.test('expect values to flow between tasks', async () => {
let result = await flowTask2.trigger(12)
expect(result).to.equal(12)
})
let result = await flowTask2.trigger(12);
expect(result).to.equal(12);
});
tap.test('expect values to flow between tasks when buffered', async () => {
let result = await flowTaskBuffered.trigger(12)
expect(result).to.equal(12)
})
let result = await flowTaskBuffered.trigger(12);
expect(result).to.equal(12);
});
tap.test('expect values to flow between tasks in Taskchain', async () => {
let result = await flowTask3.trigger(12)
expect(result).to.equal(12)
})
let result = await flowTask3.trigger(12);
expect(result).to.equal(12);
});
tap.start()
tap.start();

32
test/test.6.taskonce.ts
View File

@ -1,28 +1,28 @@
import { expect, tap } from 'tapbundle'
import { expect, tap } from '@pushrocks/tapbundle';
import * as taskbuffer from '../dist/index'
import * as taskbuffer from '../ts/index';
let myNumber = 0
let myTaskOnce: taskbuffer.TaskOnce
let myNumber = 0;
let myTaskOnce: taskbuffer.TaskOnce;
tap.test('should create a valid instance of TaskOnce', async () => {
myTaskOnce = new taskbuffer.TaskOnce({
taskFunction: async () => {
myNumber++
myNumber++;
}
})
expect(myTaskOnce).to.be.instanceof(taskbuffer.TaskOnce)
})
});
expect(myTaskOnce).to.be.instanceof(taskbuffer.TaskOnce);
});
tap.test('myNumber should still be 0', async () => {
expect(myNumber).to.equal(0)
})
expect(myNumber).to.equal(0);
});
tap.test('myTaskOnce should trigger once', async () => {
await myTaskOnce.trigger()
await myTaskOnce.trigger()
await myTaskOnce.trigger()
expect(myNumber).to.equal(1)
})
await myTaskOnce.trigger();
await myTaskOnce.trigger();
await myTaskOnce.trigger();
expect(myNumber).to.equal(1);
});
tap.start()
tap.start();