ui5-test-runner 1.1.5 → 2.0.1

package/src/job.spec.js

@@ -0,0 +1,413 @@
+const { dirname, join } = require('path')
+const { fromObject, fromCmdLine } = require('./job')
+const normalizePath = path => path.replace(/\\/g, '/') // win -> unix
+const { $valueSources } = require('./symbols')
+const { UTRError } = require('./error')
+
+const cwd = join(__dirname, '../test/project')
+
+function buildJob (parameters) {
+  return fromObject(cwd, parameters)
+}
+
+describe('job', () => {
+  describe('parameter parsing', () => {
+    it('provides default values', () => {
+      const job = buildJob({})
+      expect(job.cwd).toStrictEqual(cwd)
+      expect(job.port).toStrictEqual(0)
+      expect(job.ui5).toStrictEqual('https://ui5.sap.com')
+      expect(job.browser.startsWith(dirname(dirname(__dirname)))).toStrictEqual(true)
+      expect(normalizePath(job.browser).endsWith('defaults/puppeteer.js')).toStrictEqual(true)
+      expect(normalizePath(job.webapp).endsWith('/test/project/webapp')).toStrictEqual(true)
+      expect(job.keepAlive).toStrictEqual(false)
+      expect(job.screenshot).toStrictEqual(true)
+      expect(job[$valueSources]).toMatchObject({
+        cwd: 'default',
+        port: 'default',
+        ui5: 'default',
+        browser: 'default'
+      })
+    })
+
+    it('parses parameters', () => {
+      const job = buildJob({
+        cwd: '../project2',
+        port: 8080,
+        keepAlive: null,
+        ui5: 'http://localhost:8088/ui5'
+      })
+      expect(normalizePath(job.cwd).endsWith('/test/project2')).toStrictEqual(true)
+      expect(job.port).toStrictEqual(8080)
+      expect(job.keepAlive).toStrictEqual(true)
+      expect(job.ui5).toStrictEqual('http://localhost:8088/ui5')
+      expect(normalizePath(job.webapp).endsWith('/test/project2/webapp')).toStrictEqual(true)
+      expect(job[$valueSources]).toMatchObject({
+        cwd: 'cli',
+        port: 'cli',
+        keepAlive: 'cli',
+        ui5: 'cli',
+        browser: 'default'
+      })
+    })
+
+    describe('complex parameter parsing', () => {
+      it('implements boolean flag', () => {
+        const job = buildJob({
+          keepAlive: false,
+          coverage: null,
+          logServer: null
+        })
+        expect(job.keepAlive).toStrictEqual(false)
+        expect(job.coverage).toStrictEqual(true)
+        expect(job.logServer).toStrictEqual(true)
+      })
+
+      it('implements boolean switch off', () => {
+        const job = buildJob({
+          noCoverage: null,
+          noScreenshot: null
+        })
+        expect(job.coverage).toStrictEqual(false)
+        expect(job.screenshot).toStrictEqual(false)
+      })
+
+      it('url disables webapp checking and coverage', () => {
+        const job = buildJob({
+          webapp: 'not_a_folder',
+          url: 'http://localhost:8080'
+        })
+        expect(job.url).toStrictEqual(['http://localhost:8080'])
+        expect(job.coverage).toStrictEqual(false)
+      })
+
+      it('url still allows coverage', () => {
+        const job = buildJob({
+          webapp: 'not_a_folder',
+          url: 'http://localhost:8080',
+          coverage: true
+        })
+        expect(job.url).toStrictEqual(['http://localhost:8080'])
+        expect(job.coverage).toStrictEqual(true)
+      })
+
+      describe('multi values', () => {
+        const absoluteLibPath = join(__dirname, '../test/project/webapp/lib')
+
+        describe('url', () => {
+          it('accepts multiple urls', () => {
+            const job = buildJob({
+              url: [
+                'http://localhost:8080/page1.html',
+                'http://localhost:8080/page2.html'
+              ]
+            })
+            expect(job.url).toMatchObject([
+              'http://localhost:8080/page1.html',
+              'http://localhost:8080/page2.html'
+            ])
+          })
+        })
+
+        describe('libs', () => {
+          it('accepts one library', () => {
+            const job = buildJob({
+              libs: [absoluteLibPath]
+            })
+            expect(job.libs).toMatchObject([{
+              relative: '',
+              source: absoluteLibPath
+            }])
+          })
+
+          it('accepts two libraries', () => {
+            const project2Path = join(__dirname, '../test/project2')
+            const job = buildJob({
+              libs: [absoluteLibPath, 'project2/=../project2']
+            })
+            expect(job.libs).toMatchObject([{
+              relative: '',
+              source: absoluteLibPath
+            }, {
+              relative: 'project2/',
+              source: project2Path
+            }])
+          })
+        })
+
+        describe('browser parameters', () => {
+          it('allows passing extra parameter', () => {
+            const job = buildJob({
+              '--': ['--visible']
+            })
+            expect(job.browserArgs).toEqual(['--visible'])
+          })
+
+          it('allows passing extra parameters', () => {
+            const job = buildJob({
+              '--': ['--visible', '--verbose']
+            })
+            expect(job.browserArgs).toEqual(['--visible', '--verbose'])
+          })
+        })
+      })
+
+      describe('parameters using $/', () => {
+        const job = buildJob({
+          cwd,
+          browser: '$/selenium-webdriver.js'
+        })
+        expect(job.browser).toStrictEqual(join(__dirname, './defaults/selenium-webdriver.js'))
+        expect(job.coverageSettings).toStrictEqual(join(__dirname, './defaults/nyc.json'))
+        expect(job.reportGenerator).toEqual([join(__dirname, './defaults/report.js')])
+      })
+
+      describe('custom mappings', () => {
+        it('offers custom mappings', () => {
+          const job = buildJob({
+            cwd,
+            mappings: [
+              '^/otherlib/(.+)=file(./otherfolder/otherlib/$1)',
+              '^/ui/oDataService/v1/odata/v4/ServiceName/(.+)=url(http://localhost:18082/odata/v4/ServiceName/$1)'
+            ]
+          })
+          expect(job.mappings).toEqual([
+            {
+              match: '^/otherlib/(.+)',
+              file: './otherfolder/otherlib/$1'
+            }, {
+              match: '^/ui/oDataService/v1/odata/v4/ServiceName/(.+)',
+              url: 'http://localhost:18082/odata/v4/ServiceName/$1'
+            }
+          ])
+        })
+
+        it('rejects invalid mapping', () => {
+          expect(() => buildJob({
+            cwd,
+            mappings: [
+              '^/otherlib/(.+)=custom(./otherfolder/otherlib/$1)'
+            ]
+          })).toThrowError()
+        })
+      })
+    })
+  })
+
+  describe('validation', () => {
+    it('fails on negative integers', () => {
+      expect(() => buildJob({
+        port: -1
+      })).toThrow()
+    })
+
+    it('fails on invalid URL', () => {
+      expect(() => buildJob({
+        ui5: 'not_an_url'
+      })).toThrow()
+    })
+
+    it('fails on a missing file (does not exist)', () => {
+      expect(() => buildJob({
+        testsuite: 'not_a_file'
+      })).toThrow()
+    })
+
+    it('fails on a missing file (points to a folder)', () => {
+      expect(() => buildJob({
+        testsuite: 'lib'
+      })).toThrow()
+    })
+
+    it('fails on a missing folder (does not exist)', () => {
+      expect(() => buildJob({
+        webapp: 'not_a_folder'
+      })).toThrow()
+    })
+
+    it('fails on a missing folder (points to a file)', () => {
+      expect(() => buildJob({
+        webapp: 'webapp/lib/README.md'
+      })).toThrow()
+    })
+
+    describe('Path parameters validation', () => {
+      const parameters = ['webapp', 'browser', 'testsuite']
+
+      parameters.forEach(parameter => {
+        it(`fails on invalid path for ${parameter}`, () => {
+          expect(() => buildJob({ [parameter]: 'nope' })).toThrow()
+        })
+      })
+    })
+
+    describe('libs', () => {
+      it('fails on invalid lib path (absolute)', () => {
+        const absoluteLibPath = join(__dirname, '../test/project/webapp/lib2')
+        expect(() => buildJob({
+          libs: absoluteLibPath
+        })).toThrow()
+      })
+
+      it('fails on invalid lib path (relative)', () => {
+        expect(() => buildJob({
+          libs: '../project3'
+        })).toThrow()
+      })
+    })
+  })
+
+  describe('Using ui5-test-runner.json', () => {
+    const project2 = join(__dirname, '../test/project2')
+
+    it('enables option overriding at the command level', () => {
+      const job = fromCmdLine(cwd, [
+        '--port', '1',
+        '--port', '2',
+        '-k', 'true',
+        '-k', 'false'
+      ])
+      expect(job.port).toStrictEqual(2)
+      expect(job.keepAlive).toStrictEqual(false)
+    })
+
+    it('preload settings', () => {
+      const job = buildJob({
+        cwd: project2
+      })
+      expect(job.pageTimeout).toStrictEqual(900000)
+      expect(job.globalTimeout).toStrictEqual(3600000)
+      expect(job.failFast).toStrictEqual(true)
+      expect(job.libs).toEqual([{
+        relative: 'lib/',
+        source: join(project2, 'webapp')
+      }])
+      expect(job.browserArgs).toEqual(['-1'])
+    })
+
+    it('allows command line override', () => {
+      const job = buildJob({
+        cwd: project2,
+        globalTimeout: 900000
+      })
+      expect(job.pageTimeout).toStrictEqual(900000)
+      expect(job.globalTimeout).toStrictEqual(900000)
+      expect(job.failFast).toStrictEqual(true)
+      expect(job.libs).toEqual([{
+        relative: 'lib/',
+        source: join(project2, 'webapp')
+      }])
+      expect(job.ui5).toStrictEqual('https://ui5.sap.com')
+    })
+
+    it('preloads and overrides command line settings', () => {
+      const job = buildJob({
+        cwd: project2,
+        pageTimeout: 60000,
+        globalTimeout: 900000,
+        libs: 'project2/=../project2'
+      })
+      expect(job.pageTimeout).toStrictEqual(900000)
+      expect(job.globalTimeout).toStrictEqual(900000)
+      expect(job.failFast).toStrictEqual(true)
+      expect(job.libs).toEqual([{
+        relative: 'lib/',
+        source: join(project2, 'webapp')
+      }, {
+        relative: 'project2/',
+        source: join(cwd, '../project2')
+      }])
+      expect(job.ui5).toStrictEqual('https://ui5.sap.com')
+    })
+
+    it('preloads and concatenates browser settings', () => {
+      const job = buildJob({
+        cwd: project2,
+        '--': [-2]
+      })
+      expect(job.browserArgs).toEqual(['-1', '-2'])
+    })
+  })
+
+  describe('mode', () => {
+    it('returns legacy by default', () => {
+      expect(fromObject(cwd, {}).mode).toStrictEqual('legacy')
+    })
+
+    describe('url', () => {
+      it('enables testing external projects', () => {
+        expect(fromObject(cwd, {
+          url: ['http://myserver.remote.url/ui5-app.html']
+        }).mode).toStrictEqual('url')
+      })
+
+      // Assuming url could be  used to access 'local' server, most options are supported
+
+      describe('incompatible options', () => {
+        const incompatible = {
+          testsuite: '../project2'
+        }
+
+        Object.keys(incompatible).forEach(option => {
+          it(`is incompatible with ${option}`, () => {
+            expect(() => fromObject(cwd, {
+              url: ['http://myserver.remote.url/ui5-app.html'],
+              [option]: incompatible[option]
+            })).toThrow(UTRError.MODE_INCOMPATIBLE_OPTION(option))
+          })
+        })
+      })
+    })
+
+    describe('capabilities', () => {
+      it('triggers the capabilities tester', () => {
+        expect(fromObject(cwd, {
+          capabilities: true
+        }).mode).toStrictEqual('capabilities')
+      })
+
+      it('supports cwd, port, logServer, browser, parallel, reportDir, pageTimeout, browserCloseTimeout, failFast and keepAlive', () => {
+        expect(fromObject('.', {
+          capabilities: true,
+          cwd,
+          port: 8080,
+          logServer: true,
+          browser: '$/selenium-webdriver.js',
+          parallel: 2,
+          reportDir: join(cwd, '.report'),
+          pageTimeout: 1000,
+          browserCloseTimeout: 1000,
+          failFast: true,
+          keepAlive: true
+        }).mode).toStrictEqual('capabilities')
+      })
+
+      describe('incompatible options', () => {
+        const incompatible = {
+          libs: '../project2',
+          ui5: 'http://localhost:8088/ui5',
+          cache: join(cwd, '.cache'),
+          webapp: 'webapp',
+          testsuite: 'test/testsuite.qunit.html',
+          pageFilter: '.*',
+          pageParams: 'sap-ui-debug=true',
+          coverage: true,
+          coverageSettings: '$/nyc.json',
+          coverageTempDir: '.nyc_output',
+          coverageReportDir: 'coverage',
+          coverageReporters: 'lcov',
+          globalTimeout: 1000
+        }
+
+        Object.keys(incompatible).forEach(option => {
+          it(`is incompatible with ${option}`, () => {
+            expect(() => fromObject(cwd, {
+              capabilities: true,
+              [option]: incompatible[option]
+            })).toThrow(UTRError.MODE_INCOMPATIBLE_OPTION(option))
+          })
+        })
+      })
+    })
+  })
+})

