[test] Fix types for selectors

Bug: none
Change-Id: I84974d640a005fbbf0f1aed3c802202731b40381
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6404073
Commit-Queue: Benedikt Meurer <[email protected]>
Auto-Submit: Nikolay Vitkov <[email protected]>
Reviewed-by: Benedikt Meurer <[email protected]>

Author: Lightning00Blade

front_end/ui/legacy/components/data_grid/DataGridElement.ts

@@ -505,6 +505,12 @@ class DataGridElementNode extends SortableDataGridNode<DataGridElementNode> {
 
 customElements.define('devtools-data-grid', DataGridElement);
 
+declare global {
+  interface HTMLElementTagNameMap {
+    'devtools-data-grid': DataGridElement;
+  }
+}
+
 function hasBooleanAttribute(element: Element, name: string): boolean {
   return element.hasAttribute(name) && element.getAttribute(name) !== 'false';
 }

test/e2e/application/window-controls_test.ts

@@ -29,7 +29,7 @@ describe('The Window Controls Overlay', () => {
 
     // Verify selecting an option
     void selectOption(await controlsDropDown.toElement('select'), 'Linux');
-    const selectedOption = await controlsDropDown.evaluate(input => (input as HTMLInputElement).value);
+    const selectedOption = await controlsDropDown.evaluate(input => input.value);
     assert.strictEqual(selectedOption, 'Linux');
 
     // Verify clicking the checkbox

test/e2e/helpers/datagrid-helpers.ts

@@ -24,7 +24,7 @@ export async function getDataGridRows(
     });
   })();
 
-  return await Promise.all(handlers.map(handler => $$<HTMLTableCellElement>('td[jslog]:not(.hidden)', handler)));
+  return await Promise.all(handlers.map(handler => $$('td[jslog]:not(.hidden)', handler)));
 }
 
 export async function getDataGrid(root?: ElementHandle) {

test/e2e_non_hosted/shared/frontend-helper.ts

@@ -151,8 +151,8 @@ export class DevToolsPage extends PageWrapper {
     });
   }
 
-  async waitFor<ElementType extends Element = Element>(
-      selector: string, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) {
+  async waitFor<ElementType extends Element|null = null, Selector extends string = string>(
+      selector: Selector, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) {
     return await asyncScope.exec(() => this.waitForFunction(async () => {
       const element = await this.$<ElementType, typeof selector>(selector, root, handler);
       return (element || undefined);

test/shared/helper.ts

@@ -224,26 +224,26 @@ export const getVisibleTextContents = async (selector: string) => {
   return texts.filter(content => typeof (content) === 'string');
 };
 
-export const waitFor = async<ElementType extends Element = Element>(
-    selector: string, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) => {
+export const waitFor = async<ElementType extends Element|null = null, Selector extends string = string>(
+    selector: Selector, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) => {
   const {devToolsPage} = getBrowserAndPagesWrappers();
-  return await devToolsPage.waitFor<ElementType>(selector, root, asyncScope, handler);
+  return await devToolsPage.waitFor<ElementType, Selector>(selector, root, asyncScope, handler);
 };
 
-export const waitForVisible = async<ElementType extends Element = Element>(
-    selector: string, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) => {
+export const waitForVisible = async<ElementType extends Element|null = null, Selector extends string = string>(
+    selector: Selector, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(), handler?: string) => {
   return await asyncScope.exec(() => waitForFunction(async () => {
                                  const element = await $<ElementType, typeof selector>(selector, root, handler);
                                  const visible = await element.evaluate(node => node.checkVisibility());
                                  return visible ? element : undefined;
                                }, asyncScope), `Waiting for element matching selector '${selector}' to be visible`);
 };
 
-export const waitForMany = async (
-    selector: string, count: number, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(),
+export const waitForMany = async<ElementType extends Element|null = null, Selector extends string = string>(
+    selector: Selector, count: number, root?: puppeteer.ElementHandle, asyncScope = new AsyncScope(),
     handler?: string) => {
   return await asyncScope.exec(() => waitForFunction(async () => {
-                                 const elements = await $$(selector, root, handler);
+                                 const elements = await $$<ElementType, typeof selector>(selector, root, handler);
                                  return elements.length >= count ? elements : undefined;
                                }, asyncScope), `Waiting for ${count} elements to match selector '${selector}'`);
 };