chrome-devtools-frontend 1.0.1380117 → 1.0.1402249

package/front_end/models/trace/lantern/graph/BaseNode.test.ts

@@ -128,7 +128,7 @@ describe('BaseNode', () => {
 
       assert.strictEqual(clone.id, '1');
       assert.notEqual(node, clone);
-      assert.strictEqual(clone.getDependencies().length, 0);
+      assert.lengthOf(clone.getDependencies(), 0);
     });
 
     it('should copy isMainDocument', () => {
@@ -137,8 +137,8 @@ describe('BaseNode', () => {
       const networkNode = new NetworkNode({});
       networkNode.setIsMainDocument(true);
 
-      assert.ok(node.cloneWithoutRelationships().isMainDocument());
-      assert.ok(networkNode.cloneWithoutRelationships().isMainDocument());
+      assert.isOk(node.cloneWithoutRelationships().isMainDocument());
+      assert.isOk(networkNode.cloneWithoutRelationships().isMainDocument());
     });
   });
 
@@ -153,7 +153,7 @@ describe('BaseNode', () => {
       assert.notEqual(node, clone);
 
       const dependencies = clone.getDependencies();
-      assert.strictEqual(dependencies.length, 1);
+      assert.lengthOf(dependencies, 1);
 
       const neighborClone = dependencies[0];
       assert.strictEqual(neighborClone.id, neighbor.id);
@@ -226,12 +226,12 @@ describe('BaseNode', () => {
       clone.traverse(node => clonedIdMap.set(node.id, node));
 
       assert.strictEqual(clonedIdMap.size, 6);
-      assert.ok(clonedIdMap.has('F'), 'did not include target node');
-      assert.ok(clonedIdMap.has('E'), 'did not include dependency');
-      assert.ok(clonedIdMap.has('B'), 'did not include branched dependency');
-      assert.ok(clonedIdMap.has('C'), 'did not include branched dependency');
-      assert.strictEqual(clonedIdMap.get('G'), undefined);
-      assert.strictEqual(clonedIdMap.get('H'), undefined);
+      assert.isOk(clonedIdMap.has('F'), 'did not include target node');
+      assert.isOk(clonedIdMap.has('E'), 'did not include dependency');
+      assert.isOk(clonedIdMap.has('B'), 'did not include branched dependency');
+      assert.isOk(clonedIdMap.has('C'), 'did not include branched dependency');
+      assert.isUndefined(clonedIdMap.get('G'));
+      assert.isUndefined(clonedIdMap.get('H'));
     });
 
     it('should throw if original node is not in cloned graph', () => {
@@ -261,7 +261,7 @@ describe('BaseNode', () => {
         paths.push(traversalPath.map(node => node.id));
       });
 
-      assert.deepStrictEqual(paths, [
+      assert.deepEqual(paths, [
         ['A'],
         ['B', 'A'],
         ['C', 'A'],
@@ -288,7 +288,7 @@ describe('BaseNode', () => {
   describe('#hasCycle', () => {
     it('should return false for DAGs', () => {
       const graph = createComplexGraph();
-      assert.strictEqual(BaseNode.hasCycle(graph.nodeA), false);
+      assert.isFalse(BaseNode.hasCycle(graph.nodeA));
     });
 
     it('should return false for triangular DAGs', () => {
@@ -303,7 +303,7 @@ describe('BaseNode', () => {
       nodeA.addDependent(nodeB);
       nodeB.addDependent(nodeC);
 
-      assert.strictEqual(BaseNode.hasCycle(nodeA), false);
+      assert.isFalse(BaseNode.hasCycle(nodeA));
     });
 
     it('should return true for basic cycles', () => {
@@ -316,7 +316,7 @@ describe('BaseNode', () => {
       nodeB.addDependent(nodeC);
       nodeC.addDependent(nodeA);
 
-      assert.strictEqual(BaseNode.hasCycle(nodeA), true);
+      assert.isTrue(BaseNode.hasCycle(nodeA));
     });
 
     it('should return true for children', () => {
@@ -331,7 +331,7 @@ describe('BaseNode', () => {
       nodeB.addDependent(nodeC);
       nodeB.addDependent(nodeA);
 
-      assert.strictEqual(BaseNode.hasCycle(nodeC), true);
+      assert.isTrue(BaseNode.hasCycle(nodeC));
     });
 
     it('should return true for complex cycles', () => {
@@ -357,14 +357,14 @@ describe('BaseNode', () => {
       nodeF.addDependent(nodeG);
       nodeG.addDependent(nodeC);
 
-      assert.strictEqual(BaseNode.hasCycle(nodeA), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeB), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeC), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeD), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeE), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeF), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeG), true);
-      assert.strictEqual(BaseNode.hasCycle(nodeH), true);
+      assert.isTrue(BaseNode.hasCycle(nodeA));
+      assert.isTrue(BaseNode.hasCycle(nodeB));
+      assert.isTrue(BaseNode.hasCycle(nodeC));
+      assert.isTrue(BaseNode.hasCycle(nodeD));
+      assert.isTrue(BaseNode.hasCycle(nodeE));
+      assert.isTrue(BaseNode.hasCycle(nodeF));
+      assert.isTrue(BaseNode.hasCycle(nodeG));
+      assert.isTrue(BaseNode.hasCycle(nodeH));
     });
 
     it('works for very large graphs', () => {
@@ -378,7 +378,7 @@ describe('BaseNode', () => {
       }
 
       lastNode.addDependent(root);
-      assert.strictEqual(BaseNode.hasCycle(root), true);
+      assert.isTrue(BaseNode.hasCycle(root));
     });
   });
 });

package/front_end/models/trace/lantern/graph/PageDependencyGraph.test.ts

@@ -71,7 +71,7 @@ describe('PageDependencyGraph', () => {
       const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRequests);
       for (let i = 0; i < networkRequests.length; i++) {
         const node = networkNodeOutput.nodes[i];
-        assert.ok(node, `did not create node at index ${i}`);
+        assert.isOk(node, `did not create node at index ${i}`);
         assert.strictEqual(node.id, i + 1);
         assert.strictEqual(node.type, 'network');
         assert.strictEqual(node.request, networkRequests[i]);
@@ -156,22 +156,22 @@ describe('PageDependencyGraph', () => {
         {name: 'LaterEvent'},
       ]);
 
-      assert.strictEqual(traceEvents.length, 7);
+      assert.lengthOf(traceEvents, 7);
       const nodes = PageDependencyGraph.getCPUNodes(traceEvents);
-      assert.strictEqual(nodes.length, 2);
+      assert.lengthOf(nodes, 2);
 
       const node1 = nodes[0];
       assert.strictEqual(node1.id, '1.0');
       assert.strictEqual(node1.type, 'cpu');
       assert.strictEqual(node1.event, traceEvents[0]);
-      assert.strictEqual(node1.childEvents.length, 2);
+      assert.lengthOf(node1.childEvents, 2);
       assert.strictEqual(node1.childEvents[1].name, 'OtherEvent');
 
       const node2 = nodes[1];
       assert.strictEqual(node2.id, '1.250000');
       assert.strictEqual(node2.type, 'cpu');
       assert.strictEqual(node2.event, traceEvents[5]);
-      assert.strictEqual(node2.childEvents.length, 1);
+      assert.lengthOf(node2.childEvents, 1);
       assert.strictEqual(node2.childEvents[0].name, 'LaterEvent');
     });
 
@@ -185,15 +185,15 @@ describe('PageDependencyGraph', () => {
         {name: 'OverlappingEvent'},
       ]);
 
-      assert.strictEqual(traceEvents.length, 5);
+      assert.lengthOf(traceEvents, 5);
       const nodes = PageDependencyGraph.getCPUNodes(traceEvents);
-      assert.strictEqual(nodes.length, 2);
+      assert.lengthOf(nodes, 2);
 
       const node1 = nodes[0];
       assert.strictEqual(node1.id, '1.0');
       assert.strictEqual(node1.type, 'cpu');
       assert.strictEqual(node1.event, traceEvents[0]);
-      assert.strictEqual(node1.childEvents.length, 2);
+      assert.lengthOf(node1.childEvents, 2);
       assert.strictEqual(node1.childEvents[0].name, 'MyCustomEvent');
       assert.strictEqual(node1.childEvents[1].name, 'OtherEvent');
 
@@ -201,7 +201,7 @@ describe('PageDependencyGraph', () => {
       assert.strictEqual(node2.id, '1.400000');
       assert.strictEqual(node2.type, 'cpu');
       assert.strictEqual(node2.event, traceEvents[3]);
-      assert.strictEqual(node2.childEvents.length, 1);
+      assert.lengthOf(node2.childEvents, 1);
       assert.strictEqual(node2.childEvents[0].name, 'OverlappingEvent');
     });
   });
@@ -220,7 +220,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 4);
+      assert.lengthOf(nodes, 4);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
@@ -252,7 +252,7 @@ describe('PageDependencyGraph', () => {
       const getIds = nodes => nodes.map(node => node.id);
       const getDependencyIds = node => getIds(node.getDependencies());
 
-      assert.strictEqual(nodes.length, 6);
+      assert.lengthOf(nodes, 6);
       assert.deepEqual(getIds(nodes), [1, 2, 3, 4, '1.200000', '1.700000']);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
       assert.deepEqual(getDependencyIds(nodes[1]), [1]);
@@ -275,7 +275,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 4);
+      assert.lengthOf(nodes, 4);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
@@ -316,7 +316,7 @@ describe('PageDependencyGraph', () => {
 
       const getDependencyIds = node => node.getDependencies().map(node => node.id);
 
-      assert.strictEqual(nodes.length, 7);
+      assert.lengthOf(nodes, 7);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
       assert.deepEqual(getDependencyIds(nodes[1]), [1, '1.200000']);
       assert.deepEqual(getDependencyIds(nodes[2]), [1]);
@@ -344,7 +344,7 @@ describe('PageDependencyGraph', () => {
 
       const getDependencyIds = node => node.getDependencies().map(node => node.id);
 
-      assert.strictEqual(nodes.length, 2);
+      assert.lengthOf(nodes, 2);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
       assert.deepEqual(getDependencyIds(nodes[1]), [1]);
     });
@@ -378,7 +378,7 @@ describe('PageDependencyGraph', () => {
 
       const getDependencyIds = node => node.getDependencies().map(node => node.id);
 
-      assert.strictEqual(nodes.length, 6);
+      assert.lengthOf(nodes, 6);
 
       assert.deepEqual(getDependencyIds(nodes[0]), []);
       assert.deepEqual(getDependencyIds(nodes[1]), [0]);
@@ -424,7 +424,7 @@ describe('PageDependencyGraph', () => {
 
       const getDependencyIds = node => node.getDependencies().map(node => node.id);
 
-      assert.strictEqual(nodes.length, 6);
+      assert.lengthOf(nodes, 6);
 
       assert.deepEqual(getDependencyIds(nodes[0]), []);
       assert.deepEqual(getDependencyIds(nodes[1]), [0]);
@@ -500,11 +500,11 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 3);
+      assert.lengthOf(nodes, 3);
       assert.strictEqual(nodes[0].id, 1);
-      assert.strictEqual(nodes[0].isMainDocument(), false);
-      assert.strictEqual(nodes[1].isMainDocument(), true);
-      assert.strictEqual(nodes[2].isMainDocument(), false);
+      assert.isFalse(nodes[0].isMainDocument());
+      assert.isTrue(nodes[1].isMainDocument());
+      assert.isFalse(nodes[2].isMainDocument());
     });
 
     it('should link up script initiators', () => {
@@ -531,7 +531,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 4);
+      assert.lengthOf(nodes, 4);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
@@ -559,7 +559,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 4);
+      assert.lengthOf(nodes, 4);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
@@ -588,7 +588,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 4);
+      assert.lengthOf(nodes, 4);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
@@ -613,7 +613,7 @@ describe('PageDependencyGraph', () => {
       graph.traverse(node => nodes.push(node));
       nodes.sort((a, b) => a.id - b.id);
 
-      assert.strictEqual(nodes.length, 3);
+      assert.lengthOf(nodes, 3);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       // We don't know which of the initiators to trust in a cycle, so for now we
@@ -643,7 +643,7 @@ describe('PageDependencyGraph', () => {
       graph.traverse(node => nodes.push(node));
       nodes.sort((a, b) => a.id - b.id);
 
-      assert.strictEqual(nodes.length, 3);
+      assert.lengthOf(nodes, 3);
       assert.deepEqual(nodes.map(node => node.id), [1, 2, 3]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[2]]);
@@ -665,7 +665,7 @@ describe('PageDependencyGraph', () => {
       const nodes = [];
       graph.traverse(node => nodes.push(node));
 
-      assert.strictEqual(nodes.length, 1);
+      assert.lengthOf(nodes, 1);
       assert.deepEqual(nodes.map(node => node.id), [2]);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[0].getDependents(), []);

package/front_end/models/trace/lantern/metrics/FirstContentfulPaint.test.ts

@@ -18,7 +18,7 @@ describe('Metrics: Lantern FCP', () => {
     const data = await getComputationDataFromFixture({trace});
     const result = FirstContentfulPaint.compute(data);
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -33,8 +33,8 @@ describe('Metrics: Lantern FCP', () => {
           optimisticNodeTimings: 4,
           pessimisticNodeTimings: 4,
         });
-    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
-    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+    assert.isOk(result.optimisticGraph, 'should have created optimistic graph');
+    assert.isOk(result.pessimisticGraph, 'should have created pessimistic graph');
   });
 
   it('should handle negative request networkEndTime', async () => {

package/front_end/models/trace/lantern/metrics/Interactive.test.ts

@@ -24,7 +24,7 @@ describe('Metrics: Lantern TTI', () => {
       }),
     });
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -37,8 +37,8 @@ describe('Metrics: Lantern TTI', () => {
         });
     assert.strictEqual(result.optimisticEstimate.nodeTimings.size, 14);
     assert.strictEqual(result.pessimisticEstimate.nodeTimings.size, 31);
-    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
-    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+    assert.isOk(result.optimisticGraph, 'should have created optimistic graph');
+    assert.isOk(result.pessimisticGraph, 'should have created pessimistic graph');
   });
 
   it('should compute predicted value on iframes with substantial layout', async () => {
@@ -51,7 +51,7 @@ describe('Metrics: Lantern TTI', () => {
       }),
     });
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -62,7 +62,7 @@ describe('Metrics: Lantern TTI', () => {
           pessimistic: 2386,
           timing: 2379,
         });
-    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
-    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+    assert.isOk(result.optimisticGraph, 'should have created optimistic graph');
+    assert.isOk(result.pessimisticGraph, 'should have created pessimistic graph');
   });
 });

package/front_end/models/trace/lantern/metrics/LargestContentfulPaint.test.ts

@@ -20,7 +20,7 @@ describe('Metrics: Lantern LCP', () => {
       fcpResult: FirstContentfulPaint.compute(data),
     });
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -35,7 +35,7 @@ describe('Metrics: Lantern LCP', () => {
           optimisticNodeTimings: 8,
           pessimisticNodeTimings: 9,
         });
-    assert.ok(result.optimisticGraph, 'should have created optimistic graph');
-    assert.ok(result.pessimisticGraph, 'should have created pessimistic graph');
+    assert.isOk(result.optimisticGraph, 'should have created optimistic graph');
+    assert.isOk(result.pessimisticGraph, 'should have created pessimistic graph');
   });
 });

package/front_end/models/trace/lantern/metrics/SpeedIndex.test.ts

@@ -26,7 +26,7 @@ describe('Metrics: Lantern Speed Index', () => {
       observedSpeedIndex,
     });
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -53,7 +53,7 @@ describe('Metrics: Lantern Speed Index', () => {
       observedSpeedIndex,
     });
 
-    assert.deepStrictEqual(
+    assert.deepEqual(
         {
           timing: Math.round(result.timing),
           optimistic: Math.round(result.optimisticEstimate.timeInMs),
@@ -78,7 +78,7 @@ describe('Metrics: Lantern Speed Index', () => {
 
   it('should scale coefficients forward', async () => {
     const result = SpeedIndex.getScaledCoefficients(300);
-    assert.deepStrictEqual(result, {
+    assert.deepEqual(result, {
       intercept: 0,
       optimistic: 2.525,
       pessimistic: 0.275,

package/front_end/models/trace/lantern/metrics/TBTUtils.test.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 // TODO(crbug.com/348449529): refactor to proper devtools module
-// eslint-disable-next-line rulesdir/es_modules_import
+// eslint-disable-next-line rulesdir/es-modules-import
 import {calculateSumOfBlockingTime} from './TBTUtils.js';
 
 describe('TotalBlockingTime utils', () => {

package/front_end/models/trace/lantern/simulation/ConnectionPool.test.ts

@@ -47,9 +47,9 @@ describe('ConnectionPool', () => {
     it('should create the pool', () => {
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput}));
       // Make sure 6 connections are created for each origin
-      assert.strictEqual(pool.connectionsByOrigin.get('http://example.com').length, 6);
+      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com'), 6);
       // Make sure it populates connectionWasReused
-      assert.strictEqual(pool.connectionReusedByRequestId.get('1'), false);
+      assert.isFalse(pool.connectionReusedByRequestId.get('1'));
 
       const connection = pool.connectionsByOrigin.get('http://example.com')[0];
       assert.strictEqual(connection.rtt, rtt);
@@ -61,29 +61,29 @@ describe('ConnectionPool', () => {
       const recordA = request({url: 'https://example.com'});
       const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
       const connection = pool.connectionsByOrigin.get('https://example.com')[0];
-      assert.ok(connection.ssl, 'should have set connection TLS');
+      assert.isOk(connection.ssl, 'should have set connection TLS');
     });
 
     it('should set H2 properly', () => {
       const recordA = request({protocol: 'h2'});
       const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
       const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection.isH2(), 'should have set HTTP/2');
-      assert.strictEqual(pool.connectionsByOrigin.get('http://example.com').length, 1);
+      assert.isOk(connection.isH2(), 'should have set HTTP/2');
+      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com'), 1);
     });
 
     it('should set origin-specific RTT properly', () => {
       const additionalRttByOrigin = new Map([['http://example.com', 63]]);
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput, additionalRttByOrigin}));
       const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection.rtt, rtt + 63);
+      assert.isOk(connection.rtt, rtt + 63);
     });
 
     it('should set origin-specific server latency properly', () => {
       const serverResponseTimeByOrigin = new Map([['http://example.com', 63]]);
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput, serverResponseTimeByOrigin}));
       const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection.serverLatency, 63);
+      assert.isOk(connection.serverLatency, 63);
     });
   });
 
@@ -100,13 +100,13 @@ describe('ConnectionPool', () => {
         assert.strictEqual(pool.acquireActiveConnectionFromRequest(requestB), connectionForB);
       }
 
-      assert.deepStrictEqual(pool.connectionsInUse(), [connectionForA, connectionForB]);
+      assert.deepEqual(pool.connectionsInUse(), [connectionForA, connectionForB]);
     });
 
     it('should allocate at least 6 connections', () => {
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput}));
       for (let i = 0; i < 6; i++) {
-        assert.ok(pool.acquire(request()), `did not find connection for ${i}th request`);
+        assert.isOk(pool.acquire(request()), `did not find connection for ${i}th request`);
       }
     });
 
@@ -114,9 +114,9 @@ describe('ConnectionPool', () => {
       const records = new Array(7).fill(undefined, 0, 7).map(() => request());
       const pool = new ConnectionPool(records, simulationOptions({rtt, throughput}));
       const connections = records.map(request => pool.acquire(request));
-      assert.ok(connections[0], 'did not find connection for 1st request');
-      assert.ok(connections[5], 'did not find connection for 6th request');
-      assert.ok(connections[6], 'did not find connection for 7th request');
+      assert.isOk(connections[0], 'did not find connection for 1st request');
+      assert.isOk(connections[5], 'did not find connection for 6th request');
+      assert.isOk(connections[6], 'did not find connection for 7th request');
     });
 
     it('should be oblivious to connection reuse', () => {
@@ -125,16 +125,16 @@ describe('ConnectionPool', () => {
       const pool = new ConnectionPool([coldRecord, warmRecord], simulationOptions({rtt, throughput}));
       pool.connectionReusedByRequestId.set(warmRecord.requestId, true);
 
-      assert.ok(pool.acquire(coldRecord), 'should have acquired connection');
-      assert.ok(pool.acquire(warmRecord), 'should have acquired connection');
+      assert.isOk(pool.acquire(coldRecord), 'should have acquired connection');
+      assert.isOk(pool.acquire(warmRecord), 'should have acquired connection');
       pool.release(coldRecord);
 
       for (const connection of pool.connectionsByOrigin.get('http://example.com')) {
         connection.setWarmed(true);
       }
 
-      assert.ok(pool.acquire(coldRecord), 'should have acquired connection');
-      assert.ok(pool.acquireActiveConnectionFromRequest(warmRecord), 'should have acquired connection');
+      assert.isOk(pool.acquire(coldRecord), 'should have acquired connection');
+      assert.isOk(pool.acquireActiveConnectionFromRequest(warmRecord), 'should have acquired connection');
     });
 
     it('should acquire in order of warmness', () => {
@@ -164,7 +164,7 @@ describe('ConnectionPool', () => {
     it('noop for request without connection', () => {
       const requestA = request();
       const pool = new ConnectionPool([requestA], simulationOptions({rtt, throughput}));
-      assert.strictEqual(pool.release(requestA), undefined);
+      assert.isUndefined(pool.release(requestA));
     });
 
     it('frees the connection for reissue', () => {
@@ -174,14 +174,14 @@ describe('ConnectionPool', () => {
 
       requests.forEach(request => pool.acquire(request));
 
-      assert.strictEqual(pool.connectionsInUse().length, 6);
-      assert.ok(!pool.acquire(requests[6]), 'had connection that is in use');
+      assert.lengthOf(pool.connectionsInUse(), 6);
+      assert.isOk(!pool.acquire(requests[6]), 'had connection that is in use');
 
       pool.release(requests[0]);
-      assert.strictEqual(pool.connectionsInUse().length, 5);
+      assert.lengthOf(pool.connectionsInUse(), 5);
 
-      assert.ok(pool.acquire(requests[6]), 'could not reissue released connection');
-      assert.ok(!pool.acquire(requests[0]), 'had connection that is in use');
+      assert.isOk(pool.acquire(requests[6]), 'could not reissue released connection');
+      assert.isOk(!pool.acquire(requests[0]), 'had connection that is in use');
     });
   });
 });

package/front_end/models/trace/lantern/simulation/Simulator.test.ts

@@ -70,7 +70,7 @@ describe('DependencyGraph/Simulator', () => {
 
     function assertNodeTiming(result, node, assertions) {
       const timing = result.nodeTimings.get(node);
-      assert.ok(timing, 'missing node timing information');
+      assert.isOk(timing, 'missing node timing information');
       Object.keys(assertions).forEach(key => {
         assert.strictEqual(timing[key], assertions[key]);
       });

package/front_end/models/trace/lantern/simulation/TCPConnection.test.ts

@@ -12,7 +12,7 @@ describe('TCPConnection', () => {
       const rtt = 150;
       const throughput = 1600 * 1024;
       const connection = new TCPConnection(rtt, throughput);
-      assert.ok(connection);
+      assert.isOk(connection);
       assert.strictEqual(connection.rtt, rtt);
     });
   });

package/front_end/models/trace/root-causes/LayoutShift.test.ts

@@ -266,19 +266,19 @@ describeWithMockConnection('LayoutShift root causes', () => {
            });
 
            // Test the nodes from the LI events are assinged as the potential root causes to layout shifts correctly.
-           assert.strictEqual(shiftCausesNodeIds[0].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[0], 1);
            assert.strictEqual(shiftCausesNodeIds[0][0], resizeEventsNodeIds[0]);
 
-           assert.strictEqual(shiftCausesNodeIds[1].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[1], 1);
            assert.strictEqual(shiftCausesNodeIds[1][0], resizeEventsNodeIds[0]);
 
-           assert.strictEqual(shiftCausesNodeIds[2].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[2], 1);
            assert.strictEqual(shiftCausesNodeIds[2][0], resizeEventsNodeIds[1]);
 
-           assert.strictEqual(shiftCausesNodeIds[3].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[3], 1);
            assert.strictEqual(shiftCausesNodeIds[3][0], resizeEventsNodeIds[1]);
 
-           assert.strictEqual(shiftCausesNodeIds[4].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[4], 1);
            assert.strictEqual(shiftCausesNodeIds[4][0], resizeEventsNodeIds[2]);
          });
 
@@ -436,10 +436,10 @@ describeWithMockConnection('LayoutShift root causes', () => {
            });
 
            // Test the nodes from the LI events are assinged as the potential root causes to layout shifts correctly.
-           assert.strictEqual(shiftCausesNodeIds[0].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[0], 1);
            assert.strictEqual(shiftCausesNodeIds[0][0], iframesNodeIds[0]);
 
-           assert.strictEqual(shiftCausesNodeIds[4].length, 1);
+           assert.lengthOf(shiftCausesNodeIds[4], 1);
            assert.strictEqual(shiftCausesNodeIds[4][0], iframesNodeIds[1]);
          });
 
@@ -528,10 +528,10 @@ describeWithMockConnection('LayoutShift root causes', () => {
         });
 
         // Test no font request is marked as potential layout shift root causes
-        assert.strictEqual(shiftCausesNodeIds[0].length, 0);
-        assert.strictEqual(shiftCausesNodeIds[1].length, 0);
-        assert.strictEqual(shiftCausesNodeIds[2].length, 0);
-        assert.strictEqual(shiftCausesNodeIds[3].length, 0);
+        assert.lengthOf(shiftCausesNodeIds[0], 0);
+        assert.lengthOf(shiftCausesNodeIds[1], 0);
+        assert.lengthOf(shiftCausesNodeIds[2], 0);
+        assert.lengthOf(shiftCausesNodeIds[3], 0);
       });
       it('ignores requests for fonts that lie outside the fixed time window from ending at the "font change" layout invalidation event',
          async () => {
@@ -554,10 +554,10 @@ describeWithMockConnection('LayoutShift root causes', () => {
            });
 
            // Test no font request is marked as potential layout shift root causes
-           assert.strictEqual(shiftCausesNodeIds[0].length, 0);
-           assert.strictEqual(shiftCausesNodeIds[1].length, 0);
-           assert.strictEqual(shiftCausesNodeIds[2].length, 0);
-           assert.strictEqual(shiftCausesNodeIds[3].length, 0);
+           assert.lengthOf(shiftCausesNodeIds[0], 0);
+           assert.lengthOf(shiftCausesNodeIds[1], 0);
+           assert.lengthOf(shiftCausesNodeIds[2], 0);
+           assert.lengthOf(shiftCausesNodeIds[3], 0);
          });
     });