package/src/npm.js

@@ -0,0 +1,73 @@
+const { exec } = require('child_process')
+const { join } = require('path')
+const { stat, readFile } = require('fs/promises')
+const { UTRError } = require('./error')
+const { getOutput } = require('./output')
+
+function npm (job, ...args) {
+  return new Promise((resolve, reject) => {
+    const childProcess = exec(`npm ${args.join(' ')}`, (err, stdout, stderr) => {
+      if (err) {
+        reject(UTRError.NPM_FAILED(stderr))
+      } else {
+        resolve(stdout.trim())
+      }
+    })
+    if (args[0] === 'install') {
+      getOutput(job).monitor(childProcess)
+    }
+  })
+}
+
+async function folderExists (path) {
+  try {
+    const result = await stat(path)
+    return result.isDirectory()
+  } catch (e) {
+    return false
+  }
+}
+
+let localRoot
+let globalRoot
+
+module.exports = {
+  async resolvePackage (job, name) {
+    if (!localRoot) {
+      [localRoot, globalRoot] = await Promise.all([
+        npm(job, 'root'),
+        npm(job, 'root', '--global')
+      ])
+    }
+    let modulePath
+    let justInstalled = false
+    const localPath = join(localRoot, name)
+    if (await folderExists(localPath)) {
+      modulePath = localPath
+    } else {
+      const globalPath = join(globalRoot, name)
+      if (!await folderExists(globalPath)) {
+        if (!job.npmInstall) {
+          throw UTRError.NPM_DEPENDENCY_NOT_FOUND(name)
+        }
+        const previousStatus = job.status
+        job.status = `Installing ${name}...`
+        await npm(job, 'install', name, '-g')
+        justInstalled = true
+        job.status = previousStatus
+      }
+      modulePath = globalPath
+    }
+    const output = getOutput(job)
+    const installedPackage = JSON.parse((await readFile(join(modulePath, 'package.json'))).toString())
+    const { version: installedVersion } = installedPackage
+    output.resolvedPackage(name, modulePath, installedVersion)
+    if (!justInstalled) {
+      const latestVersion = await npm(job, 'view', name, 'version')
+      if (latestVersion !== installedVersion) {
+        output.packageNotLatest(name, latestVersion)
+      }
+    }
+    return modulePath
+  }
+}

