Add sanity check for source origin in WebLoaderStrategy::startPingLoad()
[WebKit-https.git] / Websites / perf.webkit.org / browser-tests / chart-status-evaluator-tests.js
1
2 describe('ChartStatusEvaluator', () => {
3
4     function importEvaluator(context)
5     {
6         const scripts = [
7             'lazily-evaluated-function.js',
8             'components/chart-status-evaluator.js'];
9
10         return ChartTest.importChartScripts(context).then(() => {
11             return context.importScripts(scripts, 'Test', 'Metric', 'ChartStatusEvaluator');
12         }).then(() => {
13             return context.symbols.ChartStatusEvaluator;
14         });
15     }
16
17     function makeMetric(context, name) {
18         const Test = context.symbols.Test;
19         const Metric = context.symbols.Metric;
20
21         const test = new Test(10, {name: 'SomeTest'});
22         const metric = new Metric(1, {name: name, test: test});
23
24         return metric;
25     }
26
27     describe('status on a non-interactive chart', () => {
28
29         it('should report the current value of the latest data point', () => {
30             const context = new BrowsingContext();
31             let evaluator;
32             return importEvaluator(context).then((ChartStatusEvaluator) => {
33                 const chart = ChartTest.createChartWithSampleCluster(context);
34                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
35                 chart.fetchMeasurementSets();
36
37                 const requests = context.symbols.MockRemoteAPI.requests;
38                 expect(requests.length).to.be(1);
39                 ChartTest.respondWithSampleCluster(requests[0]);
40
41                 const metric = makeMetric(context, 'Time');
42                 evaluator = new ChartStatusEvaluator(chart, metric);
43                 expect(evaluator.status()).to.be(null);
44
45                 return waitForComponentsToRender(context);
46             }).then(() => {
47                 const status = evaluator.status();
48                 expect(status).to.not.be(null);
49                 expect(status.comparison).to.be(null);
50                 expect(status.label).to.be(null);
51                 expect(status.currentValue).to.be('116 ms');
52                 expect(status.relativeDelta).to.be(null);
53             })
54         });
55
56         it('should compare the latest current data point to the baseline when for a smaller-is-better unit', () => {
57             const context = new BrowsingContext();
58             let evaluator;
59             return importEvaluator(context).then((ChartStatusEvaluator) => {
60                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'baseline'}]);
61                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
62                 chart.fetchMeasurementSets();
63
64                 const requests = context.symbols.MockRemoteAPI.requests;
65                 expect(requests.length).to.be(1);
66                 ChartTest.respondWithSampleCluster(requests[0]);
67
68                 const metric = makeMetric(context, 'Time');
69                 evaluator = new ChartStatusEvaluator(chart, metric);
70                 expect(evaluator.status()).to.be(null);
71
72                 return waitForComponentsToRender(context);
73             }).then(() => {
74                 const status = evaluator.status();
75                 expect(status).to.not.be(null);
76                 expect(status.comparison).to.be('better');
77                 expect(status.label).to.be('11.5% better than baseline (131 ms)');
78                 expect(status.currentValue).to.be('116 ms');
79                 expect(status.relativeDelta).to.be(null);
80             })
81         });
82
83         it('should compare the latest current data point to the baseline when for a bigger-is-better unit', () => {
84             const context = new BrowsingContext();
85             let evaluator;
86             return importEvaluator(context).then((ChartStatusEvaluator) => {
87                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'baseline'}]);
88                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
89                 chart.fetchMeasurementSets();
90
91                 const requests = context.symbols.MockRemoteAPI.requests;
92                 expect(requests.length).to.be(1);
93                 ChartTest.respondWithSampleCluster(requests[0]);
94
95                 const metric = makeMetric(context, 'Score');
96                 evaluator = new ChartStatusEvaluator(chart, metric);
97                 expect(evaluator.status()).to.be(null);
98
99                 return waitForComponentsToRender(context);
100             }).then(() => {
101                 const status = evaluator.status();
102                 expect(status).to.not.be(null);
103                 expect(status.comparison).to.be('worse');
104                 expect(status.label).to.be('11.5% worse than baseline (131 pt)');
105                 expect(status.currentValue).to.be('116 pt');
106                 expect(status.relativeDelta).to.be(null);
107             })
108         });
109
110         it('should compare the latest current data point to the target when for a smaller-is-better unit', () => {
111             const context = new BrowsingContext();
112             let evaluator;
113             return importEvaluator(context).then((ChartStatusEvaluator) => {
114                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}]);
115                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
116                 chart.fetchMeasurementSets();
117
118                 const requests = context.symbols.MockRemoteAPI.requests;
119                 expect(requests.length).to.be(1);
120                 ChartTest.respondWithSampleCluster(requests[0]);
121
122                 const metric = makeMetric(context, 'Time');
123                 evaluator = new ChartStatusEvaluator(chart, metric);
124                 expect(evaluator.status()).to.be(null);
125
126                 return waitForComponentsToRender(context);
127             }).then(() => {
128                 const status = evaluator.status();
129                 expect(status).to.not.be(null);
130                 expect(status.comparison).to.be('worse');
131                 expect(status.label).to.be('27.5% until target (91.0 ms)');
132                 expect(status.currentValue).to.be('116 ms');
133                 expect(status.relativeDelta).to.be(null);
134             })
135         });
136
137         it('should compare the latest current data point to the target when for a bigger-is-better unit', () => {
138             const context = new BrowsingContext();
139             let evaluator;
140             return importEvaluator(context).then((ChartStatusEvaluator) => {
141                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}]);
142                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
143                 chart.fetchMeasurementSets();
144
145                 const requests = context.symbols.MockRemoteAPI.requests;
146                 expect(requests.length).to.be(1);
147                 ChartTest.respondWithSampleCluster(requests[0]);
148
149                 const metric = makeMetric(context, 'Score');
150                 evaluator = new ChartStatusEvaluator(chart, metric);
151                 expect(evaluator.status()).to.be(null);
152
153                 return waitForComponentsToRender(context);
154             }).then(() => {
155                 const status = evaluator.status();
156                 expect(status).to.not.be(null);
157                 expect(status.comparison).to.be('better');
158                 expect(status.label).to.be('27.5% until target (91.0 pt)');
159                 expect(status.currentValue).to.be('116 pt');
160                 expect(status.relativeDelta).to.be(null);
161             })
162         });
163
164         it('should compare the latest current data point to the target when it is smaller than the baseline for a smaller-is-better unit', () => {
165             const context = new BrowsingContext();
166             let evaluator;
167             return importEvaluator(context).then((ChartStatusEvaluator) => {
168                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
169                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
170                 chart.fetchMeasurementSets();
171
172                 const requests = context.symbols.MockRemoteAPI.requests;
173                 expect(requests.length).to.be(1);
174                 ChartTest.respondWithSampleCluster(requests[0]);
175
176                 const metric = makeMetric(context, 'Time');
177                 evaluator = new ChartStatusEvaluator(chart, metric);
178                 expect(evaluator.status()).to.be(null);
179
180                 return waitForComponentsToRender(context);
181             }).then(() => {
182                 const status = evaluator.status();
183                 expect(status).to.not.be(null);
184                 expect(status.comparison).to.be(null);
185                 expect(status.label).to.be('27.5% until target (91.0 ms)');
186                 expect(status.currentValue).to.be('116 ms');
187                 expect(status.relativeDelta).to.be(null);
188             });
189         });
190
191         it('should compare the latest current data point to the baseline when it is smaller than the baseline for a bigger-is-better unit', () => {
192             const context = new BrowsingContext();
193             let evaluator;
194             return importEvaluator(context).then((ChartStatusEvaluator) => {
195                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
196                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
197                 chart.fetchMeasurementSets();
198
199                 const requests = context.symbols.MockRemoteAPI.requests;
200                 expect(requests.length).to.be(1);
201                 ChartTest.respondWithSampleCluster(requests[0]);
202
203                 const metric = makeMetric(context, 'Score');
204                 evaluator = new ChartStatusEvaluator(chart, metric);
205                 expect(evaluator.status()).to.be(null);
206
207                 return waitForComponentsToRender(context);
208             }).then(() => {
209                 const status = evaluator.status();
210                 expect(status).to.not.be(null);
211                 expect(status.comparison).to.be('worse');
212                 expect(status.label).to.be('11.5% worse than baseline (131 pt)');
213                 expect(status.currentValue).to.be('116 pt');
214                 expect(status.relativeDelta).to.be(null);
215             });
216         });
217
218         it('should compare the latest current data point to the baseline when it is bigger than the baseline and the target for a smaller-is-better unit', () => {
219             const context = new BrowsingContext();
220             let evaluator;
221             return importEvaluator(context).then((ChartStatusEvaluator) => {
222                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
223                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
224                 chart.fetchMeasurementSets();
225
226                 const requests = context.symbols.MockRemoteAPI.requests;
227                 expect(requests.length).to.be(1);
228                 ChartTest.respondWithSampleCluster(requests[0], {baselineIsSmaller: true});
229
230                 const metric = makeMetric(context, 'Time');
231                 evaluator = new ChartStatusEvaluator(chart, metric);
232                 expect(evaluator.status()).to.be(null);
233
234                 return waitForComponentsToRender(context);
235             }).then(() => {
236                 const status = evaluator.status();
237                 expect(status).to.not.be(null);
238                 expect(status.comparison).to.be('worse');
239                 expect(status.label).to.be('274.2% worse than baseline (31.0 ms)');
240                 expect(status.currentValue).to.be('116 ms');
241                 expect(status.relativeDelta).to.be(null);
242             });
243         });
244
245         it('should compare the latest current data point to the target when it is bigger than the baseline but smaller than the target for a bigger-is-better unit', () => {
246             const context = new BrowsingContext();
247             let evaluator;
248             return importEvaluator(context).then((ChartStatusEvaluator) => {
249                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
250                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
251                 chart.fetchMeasurementSets();
252
253                 const requests = context.symbols.MockRemoteAPI.requests;
254                 expect(requests.length).to.be(1);
255                 ChartTest.respondWithSampleCluster(requests[0], {baselineIsSmaller: true, targetIsBigger: true});
256
257                 const metric = makeMetric(context, 'Score');
258                 evaluator = new ChartStatusEvaluator(chart, metric);
259                 expect(evaluator.status()).to.be(null);
260
261                 return waitForComponentsToRender(context);
262             }).then(() => {
263                 const status = evaluator.status();
264                 expect(status).to.not.be(null);
265                 expect(status.comparison).to.be(null);
266                 expect(status.label).to.be('4.1% until target (121 pt)');
267                 expect(status.currentValue).to.be('116 pt');
268                 expect(status.relativeDelta).to.be(null);
269             });
270         });
271
272         it('should compare the latest current data point to the target when it is smaller than the target for a smaller-is-better unit', () => {
273             const context = new BrowsingContext();
274             let evaluator;
275             return importEvaluator(context).then((ChartStatusEvaluator) => {
276                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
277                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
278                 chart.fetchMeasurementSets();
279
280                 const requests = context.symbols.MockRemoteAPI.requests;
281                 expect(requests.length).to.be(1);
282                 ChartTest.respondWithSampleCluster(requests[0], {targetIsBigger: true});
283
284                 const metric = makeMetric(context, 'Time');
285                 evaluator = new ChartStatusEvaluator(chart, metric);
286                 expect(evaluator.status()).to.be(null);
287
288                 return waitForComponentsToRender(context);
289             }).then(() => {
290                 const status = evaluator.status();
291                 expect(status).to.not.be(null);
292                 expect(status.comparison).to.be('better');
293                 expect(status.label).to.be('4.1% better than target (121 ms)');
294                 expect(status.currentValue).to.be('116 ms');
295                 expect(status.relativeDelta).to.be(null);
296             });
297         });
298
299         it('should compare the latest current data point to the baseline when it is smaller than the target but bigger than the baseline for a bigger-is-better unit', () => {
300             const context = new BrowsingContext();
301             let evaluator;
302             return importEvaluator(context).then((ChartStatusEvaluator) => {
303                 const chart = ChartTest.createChartWithSampleCluster(context, [{type: 'current'}, {type: 'target'}, {type: 'baseline'}]);
304                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
305                 chart.fetchMeasurementSets();
306
307                 const requests = context.symbols.MockRemoteAPI.requests;
308                 expect(requests.length).to.be(1);
309                 ChartTest.respondWithSampleCluster(requests[0], {baselineIsSmaller: true, targetIsBigger: true});
310
311                 const metric = makeMetric(context, 'Score');
312                 evaluator = new ChartStatusEvaluator(chart, metric);
313                 expect(evaluator.status()).to.be(null);
314
315                 return waitForComponentsToRender(context);
316             }).then(() => {
317                 const status = evaluator.status();
318                 expect(status).to.not.be(null);
319                 expect(status.comparison).to.be(null);
320                 expect(status.label).to.be('4.1% until target (121 pt)');
321                 expect(status.currentValue).to.be('116 pt');
322                 expect(status.relativeDelta).to.be(null);
323             });
324         });
325     });
326
327     describe('status on an interactive chart', () => {
328
329         it('should not report the current value of the latest data point', () => {
330             const context = new BrowsingContext();
331             let evaluator;
332             return importEvaluator(context).then((ChartStatusEvaluator) => {
333                 const chart = ChartTest.createInteractiveChartWithSampleCluster(context);
334                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
335                 chart.fetchMeasurementSets();
336
337                 const requests = context.symbols.MockRemoteAPI.requests;
338                 expect(requests.length).to.be(1);
339                 ChartTest.respondWithSampleCluster(requests[0]);
340
341                 const metric = makeMetric(context, 'Time');
342                 evaluator = new ChartStatusEvaluator(chart, metric);
343                 expect(evaluator.status()).to.be(null);
344
345                 return waitForComponentsToRender(context);
346             }).then(() => {
347                 expect(evaluator.status()).to.be(null);
348             })
349         });
350
351         it('should report the current value and the relative delta when there is a locked indicator', () => {
352             const context = new BrowsingContext();
353             let chart;
354             let evaluator;
355             return importEvaluator(context).then((ChartStatusEvaluator) => {
356                 chart = ChartTest.createInteractiveChartWithSampleCluster(context);
357                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
358                 chart.fetchMeasurementSets();
359
360                 const requests = context.symbols.MockRemoteAPI.requests;
361                 expect(requests.length).to.be(1);
362                 ChartTest.respondWithSampleCluster(requests[0]);
363
364                 const metric = makeMetric(context, 'Time');
365                 evaluator = new ChartStatusEvaluator(chart, metric);
366                 expect(evaluator.status()).to.be(null);
367
368                 return waitForComponentsToRender(context);
369             }).then(() => {
370                 expect(evaluator.status()).to.be(null);
371
372                 const currentView = chart.sampledTimeSeriesData('current');
373                 chart.setIndicator(currentView.lastPoint().id, true);
374
375                 let status = evaluator.status();
376                 expect(status).to.not.be(null);
377                 expect(status.comparison).to.be(null);
378                 expect(status.label).to.be(null);
379                 expect(status.currentValue).to.be('116 ms');
380                 expect(status.relativeDelta).to.be('-6%');
381
382                 chart.setIndicator(currentView.previousPoint(currentView.lastPoint()).id, true);
383                 status = evaluator.status();
384                 expect(status).to.not.be(null);
385                 expect(status.comparison).to.be(null);
386                 expect(status.label).to.be(null);
387                 expect(status.currentValue).to.be('124 ms');
388                 expect(status.relativeDelta).to.be('10%');
389
390                 chart.setIndicator(currentView.firstPoint().id, true);
391                 status = evaluator.status();
392                 expect(status).to.not.be(null);
393                 expect(status.comparison).to.be(null);
394                 expect(status.label).to.be(null);
395                 expect(status.currentValue).to.be('100 ms');
396                 expect(status.relativeDelta).to.be(null);
397
398                 return waitForComponentsToRender(context);
399             });
400         });
401
402         it('should report the current value and the relative delta when there is a selection with at least two points', () => {
403             const context = new BrowsingContext();
404             let chart;
405             let evaluator;
406             return importEvaluator(context).then((ChartStatusEvaluator) => {
407                 chart = ChartTest.createInteractiveChartWithSampleCluster(context);
408                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
409                 chart.fetchMeasurementSets();
410
411                 const requests = context.symbols.MockRemoteAPI.requests;
412                 expect(requests.length).to.be(1);
413                 ChartTest.respondWithSampleCluster(requests[0]);
414
415                 const metric = makeMetric(context, 'Time');
416                 evaluator = new ChartStatusEvaluator(chart, metric);
417                 expect(evaluator.status()).to.be(null);
418
419                 return waitForComponentsToRender(context);
420             }).then(() => {
421                 expect(evaluator.status()).to.be(null);
422
423                 const currentView = chart.sampledTimeSeriesData('current');
424                 const firstPoint = currentView.firstPoint();
425                 const lastPoint = currentView.lastPoint();
426                 chart.setSelection([firstPoint.time + 1, lastPoint.time - 1]);
427
428                 let status = evaluator.status();
429                 expect(status).to.not.be(null);
430                 expect(status.comparison).to.be(null);
431                 expect(status.label).to.be(null);
432                 expect(status.currentValue).to.be('124 ms');
433                 expect(status.relativeDelta).to.be('2%');
434
435                 return waitForComponentsToRender(context);
436             });
437         });
438
439         it('should report the current value but not the relative delta when there is a selection with exaclyt one point', () => {
440             const context = new BrowsingContext();
441             let chart;
442             let evaluator;
443             return importEvaluator(context).then((ChartStatusEvaluator) => {
444                 chart = ChartTest.createInteractiveChartWithSampleCluster(context);
445                 chart.setDomain(ChartTest.sampleCluster.startTime, ChartTest.sampleCluster.endTime);
446                 chart.fetchMeasurementSets();
447
448                 const requests = context.symbols.MockRemoteAPI.requests;
449                 expect(requests.length).to.be(1);
450                 ChartTest.respondWithSampleCluster(requests[0]);
451
452                 const metric = makeMetric(context, 'Time');
453                 evaluator = new ChartStatusEvaluator(chart, metric);
454                 expect(evaluator.status()).to.be(null);
455
456                 return waitForComponentsToRender(context);
457             }).then(() => {
458                 expect(evaluator.status()).to.be(null);
459
460                 const currentView = chart.sampledTimeSeriesData('current');
461                 const firstPoint = currentView.firstPoint();
462                 chart.setSelection([firstPoint.time + 1, currentView.nextPoint(firstPoint).time + 1]);
463
464                 let status = evaluator.status();
465                 expect(status).to.not.be(null);
466                 expect(status.comparison).to.be(null);
467                 expect(status.label).to.be(null);
468                 expect(status.currentValue).to.be('122 ms');
469                 expect(status.relativeDelta).to.be(null);
470
471                 return waitForComponentsToRender(context);
472             });
473         });
474
475     });
476
477 });