<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[212520] trunk/Websites/perf.webkit.org</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/212520">212520</a></dd>
<dt>Author</dt> <dd>rniwa@webkit.org</dd>
<dt>Date</dt> <dd>2017-02-16 19:50:12 -0800 (Thu, 16 Feb 2017)</dd>
</dl>
<h3>Log Message</h3>
<pre>Modernize and fix measurement-set tests
https://bugs.webkit.org/show_bug.cgi?id=168484
Reviewed by Joseph Pecoraro.
Modernized and fixed the tests in measurement-set-tests.js.
1. Return a promise instead of manually calling done in then/catch hanlders.
2. Use arrow function everywhere.
3. Explicitly assert the number of calls to callbacks instead of asserting never reached.
The test case labled "should return false when the range ends after the fetched cluster"
was incorrectly asserting that hasFetchedRange returns false when the end time is after
the primary cluster's end time. Test an interval before the primary cluster instead.
Added a test case for hasFetchedRange returning true when the end time appears after
the end of the primary cluster and fixed hasFetchedRange to that end. Since there are
no data points after the primary cluster which is chronologically the last cluster,
there is nothing to fetch beyond its end time.
* public/v3/models/measurement-set.js:
(MeasurementSet.prototype.hasFetchedRange): Fixed the bug that this function returned
false when the end time was after the primary cluster's end by truncating the range by
the end of the primary cluster.
* unit-tests/measurement-set-tests.js:
* unit-tests/resources/mock-remote-api.js:
(assert.notReached.assert.notReached): Deleted. It's no longer used by any tests.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkWebsitesperfwebkitorgChangeLog">trunk/Websites/perf.webkit.org/ChangeLog</a></li>
<li><a href="#trunkWebsitesperfwebkitorgpublicv3modelsmeasurementsetjs">trunk/Websites/perf.webkit.org/public/v3/models/measurement-set.js</a></li>
<li><a href="#trunkWebsitesperfwebkitorgunittestsmeasurementsettestsjs">trunk/Websites/perf.webkit.org/unit-tests/measurement-set-tests.js</a></li>
<li><a href="#trunkWebsitesperfwebkitorgunittestsresourcesmockremoteapijs">trunk/Websites/perf.webkit.org/unit-tests/resources/mock-remote-api.js</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkWebsitesperfwebkitorgChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Websites/perf.webkit.org/ChangeLog (212519 => 212520)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/perf.webkit.org/ChangeLog 2017-02-17 02:52:30 UTC (rev 212519)
+++ trunk/Websites/perf.webkit.org/ChangeLog 2017-02-17 03:50:12 UTC (rev 212520)
</span><span class="lines">@@ -1,3 +1,33 @@
</span><ins>+2017-02-16 Ryosuke Niwa <rniwa@webkit.org>
+
+ Modernize and fix measurement-set tests
+ https://bugs.webkit.org/show_bug.cgi?id=168484
+
+ Reviewed by Joseph Pecoraro.
+
+ Modernized and fixed the tests in measurement-set-tests.js.
+
+ 1. Return a promise instead of manually calling done in then/catch hanlders.
+ 2. Use arrow function everywhere.
+ 3. Explicitly assert the number of calls to callbacks instead of asserting never reached.
+
+ The test case labled "should return false when the range ends after the fetched cluster"
+ was incorrectly asserting that hasFetchedRange returns false when the end time is after
+ the primary cluster's end time. Test an interval before the primary cluster instead.
+
+ Added a test case for hasFetchedRange returning true when the end time appears after
+ the end of the primary cluster and fixed hasFetchedRange to that end. Since there are
+ no data points after the primary cluster which is chronologically the last cluster,
+ there is nothing to fetch beyond its end time.
+
+ * public/v3/models/measurement-set.js:
+ (MeasurementSet.prototype.hasFetchedRange): Fixed the bug that this function returned
+ false when the end time was after the primary cluster's end by truncating the range by
+ the end of the primary cluster.
+ * unit-tests/measurement-set-tests.js:
+ * unit-tests/resources/mock-remote-api.js:
+ (assert.notReached.assert.notReached): Deleted. It's no longer used by any tests.
+
</ins><span class="cx"> 2017-02-15 Ryosuke Niwa <rniwa@webkit.org>
</span><span class="cx">
</span><span class="cx"> Update ReadMe.md and merge it with Install.md
</span></span></pre></div>
<a id="trunkWebsitesperfwebkitorgpublicv3modelsmeasurementsetjs"></a>
<div class="modfile"><h4>Modified: trunk/Websites/perf.webkit.org/public/v3/models/measurement-set.js (212519 => 212520)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/perf.webkit.org/public/v3/models/measurement-set.js 2017-02-17 02:52:30 UTC (rev 212519)
+++ trunk/Websites/perf.webkit.org/public/v3/models/measurement-set.js 2017-02-17 03:50:12 UTC (rev 212520)
</span><span class="lines">@@ -161,12 +161,13 @@
</span><span class="cx"> hasFetchedRange(startTime, endTime)
</span><span class="cx"> {
</span><span class="cx"> console.assert(startTime < endTime);
</span><del>- var foundStart = false;
- var previousEndTime = null;
</del><ins>+ let foundStart = false;
+ let previousEndTime = null;
+ endTime = Math.min(endTime, this._primaryClusterEndTime);
</ins><span class="cx"> for (var cluster of this._sortedClusters) {
</span><del>- var containsStart = cluster.startTime() <= startTime && startTime <= cluster.endTime();
- var containsEnd = cluster.startTime() <= endTime && endTime <= cluster.endTime();
- var preceedingClusterIsMissing = previousEndTime !== null && previousEndTime != cluster.startTime();
</del><ins>+ const containsStart = cluster.startTime() <= startTime && startTime <= cluster.endTime();
+ const containsEnd = cluster.startTime() <= endTime && endTime <= cluster.endTime();
+ const preceedingClusterIsMissing = previousEndTime !== null && previousEndTime != cluster.startTime();
</ins><span class="cx"> if (containsStart && containsEnd)
</span><span class="cx"> return true;
</span><span class="cx"> if (containsStart)
</span></span></pre></div>
<a id="trunkWebsitesperfwebkitorgunittestsmeasurementsettestsjs"></a>
<div class="modfile"><h4>Modified: trunk/Websites/perf.webkit.org/unit-tests/measurement-set-tests.js (212519 => 212520)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/perf.webkit.org/unit-tests/measurement-set-tests.js 2017-02-17 02:52:30 UTC (rev 212519)
+++ trunk/Websites/perf.webkit.org/unit-tests/measurement-set-tests.js 2017-02-17 03:50:12 UTC (rev 212520)
</span><span class="lines">@@ -8,40 +8,40 @@
</span><span class="cx"> require('../tools/js/v3-models.js');
</span><span class="cx"> const MockModels = require('./resources/mock-v3-models.js').MockModels;
</span><span class="cx">
</span><del>-describe('MeasurementSet', function () {
</del><ins>+describe('MeasurementSet', () => {
</ins><span class="cx"> MockModels.inject();
</span><span class="cx"> let requests = MockRemoteAPI.inject();
</span><span class="cx">
</span><del>- beforeEach(function () {
</del><ins>+ beforeEach(() => {
</ins><span class="cx"> MeasurementSet._set = null;
</span><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> function waitForMeasurementSet()
</span><span class="cx"> {
</span><del>- return Promise.resolve().then(function () {
</del><ins>+ return Promise.resolve().then(() => {
</ins><span class="cx"> return Promise.resolve();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> return Promise.resolve();
</span><span class="cx"> });
</span><span class="cx"> }
</span><span class="cx">
</span><del>- describe('findSet', function () {
- it('should create a new MeasurementSet for a new pair of platform and matric', function () {
</del><ins>+ describe('findSet', () => {
+ it('should create a new MeasurementSet for a new pair of platform and matric', () => {
</ins><span class="cx"> assert.notEqual(MeasurementSet.findSet(1, 1, 3000), MeasurementSet.findSet(1, 2, 3000));
</span><span class="cx"> assert.notEqual(MeasurementSet.findSet(1, 1, 3000), MeasurementSet.findSet(2, 1, 3000));
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should not create a new MeasurementSet when the same pair of platform and matric are requested', function () {
</del><ins>+ it('should not create a new MeasurementSet when the same pair of platform and matric are requested', () => {
</ins><span class="cx"> assert.equal(MeasurementSet.findSet(1, 1), MeasurementSet.findSet(1, 1));
</span><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- describe('findClusters', function () {
</del><ins>+ describe('findClusters', () => {
</ins><span class="cx">
</span><del>- it('should return clusters that exist', function (done) {
- var set = MeasurementSet.findSet(1, 1, 1467852503940);
- var callCount = 0;
- var promise = set.fetchBetween(1465084800000, 1470268800000, function () {
</del><ins>+ it('should return clusters that exist', () => {
+ const set = MeasurementSet.findSet(1, 1, 1467852503940);
+ let callCount = 0;
+ const promise = set.fetchBetween(1465084800000, 1470268800000, () => {
</ins><span class="cx"> callCount++;
</span><span class="cx"> });
</span><span class="cx"> assert.equal(requests.length, 1);
</span><span class="lines">@@ -58,39 +58,39 @@
</span><span class="cx"> 'clusterCount': 5,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- promise.then(function () {
</del><ins>+ return promise.then(() => {
</ins><span class="cx"> assert.deepEqual(set.findClusters(0, Date.now()), [1449532800000, 1454716800000, 1459900800000, 1465084800000, 1470268800000]);
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> });
</span><span class="cx">
</span><del>- describe('fetchBetween', function () {
- it('should always request the cached primary cluster first', function () {
- var set = MeasurementSet.findSet(1, 1, 3000);
- set.fetchBetween(1000, 2000, function () { assert.notReached(); });
</del><ins>+ describe('fetchBetween', () => {
+ it('should always request the cached primary cluster first', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ set.fetchBetween(1000, 2000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><ins>+ assert.equal(callCount, 0);
</ins><span class="cx"> });
</span><span class="cx">
</span><del>- it('should not request the cached primary cluster twice', function () {
- var set = MeasurementSet.findSet(1, 1, 3000);
- set.fetchBetween(1000, 2000, function () { assert.notReached(); });
</del><ins>+ it('should not request the cached primary cluster twice', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ set.fetchBetween(1000, 2000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><ins>+ assert.equal(callCount, 0);
</ins><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><del>- set.fetchBetween(2000, 3000, function () { assert.notReached(); });
</del><ins>+ set.fetchBetween(2000, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><ins>+ assert.equal(callCount, 0);
</ins><span class="cx"> });
</span><span class="cx">
</span><del>- it('should invoke the callback when the up-to-date cached primary cluster is fetched and it matches the requested range', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var callCount = 0;
- var promise = set.fetchBetween(2000, 3000, function () {
- callCount++;
- });
</del><ins>+ it('should invoke the callback when the requested range is in the cached primary cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ const promise = set.fetchBetween(2000, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -105,21 +105,16 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- promise.then(function () {
</del><ins>+ return promise.then(() => {
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(requests.length, 1);
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should invoke the callback and fetch a secondary cluster when the cached primary cluster is up-to-date and within in the requested range', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var callCount = 0;
- var promise = set.fetchBetween(1000, 3000, function () {
- callCount++;
- });
</del><ins>+ it('should invoke the callback and fetch a secondary cluster when the cached primary cluster is within the requested range', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ const promise = set.fetchBetween(1000, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -134,21 +129,17 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-2000.json');
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should request additional secondary clusters as requested', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- set.fetchBetween(2000, 3000, function () {
- assert.notReached();
- });
</del><ins>+ it('should request additional secondary clusters as requested', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ let callCountForWaitingCallback = 0;
+ set.fetchBetween(2000, 3000, () => callCountForWaitingCallback++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -163,31 +154,27 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- var callCount = 0;
- waitForMeasurementSet().then(function () {
</del><ins>+ let callCount = 0;
+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-3000.json');
</span><span class="cx">
</span><del>- set.fetchBetween(0, 7000, function () { callCount++; });
</del><ins>+ set.fetchBetween(0, 7000, () => callCount++);
</ins><span class="cx">
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
+ assert.equal(callCountForWaitingCallback, 0);
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(requests.length, 4);
</span><span class="cx"> assert.equal(requests[2].url, '../data/measurement-set-1-1-2000.json');
</span><span class="cx"> assert.equal(requests[3].url, '../data/measurement-set-1-1-4000.json');
</span><del>-
- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should request secondary clusters which forms a superset of the requested range', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- set.fetchBetween(2707, 4207, function () {
- assert.notReached();
- });
</del><ins>+ it('should request secondary clusters which forms a superset of the requested range', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ let callCount = 0;
+ const promise = set.fetchBetween(2707, 4207, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -202,21 +189,18 @@
</span><span class="cx"> 'clusterCount': 3,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 3);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-3000.json');
</span><span class="cx"> assert.equal(requests[2].url, '../data/measurement-set-1-1-4000.json');
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><ins>+ assert.equal(callCount, 1); // 4000-4207
</ins><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should not request secondary clusters that are not requested', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- set.fetchBetween(3200, 3700, function () {
- assert.notReached();
- });
</del><ins>+ it('should not request secondary clusters that are not requested', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ let callCountForWaitingCallback = 0;
+ set.fetchBetween(3200, 3700, () => callCountForWaitingCallback++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -231,33 +215,31 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- var callCount = 0;
- waitForMeasurementSet().then(function () {
</del><ins>+ let callCount = 0;
+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-4000.json');
</span><del>- set.fetchBetween(1207, 1293, function () { callCount++; });
</del><ins>+ set.fetchBetween(1207, 1293, () => callCount++);
</ins><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
+ assert.equal(callCountForWaitingCallback, 0);
</ins><span class="cx"> assert.equal(callCount, 0);
</span><span class="cx"> assert.equal(requests.length, 3);
</span><span class="cx"> assert.equal(requests[2].url, '../data/measurement-set-1-1-2000.json');
</span><del>- set.fetchBetween(1964, 3401, function () { callCount++; });
</del><ins>+ set.fetchBetween(1964, 3401, () => callCount++);
</ins><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
+ assert.equal(callCountForWaitingCallback, 0);
</ins><span class="cx"> assert.equal(callCount, 0);
</span><span class="cx"> assert.equal(requests.length, 4);
</span><span class="cx"> assert.equal(requests[3].url, '../data/measurement-set-1-1-3000.json');
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should not request a cluster before the very first cluster', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- set.fetchBetween(0, 3000, function () {
- assert.notReached();
- });
</del><ins>+ it('should not request a cluster before the very first cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ let callCount = 0;
+ set.fetchBetween(0, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -272,41 +254,33 @@
</span><span class="cx"> 'clusterCount': 1,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- var callCount = 0;
- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><ins>+ assert.equal(callCount, 1);
</ins><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should invoke the callback when the fetching of the primray cluster fails', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var callCount = 0;
- set.fetchBetween(1000, 3000, function () {
- callCount++;
- });
</del><ins>+ it('should invoke the callback when the fetching of the primray cluster fails', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ let rejected = false;
+ set.fetchBetween(1000, 3000, () => callCount++).catch(() => rejected = true);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="cx"> requests[0].reject(500);
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(requests.length, 1);
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><ins>+ assert(rejected);
</ins><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should request the uncached primary cluster when the cached cluster is outdated', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3005);
- var callCount = 0;
- set.fetchBetween(1000, 2000, function () {
- callCount++;
- });
</del><ins>+ it('should request the uncached primary cluster when the cached cluster is outdated', () => {
+ const set = MeasurementSet.findSet(1, 1, 3005);
+ let callCount = 0;
+ set.fetchBetween(1000, 2000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -321,43 +295,33 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- Promise.resolve().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 0);
</span><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../api/measurement-set?platform=1&metric=1');
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should request the uncached primary cluster when the cached cluster is 404', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3005);
- var callCount = 0;
- set.fetchBetween(1000, 2000, function () {
- callCount++;
- });
</del><ins>+ it('should request the uncached primary cluster when the cached cluster is 404', () => {
+ const set = MeasurementSet.findSet(1, 1, 3005);
+ let callCount = 0;
+ set.fetchBetween(1000, 2000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="cx"> requests[0].reject(404);
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 0);
</span><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../api/measurement-set?platform=1&metric=1');
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should request the uncached primary cluster when noCache is true', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var callCount = 0;
- set.fetchBetween(1000, 3000, function () {
- callCount++;
- });
</del><ins>+ it('should request the uncached primary cluster when noCache is true', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ set.fetchBetween(1000, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -372,8 +336,8 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- var noCacheFetchCount = 0;
- waitForMeasurementSet().then(function () {
</del><ins>+ let noCacheFetchCount = 0;
+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(noCacheFetchCount, 0);
</span><span class="cx"> assert.equal(set._sortedClusters.length, 1);
</span><span class="lines">@@ -391,12 +355,10 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- set.fetchBetween(1000, 3000, function () {
- noCacheFetchCount++;
- }, true /* noCache */);
</del><ins>+ set.fetchBetween(1000, 3000, () => noCacheFetchCount++, true /* noCache */);
</ins><span class="cx">
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCount, 2);
</span><span class="cx"> assert.equal(noCacheFetchCount, 0);
</span><span class="cx"> assert.equal(set._sortedClusters.length, 2);
</span><span class="lines">@@ -415,7 +377,7 @@
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCount, 2);
</span><span class="cx"> assert.equal(noCacheFetchCount, 1);
</span><span class="cx"> assert.equal(set._sortedClusters.length, 2);
</span><span class="lines">@@ -434,31 +396,23 @@
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCount, 3);
</span><span class="cx"> assert.equal(noCacheFetchCount, 2);
</span><span class="cx"> assert.equal(set._sortedClusters.length, 2);
</span><span class="cx"> assert.equal(requests.length, 4);
</span><del>-
- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should not request the primary cluster twice when multiple clients request it but should invoke all callbacks', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var callCount = 0;
- set.fetchBetween(2000, 3000, function () {
- callCount++;
- });
</del><ins>+ it('should not request the primary cluster twice when multiple clients request it but should invoke all callbacks', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ let callCount = 0;
+ set.fetchBetween(2000, 3000, () => callCount++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><del>- var alternativeCallCount = 0;
- set.fetchBetween(2000, 3000, function () {
- alternativeCallCount++;
- });
</del><ins>+ let alternativeCallCount = 0;
+ set.fetchBetween(2000, 3000, () => alternativeCallCount++);
</ins><span class="cx">
</span><span class="cx"> requests[0].resolve({
</span><span class="cx"> 'clusterStart': 1000,
</span><span class="lines">@@ -471,20 +425,17 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCount, 1);
</span><span class="cx"> assert.equal(alternativeCallCount, 1);
</span><span class="cx"> assert.equal(requests.length, 1);
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should invoke callback for each secondary clusters that are fetched or rejected', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- var callCountFor4000 = 0;
- set.fetchBetween(3200, 3700, function () { callCountFor4000++; });
</del><ins>+ it('should invoke callback for each secondary clusters that are fetched or rejected', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ let callCountFor4000 = 0;
+ set.fetchBetween(3200, 3700, () => callCountFor4000++);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -499,23 +450,23 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- var callCountFor4000To5000 = 0;
- var callCountFor2000 = 0;
- var callCountFor2000To4000 = 0;
- waitForMeasurementSet().then(function () {
</del><ins>+ let callCountFor4000To5000 = 0;
+ let callCountFor2000 = 0;
+ let callCountFor2000To4000 = 0;
+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(callCountFor4000, 0);
</span><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-4000.json');
</span><span class="cx">
</span><del>- set.fetchBetween(3708, 4800, function () { callCountFor4000To5000++; });
</del><ins>+ set.fetchBetween(3708, 4800, () => callCountFor4000To5000++);
</ins><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCountFor4000To5000, 1);
</span><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx">
</span><del>- set.fetchBetween(1207, 1293, function () { callCountFor2000++; });
</del><ins>+ set.fetchBetween(1207, 1293, () => callCountFor2000++);
</ins><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCountFor2000, 0);
</span><span class="cx"> assert.equal(requests.length, 3);
</span><span class="cx"> assert.equal(requests[2].url, '../data/measurement-set-1-1-2000.json');
</span><span class="lines">@@ -528,15 +479,15 @@
</span><span class="cx"> 'lastModified': 5000,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(requests.length, 3);
</span><span class="cx"> assert.equal(callCountFor4000, 0);
</span><span class="cx"> assert.equal(callCountFor4000To5000, 1);
</span><span class="cx"> assert.equal(callCountFor2000, 1);
</span><span class="cx">
</span><del>- set.fetchBetween(1964, 3401, function () { callCountFor2000To4000++; });
</del><ins>+ set.fetchBetween(1964, 3401, () => { callCountFor2000To4000++; });
</ins><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCountFor2000To4000, 1);
</span><span class="cx"> assert.equal(requests.length, 4);
</span><span class="cx"> assert.equal(requests[3].url, '../data/measurement-set-1-1-3000.json');
</span><span class="lines">@@ -549,7 +500,7 @@
</span><span class="cx"> 'lastModified': 5000,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCountFor4000, 0);
</span><span class="cx"> assert.equal(callCountFor4000To5000, 1);
</span><span class="cx"> assert.equal(callCountFor2000, 1);
</span><span class="lines">@@ -564,31 +515,27 @@
</span><span class="cx"> 'lastModified': 5000,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert.equal(callCountFor4000, 1);
</span><span class="cx"> assert.equal(callCountFor4000To5000, 2);
</span><span class="cx"> assert.equal(callCountFor2000, 1);
</span><span class="cx"> assert.equal(callCountFor2000To4000, 3);
</span><span class="cx"> assert.equal(requests.length, 4);
</span><del>-
- done();
- }).catch(function (error) {
- done(error);
- })
</del><ins>+ });
</ins><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> });
</span><span class="cx">
</span><del>- describe('hasFetchedRange', function () {
</del><ins>+ describe('hasFetchedRange', () => {
</ins><span class="cx">
</span><del>- it('should return false when no clusters had been fetched', function () {
</del><ins>+ it('should return false when no clusters had been fetched', () => {
</ins><span class="cx"> var set = MeasurementSet.findSet(1, 1, 3000);
</span><span class="cx"> assert(!set.hasFetchedRange(2000, 3000));
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should return true when a single cluster contains the entire range', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var promise = set.fetchBetween(2000, 3000);
</del><ins>+ it('should return true when a single cluster contains the entire range', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ const promise = set.fetchBetween(2000, 3000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -603,18 +550,15 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- promise.then(function () {
</del><ins>+ return promise.then(() => {
</ins><span class="cx"> assert(set.hasFetchedRange(2001, 2999));
</span><span class="cx"> assert(set.hasFetchedRange(2000, 3000));
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should return false when the range starts before the fetched cluster', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var promise = set.fetchBetween(2000, 3000);
</del><ins>+ it('should return false when the range starts before the fetched cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ const promise = set.fetchBetween(2000, 3000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -629,17 +573,14 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- promise.then(function () {
</del><ins>+ return promise.then(() => {
</ins><span class="cx"> assert(!set.hasFetchedRange(1500, 3000));
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should return false when the range ends after the fetched cluster', function (done) {
- var set = MeasurementSet.findSet(1, 1, 3000);
- var promise = set.fetchBetween(2000, 3000);
</del><ins>+ it('should return false when the range ends after the fetched cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ const promise = set.fetchBetween(2000, 3000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -648,23 +589,33 @@
</span><span class="cx"> 'clusterSize': 1000,
</span><span class="cx"> 'formatMap': [],
</span><span class="cx"> 'configurations': {current: []},
</span><del>- 'startTime': 2000,
- 'endTime': 3000,
- 'lastModified': 3000,
- 'clusterCount': 2,
</del><ins>+ 'startTime': 4000,
+ 'endTime': 5000,
+ 'lastModified': 5000,
+ 'clusterCount': 3,
</ins><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- promise.then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
+ assert.equal(requests.length, 2);
+ assert.equal(requests[1].url, '../data/measurement-set-1-1-3000.json');
+ requests[1].resolve({
+ 'clusterStart': 1000,
+ 'clusterSize': 1000,
+ 'formatMap': [],
+ 'configurations': {current: []},
+ 'startTime': 2000,
+ 'endTime': 3000,
+ 'lastModified': 5000,
+ 'clusterCount': 3,
+ 'status': 'OK'});
+ }).then(() => {
</ins><span class="cx"> assert(!set.hasFetchedRange(2500, 3500));
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should return true when the range is within two fetched clusters', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- var promise = set.fetchBetween(2000, 3000);
</del><ins>+ it('should return true when the range is within two fetched clusters', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ set.fetchBetween(2000, 3000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -679,7 +630,7 @@
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-3000.json');
</span><span class="cx"> requests[1].resolve({
</span><span class="lines">@@ -692,17 +643,14 @@
</span><span class="cx"> 'lastModified': 5000,
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert(set.hasFetchedRange(2500, 3500));
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><del>- it('should return false when there is a cluster missing in the range', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- var promise = set.fetchBetween(2000, 5000);
</del><ins>+ it('should return false when there is a cluster missing in the range', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ set.fetchBetween(2000, 5000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -717,7 +665,7 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 3);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-3000.json');
</span><span class="cx"> assert.equal(requests[2].url, '../data/measurement-set-1-1-4000.json');
</span><span class="lines">@@ -731,16 +679,35 @@
</span><span class="cx"> 'lastModified': 5000,
</span><span class="cx"> 'clusterCount': 2,
</span><span class="cx"> 'status': 'OK'});
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> assert(!set.hasFetchedRange(2500, 4500));
</span><span class="cx"> assert(set.hasFetchedRange(2100, 2300));
</span><span class="cx"> assert(set.hasFetchedRange(4000, 4800));
</span><del>- done();
- }).catch(function (error) {
- done(error);
</del><span class="cx"> });
</span><span class="cx"> });
</span><span class="cx">
</span><ins>+ it('should return true even when the range extends beyond the primary cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 3000);
+ const promise = set.fetchBetween(2000, 3000);
+ assert.equal(requests.length, 1);
+ assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
+
+ requests[0].resolve({
+ 'clusterStart': 1000,
+ 'clusterSize': 1000,
+ 'formatMap': [],
+ 'configurations': {current: []},
+ 'startTime': 2000,
+ 'endTime': 3000,
+ 'lastModified': 3000,
+ 'clusterCount': 2,
+ 'status': 'OK'});
+
+ return promise.then(() => {
+ assert(set.hasFetchedRange(2001, 5000));
+ });
+ });
+
</ins><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> describe('fetchedTimeSeries', () => {
</span><span class="lines">@@ -803,7 +770,7 @@
</span><span class="cx">
</span><span class="cx"> let builder;
</span><span class="cx"> let webkit;
</span><del>- beforeEach(function () {
</del><ins>+ beforeEach(() => {
</ins><span class="cx"> builder = new Builder(7, {name: 'EFL Linux 64-bit Release WK2 (Perf)', buildUrl: 'http://build.webkit.org/builders/$builderName/$buildNumber'});
</span><span class="cx"> webkit = new Repository(1, {name: 'WebKit', url: 'http://trac.webkit.org/changeset/$1'});
</span><span class="cx"> });
</span><span class="lines">@@ -982,7 +949,7 @@
</span><span class="cx">
</span><span class="cx"> });
</span><span class="cx">
</span><del>- describe('fetchSegmentation', function () {
</del><ins>+ describe('fetchSegmentation', () => {
</ins><span class="cx">
</span><span class="cx"> var simpleSegmentableValues = [
</span><span class="cx"> 1546.5603, 1548.1536, 1563.5452, 1539.7823, 1546.4184, 1548.9299, 1532.5444, 1546.2800, 1547.1760, 1551.3507,
</span><span class="lines">@@ -1008,9 +975,9 @@
</span><span class="cx"> return runs;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- it('should be able to segment a single cluster', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- var promise = set.fetchBetween(4000, 5000);
</del><ins>+ it('should be able to segment a single cluster', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ const promise = set.fetchBetween(4000, 5000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -1027,13 +994,13 @@
</span><span class="cx">
</span><span class="cx"> var timeSeries;
</span><span class="cx"> assert.equal(set.fetchedTimeSeries('current', false, false).length(), 0);
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> timeSeries = set.fetchedTimeSeries('current', false, false);
</span><span class="cx"> assert.equal(timeSeries.length(), 45);
</span><span class="cx"> assert.equal(timeSeries.firstPoint().time, 4000);
</span><span class="cx"> assert.equal(timeSeries.lastPoint().time, 4880);
</span><span class="cx"> return set.fetchSegmentation('segmentTimeSeriesByMaximizingSchwarzCriterion', [], 'current', false);
</span><del>- }).then(function (segmentation) {
</del><ins>+ }).then((segmentation) => {
</ins><span class="cx"> assert.equal(segmentation.length, 4);
</span><span class="cx">
</span><span class="cx"> assert.equal(segmentation[0].time, 4000);
</span><span class="lines">@@ -1045,13 +1012,12 @@
</span><span class="cx"> assert.almostEqual(segmentation[2].value, 1581.872);
</span><span class="cx"> assert.equal(segmentation[2].value, segmentation[3].value);
</span><span class="cx"> assert.equal(segmentation[3].time, 4880);
</span><del>- done();
- }).catch(done);
</del><ins>+ });
</ins><span class="cx"> });
</span><span class="cx">
</span><del>- it('should be able to segment two clusters', function (done) {
- var set = MeasurementSet.findSet(1, 1, 5000);
- var promise = set.fetchBetween(3000, 5000);
</del><ins>+ it('should be able to segment two clusters', () => {
+ const set = MeasurementSet.findSet(1, 1, 5000);
+ const promise = set.fetchBetween(3000, 5000);
</ins><span class="cx"> assert.equal(requests.length, 1);
</span><span class="cx"> assert.equal(requests[0].url, '../data/measurement-set-1-1.json');
</span><span class="cx">
</span><span class="lines">@@ -1066,12 +1032,12 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx">
</span><del>- waitForMeasurementSet().then(function () {
</del><ins>+ return waitForMeasurementSet().then(() => {
</ins><span class="cx"> assert.equal(requests.length, 2);
</span><span class="cx"> assert.equal(requests[1].url, '../data/measurement-set-1-1-4000.json');
</span><span class="cx"> return set.fetchSegmentation('segmentTimeSeriesByMaximizingSchwarzCriterion', [], 'current', false);
</span><del>- }).then(function (segmentation) {
- var timeSeries = set.fetchedTimeSeries('current', false, false);
</del><ins>+ }).then((segmentation) => {
+ const timeSeries = set.fetchedTimeSeries('current', false, false);
</ins><span class="cx"> assert.equal(timeSeries.length(), 15);
</span><span class="cx"> assert.equal(timeSeries.firstPoint().time, 4000);
</span><span class="cx"> assert.equal(timeSeries.lastPoint().time, 4462);
</span><span class="lines">@@ -1098,9 +1064,9 @@
</span><span class="cx"> 'clusterCount': 4,
</span><span class="cx"> 'status': 'OK'});
</span><span class="cx"> return waitForMeasurementSet();
</span><del>- }).then(function () {
</del><ins>+ }).then(() => {
</ins><span class="cx"> return set.fetchSegmentation('segmentTimeSeriesByMaximizingSchwarzCriterion', [], 'current', false);
</span><del>- }).then(function (segmentation) {
</del><ins>+ }).then((segmentation) => {
</ins><span class="cx"> var timeSeries = set.fetchedTimeSeries('current', false, false);
</span><span class="cx"> assert.equal(timeSeries.length(), 45);
</span><span class="cx"> assert.equal(timeSeries.firstPoint().time, 3000);
</span><span class="lines">@@ -1116,8 +1082,7 @@
</span><span class="cx"> assert.almostEqual(segmentation[2].value, 1581.872);
</span><span class="cx"> assert.equal(segmentation[2].value, segmentation[3].value);
</span><span class="cx"> assert.equal(segmentation[3].time, timeSeries.lastPoint().time);
</span><del>- done();
- }).catch(done);
</del><ins>+ });
</ins><span class="cx"> });
</span><span class="cx">
</span><span class="cx"> });
</span></span></pre></div>
<a id="trunkWebsitesperfwebkitorgunittestsresourcesmockremoteapijs"></a>
<div class="modfile"><h4>Modified: trunk/Websites/perf.webkit.org/unit-tests/resources/mock-remote-api.js (212519 => 212520)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Websites/perf.webkit.org/unit-tests/resources/mock-remote-api.js 2017-02-17 02:52:30 UTC (rev 212519)
+++ trunk/Websites/perf.webkit.org/unit-tests/resources/mock-remote-api.js 2017-02-17 03:50:12 UTC (rev 212520)
</span><span class="lines">@@ -1,8 +1,3 @@
</span><del>-var assert = require('assert');
-
-if (!assert.notReached)
- assert.notReached = function () { assert(false, 'This code path should not be reached'); }
-
</del><span class="cx"> var MockRemoteAPI = {
</span><span class="cx"> url: function (path)
</span><span class="cx"> {
</span></span></pre>
</div>
</div>
</body>
</html>