refactor backend client

Author: AtofStryker

packages/server/lib/automation/commands/get_frame_title.ts

@@ -0,0 +1,21 @@
+import { evaluateInFrameContext } from '../helpers/evaluate_in_frame_context'
+import type { Protocol } from 'devtools-protocol'
+import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
+import type { Client as WebDriverClient } from 'webdriver'
+
+const expressionToEvaluate = `window.document.title`
+
+export async function cdpGetFrameTitle (send: SendDebuggerCommand, contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>, frame: Protocol.Page.Frame): Promise<string> {
+  return (await evaluateInFrameContext(expressionToEvaluate, send, contexts, frame!))?.result?.value
+}
+
+export async function bidiGetFrameTitle (webDriverClient: WebDriverClient, autContextId: string): Promise<string> {
+  return (await webDriverClient.scriptEvaluate({
+    expression: expressionToEvaluate,
+    target: {
+      context: autContextId,
+    },
+    awaitPromise: false,
+    // @ts-expect-error - result is not typed
+  }))?.result?.value
+}

packages/server/lib/automation/commands/get_url.ts

@@ -0,0 +1,16 @@
+import { evaluateInFrameContext } from '../helpers/evaluate_in_frame_context'
+import type { Protocol } from 'devtools-protocol'
+import type { Client as WebDriverClient } from 'webdriver'
+import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
+
+export async function cdpGetUrl (send: SendDebuggerCommand, contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>, frame: Protocol.Page.Frame): Promise<string> {
+  return (await evaluateInFrameContext(`window.location.href`, send, contexts, frame!))?.result?.value
+}
+
+export async function bidiGetUrl (webDriverClient: WebDriverClient, autContextId: string): Promise<string> {
+  const { contexts: autContext } = await webDriverClient.browsingContextGetTree({
+    root: autContextId,
+  })
+
+  return autContext ? autContext[0].url : ''
+}

packages/server/lib/automation/commands/key_press.ts

@@ -3,8 +3,8 @@ import type { KeyPressParams, KeyPressSupportedKeys } from '@packages/types'
 import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
 import type { Client } from 'webdriver'
 import Debug from 'debug'
-import { isEqual, isError } from 'lodash'
-import type ProtocolMapping from 'devtools-protocol/types/protocol-mapping'
+import { isEqual } from 'lodash'
+import { evaluateInFrameContext } from '../helpers/evaluate_in_frame_context'
 
 const debug = Debug('cypress:server:automation:command:keypress')
 
@@ -30,28 +30,6 @@ export const CDP_KEYCODE: KeyCodeLookup = {
   'Tab': 'U+000009',
 }
 