package/src/npm.spec.js

@@ -0,0 +1,98 @@
+const { join } = require('path')
+const { resolvePackage } = require('./npm')
+const { mock } = require('child_process')
+const { cleanDir, createDir, recreateDir } = require('./tools')
+const { writeFile } = require('fs/promises')
+const { fromObject } = require('./job')
+const { getOutput } = require('./output')
+const { UTRError } = require('./error')
+
+const tmp = join(__dirname, '../tmp')
+const npmGlobal = join(tmp, 'npm/global')
+
+describe('src/npm', () => {
+  const cwd = join(__dirname, '../test/project')
+  const reportDir = join(__dirname, '../tmp/npm/report')
+
+  let job
+  let output
+
+  beforeAll(async () => {
+    await createDir(join(npmGlobal, 'existing_global'))
+    await writeFile(join(npmGlobal, 'existing_global', 'package.json'), `{
+  "version": "1.0.0"
+}`)
+    await recreateDir(reportDir)
+    await cleanDir(join(npmGlobal, 'not_existing'))
+  })
+
+  beforeEach(() => {
+    job = fromObject(cwd, {
+      reportDir,
+      coverage: false
+    })
+    job.status = 'Testing'
+    output = getOutput(job)
+    jest.spyOn(output, 'status')
+    jest.spyOn(output, 'resolvedPackage')
+    jest.spyOn(output, 'packageNotLatest')
+  })
+
+  it('detects already installed local package', async () => {
+    const path = await resolvePackage(job, 'reserve')
+    expect(path).toStrictEqual(join(__dirname, '../node_modules/reserve'))
+    expect(output.resolvedPackage).toHaveBeenCalledTimes(1)
+    expect(output.packageNotLatest).not.toHaveBeenCalled()
+  })
+
+  it('detects already installed global package (but warn as not the latest)', async () => {
+    mock({
+      api: 'exec',
+      scriptPath: 'npm',
+      args: ['view', 'existing_global', 'version'],
+      exec: async childProcess => childProcess.stdout.write('1.0.1\n'),
+      persist: true
+    })
+    const path = await resolvePackage(job, 'existing_global')
+    expect(path).toStrictEqual(join(npmGlobal, 'existing_global'))
+    expect(output.resolvedPackage).toHaveBeenCalledTimes(1)
+    expect(output.packageNotLatest).toHaveBeenCalled()
+  })
+
+  it('fails if --no-npm-install is set', async () => {
+    await expect(resolvePackage({
+      ...job,
+      npmInstall: false
+    }, 'not_existing')).rejects.toThrowError(UTRError.NPM_DEPENDENCY_NOT_FOUND('not_existing'))
+  })
+
+  it('installs missing package globally', async () => {
+    mock({
+      api: 'exec',
+      scriptPath: 'npm',
+      args: ['install', 'not_existing', '-g'],
+      exec: async childProcess => {
+        await createDir(join(npmGlobal, 'not_existing'))
+        await writeFile(join(npmGlobal, 'not_existing', 'package.json'), `{
+  "version": "1.0.0"
+}`)
+        childProcess.stdout.write('OK installed')
+      }
+    })
+    const path = await resolvePackage(job, 'not_existing')
+    expect(path).toStrictEqual(join(npmGlobal, 'not_existing'))
+    expect(output.resolvedPackage).toHaveBeenCalledTimes(1)
+    expect(output.packageNotLatest).not.toHaveBeenCalled()
+  })
+
+  it('fails if the package cannot be installed', async () => {
+    mock({
+      api: 'exec',
+      scriptPath: 'npm',
+      args: ['install', 'fail_to_install', '-g'],
+      exec: childProcess => { throw new Error('KO failed') }
+    })
+    await expect(resolvePackage(job, 'fail_to_install')).rejects.toThrowError(UTRError.NPM_FAILED('Error: KO failed'))
+    expect(output.status).toHaveBeenCalledTimes(1) // Won't restore previous status
+  })
+})

