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