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 <[email protected]>
Reviewed-by: Changhao Han <[email protected]>

Author: bmeurer

Diff for: .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',

Diff for: 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() {

Diff for: 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', () => {

Diff for: 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'));
     });

Diff for: 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]);

Diff for: 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 () => {

Diff for: 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');
   });
 });

Diff for: 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');
   });
 });

Diff for: 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');
     });
   });
 });

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

Diff for: 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);
     });
   });

Diff for: front_end/panels/ai_assistance/components/ChatView.test.ts

@@ -59,7 +59,7 @@ css
           const elem = renderToElem(linkCase, linklessRenderer);
           assert.lengthOf(elem.querySelectorAll('a, x-link, devtools-link'), 0);
           assert.isFalse(['<a', '<x-link', '<devtools-link'].some(tagName => elem.outerHTML.includes(tagName)));
-          assert.ok(elem.textContent?.includes('( https://z.com )'), linkCase);
+          assert.isOk(elem.textContent?.includes('( https://z.com )'), linkCase);
         }
       });
 
@@ -90,7 +90,7 @@ css
           assert.isFalse(['<a', '<x-link', '<devtools-link', '<img', '<devtools-markdown-image'].some(
               tagName => elem.outerHTML.includes(tagName)));
 
-          assert.ok(elem.textContent?.includes('( https://z.com/i.png )'), imageCase);
+          assert.isOk(elem.textContent?.includes('( https://z.com/i.png )'), imageCase);
         }
       });
     });

Diff for: front_end/panels/recorder/RecorderController.test.ts

