Consistently prefer assert.isOk and assert.isNotOk.

`assert.ok` is an alias for `assert.isOk`, and similarly `assert.notOk`
is an alias for `assert.isNotOk`. For consistency with other assertions
such as `assert.isNull` and `assert.isNotNull`, we enforce the use of
the slightly longer form here as well.

Bug: 386335487
Change-Id: If845a5675a78598d01b30532985239f74f701db7
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6120409
Commit-Queue: Benedikt Meurer <bmeurer@chromium.org>
Reviewed-by: Changhao Han <changhaohan@chromium.org>

Author: bmeurer

.eslintrc.js

@@ -298,6 +298,7 @@ module.exports = {
       'rulesdir/no-assert-equal-boolean-null-undefined' : 'error',
       'rulesdir/no-repeated-tests' : 'error',
       'rulesdir/no-screenshot-test-outside-perf-panel' : 'error',
+      'rulesdir/prefer-assert-is-ok' : 'error',
       'rulesdir/prefer-assert-length-of' : 'error',
       'rulesdir/trace-engine-test-timeouts' : 'error',
       '@typescript-eslint/no-non-null-assertion' : 'off',

front_end/models/trace/ModelImpl.test.ts

@@ -17,8 +17,8 @@ describeWithEnvironment('TraceModel', function() {
     });
 
     await TraceLoader.rawEvents(this, 'basic.json.gz').then(events => model.parse(events));
-    assert.ok(events.includes('PROGRESS_UPDATE'));
-    assert.ok(events.includes('COMPLETE'));
+    assert.isOk(events.includes('PROGRESS_UPDATE'));
+    assert.isOk(events.includes('COMPLETE'));
   });
 
   it('supports parsing a generic trace that has no browser specific details', async function() {

front_end/models/trace/lantern/core/NetworkAnalyzer.test.ts

@@ -57,7 +57,7 @@ describe('NetworkAnalyzer', () => {
 
   function assertCloseEnough(valueA, valueB, threshold = 1) {
     const message = `${valueA} was not close enough to ${valueB}`;
-    assert.ok(Math.abs(valueA - valueB) < threshold, message);
+    assert.isOk(Math.abs(valueA - valueB) < threshold, message);
   }
 
   describe('#estimateIfConnectionWasReused', () => {

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

@@ -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());
     });
   });
 
@@ -226,10 +226,10 @@ 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.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'));
     });

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

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

@@ -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 () => {

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

@@ -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 () => {
@@ -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');
   });
 });

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

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

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

@@ -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.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);
     });
   });
 
@@ -106,17 +106,17 @@ describe('ConnectionPool', () => {
     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`);
       }
     });
 
     it('should allocate all connections', () => {
       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', () => {
@@ -175,13 +175,13 @@ describe('ConnectionPool', () => {
       requests.forEach(request => pool.acquire(request));
 
       assert.lengthOf(pool.connectionsInUse(), 6);
-      assert.ok(!pool.acquire(requests[6]), 'had connection that is in use');
+      assert.isOk(!pool.acquire(requests[6]), 'had connection that is in use');
 
       pool.release(requests[0]);
       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');
     });
   });
 });

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