package/src/options.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const { InvalidArgumentError } = require('commander')
+
+function integer (value) {
+  const result = parseInt(value, 10)
+  if (isNaN(result)) {
+    throw new InvalidArgumentError('Invalid integer')
+  }
+  if (result < 0) {
+    throw new InvalidArgumentError('Only >= 0')
+  }
+  return result
+}
+
+module.exports = {
+  any (value) {
+    return value
+  },
+
+  boolean (value, defaultValue) {
+    if (value === undefined) {
+      return !defaultValue
+    }
+    if (['true', 'yes', 'on'].includes(value)) {
+      return true
+    }
+    if (['false', 'no', 'off'].includes(value)) {
+      return false
+    }
+    throw new InvalidArgumentError('Invalid boolean')
+  },
+
+  integer,
+
+  timeout (value) {
+    const int = integer(value)
+    if (value.endsWith('ms')) {
+      return int
+    }
+    const specifier = value.substring(int.toString().length)
+    if (['s', 'sec'].includes(specifier)) {
+      return int * 1000
+    }
+    if (['m', 'min'].includes(specifier)) {
+      return int * 60 * 1000
+    }
+    if (specifier) {
+      throw new InvalidArgumentError('Invalid timeout')
+    }
+    return int
+  },
+
+  url (value) {
+    if (!value.match(/^https?:\/\/[^ "]+$/)) {
+      throw new InvalidArgumentError('Invalid URL')
+    }
+    return value
+  },
+
+  arrayOf (typeValidator) {
+    return function (value, previousValue) {
+      let result
+      if (previousValue === undefined) {
+        result = []
+      } else {
+        result = [...previousValue]
+      }
+      result.push(typeValidator(value))
+      return result
+    }
+  }
+}