-export async function evaluateInFrameContext (expression: string,
-  send: SendDebuggerCommand,
-  contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>,
-  frame: Protocol.Page.Frame): Promise<ProtocolMapping.Commands['Runtime.evaluate']['returnType']> {
-  for (const [contextId, context] of contexts.entries()) {
-    if (context.auxData?.frameId === frame.id) {
-      try {
-        return await send('Runtime.evaluate', {
-          expression,
-          contextId,
-        })
-      } catch (e) {
-        if (isError(e) && (e as Error).message.includes('Cannot find context with specified id')) {
-          debug('found invalid context %d, removing', contextId)
-          contexts.delete(contextId)
-        }
-      }
-    }
-  }
-  throw new Error('Unable to find valid context for frame')
-}
-
 export async function cdpKeyPress (
   { key }: KeyPressParams, send: SendDebuggerCommand,
   contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>,

packages/server/lib/automation/commands/navigate_history.ts

@@ -0,0 +1,20 @@
+import { evaluateInFrameContext } from '../helpers/evaluate_in_frame_context'
+import type { Protocol } from 'devtools-protocol'
+import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
+import type { Client as WebDriverClient } from 'webdriver'
+
+const expressionToEvaluate = (historyNumber: number) => `window.history.go(${historyNumber})`
+
+export async function cdpNavigateHistory (send: SendDebuggerCommand, contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>, frame: Protocol.Page.Frame, historyNumber: number): Promise<void> {
+  await evaluateInFrameContext(expressionToEvaluate(historyNumber), send, contexts, frame)
+}
+
+export async function bidiNavigateHistory (webDriverClient: WebDriverClient, autContextId: string, historyNumber: number): Promise<void> {
+  await webDriverClient.scriptEvaluate({
+    expression: expressionToEvaluate(historyNumber),
+    target: {
+      context: autContextId,
+    },
+    awaitPromise: false,
+  })
+}

packages/server/lib/automation/commands/reload_frame.ts

@@ -0,0 +1,20 @@
+import { evaluateInFrameContext } from '../helpers/evaluate_in_frame_context'
+import type { Protocol } from 'devtools-protocol'
+import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
+import type { Client as WebDriverClient } from 'webdriver'
+
+const expressionToEvaluate = (forceReload = false) => `window.location.reload(${forceReload})`
+
+export async function cdpReloadFrame (send: SendDebuggerCommand, contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>, frame: Protocol.Page.Frame, forceReload: boolean): Promise<void> {
+  await evaluateInFrameContext(expressionToEvaluate(forceReload), send, contexts, frame)
+}
+
+export async function bidiReloadFrame (webDriverClient: WebDriverClient, autContextId: string, forceReload: boolean): Promise<void> {
+  await webDriverClient.scriptEvaluate({
+    expression: expressionToEvaluate(forceReload),
+    target: {
+      context: autContextId,
+    },
+    awaitPromise: false,
+  })
+}

packages/server/lib/automation/helpers/evaluate_in_frame_context.ts

@@ -0,0 +1,29 @@
+import type { Protocol } from 'devtools-protocol'
+import type { SendDebuggerCommand } from '../../browsers/cdp_automation'
+import Debug from 'debug'
+import { isError } from 'lodash'
+import type ProtocolMapping from 'devtools-protocol/types/protocol-mapping'
+
+const debug = Debug('cypress:server:automation:helpers:evaluate_in_frame_context')
+
+export async function evaluateInFrameContext (expression: string,
+  send: SendDebuggerCommand,
+  contexts: Map<Protocol.Runtime.ExecutionContextId, Protocol.Runtime.ExecutionContextDescription>,
+  frame: Protocol.Page.Frame): Promise<ProtocolMapping.Commands['Runtime.evaluate']['returnType']> {
+  for (const [contextId, context] of contexts.entries()) {
+    if (context.auxData?.frameId === frame.id) {
+      try {
+        return await send('Runtime.evaluate', {
+          expression,
+          contextId,
+        })
+      } catch (e) {
+        if (isError(e) && (e as Error).message.includes('Cannot find context with specified id')) {
+          debug('found invalid context %d, removing', contextId)
+          contexts.delete(contextId)
+        }
+      }
+    }
+  }
+  throw new Error('Unable to find valid context for frame')
+}

packages/server/lib/browsers/bidi_automation.ts

@@ -21,6 +21,10 @@ import type {
   NetworkSameSite,
 } from 'webdriver/build/bidi/localTypes'
 import type { CyCookie } from './webkit-automation'
+import { bidiGetUrl } from '../automation/commands/get_url'
+import { bidiReloadFrame } from '../automation/commands/reload_frame'
+import { bidiNavigateHistory } from '../automation/commands/navigate_history'
+import { bidiGetFrameTitle } from '../automation/commands/get_frame_title'
 
 const BIDI_DEBUG_NAMESPACE = 'cypress:server:browsers:bidi_automation'
 const BIDI_COOKIE_DEBUG_NAMESPACE = `${BIDI_DEBUG_NAMESPACE}:cookies`
@@ -662,11 +666,7 @@ export class BidiAutomation {
         case 'get:aut:url':
         {
           if (this.autContextId) {
-            const { contexts: autContext } = await this.webDriverClient.browsingContextGetTree({
-              root: this.autContextId,
-            })
-
-            return autContext ? autContext[0].url : ''
+            return bidiGetUrl(this.webDriverClient, this.autContextId)
           }
 
           throw new Error('Cannot get AUT url: no AUT context initialized')
@@ -675,13 +675,7 @@ export class BidiAutomation {
         case 'reload:aut:frame':
         {
           if (this.autContextId) {
-            await this.webDriverClient.scriptEvaluate({
-              expression: `window.location.reload(${data.forceReload || false})`,
-              target: {
-                context: this.autContextId,
-              },
-              awaitPromise: false,
-            })
+            await bidiReloadFrame(this.webDriverClient, this.autContextId, data.forceRelease)
 
             return
           }
@@ -691,32 +685,15 @@ export class BidiAutomation {
         case 'navigate:aut:history':
         {
           if (this.autContextId) {
-            await this.webDriverClient.scriptEvaluate({
-              expression: `window.history.go(${data.historyNumber})`,
-              target: {
-                context: this.autContextId,
-              },
-              awaitPromise: false,
-            })
-
-            return
+            await bidiNavigateHistory(this.webDriverClient, this.autContextId, data.historyNumber)
           }
 
           throw new Error('Cannot navigate AUT frame history: no AUT context initialized')
         }
         case 'get:aut:title':
         {
           if (this.autContextId) {
-            // @ts-expect-error - result is not typed
-            const { result } = await this.webDriverClient.scriptEvaluate({
-              expression: `window.document.title`,
-              target: {
-                context: this.autContextId,
-              },
-              awaitPromise: false,
-            })
-
-            return result.value
+            return bidiGetFrameTitle(this.webDriverClient, this.autContextId)
           }
 
           throw new Error('Cannot get AUT title no AUT context initialized')

packages/server/lib/browsers/cdp_automation.ts

@@ -14,7 +14,11 @@ import type { CDPClient, ProtocolManagerShape, WriteVideoFrame, AutomationMiddle
 import type { Automation } from '../automation'
 import { cookieMatches, CyCookie, CyCookieFilter } from '../automation/util'
 import { DEFAULT_NETWORK_ENABLE_OPTIONS, CriClient } from './cri-client'
-import { cdpKeyPress, evaluateInFrameContext } from '../automation/commands/key_press'
+import { cdpKeyPress } from '../automation/commands/key_press'
+import { cdpGetUrl } from '../automation/commands/get_url'
+import { cdpReloadFrame } from '../automation/commands/reload_frame'
+import { cdpNavigateHistory } from '../automation/commands/navigate_history'
+import { cdpGetFrameTitle } from '../automation/commands/get_frame_title'
 
 export type CdpCommand = keyof ProtocolMapping.Commands
 
@@ -476,16 +480,6 @@ export class CdpAutomation implements CDPClient, AutomationMiddleware {
     }
   }
 
-  private _getAutUrl = async () => {
-    const frame = await this._getAutFrame()
-
-    if (!frame) {
-      throw new Error('Could not find AUT frame')
-    }
-
-    return ((frame?.url || '') + (frame?.urlFragment || '')) || ''
-  }
-
   _handlePausedRequests = async (client: CriClient) => {
     // NOTE: only supported in chromium based browsers
     await client.send('Fetch.enable', {
@@ -637,26 +631,27 @@ export class CdpAutomation implements CDPClient, AutomationMiddleware {
       {
         const frame = await this._getAutFrame()
 
-        return (await evaluateInFrameContext(`window.location.href`, this.sendDebuggerCommandFn, this.executionContexts, frame!))?.result?.value
+        return cdpGetUrl(this.sendDebuggerCommandFn, this.executionContexts, frame!)
       }
       case 'reload:aut:frame':
       {
         const frame = await this._getAutFrame()
 
-        return evaluateInFrameContext(`window.location.reload(${data.forceReload || false})`, this.sendDebuggerCommandFn, this.executionContexts, frame!)
+        await cdpReloadFrame(this.sendDebuggerCommandFn, this.executionContexts, frame!, data.forceReload)
+
+        return
       }
       case 'navigate:aut:history':
       {
         const frame = await this._getAutFrame()
 
-        return evaluateInFrameContext(`window.history.go(${data.historyNumber})`, this.sendDebuggerCommandFn, this.executionContexts, frame!)
+        return cdpNavigateHistory(this.sendDebuggerCommandFn, this.executionContexts, frame!, data.historyNumber!)
       }
-
       case 'get:aut:title':
       {
         const frame = await this._getAutFrame()
 
-        return (await evaluateInFrameContext(`window.document.title`, this.sendDebuggerCommandFn, this.executionContexts, frame!))?.result?.value
+        return cdpGetFrameTitle(this.sendDebuggerCommandFn, this.executionContexts, frame!)
       }
       default:
         throw new Error(`No automation handler registered for: '${message}'`)