@arisan/data-api/lib/routers/mountEventInfo.spec.js

The Universal Database API Gateway for CLIO's Modules

'use strict';

var _chai = require('chai');

var _powMongodbFixtures = require('pow-mongodb-fixtures');

var _mongodbUri = require('mongodb-uri');

var _mongodbUri2 = _interopRequireDefault(_mongodbUri);

var _DataAPI = require('../DataAPI');

var _DataAPI2 = _interopRequireDefault(_DataAPI);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const request = require('supertest');
//endregion

//region 2. Project Libraries
/* eslint-disable import/newline-after-import, import/first */

//region 1. Platform Libraries

//endregion

describe('Route .../event-info', () => {
    const mongo = _mongodbUri2.default.parse(process.env.CLIO_MONGO_URL);
    const fixtures = (0, _powMongodbFixtures.connect)(mongo.database, {
        host: mongo.hosts[0].host,
        port: mongo.hosts[0].port,
        user: mongo.username,
        pass: mongo.password
    });
    const dataAPI = new _DataAPI2.default();
    const camera = {
        _id: (0, _powMongodbFixtures.createObjectId)('123456789a123456789b1231'),
        public_address: '123.123.123.123',
        web_port: 80,
        username: 'onvif',
        password: 'onvif',
        trigger_cooldown_duration: 180,
        prealarm_duration: 10,
        event_video_duration: 20,
        active_stream_index: 1,
        streams: [{}, {
            rtsp_url: 'rtsp://url',
            frame_rate_limit: 15,
            gov_length: 15
        }]
    };
    const cameraWithoutRTSP = {
        _id: (0, _powMongodbFixtures.createObjectId)('123456789a123456789b1232'),
        public_address: '123.123.123.124',
        web_port: 80,
        username: 'onvif',
        password: 'onvif',
        trigger_cooldown_duration: 180,
        prealarm_duration: 10,
        event_video_duration: 20,
        active_stream_index: 1,
        streams: [{}, {
            frame_rate_limit: 15,
            gov_length: 15
        }]
    };
    const cameraWithoutHost = {
        _id: (0, _powMongodbFixtures.createObjectId)('123456789a123456789b1233'),
        username: 'onvif',
        password: 'onvif',
        trigger_cooldown_duration: 180,
        prealarm_duration: 10,
        event_video_duration: 20,
        active_stream_index: 1,
        streams: [{}, {
            rtsp_url: 'rtsp://url',
            frame_rate_limit: 15,
            gov_length: 15
        }]
    };
    const cameraWithoutUser = {
        _id: (0, _powMongodbFixtures.createObjectId)('123456789a123456789b1234'),
        public_address: '123.123.123.123',
        web_port: 80,
        trigger_cooldown_duration: 180,
        prealarm_duration: 10,
        event_video_duration: 20,
        active_stream_index: 1,
        streams: [{}, {
            rtsp_url: 'rtsp://url',
            frame_rate_limit: 15,
            gov_length: 15
        }]
    };
    const invalidId = '123456789a123456789b1235';
    const invalidIndex = 2;

    before(function before(done) {
        this.timeout(5000);
        fixtures.clearAndLoad({
            cameras: [camera, cameraWithoutRTSP, cameraWithoutHost, cameraWithoutUser]
        }, err => {
            if (err) {
                throw new Error(err.message);
            }
            dataAPI.initialize({
                environment: 'unit-test',
                heartbeatInterval: 10,
                logLevel: 'DEBUG',
                mongoUrl: process.env.CLIO_MONGO_URL,
                port: 15925
            });
            dataAPI.start(done);
        });
    });

    it('GET existing stream should succeed', done => {
        const host = camera.public_address;
        const port = camera.web_port;
        const expectedResult = {
            rtspUrl: camera.streams[camera.active_stream_index].rtsp_url,
            httpUrl: `http://${camera.username}:${camera.password}@${host}:${port}`,
            idleTime: camera.trigger_cooldown_duration * 1000,
            preAlarmSec: camera.prealarm_duration,
            videoDurationSec: camera.event_video_duration,
            frameRateRef: camera.streams[camera.active_stream_index].frame_rate_limit,
            gopSizeRef: camera.streams[camera.active_stream_index].gov_length
        };
        request(dataAPI.expressApp).get(`/cameras/${camera._id}/streams/${camera.active_stream_index}/event-info`).expect(200).expect(res => _chai.assert.deepEqual(expectedResult, res.body)).end( /** @type function */done);
    });

    it('GET no user camera should succeed', done => {
        const activeIndex = cameraWithoutUser.active_stream_index;
        const expectedResult = {
            rtspUrl: cameraWithoutUser.streams[cameraWithoutUser.active_stream_index].rtsp_url,
            httpUrl: `http://${cameraWithoutUser.public_address}:${cameraWithoutUser.web_port}`,
            idleTime: cameraWithoutUser.trigger_cooldown_duration * 1000,
            preAlarmSec: cameraWithoutUser.prealarm_duration,
            videoDurationSec: cameraWithoutUser.event_video_duration,
            frameRateRef: cameraWithoutUser.streams[activeIndex].frame_rate_limit,
            gopSizeRef: cameraWithoutUser.streams[activeIndex].gov_length
        };
        request(dataAPI.expressApp).get(`/cameras/${cameraWithoutUser._id.toHexString()}/streams/${activeIndex}/event-info`).expect(200).expect(res => _chai.assert.deepEqual(expectedResult, res.body)).end( /** @type function */done);
    });

    it('GET nonexistent camera should fail', done => {
        request(dataAPI.expressApp).get(`/cameras/${invalidId}/streams/0/event-info`).expect(500).end( /** @type function */done);
    });

    it('GET nonexistent stream should fail', done => {
        request(dataAPI.expressApp).get(`/cameras/${camera._id.toHexString()}/streams/${invalidIndex}/event-info`).expect(500).end( /** @type function */done);
    });

    it('GET should fail if no RTSP URL', done => {
        request(dataAPI.expressApp).get(`/cameras/${cameraWithoutRTSP._id.toHexString()}/streams/${cameraWithoutRTSP.active_stream_index}/event-info`).expect(500).end( /** @type function */done);
    });

    it('GET should fail if no host', done => {
        request(dataAPI.expressApp).get(`/cameras/${cameraWithoutHost._id.toHexString()}/streams/${cameraWithoutHost.active_stream_index}/event-info`).expect(500).end( /** @type function */done);
    });

    after(done => dataAPI.stop(done));
});
//# sourceMappingURL=mountEventInfo.spec.js.map