188 lines
7.1 KiB
JavaScript
188 lines
7.1 KiB
JavaScript
'use strict';
|
|
|
|
const assert = require('assert');
|
|
const fs = require('fs');
|
|
|
|
const Config = require('../tools/js/config.js');
|
|
const Database = require('../tools/js/database.js');
|
|
|
|
describe('config.json', () => {
|
|
it('should be a valid file', () => {
|
|
assert.doesNotThrow(() => {
|
|
fs.readFileSync(Config.configFilePath())
|
|
});
|
|
});
|
|
|
|
it('should be a valid JSON', () => {
|
|
assert.doesNotThrow(() => {
|
|
JSON.parse(fs.readFileSync(Config.configFilePath()));
|
|
});
|
|
});
|
|
|
|
it('should define `siteTitle`', () => {
|
|
assert.equal(typeof Config.value('siteTitle'), 'string');
|
|
});
|
|
|
|
it('should define `dataDirectory`', () => {
|
|
assert.ok(Config.value('dataDirectory'));
|
|
assert.ok(fs.existsSync(Config.path('dataDirectory')), 'dataDirectory should exist');
|
|
assert.ok(fs.statSync(Config.path('dataDirectory')).isDirectory(), 'dataDirectory should be a dictionary');
|
|
});
|
|
|
|
it('should define `jsonCacheMaxAge`', () => {
|
|
assert.equal(typeof Config.value('jsonCacheMaxAge'), 'number');
|
|
});
|
|
|
|
it('should define `jsonCacheMaxAge`', () => {
|
|
assert.equal(typeof Config.value('jsonCacheMaxAge'), 'number');
|
|
});
|
|
|
|
it('should define `clusterStart`', () => {
|
|
const clusterStart = Config.value('clusterStart');
|
|
assert.ok(clusterStart instanceof Array);
|
|
assert.equal(clusterStart.length, [2000, 1, 1, 0, 0].length,
|
|
'Must specify year, month, date, hour, and minute');
|
|
const maxYear = (new Date).getFullYear() + 1;
|
|
assert.ok(clusterStart[0] >= 1970 && clusterStart[0] <= maxYear, `year must be between 1970 and ${maxYear}`);
|
|
assert.ok(clusterStart[1] >= 1 && clusterStart[1] <= 12, 'month must be between 1 and 12');
|
|
assert.ok(clusterStart[2] >= 1 && clusterStart[2] <= 31, 'date must be between 1 and 31');
|
|
assert.ok(clusterStart[3] >= 0 && clusterStart[3] <= 60, 'minute must be between 0 and 60');
|
|
assert.ok(clusterStart[4] >= 0 && clusterStart[4] <= 60, 'minute must be between 0 and 60');
|
|
});
|
|
|
|
it('should define `clusterSize`', () => {
|
|
const clusterSize = Config.value('clusterSize');
|
|
assert.ok(clusterSize instanceof Array);
|
|
assert.equal(clusterSize.length, [0, 2, 0].length,
|
|
'Must specify the number of years, months, and days');
|
|
assert.equal(typeof clusterSize[0], 'number', 'the number of year must be a number');
|
|
assert.equal(typeof clusterSize[1], 'number', 'the number of month must be a number');
|
|
assert.equal(typeof clusterSize[2], 'number', 'the number of days must be a number');
|
|
});
|
|
|
|
describe('`dashboards`', () => {
|
|
const dashboards = Config.value('dashboards');
|
|
|
|
it('should exist for v2 and v3 UI', () => {
|
|
assert.equal(typeof dashboards, 'object');
|
|
});
|
|
|
|
it('dashboard names that do not contain /', () => {
|
|
for (let name in dashboards)
|
|
assert.ok(name.indexOf('/') < 0, 'Dashboard name "${name}" should not contain "/"');
|
|
});
|
|
|
|
it('each dashboard must be an array', () => {
|
|
for (let name in dashboards)
|
|
assert.ok(dashboards[name] instanceof Array);
|
|
});
|
|
|
|
it('each row in a dashboard must be an array', () => {
|
|
for (let name in dashboards) {
|
|
for (let row of dashboards[name])
|
|
console.assert(row instanceof Array);
|
|
}
|
|
});
|
|
|
|
it('each cell in a dashboard must be an array or a string', () => {
|
|
for (let name in dashboards) {
|
|
for (let row of dashboards[name]) {
|
|
for (let cell of row) {
|
|
if (cell instanceof Array)
|
|
assert.ok(cell.length == 0 || cell.length == 2,
|
|
'Each cell must be empty or specify [platform, metric] pair');
|
|
else
|
|
assert.equal(typeof cell, 'string');
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
describe('`database`', () => {
|
|
it('should exist', () => {
|
|
assert.ok(Config.value('database'));
|
|
});
|
|
|
|
it('should define `database.host`', () => {
|
|
assert.equal(typeof Config.value('database.host'), 'string');
|
|
});
|
|
|
|
it('should define `database.port`', () => {
|
|
assert.equal(typeof Config.value('database.port'), 'string');
|
|
});
|
|
|
|
it('should define `database.username`', () => {
|
|
assert.equal(typeof Config.value('database.username'), 'string');
|
|
});
|
|
|
|
it('should define `database.password`', () => {
|
|
assert.equal(typeof Config.value('database.password'), 'string');
|
|
});
|
|
|
|
it('should define `database.name`', () => {
|
|
assert.equal(typeof Config.value('database.name'), 'string');
|
|
});
|
|
|
|
it('should be able to connect to the database', () => {
|
|
let database = new Database;
|
|
database.connect().then(() => {
|
|
database.disconnect();
|
|
}, (error) => {
|
|
database.disconnect();
|
|
throw error;
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('optional configurations', () => {
|
|
function assertNullOrType(value, type) {
|
|
if (value !== null)
|
|
assert.equal(typeof value, type);
|
|
}
|
|
|
|
it('`debug` should be `null` or a boolean', () => {
|
|
assertNullOrType(Config.value('debug'), 'boolean');
|
|
});
|
|
|
|
it('`maintenanceMode` should be `null` or a boolean', () => {
|
|
assertNullOrType(Config.value('maintenanceMode'), 'boolean');
|
|
});
|
|
|
|
it('`maintenanceDirectory` should be `null` or a string', () => {
|
|
assertNullOrType(Config.value('maintenanceDirectory'), 'string');
|
|
});
|
|
|
|
it('`maintenanceDirectory` should be a string if `maintenanceMode` is true', () => {
|
|
if (Config.value('maintenanceMode'))
|
|
assert.equal(Config.value('maintenanceDirectory'), 'string');
|
|
});
|
|
|
|
it('`universalWorkerPassword` should be `null` or a string', () => {
|
|
assertNullOrType(Config.value('universalWorkerPassword'), 'string');
|
|
});
|
|
|
|
it('`database.ssl` should be `null` or a dictionary', () => {
|
|
assertNullOrType(Config.value('database.ssl'), 'object');
|
|
});
|
|
|
|
it('`database.ssl.rootcert` should be `null` or a string', () => {
|
|
assertNullOrType(Config.value('database.ssl.rootcert'), 'string');
|
|
});
|
|
|
|
it('`database.ssl.cert` should be `null` or a string', () => {
|
|
assertNullOrType(Config.value('database.ssl.cert'), 'string');
|
|
});
|
|
|
|
it('`database.ssl.key` should be `null` or a string', () => {
|
|
assertNullOrType(Config.value('database.ssl.key'), 'string');
|
|
});
|
|
|
|
it('`database.ssl.mode` should be `null` or a string in 1 of 6 options', () => {
|
|
assertNullOrType(Config.value('database.ssl.mode'), 'string');
|
|
assert.ok([null, 'disable', 'allow', 'prefer', 'require', 'verify-ca', 'verify-full'].includes(Config.value('database.ssl.mode')))
|
|
});
|
|
});
|
|
});
|