BuildbotSyncer should be able to fetch JSON from buildbot
[WebKit-https.git] / Websites / perf.webkit.org / server-tests / api-manifest.js
1 'use strict';
2
3 let assert = require('assert');
4
5 require('../tools/js/v3-models.js');
6
7 let TestServer = require('./resources/test-server.js');
8
9 describe('/api/build-requests', function () {
10     this.timeout(10000);
11     TestServer.inject();
12
13     beforeEach(function () {
14         Builder.clearStaticMap();
15         BugTracker.clearStaticMap();
16         Test.clearStaticMap();
17         Metric.clearStaticMap();
18         Platform.clearStaticMap();
19         Repository.clearStaticMap();
20     });
21
22     it("should generate an empty manifest when database is empty", function (done) {
23         TestServer.remoteAPI().getJSON('/api/manifest').then(function (manifest) {
24             assert.deepEqual(Object.keys(manifest).sort(), ['all', 'bugTrackers', 'builders', 'dashboard', 'dashboards',
25                 'elapsedTime', 'metrics', 'repositories', 'siteTitle', 'status', 'tests']);
26
27             assert.equal(typeof(manifest.elapsedTime), 'number');
28             delete manifest.elapsedTime;
29
30             assert.deepEqual(manifest, {
31                 siteTitle: TestServer.testConfig().siteTitle,
32                 all: {},
33                 bugTrackers: {},
34                 builders: {},
35                 dashboard: {},
36                 dashboards: {},
37                 metrics: {},
38                 repositories: {},
39                 tests: {},
40                 status: 'OK'
41             });
42             done();
43         }).catch(done);
44     });
45
46     const bugzillaData = {id: 1, name: 'Bugzilla', bug_url: 'https://webkit.org/b/$number', new_bug_url: 'https://bugs.webkit.org/'};
47     const radarData = {id: 2, name: 'Radar'};
48
49     it("should generate manifest with bug trackers without repositories", function (done) {
50         TestServer.database().connect();
51         TestServer.database().insert('bug_trackers', bugzillaData).then(function () {
52             return TestServer.remoteAPI().getJSON('/api/manifest');
53         }).then(function (content) {
54             assert.deepEqual(content.bugTrackers, {1: {name: 'Bugzilla', bugUrl: 'https://webkit.org/b/$number',
55                 newBugUrl: 'https://bugs.webkit.org/', repositories: null}});
56
57             let manifest = Manifest._didFetchManifest(content);
58             let tracker = BugTracker.findById(1);
59             assert(tracker);
60             assert.equal(tracker.name(), 'Bugzilla');
61             assert.equal(tracker.bugUrl(123), 'https://webkit.org/b/123');
62             assert.equal(tracker.newBugUrl(), 'https://bugs.webkit.org/');
63
64             done();
65         }).catch(done);
66     });
67
68     it("should generate manifest with bug trackers and repositories", function (done) {
69         let db = TestServer.database();
70         db.connect();
71         Promise.all([
72             db.insert('bug_trackers', bugzillaData),
73             db.insert('bug_trackers', radarData),
74             db.insert('repositories', {id: 11, name: 'WebKit', url: 'https://trac.webkit.org/$1'}),
75             db.insert('repositories', {id: 9, name: 'OS X'}),
76             db.insert('repositories', {id: 22, name: 'iOS'}),
77             db.insert('tracker_repositories', {tracker: bugzillaData.id, repository: 11}),
78             db.insert('tracker_repositories', {tracker: radarData.id, repository: 9}),
79             db.insert('tracker_repositories', {tracker: radarData.id, repository: 22}),
80         ]).then(function () {
81             return TestServer.remoteAPI().getJSON('/api/manifest');
82         }).then(function (content) {
83             let manifest = Manifest._didFetchManifest(content);
84
85             let webkit = Repository.findById(11);
86             assert(webkit);
87             assert.equal(webkit.name(), 'WebKit');
88             assert.equal(webkit.urlForRevision(123), 'https://trac.webkit.org/123');
89
90             let osx = Repository.findById(9);
91             assert(osx);
92             assert.equal(osx.name(), 'OS X');
93
94             let ios = Repository.findById(22);
95             assert(ios);
96             assert.equal(ios.name(), 'iOS');
97
98             let tracker = BugTracker.findById(1);
99             assert(tracker);
100             assert.equal(tracker.name(), 'Bugzilla');
101             assert.equal(tracker.bugUrl(123), 'https://webkit.org/b/123');
102             assert.equal(tracker.newBugUrl(), 'https://bugs.webkit.org/');
103             assert.deepEqual(tracker.repositories(), [webkit]);
104
105             tracker = BugTracker.findById(2);
106             assert(tracker);
107             assert.equal(tracker.name(), 'Radar');
108             assert.deepEqual(Repository.sortByName(tracker.repositories()), [osx, ios]);
109
110             done();
111         }).catch(done);
112     });
113
114     it("should generate manifest with builders", function (done) {
115         let db = TestServer.database();
116         db.connect();
117         Promise.all([
118             db.insert('builders', {id: 1, name: 'SomeBuilder', password_hash: 'a',
119                 build_url: 'https://build.webkit.org/builders/$builderName/build/$buildNumber'}),
120             db.insert('builders', {id: 2, name: 'SomeOtherBuilder', password_hash: 'b'})
121         ]).then(function () {
122             return TestServer.remoteAPI().getJSON('/api/manifest');
123         }).then(function (content) {
124             assert.deepEqual(content.builders, {
125                 '1': {name: 'SomeBuilder', buildUrl: 'https://build.webkit.org/builders/$builderName/build/$buildNumber'},
126                 '2': {name: 'SomeOtherBuilder', buildUrl: null}
127             });
128
129             let manifest = Manifest._didFetchManifest(content);
130
131             let builder = Builder.findById(1);
132             assert(builder);
133             assert.equal(builder.name(), 'SomeBuilder');
134             assert.equal(builder.urlForBuild(123), 'https://build.webkit.org/builders/SomeBuilder/build/123');
135
136             builder = Builder.findById(2);
137             assert(builder);
138             assert.equal(builder.name(), 'SomeOtherBuilder');
139             assert.equal(builder.urlForBuild(123), null);
140
141             done();
142         }).catch(done);
143     });
144
145     it("should generate manifest with tests, metrics, and platforms", function (done) {
146         let db = TestServer.database();
147         db.connect();
148         Promise.all([
149             db.insert('tests', {id: 1, name: 'SomeTest'}),
150             db.insert('tests', {id: 2, name: 'SomeOtherTest'}),
151             db.insert('tests', {id: 3, name: 'ChildTest', parent: 1}),
152             db.insert('tests', {id: 4, name: 'GrandChild', parent: 3}),
153             db.insert('aggregators', {id: 200, name: 'Total'}),
154             db.insert('test_metrics', {id: 5, test: 1, name: 'Time'}),
155             db.insert('test_metrics', {id: 6, test: 2, name: 'Time', aggregator: 200}),
156             db.insert('test_metrics', {id: 7, test: 2, name: 'Malloc', aggregator: 200}),
157             db.insert('test_metrics', {id: 8, test: 3, name: 'Time'}),
158             db.insert('test_metrics', {id: 9, test: 4, name: 'Time'}),
159             db.insert('platforms', {id: 23, name: 'iOS 9 iPhone 5s'}),
160             db.insert('platforms', {id: 46, name: 'Trunk Mavericks'}),
161             db.insert('test_configurations', {id: 101, metric: 5, platform: 46, type: 'current'}),
162             db.insert('test_configurations', {id: 102, metric: 6, platform: 46, type: 'current'}),
163             db.insert('test_configurations', {id: 103, metric: 7, platform: 46, type: 'current'}),
164             db.insert('test_configurations', {id: 104, metric: 8, platform: 46, type: 'current'}),
165             db.insert('test_configurations', {id: 105, metric: 9, platform: 46, type: 'current'}),
166             db.insert('test_configurations', {id: 106, metric: 5, platform: 23, type: 'current'}),
167             db.insert('test_configurations', {id: 107, metric: 5, platform: 23, type: 'baseline'}),
168         ]).then(function () {
169             return TestServer.remoteAPI().getJSON('/api/manifest');
170         }).then(function (content) {
171             assert.deepEqual(content.tests, {
172                 "1": {"name": "SomeTest", "parentId": null, "url": null},
173                 "2": {"name": "SomeOtherTest", "parentId": null, "url": null},
174                 "3": {"name": "ChildTest", "parentId": "1", "url": null},
175                 "4": {"name": "GrandChild", "parentId": "3", "url": null},
176             });
177
178             assert.deepEqual(content.metrics, {
179                 '5': {name: 'Time', test: '1', aggregator: null},
180                 '6': {name: 'Time', test: '2', aggregator: 'Total'},
181                 '7': {name: 'Malloc', test: '2', aggregator: 'Total'},
182                 '8': {name: 'Time', test: '3', aggregator: null},
183                 '9': {name: 'Time', test: '4', aggregator: null},
184             });
185
186             let manifest = Manifest._didFetchManifest(content);
187
188             let someTest = Test.findById(1);
189             let someTestMetric = Metric.findById(5);
190             let someOtherTest = Test.findById(2);
191             let someOtherTestTime = Metric.findById(6);
192             let someOtherTestMalloc = Metric.findById(7);
193             let childTest = Test.findById(3);
194             let childTestMetric = Metric.findById(8);
195             let grandChildTest = Test.findById(4);
196             let ios9iphone5s = Platform.findById(23);
197             let mavericks = Platform.findById(46);
198             assert(someTest);
199             assert(someTestMetric);
200             assert(someOtherTest);
201             assert(someOtherTestTime);
202             assert(someOtherTestMalloc);
203             assert(childTest);
204             assert(childTestMetric);
205             assert(grandChildTest);
206             assert(ios9iphone5s);
207             assert(mavericks);
208
209             assert.equal(mavericks.name(), 'Trunk Mavericks');
210             assert(mavericks.hasTest(someTest));
211             assert(mavericks.hasTest(someOtherTest));
212             assert(mavericks.hasTest(childTest));
213             assert(mavericks.hasTest(grandChildTest));
214             assert(mavericks.hasMetric(someTestMetric));
215             assert(mavericks.hasMetric(someOtherTestTime));
216             assert(mavericks.hasMetric(someOtherTestMalloc));
217             assert(mavericks.hasMetric(childTestMetric));
218
219             assert.equal(ios9iphone5s.name(), 'iOS 9 iPhone 5s');
220             assert(ios9iphone5s.hasTest(someTest));
221             assert(!ios9iphone5s.hasTest(someOtherTest));
222             assert(!ios9iphone5s.hasTest(childTest));
223             assert(!ios9iphone5s.hasTest(grandChildTest));
224             assert(ios9iphone5s.hasMetric(someTestMetric));
225             assert(!ios9iphone5s.hasMetric(someOtherTestTime));
226             assert(!ios9iphone5s.hasMetric(someOtherTestMalloc));
227             assert(!ios9iphone5s.hasMetric(childTestMetric));
228
229             assert.equal(someTest.name(), 'SomeTest');
230             assert.equal(someTest.parentTest(), null);
231             assert.deepEqual(someTest.path(), [someTest]);
232             assert(!someTest.onlyContainsSingleMetric());
233             assert.deepEqual(someTest.childTests(), [childTest]);
234             assert.deepEqual(someTest.metrics(), [someTestMetric]);
235
236             assert.equal(someTestMetric.name(), 'Time');
237             assert.equal(someTestMetric.aggregatorName(), null);
238             assert.equal(someTestMetric.label(), 'Time');
239             assert.deepEqual(someTestMetric.childMetrics(), childTest.metrics());
240             assert.equal(someTestMetric.fullName(), 'SomeTest : Time');
241
242             assert.equal(someOtherTest.name(), 'SomeOtherTest');
243             assert.equal(someOtherTest.parentTest(), null);
244             assert.deepEqual(someOtherTest.path(), [someOtherTest]);
245             assert(!someOtherTest.onlyContainsSingleMetric());
246             assert.deepEqual(someOtherTest.childTests(), []);
247             assert.equal(someOtherTest.metrics().length, 2);
248             assert.equal(someOtherTest.metrics()[0].name(), 'Time');
249             assert.equal(someOtherTest.metrics()[0].aggregatorName(), 'Total');
250             assert.equal(someOtherTest.metrics()[0].label(), 'Time : Total');
251             assert.equal(someOtherTest.metrics()[0].childMetrics().length, 0);
252             assert.equal(someOtherTest.metrics()[0].fullName(), 'SomeOtherTest : Time : Total');
253             assert.equal(someOtherTest.metrics()[1].name(), 'Malloc');
254             assert.equal(someOtherTest.metrics()[1].aggregatorName(), 'Total');
255             assert.equal(someOtherTest.metrics()[1].label(), 'Malloc : Total');
256             assert.equal(someOtherTest.metrics()[1].childMetrics().length, 0);
257             assert.equal(someOtherTest.metrics()[1].fullName(), 'SomeOtherTest : Malloc : Total');
258
259             assert.equal(childTest.name(), 'ChildTest');
260             assert.equal(childTest.parentTest(), someTest);
261             assert.deepEqual(childTest.path(), [someTest, childTest]);
262             assert(!childTest.onlyContainsSingleMetric());
263             assert.deepEqual(childTest.childTests(), [grandChildTest]);
264             assert.equal(childTest.metrics().length, 1);
265             assert.equal(childTest.metrics()[0].label(), 'Time');
266             assert.equal(childTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest : Time');
267
268             assert.equal(grandChildTest.name(), 'GrandChild');
269             assert.equal(grandChildTest.parentTest(), childTest);
270             assert.deepEqual(grandChildTest.path(), [someTest, childTest, grandChildTest]);
271             assert(grandChildTest.onlyContainsSingleMetric());
272             assert.deepEqual(grandChildTest.childTests(), []);
273             assert.equal(grandChildTest.metrics().length, 1);
274             assert.equal(grandChildTest.metrics()[0].label(), 'Time');
275             assert.equal(grandChildTest.metrics()[0].fullName(), 'SomeTest \u220B ChildTest \u220B GrandChild : Time');
276
277             done();
278         }).catch(done);
279     });
280
281 });