@seleniumhq/code-export-javascript-mocha 4.0.13 → 4.1.0-beta.2

package/__test__/src/command.spec.js

@@ -16,12 +16,10 @@
 // under the License.
 
 import Command from '../../src/command'
-import {
-  Commands,
-  ControlFlowCommandNames,
-} from '../../../selenium-ide/src/neo/models/Command'
+import { Commands } from '@seleniumhq/side-model'
+import { ControlFlowCommandNames } from '@seleniumhq/side-runtime/dist/playback-tree/commands'
 import { opts } from '../../src/index'
-import { codeExport as exporter } from '@seleniumhq/side-code-export'
+import { codeExport as exporter } from 'side-code-export'
 
 const commandPrefixPadding = opts.commandPrefixPadding
 
@@ -34,22 +32,11 @@ async function prettify(command, { fullPayload } = {}) {
 }
 
 describe('command code emitter', () => {
-  it('should emit all known commands', () => {
-    let result = []
-    Commands.array.forEach(command => {
-      if (!Command.canEmit(command)) {
-        result.push(command)
-      }
-    })
-    expect(() => {
-      if (result.length) {
-        if (result.length === 1) {
-          throw new Error(`${result[0]} has no emitter, write one!`)
-        } else {
-          throw new Error(`No emitters for ${result.join(', ')}. Write them!`)
-        }
-      }
-    }).not.toThrow()
+  it('should have an emitter for every command', () => {
+    const missing = Object.keys(Commands).filter(
+      (command) => !Command.emitters[command]
+    )
+    expect(missing).toEqual([])
   })
   it('should emit `add selection` command', () => {
     const command = {
@@ -375,14 +362,6 @@ describe('command code emitter', () => {
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it.skip('should emit `mouse move` event', () => {
-    const command = {
-      command: 'mouseMove',
-      target: 'id=button',
-      value: '',
-    }
-    return expect(prettify(command)).resolves.toMatchSnapshot()
-  })
   it('should emit `mouse move at` event', () => {
     const command = {
       command: 'mouseMoveAt',
@@ -463,6 +442,14 @@ describe('command code emitter', () => {
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
+  it('should emit `run` command for a test with a capitalized name', () => {
+    const command = { command: 'run', target: 'Some Test Case', value: '' }
+    return expect(prettify(command)).resolves.toMatchSnapshot()
+  })
+  it('should emit a comment for `run` with a test name from a variable', async () => {
+    const command = { command: 'run', target: '${testName}', value: '' }
+    expect(await Command.emit(command, opts)).toMatchSnapshot()
+  })
   it('should emit `run script` command', () => {
     const command = {
       command: 'runScript',
@@ -566,22 +553,6 @@ describe('command code emitter', () => {
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should skip playback supported commands, that are not supported in webdriver', () => {
-    return Promise.all([
-      expect(
-        prettify({ command: 'answerOnNextPrompt', target: 'blah' })
-      ).resolves.toBe(undefined),
-      expect(
-        prettify({ command: 'chooseCancelOnNextConfirmation' })
-      ).resolves.toBe(undefined),
-      expect(prettify({ command: 'chooseCancelOnNextPrompt' })).resolves.toBe(
-        undefined
-      ),
-      expect(prettify({ command: 'chooseOkOnNextConfirmation' })).resolves.toBe(
-        undefined
-      ),
-    ])
-  })
   it('should emit `store` command', () => {
     const command = {
       command: 'store',
@@ -638,26 +609,26 @@ describe('command code emitter', () => {
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `store xpath count` command', () => {
+  it('should emit `store element count` command', () => {
     const command = {
-      command: 'storeXpathCount',
+      command: 'storeElementCount',
       target: 'xpath=button',
       value: 'myVar',
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `submit` command', () => {
+  it('should emit `times` command', () => {
     const command = {
-      command: 'submit',
-      target: 'id=form',
+      command: ControlFlowCommandNames.times,
+      target: '5',
       value: '',
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `times` command', () => {
+  it('should emit `times` command with a variable count', () => {
     const command = {
       command: ControlFlowCommandNames.times,
-      target: '5',
+      target: '${count}',
       value: '',
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
@@ -846,25 +817,41 @@ describe('command code emitter', () => {
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `answer on visible prompt` command', () => {
+  it('should emit `answer prompt` command', () => {
     const command = {
-      command: 'webdriverAnswerOnVisiblePrompt',
+      command: 'answerPrompt',
       target: 'an answer',
       value: '',
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `choose cancel on visible prompt` command', () => {
+  it('should emit `dismiss prompt` command', () => {
+    const command = {
+      command: 'dismissPrompt',
+      target: '',
+      value: '',
+    }
+    return expect(prettify(command)).resolves.toMatchSnapshot()
+  })
+  it('should emit `accept confirmation` command', () => {
+    const command = {
+      command: 'acceptConfirmation',
+      target: '',
+      value: '',
+    }
+    return expect(prettify(command)).resolves.toMatchSnapshot()
+  })
+  it('should emit `accept alert` command', () => {
     const command = {
-      command: 'webdriverChooseCancelOnVisiblePrompt',
+      command: 'acceptAlert',
       target: '',
       value: '',
     }
     return expect(prettify(command)).resolves.toMatchSnapshot()
   })
-  it('should emit `choose ok on visible confirmation` command', () => {
+  it('should emit `dismiss confirmation` command', () => {
     const command = {
-      command: 'webdriverChooseOkOnVisibleConfirmation',
+      command: 'dismissConfirmation',
       target: '',
       value: '',
     }

package/__test__/src/index.spec.js

@@ -16,15 +16,11 @@
 // under the License.
 
 import fs from 'fs'
+import { spawnSync } from 'child_process'
+import os from 'os'
 import path from 'path'
-import codeExport, {
-  emitTest,
-  emitSuite,
-  _emitMethod,
-  _findTestByName,
-} from '../../src'
+import languageExport from '../../src'
 import Command from '../../src/command'
-import { project as projectProcessor } from '@seleniumhq/side-code-export'
 
 function readFile(filename) {
   return JSON.parse(
@@ -43,110 +39,120 @@ function readFile(filename) {
   )
 }
 
+const options = (project) => ({
+  project,
+  tests: project.tests,
+  enableOriginTracing: false,
+  enableDescriptionAsComment: false,
+  beforeEachOptions: {},
+})
+
+// Checks that the exported code compiles, with the first checker installed
+const checkers = [[process.execPath, '--check']]
+function expectValidSyntax(body) {
+  const file = path.join(
+    fs.mkdtempSync(path.join(os.tmpdir(), 'side-export-')),
+    'test.js'
+  )
+  fs.writeFileSync(file, body)
+  for (const [command, ...args] of checkers) {
+    const result = spawnSync(command, [...args, file], { encoding: 'utf8' })
+    // Skip a checker that isn't installed, and fail on any other error
+    if (result.error?.code === 'ENOENT') continue
+    if (result.error) throw result.error
+    expect(result.stderr).toBe('')
+    expect(result.status).toBe(0)
+    return
+  }
+}
+
 describe('Code Export JavaScript Mocha', () => {
   it('should export a test', async () => {
     const project = readFile('single-test.side')
-    const results = await emitTest({
-      baseUrl: project.url,
+    const results = await languageExport.emit.test({
+      ...options(project),
       test: project.tests[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a test with grid execution', async () => {
     const project = readFile('single-test.side')
-    const results = await emitTest({
-      baseUrl: project.url,
+    const results = await languageExport.emit.test({
+      ...options(project),
       test: project.tests[0],
-      tests: project.tests,
       beforeEachOptions: {
         browserName: 'Firefox',
         gridUrl: 'http://localhost:4444/wd/hub',
       },
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a suite', async () => {
-    const project = normalizeProject(readFile('single-suite.side'))
-    const results = await emitSuite({
-      baseUrl: project.url,
+    const project = readFile('single-suite.side')
+    const results = await languageExport.emit.suite({
+      ...options(project),
       suite: project.suites[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a test with a reused test method', async () => {
-    const project = normalizeProject(readFile('test-case-reuse.side'))
-    const results = await emitTest({
-      baseUrl: project.url,
+    const project = readFile('test-case-reuse.side')
+    const results = await languageExport.emit.test({
+      ...options(project),
       test: project.tests[1],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a suite with a reused test method', async () => {
-    const project = normalizeProject(readFile('test-case-reuse.side'))
-    const results = await emitSuite({
-      baseUrl: project.url,
+    const project = readFile('test-case-reuse.side')
+    const results = await languageExport.emit.suite({
+      ...options(project),
       suite: project.suites[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a suite that uses control flow commands', async () => {
-    const project = normalizeProject(readFile('control-flow-suite.side'))
-    const results = await emitSuite({
-      baseUrl: project.url,
+    const project = readFile('control-flow-suite.side')
+    const results = await languageExport.emit.suite({
+      ...options(project),
       suite: project.suites[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a test with commands that open a new window', async () => {
-    const project = normalizeProject(readFile('select-window.side'))
-    const results = await emitTest({
-      baseUrl: project.url,
+    const project = readFile('select-window.side')
+    const results = await languageExport.emit.test({
+      ...options(project),
       test: project.tests[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a suite with commands that open a new window inside of a reused test method', async () => {
-    const project = normalizeProject(readFile('nested-select-window.side'))
-    const results = await emitSuite({
-      baseUrl: project.url,
+    const project = readFile('nested-select-window.side')
+    const results = await languageExport.emit.suite({
+      ...options(project),
       suite: project.suites[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export a suite with just one new window util method when there are multiple commands that open a new window', async () => {
-    const project = normalizeProject(readFile('nested-select-window-v2.side'))
-    const results = await emitSuite({
-      baseUrl: project.url,
+    const project = readFile('nested-select-window-v2.side')
+    const results = await languageExport.emit.suite({
+      ...options(project),
       suite: project.suites[0],
-      tests: project.tests,
     })
-    expect(results.body).toBeDefined()
     expect(results.body).toMatchSnapshot()
+    expectValidSyntax(results.body)
   })
   it('should export the command emitter', () => {
-    expect(Command.emit).toStrictEqual(codeExport.emit.command)
+    expect(languageExport.emit.command).toBe(Command.emit)
   })
 })
-
-function normalizeProject(project) {
-  let _project = { ...project }
-  _project.suites.forEach(suite => {
-    projectProcessor.normalizeTestsInSuite({ suite, tests: _project.tests })
-  })
-  return _project
-}

package/dist/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"AAiBA,OAAO,EACL,cAAc,EAEd,sBAAsB,EACtB,eAAe,EACf,uBAAuB,EAExB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAIrD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAoG5D,CAAA;AAID,iBAAS,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,QAE1D;AAED,iBAAS,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,mCAM3D;AAUD,iBAAS,iBAAiB;;;;;;sCACiB,MAAM;;;;GA8BhD;AAED,iBAAe,qBAAqB,CAClC,OAAO,EAAE,YAAY,EACrB,cAAc,EAAE,sBAAsB,mBAOvC;;;;;;;;;;AAyyBD,wBAKC"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"AAiBA,OAAO,EACL,cAAc,EAEd,sBAAsB,EACtB,eAAe,EACf,uBAAuB,EAGxB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAIrD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CA8F5D,CAAA;AAID,iBAAS,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,QAE1D;AAED,iBAAS,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,mCAO3D;AAgBD,iBAAS,iBAAiB;;;;;;sCACiB,MAAM;;;;GA8BhD;AAED,iBAAe,qBAAqB,CAClC,OAAO,EAAE,YAAY,EACrB,cAAc,EAAE,sBAAsB,mBAOvC;;;;;;;;;;AA+1BD,wBAKC"}

package/dist/command.js

@@ -25,7 +25,6 @@ const location_1 = __importDefault(require("./location"));
 const selection_1 = __importDefault(require("./selection"));
 exports.emitters = {
     addSelection: emitSelect,
-    answerOnNextPrompt: skip,
     assert: emitAssert,
     assertAlert: emitAssertAlert,
     assertChecked: emitVerifyChecked,
@@ -44,9 +43,6 @@ exports.emitters = {
     assertText: emitVerifyText,
     assertTitle: emitVerifyTitle,
     check: emitCheck,
-    chooseCancelOnNextConfirmation: skip,
-    chooseCancelOnNextPrompt: skip,
-    chooseOkOnNextConfirmation: skip,
     click: emitClick,
     clickAt: emitClick,
     close: emitClose,
@@ -66,7 +62,6 @@ exports.emitters = {
     if: emitControlFlowIf,
     mouseDown: emitMouseDown,
     mouseDownAt: emitMouseDown,
-    mouseMove: emitMouseMove,
     mouseMoveAt: emitMouseMove,
     mouseOver: emitMouseMove,
     mouseOut: emitMouseOut,
@@ -91,8 +86,7 @@ exports.emitters = {
     storeTitle: emitStoreTitle,
     storeValue: emitStoreValue,
     storeWindowHandle: emitStoreWindowHandle,
-    storeXpathCount: emitStoreXpathCount,
-    submit: emitSubmit,
+    storeElementCount: emitStoreXpathCount,
     times: emitControlFlowTimes,
     type: emitType,
     uncheck: emitUncheck,
@@ -116,11 +110,12 @@ exports.emitters = {
     waitForElementNotEditable: emitWaitForElementNotEditable,
     waitForElementNotPresent: emitWaitForElementNotPresent,
     waitForElementNotVisible: emitWaitForElementNotVisible,
-    webdriverAnswerOnVisiblePrompt: emitAnswerOnNextPrompt,
+    answerPrompt: emitAnswerOnNextPrompt,
     waitForText: emitWaitForText,
-    webdriverChooseCancelOnVisibleConfirmation: emitChooseCancelOnNextConfirmation,
-    webdriverChooseCancelOnVisiblePrompt: emitChooseCancelOnNextConfirmation,
-    webdriverChooseOkOnVisibleConfirmation: emitChooseOkOnNextConfirmation,
+    dismissConfirmation: emitChooseCancelOnNextConfirmation,
+    dismissPrompt: emitChooseCancelOnNextConfirmation,
+    acceptConfirmation: emitChooseOkOnNextConfirmation,
+    acceptAlert: emitChooseOkOnNextConfirmation,
     while: emitControlFlowWhile,
 };
 side_code_export_1.codeExport.register.preprocessors(exports.emitters);
@@ -131,9 +126,15 @@ function emit(command, context) {
     return side_code_export_1.codeExport.emit.command(command, exports.emitters[command.command], {
         context,
         variableLookup,
+        variableInString,
         emitNewWindowHandling,
     });
 }
+// How a variable is joined with a string literal, e.g. "Hi " + name
+const variableInString = {
+    quotes: ['"', "'", '`'],
+    toString: (lookup) => `String(${lookup})`,
+};
 function variableLookup(varName) {
     return `vars["${varName}"]`;
 }
@@ -231,9 +232,14 @@ function generateScriptArguments(script) {
         .map((varName) => `vars["${varName}"]`)
         .join(',')}`;
 }
-function emitControlFlowDo() {
+// The name of the counter of a loop, unique in a test
+const loopCounter = (context) => `loop${context?.loopId ?? 1}`;
+function emitControlFlowDo(_target, _value, context) {
     return Promise.resolve({
-        commands: [{ level: 0, statement: 'do {' }],
+        commands: [
+            { level: 0, statement: `let ${loopCounter(context)} = 0` },
+            { level: 0, statement: 'do {' },
+        ],
         endingLevelAdjustment: 1,
     });
 }
@@ -288,36 +294,49 @@ function emitControlFlowForEach(collectionVarName, iteratorVarName) {
         ],
     });
 }
-function emitControlFlowRepeatIf(script) {
+function emitControlFlowRepeatIf(script, value, context) {
     return Promise.resolve({
         commands: [
             {
-                level: 0,
-                statement: `} while(!!${generateExpressionScript(script)})`,
+                level: 1,
+                statement: `if (++${loopCounter(context)} > ${side_code_export_1.codeExport.parsers.loopLimit(value)}) throw new Error('${side_code_export_1.codeExport.parsers.loopLimitMessage}')`,
             },
+            { level: 0, statement: `} while(!!${generateExpressionScript(script)})` },
         ],
         startingLevelAdjustment: -1,
     });
 }
-function emitControlFlowTimes(target) {
-    const commands = [
-        {
-            level: 0,
-            statement: `const times = ${target}`,
-        },
-        {
+function emitControlFlowTimes(target, value, context) {
+    const loop = loopCounter(context);
+    const times = `times${context?.loopId ?? 1}`;
+    const count = side_code_export_1.codeExport.parsers.loopCount(target, (count) => `Math.floor(Number(${count}))`);
+    const commands = [{ level: 0, statement: `const ${times} = ${count}` }];
+    if (count !== target) {
+        commands.push({
             level: 0,
-            statement: `for(let i = 0; i < times; i++) {`,
-        },
-    ];
-    return Promise.resolve({ commands, endingLevelAdjustment: 1 });
+            statement: `if (isNaN(${times})) throw new Error('Invalid number provided as a target.')`,
+        });
+    }
+    commands.push({
+        level: 0,
+        statement: `for (let ${loop} = 0; ${loop} < ${times}; ${loop}++) {`,
+    }, {
+        level: 1,
+        statement: `if (${loop} >= ${side_code_export_1.codeExport.parsers.loopLimit(value)}) throw new Error('${side_code_export_1.codeExport.parsers.loopLimitMessage}')`,
+    });
+    return Promise.resolve({ commands });
 }
-function emitControlFlowWhile(script) {
+function emitControlFlowWhile(script, value, context) {
+    const loop = loopCounter(context);
     return Promise.resolve({
         commands: [
+            { level: 0, statement: `let ${loop} = 0` },
             { level: 0, statement: `while(!!${generateExpressionScript(script)}) {` },
+            {
+                level: 1,
+                statement: `if (++${loop} > ${side_code_export_1.codeExport.parsers.loopLimit(value)}) throw new Error('${side_code_export_1.codeExport.parsers.loopLimitMessage}')`,
+            },
         ],
-        endingLevelAdjustment: 1,
     });
 }
 async function emitDoubleClick(target) {
@@ -355,8 +374,7 @@ async function emitDragAndDrop(dragged, dropped) {
     return Promise.resolve({ commands });
 }
 async function emitEcho(message) {
-    const _message = message.startsWith('vars[') ? message : `"${message}"`;
-    return Promise.resolve(`console.log(${_message})`);
+    return Promise.resolve(`console.log("${message}")`);
 }
 async function emitEditContent(locator, content) {
     const commands = [
@@ -452,8 +470,12 @@ async function emitPause(time) {
     const commands = [{ level: 0, statement: `await driver.sleep(${time})` }];
     return Promise.resolve({ commands });
 }
-async function emitRun(testName) {
-    return Promise.resolve(`${side_code_export_1.codeExport.parsers.sanitizeName(testName)}()`);
+async function emitRun(testName, _value, context) {
+    // The test to run is only known during playback
+    if ((0, side_code_export_1.hasVariable)(testName)) {
+        return Promise.resolve(`${context.commentPrefix} Cannot export run with a test name from a variable: ${testName}`);
+    }
+    return Promise.resolve(`await ${side_code_export_1.codeExport.parsers.uncapitalize(side_code_export_1.codeExport.parsers.sanitizeName(testName))}()`);
 }
 async function emitRunScript(script) {
     return Promise.resolve(`await driver.executeScript("${script.script}${generateScriptArguments(script)}")`);
@@ -536,10 +558,7 @@ function generateSendKeysInput(value) {
     if (typeof value === 'object') {
         return value
             .map((s) => {
-            if (s.startsWith('vars[')) {
-                return s;
-            }
-            else if (s.startsWith('Key[')) {
+            if (s.startsWith('Key[')) {
                 const key = s.match(/\['(.*)'\]/)?.[1];
                 return `Key.${key}`;
             }
@@ -603,9 +622,6 @@ async function emitStoreXpathCount(locator, varName) {
     const result = `await driver.findElements(${await location_1.default.emit(locator)}).length`;
     return Promise.resolve(variableSetter(varName, result));
 }
-async function emitSubmit(_locator) {
-    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) {
     return Promise.resolve(`await driver.findElement(${await location_1.default.emit(target)}).sendKeys(${generateSendKeysInput(value)})`);
 }
@@ -687,7 +703,7 @@ async function emitVerifyNotSelectedValue(locator, expectedValue) {
         },
         {
             level: 1,
-            statement: `assert.equal(value, "${side_code_export_1.codeExport.emit.text(expectedValue)}")`,
+            statement: `assert.equal(value, "${expectedValue}")`,
         },
         { level: 0, statement: `}` },
     ];
@@ -702,7 +718,7 @@ async function emitVerifyNotText(locator, text) {
         },
         {
             level: 1,
-            statement: `assert.notEqual(text, "${side_code_export_1.codeExport.emit.text(text)}")`,
+            statement: `assert.notEqual(text, "${text}")`,
         },
         { level: 0, statement: `}` },
     ];
@@ -734,7 +750,7 @@ async function emitVerifyText(locator, text) {
     const commands = [
         {
             level: 0,
-            statement: `assert.equal(await driver.findElement(${await location_1.default.emit(locator)}).getText(), "${side_code_export_1.codeExport.emit.text(text)}")`,
+            statement: `assert.equal(await driver.findElement(${await location_1.default.emit(locator)}).getText(), "${text}")`,
         },
     ];
     return Promise.resolve({ commands });