Make unit tests return a promise instead of manually calling done
[WebKit-https.git] / Websites / perf.webkit.org / unit-tests / checkconfig.js
1 'use strict';
2
3 const assert = require('assert');
4 const fs = require('fs');
5
6 const Config = require('../tools/js/config.js');
7 const Database = require('../tools/js/database.js');
8
9 describe('config.json', () => {
10     it('should be a valid file', () => {
11         assert.doesNotThrow(() => {
12             fs.readFileSync(Config.configFilePath())
13         });
14     });
15
16     it('should be a valid JSON', () => {
17         assert.doesNotThrow(() => {
18             JSON.parse(fs.readFileSync(Config.configFilePath()));
19         });
20     });
21
22     it('should define `siteTitle`', () => {
23         assert.equal(typeof Config.value('siteTitle'), 'string');
24     });
25
26     it('should define `dataDirectory`', () => {
27         assert.ok(Config.value('dataDirectory'));
28         assert.ok(fs.existsSync(Config.path('dataDirectory')), 'dataDirectory should exist');
29         assert.ok(fs.statSync(Config.path('dataDirectory')).isDirectory(), 'dataDirectory should be a dictionary');
30     });
31
32     it('should define `jsonCacheMaxAge`', () => {
33         assert.equal(typeof Config.value('jsonCacheMaxAge'), 'number');
34     });
35
36     it('should define `jsonCacheMaxAge`', () => {
37         assert.equal(typeof Config.value('jsonCacheMaxAge'), 'number');
38     });
39
40     it('should define `clusterStart`', () => {
41         const clusterStart = Config.value('clusterStart');
42         assert.ok(clusterStart instanceof Array);
43         assert.equal(clusterStart.length, [2000, 1, 1, 0, 0].length,
44             'Must specify year, month, date, hour, and minute');
45         const maxYear = (new Date).getFullYear() + 1;
46         assert.ok(clusterStart[0] >= 1970 && clusterStart[0] <= maxYear, `year must be between 1970 and ${maxYear}`);
47         assert.ok(clusterStart[1] >= 1 && clusterStart[1] <= 12, 'month must be between 1 and 12');
48         assert.ok(clusterStart[2] >= 1 && clusterStart[2] <= 31, 'date must be between 1 and 31');
49         assert.ok(clusterStart[3] >= 0 && clusterStart[3] <= 60, 'minute must be between 0 and 60');
50         assert.ok(clusterStart[4] >= 0 && clusterStart[4] <= 60, 'minute must be between 0 and 60');
51     });
52
53     it('should define `clusterSize`', () => {
54         const clusterSize = Config.value('clusterSize');
55         assert.ok(clusterSize instanceof Array);
56         assert.equal(clusterSize.length, [0, 2, 0].length,
57             'Must specify the number of years, months, and days');
58         assert.equal(typeof clusterSize[0], 'number', 'the number of year must be a number');
59         assert.equal(typeof clusterSize[1], 'number', 'the number of month must be a number');
60         assert.equal(typeof clusterSize[2], 'number', 'the number of days must be a number');
61     });
62
63     describe('`dashboards`', () => {
64         const dashboards = Config.value('dashboards');
65
66         it('should exist for v2 and v3 UI', () => {
67             assert.equal(typeof dashboards, 'object');
68         });
69
70         it('dashboard names that do not contain /', () => {
71             for (let name in dashboards)
72                 assert.ok(name.indexOf('/') < 0, 'Dashboard name "${name}" should not contain "/"');
73         });
74
75         it('each dashboard must be an array', () => {
76             for (let name in dashboards)
77                 assert.ok(dashboards[name] instanceof Array);
78         });
79
80         it('each row in a dashboard must be an array', () => {
81             for (let name in dashboards) {
82                 for (let row of dashboards[name])
83                     console.assert(row instanceof Array);
84             }
85         });
86
87         it('each cell in a dashboard must be an array or a string', () => {
88             for (let name in dashboards) {
89                 for (let row of dashboards[name]) {
90                     for (let cell of row) {
91                         if (cell instanceof Array)
92                             assert.ok(cell.length == 0 || cell.length == 2,
93                                 'Each cell must be empty or specify [platform, metric] pair');
94                         else
95                             assert.equal(typeof cell, 'string');
96                     }
97                 }
98             }
99         });
100
101     });
102
103     describe('`database`', () => {
104         it('should exist', () => {
105             assert.ok(Config.value('database'));
106         });
107
108         it('should define `database.host`', () => {
109             assert.equal(typeof Config.value('database.host'), 'string');
110         });
111
112         it('should define `database.port`', () => {
113             assert.equal(typeof Config.value('database.port'), 'string');
114         });
115
116         it('should define `database.username`', () => {
117             assert.equal(typeof Config.value('database.username'), 'string');
118         });
119
120         it('should define `database.password`', () => {
121             assert.equal(typeof Config.value('database.password'), 'string');
122         });
123
124         it('should define `database.name`', () => {
125             assert.equal(typeof Config.value('database.name'), 'string');
126         });
127
128         it('should be able to connect to the database', () => {
129             let database = new Database;
130             database.connect().then(() => {
131                 database.disconnect();
132             }, (error) => {
133                 database.disconnect();
134                 throw error;
135             });
136         });
137     });
138
139     describe('optional configurations', () => {
140         function assertNullOrType(value, type) {
141             if (value !== null)
142                 assert.equal(typeof value, type);
143         }
144
145         it('`debug` should be `null` or a boolean', () => {
146             assertNullOrType(Config.value('debug'), 'boolean');
147         });
148
149         it('`maintenanceMode` should be `null` or a boolean', () => {
150             assertNullOrType(Config.value('maintenanceMode'), 'boolean');
151         });
152
153         it('`maintenanceDirectory` should be `null` or a string', () => {
154             assertNullOrType(Config.value('maintenanceDirectory'), 'string');
155         });
156
157         it('`maintenanceDirectory` should be a string if `maintenanceMode` is true', () => {
158             if (Config.value('maintenanceMode'))
159                 assert.equal(Config.value('maintenanceDirectory'), 'string');
160         });
161
162         it('`universalSlavePassword` should be `null` or a string', () => {
163             assertNullOrType(Config.value('universalSlavePassword'), 'string');
164         });
165     });
166 });