iqs-services-signals-node
Version:
Operational signals microservice in Node.js
333 lines (289 loc) • 9.73 kB
text/typescript
let _ = require('lodash');
let async = require('async');
let assert = require('chai').assert;
import { FilterParams } from 'pip-services3-commons-node';
import { PagingParams } from 'pip-services3-commons-node';
import { AnyValueMap } from 'pip-services3-commons-node';
import { SignalV1 } from '../../src/data/version1/SignalV1';
import { ISignalsPersistence } from '../../src/persistence/ISignalsPersistence';
let SIGNAL1: SignalV1 = {
id: '1',
org_id: '1',
time: new Date(),
device_id: '1',
type: 1
};
let SIGNAL2: SignalV1 = {
id: '2',
org_id: '1',
time: new Date(),
device_id: '1',
type: 2,
lock_until: new Date().getTime() + 10000
};
let SIGNAL3: SignalV1 = {
id: '3',
org_id: '2',
time: new Date(),
device_id: '2',
type: 4,
sent: true
};
export class SignalsPersistenceFixture {
private _persistence: ISignalsPersistence;
constructor(persistence) {
assert.isNotNull(persistence);
this._persistence = persistence;
}
private testCreateSignals(done) {
async.series([
// Create one signal
(callback) => {
this._persistence.create(
null,
SIGNAL1,
(err, signal) => {
assert.isNull(err);
assert.isObject(signal);
assert.equal(signal.org_id, SIGNAL1.org_id);
assert.equal(signal.type, SIGNAL1.type);
assert.equal(signal.device_id, SIGNAL1.device_id);
callback();
}
);
},
// Create another signal
(callback) => {
this._persistence.create(
null,
SIGNAL2,
(err, signal) => {
assert.isNull(err);
assert.isObject(signal);
assert.equal(signal.org_id, SIGNAL2.org_id);
assert.equal(signal.type, SIGNAL2.type);
assert.equal(signal.device_id, SIGNAL2.device_id);
callback();
}
);
},
// Create yet another signal
(callback) => {
this._persistence.create(
null,
SIGNAL3,
(err, signal) => {
assert.isNull(err);
assert.isObject(signal);
assert.equal(signal.org_id, SIGNAL3.org_id);
assert.equal(signal.type, SIGNAL3.type);
assert.equal(signal.device_id, SIGNAL3.device_id);
callback();
}
);
}
], done);
}
public testCrudOperations(done) {
let signal1: SignalV1;
async.series([
// Create items
(callback) => {
this.testCreateSignals(callback);
},
// Get all signals
(callback) => {
this._persistence.getPageByFilter(
null,
new FilterParams(),
new PagingParams(),
(err, page) => {
assert.isNull(err);
assert.isObject(page);
assert.lengthOf(page.data, 3);
signal1 = page.data[0];
callback();
}
);
},
// Update the signal
(callback) => {
let data = AnyValueMap.fromTuples(
'lock_until', null,
'sent', true
);
this._persistence.updatePartially(
null,
signal1.id,
data,
(err, signal) => {
assert.isNull(err);
assert.isObject(signal);
assert.isTrue(signal.sent);
assert.equal(signal.id, signal1.id);
callback();
}
);
},
// Delete signal
(callback) => {
this._persistence.deleteById(
null,
signal1.id,
(err) => {
assert.isNull(err);
callback();
}
);
},
// Try to get delete signal
(callback) => {
this._persistence.getOneById(
null,
signal1.id,
(err, signal) => {
assert.isNull(err);
assert.isNull(signal || null);
callback();
}
);
}
], done);
}
public testLock(done) {
async.series([
// Create items
(callback) => {
this.testCreateSignals(callback);
},
// Lock unlocked item
(callback) => {
this._persistence.lock(
null,
SIGNAL1.id,
10000,
(err, result) => {
assert.isNull(err);
assert.isTrue(result);
callback();
}
);
},
// Lock already llocked item
(callback) => {
this._persistence.lock(
null,
SIGNAL1.id,
10000,
(err, result) => {
assert.isNull(err);
assert.isFalse(result);
callback();
}
);
},
// Try to get delete signal
(callback) => {
this._persistence.getOneById(
null,
SIGNAL1.id,
(err, signal) => {
assert.isNull(err);
assert.isObject(signal);
assert.isTrue(signal.lock_until > 0);
callback();
}
);
}
], done);
}
public testGetWithFilter(done) {
async.series([
// Create signals
(callback) => {
this.testCreateSignals(callback);
},
// Get signals filtered by org_id
(callback) => {
this._persistence.getPageByFilter(
null,
FilterParams.fromValue({
org_id: '1'
}),
new PagingParams(),
(err, signals) => {
assert.isNull(err);
assert.isObject(signals);
assert.lengthOf(signals.data, 2);
callback();
}
);
},
// Get signals by type
(callback) => {
this._persistence.getPageByFilter(
null,
FilterParams.fromValue({
device_id: '1'
}),
new PagingParams(),
(err, signals) => {
assert.isNull(err);
assert.isObject(signals);
assert.lengthOf(signals.data, 2);
callback();
}
);
},
// Get signals filtered by sent
(callback) => {
this._persistence.getPageByFilter(
null,
FilterParams.fromValue({
sent: false
}),
new PagingParams(),
(err, signals) => {
assert.isNull(err);
assert.isObject(signals);
assert.lengthOf(signals.data, 2);
callback();
}
);
},
// Get signals filtered by sent
(callback) => {
this._persistence.getPageByFilter(
null,
FilterParams.fromValue({
locked: false
}),
new PagingParams(),
(err, signals) => {
assert.isNull(err);
assert.isObject(signals);
assert.lengthOf(signals.data, 2);
callback();
}
);
},
// Get signals filtered by severity
(callback) => {
this._persistence.getPageByFilter(
null,
FilterParams.fromValue({
from_time: SIGNAL1.time,
to_time: new Date(SIGNAL3.time.getTime() + 100)
}),
new PagingParams(),
(err, signals) => {
assert.isNull(err);
assert.isObject(signals);
assert.lengthOf(signals.data, 3);
callback();
}
);
}
], done);
}
}