selenium-side-runner 4.0.0-alpha.60 → 4.0.0-alpha.62

package/src/__tests__/proxy.spec.ts

@@ -15,23 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
+import { ProxyCapabilities } from '../types'
 import ParseProxy from '../proxy'
 
 describe('proxy parser', () => {
   it('should parse a direct proxy', () => {
-    expect(ParseProxy('direct')).toEqual({
+    expect(ParseProxy('direct')).toEqual<ProxyCapabilities>({
       proxyType: 'direct',
     })
   })
   it('should parse a system proxy', () => {
-    expect(ParseProxy('system')).toEqual({
+    expect(ParseProxy('system')).toEqual<ProxyCapabilities>({
       proxyType: 'system',
     })
   })
   it('should parse a pac proxy', () => {
-    expect(ParseProxy('pac', 'http://localhost/pac')).toEqual({
+    expect(
+      ParseProxy('pac', 'http://localhost/pac')
+    ).toEqual<ProxyCapabilities>({
       proxyType: 'pac',
-      proxyOptions: 'http://localhost/pac',
+      proxyAutoconfigUrl: 'http://localhost/pac',
     })
   })
   it('should throw if no pac file was given', () => {
@@ -40,19 +43,16 @@ describe('proxy parser', () => {
     )
   })
   it('should parse a manual proxy', () => {
-    expect(ParseProxy('manual', {})).toEqual({
+    expect(ParseProxy('manual', {})).toEqual<ProxyCapabilities>({
       proxyType: 'manual',
-      proxyOptions: {},
     })
   })
   it('should omit redundant keys from the proxy', () => {
     expect(
       ParseProxy('manual', { test: 4, http: 'http://localhost:4324' })
-    ).toEqual({
+    ).toEqual<ProxyCapabilities>({
       proxyType: 'manual',
-      proxyOptions: {
-        http: 'http://localhost:4324',
-      },
+      httpProxy: 'http://localhost:4324',
     })
   })
   it('should whitelist the allowed proxy protocols', () => {
@@ -64,20 +64,17 @@ describe('proxy parser', () => {
         ftp: 'http://localhost:4324',
         bypass: ['http://something.com'],
       })
-    ).toEqual({
+    ).toEqual<ProxyCapabilities>({
       proxyType: 'manual',
-      proxyOptions: {
-        http: 'http://localhost:4324',
-        https: 'http://localhost:4324',
-        ftp: 'http://localhost:4324',
-        bypass: ['http://something.com'],
-      },
+      httpProxy: 'http://localhost:4324',
+      ftpProxy: 'http://localhost:4324',
+      sslProxy: 'http://localhost:4324',
+      noProxy: ['http://something.com'],
     })
   })
   it('should return an empty object if no options were given to manual proxy', () => {
-    expect(ParseProxy('manual')).toEqual({
+    expect(ParseProxy('manual')).toEqual<ProxyCapabilities>({
       proxyType: 'manual',
-      proxyOptions: {},
     })
   })
   it('should throw if non object was passed to manual proxy type', () => {
@@ -87,31 +84,27 @@ describe('proxy parser', () => {
     )
   })
   it('should parse socks proxy', () => {
-    expect(ParseProxy('socks', { socksProxy: 'localhost:213' })).toEqual({
-      proxyType: 'socks',
-      proxyOptions: {
-        socksProxy: 'localhost:213',
-      },
+    expect(
+      ParseProxy('socks', { socksProxy: 'localhost:213' })
+    ).toEqual<ProxyCapabilities>({
+      proxyType: 'manual',
+      socksProxy: 'localhost:213',
     })
   })
   it('should parse socks proxy version', () => {
     expect(
       ParseProxy('socks', { socksProxy: 'localhost:213', socksVersion: 5 })
-    ).toEqual({
-      proxyType: 'socks',
-      proxyOptions: {
-        socksProxy: 'localhost:213',
-        socksVersion: 5,
-      },
+    ).toEqual<ProxyCapabilities>({
+      proxyType: 'manual',
+      socksProxy: 'localhost:213',
+      socksVersion: 5,
     })
     expect(
       ParseProxy('socks', { socksProxy: 'localhost:213', socksVersion: '5' })
-    ).toEqual({
-      proxyType: 'socks',
-      proxyOptions: {
-        socksProxy: 'localhost:213',
-        socksVersion: 5,
-      },
+    ).toEqual<ProxyCapabilities>({
+      proxyType: 'manual',
+      socksProxy: 'localhost:213',
+      socksVersion: 5,
     })
   })
   it('should throw if no socks proxy url was given', () => {

package/src/bin.ts

@@ -191,9 +191,9 @@ configuration.debugStartup &&
   console.debug('Configuration:', util.inspect(configuration))
 
 // All the stuff that goes into a big wrapped jest command
-const jest = 'node '+ resolveBin.sync('jest')
+const jest = 'node ' + resolveBin.sync('jest')
 const jestArgs = [
-  '--config=' + path.join(__dirname, '..', 'jest.config.js'),
+  '--config=' + path.join(__dirname, '..', 'runner.jest.config.js'),
   '--maxConcurrency=' + configuration.maxWorkers,
 ]
   .concat(
@@ -204,7 +204,7 @@ const jestArgs = [
         ]
       : []
   )
-  .concat(options.jestOptions.slice(1, -1).split(' '))
+  .concat(options.jestOptions.slice(1, -1).split(' ').filter(Boolean))
   .concat(['--runTestsByPath', path.join(__dirname, 'main.test.js')])
 
 const jestEnv = {
@@ -215,6 +215,7 @@ const jestEnv = {
 configuration.debugStartup &&
   console.debug('Jest command:', jest, jestArgs, jestEnv)
 spawn(jest, jestArgs, {
+  cwd: process.cwd(),
   env: jestEnv,
   shell: true,
   stdio: 'inherit',

package/src/capabilities.ts

@@ -63,7 +63,7 @@ function assignStringKey(key: string, value: string, keyObject: KeyObject) {
 function parseStringValue(value: string) {
   // is array
   if (/^\[.*\]$/.test(value)) {
-    const matches = value.slice(1, -2).match(/(([^,]*)*)/g) as string[]
+    const matches = value.slice(1, -1).match(/(([^,]*)*)/g) as string[]
     return matches.filter((s) => !!s).map((s) => s.trim())
   }
   try {
@@ -81,7 +81,7 @@ function parseStringValue(value: string) {
 function trimSingleQuote(value: string) {
   let str = value.trim()
   if (str[0] === str[str.length - 1] && str[0] === "'") {
-    return str.slice(1, -2)
+    return str.slice(1, -1)
   }
   return str
 }

package/src/main.test.ts

@@ -20,13 +20,13 @@ import fs from 'fs'
 import { globSync } from 'glob'
 import { createLogger, format, transports } from 'winston'
 import { Configuration, Project } from './types'
-import buildRegister from './register'
-import buildRunners from './run'
+import buildRun from './run'
 import { ProjectShape, SuiteShape, TestShape } from '@seleniumhq/side-model'
 import {
   correctPluginPaths,
   loadPlugins,
   PluginHooks,
+  Variables,
 } from '@seleniumhq/side-runtime'
 
 const metadata = require('../package.json')
@@ -119,15 +119,21 @@ const factoryParams = {
   configuration,
   logger: logger as unknown as Console,
 }
-const register = buildRegister(factoryParams)
-const runners = buildRunners(factoryParams)
+const getTestByID = (project: ProjectShape) => (testID: string) =>
+  project.tests.find((t) => t.id === testID) as TestShape
+
+const run = buildRun(factoryParams)
+
+let plugins: Awaited<ReturnType<typeof loadPlugins>> | undefined
 each(projects).describe(projectTitle, (project: Project) => {
   try {
     const pluginPaths = correctPluginPaths(project.path, project?.plugins ?? [])
     const runHook = (hookName: keyof PluginHooks) => async () => {
-      const plugins = await loadPlugins(pluginPaths)
+      if (!plugins) {
+        plugins = await loadPlugins(pluginPaths)
+      }
       await Promise.all(
-        plugins.map(async (plugin) => {
+        plugins!.map(async (plugin) => {
           const hook = plugin.hooks?.[hookName]
           if (hook) {
             await hook({ ...factoryParams, project })
@@ -144,14 +150,19 @@ each(projects).describe(projectTitle, (project: Project) => {
     if (suites.length) {
       each(suites).describe(suiteTitle, (suite: SuiteShape) => {
         const isParallel = suite.parallel
-        const tests = suite.tests.map((tID) => register.test(project, tID))
+        const suiteVariables = new Variables()
+        const tests = suite.tests.map(getTestByID(project))
 
         const testExecutor = each(tests)
         const testMethod = isParallel
           ? testExecutor.test.concurrent
           : testExecutor.test
         testMethod(testTitle, async (test: TestShape) => {
-          await runners.test(project, test)
+          await run(
+            project,
+            test,
+            suite.persistSession ? suiteVariables : new Variables()
+          )
         })
       })
     } else {
@@ -159,9 +170,9 @@ each(projects).describe(projectTitle, (project: Project) => {
       Project ${project.name} doesn't have any suites matching filter ${configuration.filter},
       attempting to iterate all tests in project
     `)
-      const tests = project.tests
-        .map((test) => register.test(project, test.id))
-        .filter((test) => new RegExp(configuration.filter).test(test.name))
+      const tests = project.tests.filter((test) =>
+        new RegExp(configuration.filter).test(test.name)
+      )
       if (!tests.length) {
         throw new Error(
           `No suites or tests found in project ${project.name} matching filter ${configuration.filter}, unable to test!`
@@ -169,7 +180,7 @@ each(projects).describe(projectTitle, (project: Project) => {
       }
       const testExecutor = each(tests)
       testExecutor.test(testTitle, async (test: TestShape) => {
-        await runners.test(project, test)
+        await run(project, test, new Variables())
       })
     }
   } catch (e) {

package/src/run.ts

@@ -26,10 +26,9 @@ import {
   WebDriverExecutor,
 } from '@seleniumhq/side-runtime'
 import { WebDriverExecutorConstructorArgs } from '@seleniumhq/side-runtime/dist/webdriver'
-import { SuiteShape, TestShape } from '@seleniumhq/side-model'
+import { TestShape } from '@seleniumhq/side-model'
 import fs from 'fs/promises'
 import path from 'path'
-import Satisfies from './versioner'
 import { Configuration, Project } from './types'
 
 export interface HoistedThings {
@@ -37,8 +36,9 @@ export interface HoistedThings {
   logger: Console
 }
 
-const buildRunners = ({ configuration, logger }: HoistedThings) => {
-  const runTest = async (project: Project, test: TestShape) => {
+const buildRun =
+  ({ configuration, logger }: HoistedThings) =>
+  async (project: Project, test: TestShape, variables = new Variables()) => {
     logger.info(`Running test ${test.name}`)
     const pluginPaths = correctPluginPaths(project.path, project?.plugins ?? [])
     const plugins = await loadPlugins(pluginPaths)
@@ -73,7 +73,7 @@ const buildRunners = ({ configuration, logger }: HoistedThings) => {
           getTestByName: (name: string) =>
             project.tests.find((t) => t.name === name) as TestShape,
           logger,
-          variables: new Variables(),
+          variables,
         })
         const onComplete = async (failure: any) => {
           // I know this feature is over aggressive for a tool to be deprecated
@@ -165,56 +165,4 @@ const buildRunners = ({ configuration, logger }: HoistedThings) => {
     }
   }
 
-  const runSuite = async (project: Project, suite: SuiteShape) => {
-    logger.info(`Running suite ${suite.name}`)
-    if (!suite.tests.length) {
-      throw new Error(
-        `The suite ${suite.name} has no tests, add tests to the suite using the IDE.`
-      )
-    }
-    for (let i = 0, ii = suite.tests.length; i != ii; i++) {
-      await runTest(
-        project,
-        project.tests.find((t) => t.id === suite.tests[i]) as TestShape
-      )
-    }
-    logger.info(`Finished suite ${suite.name}`)
-  }
-
-  const runProject = async (project: Project) => {
-    logger.info(`Running project ${project.name}`)
-    if (!configuration.force) {
-      let warning = Satisfies(project.version, '2.0')
-      if (warning) {
-        logger.warn(warning)
-      }
-    } else {
-      logger.warn("--force is set, ignoring project's version")
-    }
-    if (!project.suites.length) {
-      throw new Error(
-        `The project ${project.name} has no test suites defined, create a suite using the IDE.`
-      )
-    }
-
-    for (let i = 0, ii = project.suites.length; i != ii; i++) {
-      await runSuite(project, project.suites[i])
-    }
-    logger.info(`Finished project ${project.name}`)
-  }
-
-  const runAll = async (projects: Project[]) => {
-    for (let i = 0, ii = projects.length; i != ii; i++) {
-      await runProject(projects[i])
-    }
-  }
-
-  return {
-    all: runAll,
-    project: runProject,
-    suite: runSuite,
-    test: runTest,
-  }
-}
-
-export default buildRunners
+export default buildRun