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 });