54acb161002b1f16c433e62c654e3c25de91e627
[WebKit.git] / Websites / perf.webkit.org / server-tests / api-manifest-tests.js
1 'use strict';
2
3 const assert = require('assert');
4
5 require('../tools/js/v3-models.js');
6
7 const MockData = require('./resources/mock-data.js');
8 const TestServer = require('./resources/test-server.js');
9 const prepareServerTest = require('./resources/common-operations.js').prepareServerTest;
10
11 describe('/api/manifest', function () {
12     prepareServerTest(this);
13
14     it("should generate an empty manifest when database is empty", () => {
15         return TestServer.remoteAPI().getJSON('/api/manifest').then((manifest) => {
16             assert.deepEqual(Object.keys(manifest).sort(), ['all', 'bugTrackers', 'builders', 'dashboard', 'dashboards',
17                 'elapsedTime', 'fileUploadSizeLimit', 'metrics', 'repositories', 'siteTitle', 'status', 'summaryPages', 'tests', 'triggerables']);
18
19             assert.equal(typeof(manifest.elapsedTime), 'number');
20             delete manifest.elapsedTime;
21
22             assert.deepStrictEqual(manifest, {
23                 siteTitle: TestServer.testConfig().siteTitle,
24                 all: {},
25                 bugTrackers: {},
26                 builders: {},
27                 dashboard: {},
28                 dashboards: {},
29                 fileUploadSizeLimit: 2097152, // 2MB during testing.
30                 metrics: {},
31                 repositories: {},
32                 tests: {},
33                 triggerables: {},
34                 summaryPages: [],
35                 status: 'OK'
36             });
37         });
38     });
39
40     const bugzillaData = {id: 1, name: 'Bugzilla', bug_url: 'https://webkit.org/b/$number', new_bug_url: 'https://bugs.webkit.org/'};
41     const radarData = {id: 2, name: 'Radar'};
42
43     it("should generate manifest with bug trackers without repositories", () => {
44         return TestServer.database().insert('bug_trackers', bugzillaData).then(() => {
45             return TestServer.remoteAPI().getJSON('/api/manifest');
46         }).then((content) => {
47             assert.deepEqual(content.bugTrackers, {1: {name: 'Bugzilla', bugUrl: 'https://webkit.org/b/$number',
48                 newBugUrl: 'https://bugs.webkit.org/', repositories: null}});
49
50             let manifest = Manifest._didFetchManifest(content);
51             let tracker = BugTracker.findById(1);
52             assert(tracker);
53             assert.equal(tracker.name(), 'Bugzilla');
54             assert.equal(tracker.bugUrl(123), 'https://webkit.org/b/123');
55             assert.equal(tracker.newBugUrl(), 'https://bugs.webkit.org/');
56         });
57     });
58
59     it("should generate manifest with bug trackers and repositories", () => {
60         let db = TestServer.database();
61         return Promise.all([
62             db.insert('bug_trackers', bugzillaData),
63             db.insert('bug_trackers', radarData),
64             db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
65             db.insert('repositories', {id: 9, name: 'OS X'}),
66             db.insert('repositories', {id: 22, name: 'iOS'}),
67             db.insert('tracker_repositories', {tracker: bugzillaData.id, repository: 11}),
68             db.insert('tracker_repositories', {tracker: radarData.id, repository: 9}),
69             db.insert('tracker_repositories', {tracker: radarData.id, repository: 22}),
70         ]).then(() => {
71             return TestServer.remoteAPI().getJSON('/api/manifest');
72         }).then((content) => {
73             let manifest = Manifest._didFetchManifest(content);
74
75             let webkit = Repository.findById(11);
76             assert(webkit);
77             assert.equal(webkit.name(), 'WebKit');
78             assert.equal(webkit.urlForRevision(123), 'https://trac.webkit.org/123');
79
80             let osx = Repository.findById(9);
81             assert(osx);
82             assert.equal(osx.name(), 'OS X');
83
84             let ios = Repository.findById(22);
85             assert(ios);
86             assert.equal(ios.name(), 'iOS');
87
88             let tracker = BugTracker.findById(1);
89             assert(tracker);
90             assert.equal(tracker.name(), 'Bugzilla');
91             assert.equal(tracker.bugUrl(123), 'https://webkit.org/b/123');
92             assert.equal(tracker.newBugUrl(), 'https://bugs.webkit.org/');
93             assert.deepEqual(tracker.repositories(), [webkit]);
94
95             tracker = BugTracker.findById(2);
96             assert(tracker);
97             assert.equal(tracker.name(), 'Radar');
98             assert.deepEqual(Repository.sortByName(tracker.repositories()), [osx, ios]);
99         });
100     });
101
102     it("should generate manifest with builders", () => {
103         let db = TestServer.database();
104         return Promise.all([
105             db.insert('builders', {id: 1, name: 'SomeBuilder', password_hash: 'a',
106                 build_url: 'https://build.webkit.org/builders/$builderName/build/$buildNumber'}),
107             db.insert('builders', {id: 2, name: 'SomeOtherBuilder', password_hash: 'b'})
108         ]).then(() => {
109             return TestServer.remoteAPI().getJSON('/api/manifest');
110         }).then((content) => {
111             assert.deepEqual(content.builders, {
112                 '1': {name: 'SomeBuilder', buildUrl: 'https://build.webkit.org/builders/$builderName/build/$buildNumber'},
113                 '2': {name: 'SomeOtherBuilder', buildUrl: null}
114             });
115
116             let manifest = Manifest._didFetchManifest(content);
117
118             let builder = Builder.findById(1);
119             assert(builder);
120             assert.equal(builder.name(), 'SomeBuilder');
121             assert.equal(builder.urlForBuild(123), 'https://build.webkit.org/builders/SomeBuilder/build/123');
122
123             builder = Builder.findById(2);
124             assert(builder);
125             assert.equal(builder.name(), 'SomeOtherBuilder');
126             assert.equal(builder.urlForBuild(123), null);
127         });
128     });
129
130     it("should generate manifest with tests, metrics, and platforms", () => {
131         let db = TestServer.database();
132         return Promise.all([
133             db.insert('tests', {id: 1, name: 'SomeTest'}),
134             db.insert('tests', {id: 2, name: 'SomeOtherTest'}),
135             db.insert('tests', {id: 3, name: 'ChildTest', parent: 1}),
136             db.insert('tests', {id: 4, name: 'GrandChild', parent: 3}),
137             db.insert('aggregators', {id: 200, name: 'Total'}),
138             db.insert('test_metrics', {id: 5, test: 1, name: 'Time'}),
139             db.insert('test_metrics', {id: 6, test: 2, name: 'Time', aggregator: 200}),
140             db.insert('test_metrics', {id: 7, test: 2, name: 'Malloc', aggregator: 200}),
141             db.insert('test_metrics', {id: 8, test: 3, name: 'Time'}),
142             db.insert('test_metrics', {id: 9, test: 4, name: 'Time'}),
143             db.insert('platforms', {id: 23, name: 'iOS 9 iPhone 5s'}),
144             db.insert('platforms', {id: 46, name: 'Trunk Mavericks'}),
145             db.insert('test_configurations', {id: 101, metric: 5, platform: 46, type: 'current'}),
146             db.insert('test_configurations', {id: 102, metric: 6, platform: 46, type: 'current'}),
147             db.insert('test_configurations', {id: 103, metric: 7, platform: 46, type: 'current'}),
148             db.insert('test_configurations', {id: 104, metric: 8, platform: 46, type: 'current'}),
149             db.insert('test_configurations', {id: 105, metric: 9, platform: 46, type: 'current'}),
150             db.insert('test_configurations', {id: 106, metric: 5, platform: 23, type: 'current'}),
151             db.insert('test_configurations', {id: 107, metric: 5, platform: 23, type: 'baseline'}),
152         ]).then(() => {
153             return TestServer.remoteAPI().getJSON('/api/manifest');
154         }).then((content) => {
155             assert.deepEqual(content.tests, {
156                 "1": {"name": "SomeTest", "parentId": null, "url": null},
157                 "2": {"name": "SomeOtherTest", "parentId": null, "url": null},
158                 "3": {"name": "ChildTest", "parentId": "1", "url": null},
159                 "4": {"name": "GrandChild", "parentId": "3", "url": null},
160             });
161
162             assert.deepEqual(content.metrics, {
163                 '5': {name: 'Time', test: '1', aggregator: null},
164                 '6': {name: 'Time', test: '2', aggregator: 'Total'},
165                 '7': {name: 'Malloc', test: '2', aggregator: 'Total'},
166                 '8': {name: 'Time', test: '3', aggregator: null},
167                 '9': {name: 'Time', test: '4', aggregator: null},
168             });
169
170             let manifest = Manifest._didFetchManifest(content);
171
172             let someTest = Test.findById(1);
173             let someTestMetric = Metric.findById(5);
174             let someOtherTest = Test.findById(2);
175             let someOtherTestTime = Metric.findById(6);
176             let someOtherTestMalloc = Metric.findById(7);
177             let childTest = Test.findById(3);
178             let childTestMetric = Metric.findById(8);
179             let grandChildTest = Test.findById(4);
180             let ios9iphone5s = Platform.findById(23);
181             let mavericks = Platform.findById(46);
182             assert(someTest);
183             assert(someTestMetric);
184             assert(someOtherTest);
185             assert(someOtherTestTime);
186             assert(someOtherTestMalloc);
187             assert(childTest);
188             assert(childTestMetric);
189             assert(grandChildTest);
190             assert(ios9iphone5s);
191             assert(mavericks);
192
193             assert.equal(mavericks.name(), 'Trunk Mavericks');
194             assert(mavericks.hasTest(someTest));
195             assert(mavericks.hasTest(someOtherTest));
196             assert(mavericks.hasTest(childTest));
197             assert(mavericks.hasTest(grandChildTest));
198             assert(mavericks.hasMetric(someTestMetric));
199             assert(mavericks.hasMetric(someOtherTestTime));
200             assert(mavericks.hasMetric(someOtherTestMalloc));
201             assert(mavericks.hasMetric(childTestMetric));
202
203             assert.equal(ios9iphone5s.name(), 'iOS 9 iPhone 5s');
204             assert(ios9iphone5s.hasTest(someTest));
205             assert(!ios9iphone5s.hasTest(someOtherTest));
206             assert(!ios9iphone5s.hasTest(childTest));
207             assert(!ios9iphone5s.hasTest(grandChildTest));
208             assert(ios9iphone5s.hasMetric(someTestMetric));
209             assert(!ios9iphone5s.hasMetric(someOtherTestTime));
210             assert(!ios9iphone5s.hasMetric(someOtherTestMalloc));
211             assert(!ios9iphone5s.hasMetric(childTestMetric));
212
213             assert.equal(someTest.name(), 'SomeTest');
214             assert.equal(someTest.parentTest(), null);
215             assert.deepEqual(someTest.path(), [someTest]);
216             assert(!someTest.onlyContainsSingleMetric());
217             assert.deepEqual(someTest.childTests(), [childTest]);
218             assert.deepEqual(someTest.metrics(), [someTestMetric]);
219
220             assert.equal(someTestMetric.name(), 'Time');
221             assert.equal(someTestMetric.aggregatorName(), null);
222             assert.equal(someTestMetric.label(), 'Time');
223             assert.deepEqual(someTestMetric.childMetrics(), childTest.metrics());
224             assert.equal(someTestMetric.fullName(), 'SomeTest : Time');
225
226             assert.equal(someOtherTest.name(), 'SomeOtherTest');
227             assert.equal(someOtherTest.parentTest(), null);
228             assert.deepEqual(someOtherTest.path(), [someOtherTest]);
229             assert(!someOtherTest.onlyContainsSingleMetric());
230             assert.deepEqual(someOtherTest.childTests(), []);
231             assert.equal(someOtherTest.metrics().length, 2);
232             assert.equal(someOtherTest.metrics()[0].name(), 'Time');
233             assert.equal(someOtherTest.metrics()[0].aggregatorName(), 'Total');
234             assert.equal(someOtherTest.metrics()[0].label(), 'Time : Total');
235             assert.equal(someOtherTest.metrics()[0].childMetrics().length, 0);
236             assert.equal(someOtherTest.metrics()[0].fullName(), 'SomeOtherTest : Time : Total');
237             assert.equal(someOtherTest.metrics()[1].name(), 'Malloc');
238             assert.equal(someOtherTest.metrics()[1].aggregatorName(), 'Total');
239             assert.equal(someOtherTest.metrics()[1].label(), 'Malloc : Total');
240             assert.equal(someOtherTest.metrics()[1].childMetrics().length, 0);
241             assert.equal(someOtherTest.metrics()[1].fullName(), 'SomeOtherTest : Malloc : Total');
242
243             assert.equal(childTest.name(), 'ChildTest');
244             assert.equal(childTest.parentTest(), someTest);
245             assert.deepEqual(childTest.path(), [someTest, childTest]);
246             assert(!childTest.onlyContainsSingleMetric());
247             assert.deepEqual(childTest.childTests(), [grandChildTest]);
248             assert.equal(childTest.metrics().length, 1);
249             assert.equal(childTest.metrics()[0].label(), 'Time');
250             assert.equal(childTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest : Time');
251
252             assert.equal(grandChildTest.name(), 'GrandChild');
253             assert.equal(grandChildTest.parentTest(), childTest);
254             assert.deepEqual(grandChildTest.path(), [someTest, childTest, grandChildTest]);
255             assert(grandChildTest.onlyContainsSingleMetric());
256             assert.deepEqual(grandChildTest.childTests(), []);
257             assert.equal(grandChildTest.metrics().length, 1);
258             assert.equal(grandChildTest.metrics()[0].label(), 'Time');
259             assert.equal(grandChildTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest \u220B GrandChild : Time');
260         });
261     });
262
263     it("should generate manifest with triggerables", () => {
264         let db = TestServer.database();
265         return Promise.all([
266             db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
267             db.insert('repositories', {id: 9, name: 'OS X'}),
268             db.insert('repositories', {id: 101, name: 'WebKit', owner: 9, url: 'https://trac.webkit.org/$1'}),
269             db.insert('build_triggerables', {id: 200, name: 'build.webkit.org'}),
270             db.insert('build_triggerables', {id: 201, name: 'ios-build.webkit.org'}),
271             db.insert('build_triggerables', {id: 202, name: 'mac-build.webkit.org', disabled: true}),
272             db.insert('tests', {id: 1, name: 'SomeTest'}),
273             db.insert('tests', {id: 2, name: 'SomeOtherTest'}),
274             db.insert('tests', {id: 3, name: 'ChildTest', parent: 1}),
275             db.insert('platforms', {id: 23, name: 'iOS 9 iPhone 5s'}),
276             db.insert('platforms', {id: 46, name: 'Trunk Mavericks'}),
277             db.insert('platforms', {id: 104, name: 'Trunk Sierra MacBookPro11,2'}),
278             db.insert('test_metrics', {id: 5, test: 1, name: 'Time'}),
279             db.insert('test_metrics', {id: 8, test: 2, name: 'FrameRate'}),
280             db.insert('test_metrics', {id: 9, test: 3, name: 'Time'}),
281             db.insert('test_configurations', {id: 101, metric: 5, platform: 46, type: 'current'}),
282             db.insert('test_configurations', {id: 102, metric: 8, platform: 46, type: 'current'}),
283             db.insert('test_configurations', {id: 103, metric: 9, platform: 46, type: 'current'}),
284             db.insert('test_configurations', {id: 104, metric: 5, platform: 23, type: 'current'}),
285             db.insert('test_configurations', {id: 105, metric: 8, platform: 23, type: 'current'}),
286             db.insert('test_configurations', {id: 106, metric: 9, platform: 23, type: 'current'}),
287             db.insert('test_configurations', {id: 107, metric: 5, platform: 104, type: 'current'}),
288             db.insert('test_configurations', {id: 108, metric: 8, platform: 104, type: 'current'}),
289             db.insert('test_configurations', {id: 109, metric: 9, platform: 104, type: 'current'}),
290             db.insert('triggerable_repository_groups', {id: 300, triggerable: 200, name: 'default'}),
291             db.insert('triggerable_repository_groups', {id: 301, triggerable: 201, name: 'default'}),
292             db.insert('triggerable_repository_groups', {id: 302, triggerable: 202, name: 'system-and-webkit'}),
293             db.insert('triggerable_repository_groups', {id: 312, triggerable: 202, name: 'system-and-roots', accepts_roots: true}),
294             db.insert('triggerable_repositories', {group: 300, repository: 11}),
295             db.insert('triggerable_repositories', {group: 301, repository: 11}),
296             db.insert('triggerable_repositories', {group: 302, repository: 11}),
297             db.insert('triggerable_repositories', {group: 302, repository: 9}),
298             db.insert('triggerable_repositories', {group: 312, repository: 9}),
299             db.insert('triggerable_configurations', {triggerable: 200, test: 1, platform: 46}),
300             db.insert('triggerable_configurations', {triggerable: 200, test: 2, platform: 46}),
301             db.insert('triggerable_configurations', {triggerable: 201, test: 1, platform: 23}),
302             db.insert('triggerable_configurations', {triggerable: 201, test: 2, platform: 23}),
303             db.insert('triggerable_configurations', {triggerable: 202, test: 1, platform: 104}),
304             db.insert('triggerable_configurations', {triggerable: 202, test: 2, platform: 104}),
305         ]).then(() => {
306             return Manifest.fetch();
307         }).then(() => {
308             const webkit = Repository.findById(11);
309             assert.equal(webkit.name(), 'WebKit');
310             assert.equal(webkit.urlForRevision(123), 'https://trac.webkit.org/123');
311
312             const osWebkit1 = Repository.findById(101);
313             assert.equal(osWebkit1.name(), 'WebKit');
314             assert.equal(osWebkit1.owner(), 9);
315             assert.equal(osWebkit1.urlForRevision(123), 'https://trac.webkit.org/123');
316
317             const osx = Repository.findById(9);
318             assert.equal(osx.name(), 'OS X');
319
320             const someTest = Test.findById(1);
321             assert.equal(someTest.name(), 'SomeTest');
322
323             const someOtherTest = Test.findById(2);
324             assert.equal(someOtherTest.name(), 'SomeOtherTest');
325
326             const childTest = Test.findById(3);
327             assert.equal(childTest.name(), 'ChildTest');
328
329             const ios9iphone5s = Platform.findById(23);
330             assert.equal(ios9iphone5s.name(), 'iOS 9 iPhone 5s');
331
332             const mavericks = Platform.findById(46);
333             assert.equal(mavericks.name(), 'Trunk Mavericks');
334
335             const sierra = Platform.findById(104);
336             assert.equal(sierra.name(), 'Trunk Sierra MacBookPro11,2');
337
338             assert.equal(Triggerable.all().length, 3);
339
340             const osxTriggerable = Triggerable.findByTestConfiguration(someTest, mavericks);
341             assert.equal(osxTriggerable.name(), 'build.webkit.org');
342             assert.deepEqual(osxTriggerable.acceptedRepositories(), [webkit]);
343
344             assert.equal(Triggerable.findByTestConfiguration(someOtherTest, mavericks), osxTriggerable);
345             assert.equal(Triggerable.findByTestConfiguration(childTest, mavericks), osxTriggerable);
346
347             const iosTriggerable = Triggerable.findByTestConfiguration(someOtherTest, ios9iphone5s);
348             assert.notEqual(iosTriggerable, osxTriggerable);
349             assert.equal(iosTriggerable.name(), 'ios-build.webkit.org');
350             assert.deepEqual(iosTriggerable.acceptedRepositories(), [webkit]);
351
352             assert.equal(Triggerable.findByTestConfiguration(someOtherTest, ios9iphone5s), iosTriggerable);
353             assert.equal(Triggerable.findByTestConfiguration(childTest, ios9iphone5s), iosTriggerable);
354
355             const macTriggerable = Triggerable.findByTestConfiguration(someTest, sierra);
356             assert.equal(macTriggerable.name(), 'mac-build.webkit.org');
357             assert.deepEqual(Repository.sortByName(macTriggerable.acceptedRepositories()), [osx, webkit]);
358             assert(macTriggerable.acceptsTest(someTest));
359
360             const groups = macTriggerable.repositoryGroups();
361             assert.deepEqual(groups.length, 2);
362             TriggerableRepositoryGroup.sortByName(groups);
363
364             assert.equal(groups[0].name(), 'system-and-roots');
365             assert.equal(groups[0].acceptsCustomRoots(), true);
366             assert.deepEqual(Repository.sortByName(groups[0].repositories()), [osx]);
367
368             assert.equal(groups[1].name(), 'system-and-webkit');
369             assert.equal(groups[1].acceptsCustomRoots(), false);
370             assert.deepEqual(Repository.sortByName(groups[1].repositories()), [osx, webkit]);
371
372         });
373     });
374
375 });