@seleniumhq/code-export-python-pytest 3.17.2 → 4.0.0-alpha.0

package/src/{command.js → command.ts}

@@ -15,11 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-import { codeExport as exporter } from '@seleniumhq/side-utils'
+import {
+  codeExport as exporter,
+  ExportFlexCommandShape,
+  PrebuildEmitter,
+  ProcessedCommandEmitter,
+  ScriptShape,
+} from '@seleniumhq/side-code-export'
+import { CommandShape } from '@seleniumhq/side-model'
 import location from './location'
 import selection from './selection'
 
-export const emitters = {
+export const emitters: Record<string, ProcessedCommandEmitter> = {
   addSelection: emitSelect,
   answerOnNextPrompt: skip,
   assert: emitAssert,
@@ -114,7 +121,8 @@ export const emitters = {
   waitForElementNotVisible: emitWaitForElementNotVisible,
   webdriverAnswerOnVisiblePrompt: emitAnswerOnNextPrompt,
   waitForText: emitWaitForText,
-  webdriverChooseCancelOnVisibleConfirmation: emitChooseCancelOnNextConfirmation,
+  webdriverChooseCancelOnVisibleConfirmation:
+    emitChooseCancelOnNextConfirmation,
   webdriverChooseCancelOnVisiblePrompt: emitChooseCancelOnNextConfirmation,
   webdriverChooseOkOnVisibleConfirmation: emitChooseOkOnNextConfirmation,
   while: emitControlFlowWhile,
@@ -122,31 +130,27 @@ export const emitters = {
 
 exporter.register.preprocessors(emitters)
 
-function register(command, emitter) {
+function register(command: string, emitter: PrebuildEmitter) {
   exporter.register.emitter({ command, emitter, emitters })
 }
 
-function emit(command) {
+function emit(command: CommandShape) {
   return exporter.emit.command(command, emitters[command.command], {
     variableLookup,
     emitNewWindowHandling,
   })
 }
 
-function canEmit(commandName) {
-  return !!emitters[commandName]
-}
-
-function variableLookup(varName) {
+function variableLookup(varName: string) {
   return `self.vars["${varName}"]`
 }
 
-function variableSetter(varName, value) {
+function variableSetter(varName: string, value: string) {
   return varName ? `self.vars["${varName}"] = ${value}` : ''
 }
 
 function emitWaitForWindow() {
-  const generateMethodDeclaration = name => {
+  const generateMethodDeclaration = (name: string) => {
     return `def ${name}(self, timeout = 2):`
   }
   const commands = [
@@ -169,7 +173,10 @@ function emitWaitForWindow() {
   })
 }
 
-async function emitNewWindowHandling(command, emittedCommand) {
+async function emitNewWindowHandling(
+  command: CommandShape,
+  emittedCommand: ExportFlexCommandShape
+) {
   return Promise.resolve(
     `self.vars["window_handles"] = self.driver.window_handles\n${await emittedCommand}\nself.vars["${
       command.windowHandleName
@@ -177,7 +184,7 @@ async function emitNewWindowHandling(command, emittedCommand) {
   )
 }
 
-function emitAssert(varName, value) {
+function emitAssert(varName: string, value: string) {
   let _value
   if (value === 'true' || value === 'false') {
     _value = exporter.parsers.capitalize(value)
@@ -190,13 +197,13 @@ function emitAssert(varName, value) {
   return Promise.resolve(result)
 }
 
-function emitAssertAlert(alertText) {
+function emitAssertAlert(alertText: string) {
   return Promise.resolve(
     `assert self.driver.switch_to.alert.text == "${alertText}"`
   )
 }
 
-function emitAnswerOnNextPrompt(textToSend) {
+function emitAnswerOnNextPrompt(textToSend: string) {
   const commands = [
     { level: 0, statement: 'alert = self.driver.switch_to.alert' },
     { level: 0, statement: `alert.send_keys("${textToSend}")` },
@@ -205,7 +212,7 @@ function emitAnswerOnNextPrompt(textToSend) {
   return Promise.resolve({ commands })
 }
 
-async function emitCheck(locator) {
+async function emitCheck(locator: string) {
   const commands = [
     {
       level: 0,
@@ -229,7 +236,7 @@ function emitChooseOkOnNextConfirmation() {
   return Promise.resolve(`self.driver.switch_to.alert.accept()`)
 }
 
-async function emitClick(target) {
+async function emitClick(target: string) {
   return Promise.resolve(
     `self.driver.find_element(${await location.emit(target)}).click()`
   )
@@ -239,15 +246,15 @@ async function emitClose() {
   return Promise.resolve(`self.driver.close()`)
 }
 
-function generateExpressionScript(script) {
+function generateExpressionScript(script: ScriptShape) {
   return `self.driver.execute_script("return (${
     script.script
   })"${generateScriptArguments(script)})`
 }
 
-function generateScriptArguments(script) {
+function generateScriptArguments(script: ScriptShape) {
   return `${script.argv.length ? ', ' : ''}${script.argv
-    .map(varName => `self.vars["${varName}"]`)
+    .map((varName) => `self.vars["${varName}"]`)
     .join(',')}`
 }
 
@@ -269,7 +276,7 @@ function emitControlFlowElse() {
   })
 }
 
-function emitControlFlowElseIf(script) {
+function emitControlFlowElseIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       {
@@ -290,7 +297,7 @@ function emitControlFlowEnd() {
   })
 }
 
-function emitControlFlowIf(script) {
+function emitControlFlowIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       { level: 0, statement: `if ${generateExpressionScript(script)}:` },
@@ -299,7 +306,10 @@ function emitControlFlowIf(script) {
   })
 }
 
-function emitControlFlowForEach(collectionVarName, iteratorVarName) {
+function emitControlFlowForEach(
+  collectionVarName: string,
+  iteratorVarName: string
+) {
   return Promise.resolve({
     commands: [
       {
@@ -318,7 +328,7 @@ function emitControlFlowForEach(collectionVarName, iteratorVarName) {
   })
 }
 
-function emitControlFlowRepeatIf(script) {
+function emitControlFlowRepeatIf(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       {
@@ -330,12 +340,12 @@ function emitControlFlowRepeatIf(script) {
   })
 }
 
-function emitControlFlowTimes(target) {
+function emitControlFlowTimes(target: string) {
   const commands = [{ level: 0, statement: `for i in range(0, ${target}):` }]
   return Promise.resolve({ commands, endingLevelAdjustment: 1 })
 }
 
-function emitControlFlowWhile(script) {
+function emitControlFlowWhile(script: ScriptShape) {
   return Promise.resolve({
     commands: [
       { level: 0, statement: `while ${generateExpressionScript(script)}:` },
@@ -344,7 +354,7 @@ function emitControlFlowWhile(script) {
   })
 }
 
-async function emitDoubleClick(target) {
+async function emitDoubleClick(target: string) {
   const commands = [
     {
       level: 0,
@@ -358,7 +368,7 @@ async function emitDoubleClick(target) {
   return Promise.resolve({ commands })
 }
 
-async function emitDragAndDrop(dragged, dropped) {
+async function emitDragAndDrop(dragged: string, dropped: string) {
   const commands = [
     {
       level: 0,
@@ -381,7 +391,7 @@ async function emitDragAndDrop(dragged, dropped) {
   return Promise.resolve({ commands })
 }
 
-function translateToPythonString(str) {
+function translateToPythonString(str: string) {
   const regExp = /self.vars\["\w+"]/
   const vars = str.match(regExp)
 
@@ -393,12 +403,12 @@ function translateToPythonString(str) {
   return `"${str}"`
 }
 
-async function emitEcho(message) {
+async function emitEcho(message: string) {
   const _message = translateToPythonString(message)
   return Promise.resolve(`print(${_message})`)
 }
 
-async function emitEditContent(locator, content) {
+async function emitEditContent(locator: string, content: string) {
   const commands = [
     {
       level: 0,
@@ -414,7 +424,7 @@ async function emitEditContent(locator, content) {
   return Promise.resolve({ commands })
 }
 
-async function emitExecuteScript(script, varName) {
+async function emitExecuteScript(script: ScriptShape, varName: string) {
   const scriptString = script.script.replace(/"/g, "'")
   const result = `self.driver.execute_script("${scriptString}"${generateScriptArguments(
     script
@@ -422,14 +432,14 @@ async function emitExecuteScript(script, varName) {
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitExecuteAsyncScript(script, varName) {
+async function emitExecuteAsyncScript(script: ScriptShape, varName: string) {
   const result = `self.driver.execute_async_script("var callback = arguments[arguments.length - 1];${
     script.script
   }.then(callback).catch(callback);${generateScriptArguments(script)}")`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitMouseDown(locator) {
+async function emitMouseDown(locator: string) {
   const commands = [
     {
       level: 0,
@@ -446,7 +456,7 @@ async function emitMouseDown(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitMouseMove(locator) {
+async function emitMouseMove(locator: string) {
   const commands = [
     {
       level: 0,
@@ -472,7 +482,7 @@ async function emitMouseOut() {
   return Promise.resolve({ commands })
 }
 
-async function emitMouseUp(locator) {
+async function emitMouseUp(locator: string) {
   const commands = [
     {
       level: 0,
@@ -489,24 +499,25 @@ async function emitMouseUp(locator) {
   return Promise.resolve({ commands })
 }
 
-function emitOpen(target) {
+function emitOpen(target: string) {
   const url = /^(file|http|https):\/\//.test(target)
     ? `"${target}"`
-    : `"${global.baseUrl}${target}"`
+    : // @ts-expect-error globals yuck
+      `"${global.baseUrl}${target}"`
   return Promise.resolve(`self.driver.get(${url})`)
 }
 
-async function emitPause(time) {
+async function emitPause(time: number) {
   const sec = time / 1000
   const commands = [{ level: 0, statement: `time.sleep(${sec})` }]
   return Promise.resolve({ commands })
 }
 
-async function emitRun(testName) {
+async function emitRun(testName: string) {
   return Promise.resolve(`self.${exporter.parsers.sanitizeName(testName)}()`)
 }
 
-async function emitRunScript(script) {
+async function emitRunScript(script: ScriptShape) {
   return Promise.resolve(
     `self.driver.execute_script("${script.script}${generateScriptArguments(
       script
@@ -514,12 +525,12 @@ async function emitRunScript(script) {
   )
 }
 
-async function emitSetWindowSize(size) {
+async function emitSetWindowSize(size: string) {
   const [width, height] = size.split('x')
   return Promise.resolve(`self.driver.set_window_size(${width}, ${height})`)
 }
 
-async function emitSelect(selectElement, option) {
+async function emitSelect(selectElement: string, option: string) {
   const commands = [
     {
       level: 0,
@@ -537,13 +548,13 @@ async function emitSelect(selectElement, option) {
   return Promise.resolve({ commands })
 }
 
-async function emitSelectFrame(frameLocation) {
+async function emitSelectFrame(frameLocation: string) {
   if (frameLocation === 'relative=top' || frameLocation === 'relative=parent') {
     return Promise.resolve('self.driver.switch_to.default_content()')
   } else if (/^index=/.test(frameLocation)) {
     return Promise.resolve(
       `self.driver.switch_to.frame(${Math.floor(
-        frameLocation.split('index=')[1]
+        Number(frameLocation.split('index=')?.[1])
       )})`
     )
   } else {
@@ -561,7 +572,7 @@ async function emitSelectFrame(frameLocation) {
   }
 }
 
-async function emitSelectWindow(windowLocation) {
+async function emitSelectWindow(windowLocation: string) {
   if (/^handle=/.test(windowLocation)) {
     return Promise.resolve(
       `self.driver.switch_to.window(${windowLocation.split('handle=')[1]})`
@@ -599,14 +610,14 @@ async function emitSelectWindow(windowLocation) {
   }
 }
 
-function generateSendKeysInput(value) {
+function generateSendKeysInput(value: string | string[]) {
   if (typeof value === 'object') {
     return value
-      .map(s => {
+      .map((s) => {
         if (s.startsWith('self.vars[')) {
           return s
         } else if (s.startsWith('Key[')) {
-          const key = s.match(/\['(.*)'\]/)[1]
+          const key = s.match(/\['(.*)'\]/)?.[1]
           return `Keys.${key}`
         } else {
           return `"${s}"`
@@ -622,7 +633,7 @@ function generateSendKeysInput(value) {
   }
 }
 
-async function emitSendKeys(target, value) {
+async function emitSendKeys(target: string, value: string) {
   return Promise.resolve(
     `self.driver.find_element(${await location.emit(
       target
@@ -636,11 +647,11 @@ function emitSetSpeed() {
   )
 }
 
-async function emitStore(value, varName) {
+async function emitStore(value: string, varName: string) {
   return Promise.resolve(variableSetter(varName, `"${value}"`))
 }
 
-async function emitStoreAttribute(locator, varName) {
+async function emitStoreAttribute(locator: string, varName: string) {
   const attributePos = locator.lastIndexOf('@')
   const elementLocator = locator.slice(0, attributePos)
   const attributeName = locator.slice(attributePos + 1)
@@ -656,48 +667,48 @@ async function emitStoreAttribute(locator, varName) {
   return Promise.resolve({ commands })
 }
 
-async function emitStoreJson(json, varName) {
+async function emitStoreJson(json: string, varName: string) {
   return Promise.resolve(variableSetter(varName, `json.loads('${json}')`))
 }
 
-async function emitStoreText(locator, varName) {
+async function emitStoreText(locator: string, varName: string) {
   const result = `self.driver.find_element(${await location.emit(
     locator
   )}).text`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitStoreTitle(_, varName) {
+async function emitStoreTitle(_: string, varName: string) {
   return Promise.resolve(variableSetter(varName, 'self.driver.title'))
 }
 
-async function emitStoreValue(locator, varName) {
+async function emitStoreValue(locator: string, varName: string) {
   const result = `self.driver.find_element(${await location.emit(
     locator
   )}).get_attribute("value")`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitStoreWindowHandle(varName) {
+async function emitStoreWindowHandle(varName: string) {
   return Promise.resolve(
     variableSetter(varName, 'self.driver.current_window_handle')
   )
 }
 
-async function emitStoreXpathCount(locator, varName) {
+async function emitStoreXpathCount(locator: string, varName: string) {
   const result = `len(self.driver.find_elements(${await location.emit(
     locator
   )}))`
   return Promise.resolve(variableSetter(varName, result))
 }
 
-async function emitSubmit(_locator) {
+async function emitSubmit(_locator: string) {
   return Promise.resolve(
     `raise Exception("'submit' is not a supported command in Selenium WebDriver. Please re-record the step in the IDE.")`
   )
 }
 
-async function emitType(target, value) {
+async function emitType(target: string, value: string) {
   return Promise.resolve(
     `self.driver.find_element(${await location.emit(
       target
@@ -705,7 +716,7 @@ async function emitType(target, value) {
   )
 }
 
-async function emitUncheck(locator) {
+async function emitUncheck(locator: string) {
   const commands = [
     {
       level: 0,
@@ -718,7 +729,7 @@ async function emitUncheck(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyChecked(locator) {
+async function emitVerifyChecked(locator: string) {
   return Promise.resolve(
     `assert self.driver.find_element(${await location.emit(
       locator
@@ -726,7 +737,7 @@ async function emitVerifyChecked(locator) {
   )
 }
 
-async function emitVerifyEditable(locator) {
+async function emitVerifyEditable(locator: string) {
   const commands = [
     {
       level: 0,
@@ -739,7 +750,7 @@ async function emitVerifyEditable(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyElementPresent(locator) {
+async function emitVerifyElementPresent(locator: string) {
   const commands = [
     {
       level: 0,
@@ -752,7 +763,7 @@ async function emitVerifyElementPresent(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyElementNotPresent(locator) {
+async function emitVerifyElementNotPresent(locator: string) {
   const commands = [
     {
       level: 0,
@@ -765,7 +776,7 @@ async function emitVerifyElementNotPresent(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotChecked(locator) {
+async function emitVerifyNotChecked(locator: string) {
   return Promise.resolve(
     `assert self.driver.find_element(${await location.emit(
       locator
@@ -773,7 +784,7 @@ async function emitVerifyNotChecked(locator) {
   )
 }
 
-async function emitVerifyNotEditable(locator) {
+async function emitVerifyNotEditable(locator: string) {
   const commands = [
     {
       level: 0,
@@ -786,7 +797,10 @@ async function emitVerifyNotEditable(locator) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotSelectedValue(locator, expectedValue) {
+async function emitVerifyNotSelectedValue(
+  locator: string,
+  expectedValue: string
+) {
   const commands = [
     {
       level: 0,
@@ -802,7 +816,7 @@ async function emitVerifyNotSelectedValue(locator, expectedValue) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyNotText(locator, text) {
+async function emitVerifyNotText(locator: string, text: string) {
   const commands = [
     {
       level: 0,
@@ -815,7 +829,7 @@ async function emitVerifyNotText(locator, text) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifySelectedLabel(locator, labelValue) {
+async function emitVerifySelectedLabel(locator: string, labelValue: string) {
   const commands = [
     {
       level: 0,
@@ -838,7 +852,7 @@ async function emitVerifySelectedLabel(locator, labelValue) {
   })
 }
 
-async function emitVerifyText(locator, text) {
+async function emitVerifyText(locator: string, text: string) {
   const commands = [
     {
       level: 0,
@@ -850,7 +864,7 @@ async function emitVerifyText(locator, text) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyValue(locator, value) {
+async function emitVerifyValue(locator: string, value: string) {
   const commands = [
     {
       level: 0,
@@ -863,11 +877,11 @@ async function emitVerifyValue(locator, value) {
   return Promise.resolve({ commands })
 }
 
-async function emitVerifyTitle(title) {
+async function emitVerifyTitle(title: string) {
   return Promise.resolve(`assert self.driver.title == "${title}"`)
 }
 
-async function emitWaitForElementEditable(locator, timeout) {
+async function emitWaitForElementEditable(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -880,7 +894,7 @@ async function emitWaitForElementEditable(locator, timeout) {
   return Promise.resolve({ commands })
 }
 
-async function emitWaitForText(locator, text) {
+async function emitWaitForText(locator: string, text: string) {
   const timeout = 30000
   const sec = timeout / 1000
   const commands = [
@@ -895,10 +909,10 @@ async function emitWaitForText(locator, text) {
 }
 
 function skip() {
-  return Promise.resolve(undefined)
+  return Promise.resolve('')
 }
 
-async function emitWaitForElementPresent(locator, timeout) {
+async function emitWaitForElementPresent(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -911,7 +925,7 @@ async function emitWaitForElementPresent(locator, timeout) {
   return Promise.resolve({ commands })
 }
 
-async function emitWaitForElementVisible(locator, timeout) {
+async function emitWaitForElementVisible(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -926,7 +940,7 @@ async function emitWaitForElementVisible(locator, timeout) {
   })
 }
 
-async function emitWaitForElementNotEditable(locator, timeout) {
+async function emitWaitForElementNotEditable(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -941,7 +955,7 @@ async function emitWaitForElementNotEditable(locator, timeout) {
   })
 }
 
-async function emitWaitForElementNotPresent(locator, timeout) {
+async function emitWaitForElementNotPresent(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -956,7 +970,7 @@ async function emitWaitForElementNotPresent(locator, timeout) {
   })
 }
 
-async function emitWaitForElementNotVisible(locator, timeout) {
+async function emitWaitForElementNotVisible(locator: string, timeout: number) {
   const sec = timeout / 1000
   const commands = [
     {
@@ -972,8 +986,8 @@ async function emitWaitForElementNotVisible(locator, timeout) {
 }
 
 export default {
-  canEmit,
   emit,
+  emitters,
   register,
-  extras: { emitWaitForWindow },
+  extras: { emitNewWindowHandling, emitWaitForWindow },
 }

package/src/{hook.js → hook.ts}

@@ -14,7 +14,7 @@
 // KIND, either express or implied.  See the License for the specific language governing permissions and limitations
 // under the License.
 
-import { codeExport as exporter } from '@seleniumhq/side-utils'
+import { HookFunctionInputs } from "@seleniumhq/side-code-export"
 
 const emitters = {
   afterAll,
@@ -28,17 +28,7 @@ const emitters = {
   inEachEnd: empty,
 }
 
-function generate(hookName) {
-  return new exporter.hook(emitters[hookName]())
-}
-
-export function generateHooks() {
-  let result = {}
-  Object.keys(emitters).forEach(hookName => {
-    result[hookName] = generate(hookName)
-  })
-  return result
-}
+export default emitters
 
 function afterAll() {
   const params = {
@@ -82,7 +72,7 @@ function beforeAll() {
 }
 
 function beforeEach() {
-  const params = {
+  const params: HookFunctionInputs = {
     startingSyntax: ({ browserName, gridUrl } = {}) => ({
       commands: [
         { level: 0, statement: 'def setup_method(self, method):' },