@@ -57,7 +57,7 @@ describeWithEnvironment('RecorderController', () => {
       const createRecordingView = controller.shadowRoot?.querySelector(
           'devtools-create-recording-view',
       );
-      assert.ok(createRecordingView);
+      assert.isOk(createRecordingView);
       createRecordingView?.dispatchEvent(
           new Components.CreateRecordingView.RecordingCancelledEvent(),
       );
@@ -74,7 +74,7 @@ describeWithEnvironment('RecorderController', () => {
       const recordingView = controller.shadowRoot?.querySelector(
           'devtools-recording-view',
       );
-      assert.ok(recordingView);
+      assert.isOk(recordingView);
       recordingView?.dispatchEvent(event);
       await coordinator.done();
     }

Diff for: front_end/panels/recorder/components/CreateRecordingView.test.ts

@@ -30,11 +30,11 @@ describeWithEnvironment('CreateRecordingView', () => {
     const input = view.shadowRoot?.querySelector(
                       '#user-flow-name',
                       ) as HTMLInputElement;
-    assert.ok(input);
+    assert.isOk(input);
     const button = view.shadowRoot?.querySelector(
                        'devtools-control-button',
                        ) as Components.ControlButton.ControlButton;
-    assert.ok(button);
+    assert.isOk(button);
     const onceClicked = new Promise<Components.CreateRecordingView.RecordingStartedEvent>(
         resolve => {
           view.addEventListener('recordingstarted', resolve, {once: true});
@@ -78,11 +78,11 @@ describeWithEnvironment('CreateRecordingView', () => {
     let input = view.shadowRoot?.querySelector(
                     '#selector-attribute',
                     ) as HTMLInputElement;
-    assert.ok(input);
+    assert.isOk(input);
     const button = view.shadowRoot?.querySelector(
                        'devtools-control-button',
                        ) as Components.ControlButton.ControlButton;
-    assert.ok(button);
+    assert.isOk(button);
     const onceClicked = new Promise<Components.CreateRecordingView.RecordingStartedEvent>(
         resolve => {
           view.addEventListener('recordingstarted', resolve, {once: true});
@@ -96,7 +96,7 @@ describeWithEnvironment('CreateRecordingView', () => {
     input = view.shadowRoot?.querySelector(
                 '#selector-attribute',
                 ) as HTMLInputElement;
-    assert.ok(input);
+    assert.isOk(input);
     assert.strictEqual(input.value, 'data-custom-attribute');
   });
 
@@ -110,7 +110,7 @@ describeWithEnvironment('CreateRecordingView', () => {
     const button = view.shadowRoot?.querySelector(
                        'devtools-control-button',
                        ) as Components.ControlButton.ControlButton;
-    assert.ok(button);
+    assert.isOk(button);
     const onceClicked = new Promise<Components.CreateRecordingView.RecordingStartedEvent>(
         resolve => {
           view.addEventListener('recordingstarted', resolve, {once: true});

Diff for: front_end/panels/recorder/components/RecordingListView.test.ts

@@ -22,7 +22,7 @@ describeWithEnvironment('RecordingListView', () => {
     view.recordings = [{storageName: 'storage-test', name: 'test'}];
     await coordinator.done();
     const recording = view.shadowRoot?.querySelector('.row') as HTMLDivElement;
-    assert.ok(recording);
+    assert.isOk(recording);
     const eventSent = new Promise<Components.RecordingListView.OpenRecordingEvent>(
         resolve => {
           view.addEventListener('openrecording', resolve, {once: true});
@@ -41,7 +41,7 @@ describeWithEnvironment('RecordingListView', () => {
     const deleteButton = view.shadowRoot?.querySelector(
                              '.delete-recording-button',
                              ) as HTMLButtonElement;
-    assert.ok(deleteButton);
+    assert.isOk(deleteButton);
     const eventSent = new Promise<Components.RecordingListView.DeleteRecordingEvent>(
         resolve => {
           view.addEventListener('deleterecording', resolve, {once: true});
@@ -60,7 +60,7 @@ describeWithEnvironment('RecordingListView', () => {
     const deleteButton = view.shadowRoot?.querySelector(
                              '.delete-recording-button',
                              ) as HTMLDivElement;
-    assert.ok(deleteButton);
+    assert.isOk(deleteButton);
     let forceResolve: Function|undefined;
     const eventSent = new Promise<Components.RecordingListView.OpenRecordingEvent>(
         resolve => {

Diff for: front_end/panels/recorder/components/RecordingView.test.ts

@@ -98,15 +98,15 @@ describeWithEnvironment('RecordingView', () => {
     const button = view.shadowRoot?.querySelector(
                        '.show-code',
                        ) as HTMLDivElement;
-    assert.ok(button);
+    assert.isOk(button);
     dispatchClickEvent(button);
   }
 
   function clickHideCode(view: Components.RecordingView.RecordingView) {
     const button = view.shadowRoot?.querySelector(
                        '[title="Hide code"]',
                        ) as HTMLDivElement;
-    assert.ok(button);
+    assert.isOk(button);
     dispatchClickEvent(button);
   }
 
@@ -122,7 +122,7 @@ describeWithEnvironment('RecordingView', () => {
     const menu = view.shadowRoot?.querySelector(
                      'devtools-select-menu',
                      ) as Menus.SelectMenu.SelectMenu;
-    assert.ok(menu);
+    assert.isOk(menu);
 
     const event = new Menus.SelectMenu.SelectMenuItemSelectedEvent(Models.ConverterIds.ConverterIds.REPLAY);
     menu.dispatchEvent(event);

Diff for: front_end/ui/components/split_view/SplitView.test.ts

@@ -19,7 +19,7 @@ describe('SplitView', () => {
     const resizer = view.shadowRoot?.querySelector(
                         '#resizer',
                         ) as HTMLDivElement;
-    assert.ok(resizer);
+    assert.isOk(resizer);
 
     assert.strictEqual(
         view.style.getPropertyValue('--current-main-area-size'),
@@ -59,7 +59,7 @@ describe('SplitView', () => {
     const resizer = view.shadowRoot?.querySelector(
                         '#resizer',
                         ) as HTMLDivElement;
-    assert.ok(resizer);
+    assert.isOk(resizer);
 
     view.style.width = '600px';
     view.style.height = '800px';
@@ -81,7 +81,7 @@ describe('SplitView', () => {
     const resizer = view.shadowRoot?.querySelector(
                         '#resizer',
                         ) as HTMLDivElement;
-    assert.ok(resizer);
+    assert.isOk(resizer);
 
     await coordinator.done({waitForWork: true});
 
@@ -99,7 +99,7 @@ describe('SplitView', () => {
     const resizer = view.shadowRoot?.querySelector(
                         '#resizer',
                         ) as HTMLDivElement;
-    assert.ok(resizer);
+    assert.isOk(resizer);
 
     view.style.width = '600px';
     view.style.height = '550px';