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