ui5-test-runner 4.0.0 → 4.1.0

package/src/cors.spec.js

@@ -1,41 +0,0 @@
-'use script'
-
-const Request = require('reserve/mock/Request')
-const Response = require('reserve/mock/Response')
-const cors = require('./cors')
-
-const origin = 'npmjs.com'
-
-describe('src/cors', () => {
-  it('handles CORS attributes', async () => {
-    const request = new Request('GET', '/', { origin })
-    const response = new Response()
-    cors.custom(request, response)
-    expect(response.statusCode).toBeUndefined()
-    expect(response.headers).toMatchObject({
-      'access-control-allow-origin': origin,
-      'access-control-allow-credentials': 'true'
-    })
-  })
-
-  it('does not impact response if origin is missing', async () => {
-    const request = new Request('GET', '/')
-    const response = new Response()
-    cors.custom(request, response)
-    expect(response.statusCode).toBeUndefined()
-    expect(response.headers).toMatchObject({})
-  })
-
-  it('handles CORS preflight', async () => {
-    const request = new Request('OPTIONS', '/', { origin })
-    const response = new Response()
-    cors.custom(request, response)
-    expect(response.statusCode).toStrictEqual(200)
-    expect(response.headers).toMatchObject({
-      'access-control-allow-origin': origin,
-      'access-control-allow-headers': 'content-type, content-length, x-page-url',
-      'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
-      'access-control-allow-credentials': 'true'
-    })
-  })
-})

package/src/coverage.spec.js

@@ -1,120 +0,0 @@
-const { join } = require('path')
-const { fromObject } = require('./job')
-const { instrument, generateCoverageReport, mappings } = require('./coverage')
-const { stat } = require('fs/promises')
-const { cleanDir, createDir } = require('./tools')
-const { getOutput } = require('./output')
-const { $remoteOnLegacy } = require('./symbols')
-
-describe('src/coverage', () => {
-  const cwd = join(__dirname, '../test/project')
-  const path = join(__dirname, '../tmp/coverage')
-
-  beforeAll(() => {
-    return cleanDir(path)
-  })
-
-  describe('disabled', () => {
-    const basePath = join(path, 'disabled')
-    let job
-
-    beforeAll(async () => {
-      const reportDir = join(basePath, 'report')
-      await createDir(reportDir)
-      job = fromObject(cwd, {
-        reportDir,
-        coverageTempDir: join(basePath, 'coverage/temp'),
-        coverageReportDir: join(basePath, 'coverage/report'),
-        coverage: false
-      })
-    })
-
-    it('does not instrument sources', async () => {
-      await instrument(job)
-      await expect(() => stat(join(basePath, 'coverage/temp/settings/nyc.json'))).rejects.toThrow()
-    })
-
-    it('does not generate a report', async () => {
-      await generateCoverageReport(job)
-      await expect(() => stat(join(basePath, 'coverage/temp/coverage.json'))).rejects.toThrow()
-      await expect(() => stat(join(basePath, 'coverage/report'))).rejects.toThrow()
-    })
-
-    it('does not create a mapping', async () => {
-      const coverageMappings = await mappings(job)
-      expect(coverageMappings.length).toStrictEqual(0)
-    })
-  })
-
-  describe('enabled', () => {
-    const basePath = join(path, 'enabled')
-    let job
-
-    beforeAll(async function () {
-      const reportDir = join(basePath, 'report')
-      await createDir(reportDir)
-      job = fromObject(cwd, {
-        reportDir,
-        coverageTempDir: join(basePath, 'coverage/temp'),
-        coverageReportDir: join(basePath, 'coverage/report'),
-        coverage: true
-      })
-    })
-
-    it('instruments sources', async () => {
-      await instrument(job)
-      const nycJsonStat = await stat(join(basePath, 'coverage/temp/settings/nyc.json'))
-      expect(nycJsonStat.isFile()).toStrictEqual(true)
-    })
-
-    it('generates a report', async () => {
-      await generateCoverageReport(job)
-      const reportStat = await stat(join(basePath, 'coverage/report'))
-      expect(reportStat.isDirectory()).toStrictEqual(true)
-    })
-
-    it('creates a mapping', async () => {
-      const coverageMappings = await mappings(job)
-      expect(coverageMappings.length).toStrictEqual(1)
-    })
-
-    describe('--url compatibility', () => {
-      let output
-      let instrumentationSkipped
-
-      beforeAll(() => {
-        output = getOutput(job)
-        instrumentationSkipped = jest.spyOn(output, 'instrumentationSkipped')
-      })
-
-      beforeEach(() => {
-        instrumentationSkipped.mockReset()
-      })
-
-      afterAll(() => {
-        instrumentationSkipped.mockRestore()
-      })
-
-      it('does *not* instrument if the URL does not match current port', async () => {
-        Object.assign(job, {
-          mode: 'url',
-          port: 8080,
-          url: ['http://localhost:8081/whatever/test.html']
-        })
-        await instrument(job)
-        expect(instrumentationSkipped).toHaveBeenCalled()
-      })
-
-      it('**does** instrument anyway if the URL matches current port', async () => {
-        Object.assign(job, {
-          mode: 'url',
-          port: 8080,
-          url: ['http://localhost:8080/whatever/test.html'],
-          [$remoteOnLegacy]: true // added on job finalization
-        })
-        await instrument(job)
-        expect(instrumentationSkipped).not.toHaveBeenCalled()
-      })
-    })
-  })
-})

package/src/csv-reader.spec.js

@@ -1,42 +0,0 @@
-const { buildCsvReader } = require('./csv-reader')
-const { createReadStream } = require('fs')
-const { Readable } = require('stream')
-
-jest.mock('fs')
-
-describe('src/csv-reader', () => {
-  beforeEach(() => {
-    createReadStream.mockReset()
-    createReadStream.mockImplementation(() => {
-      const s = new Readable()
-      s._read = () => {}
-      s.push(`timestamp\ttext
-1\tabc
-2\thello world
-3\t"abc\\td"
-`)
-      s.push(null)
-      return s
-    })
-  })
-
-  it('allocates an iterator', () => {
-    const reader = buildCsvReader('test.csv')
-    expect(reader).not.toBeUndefined()
-    expect(typeof reader.next).toBe('function')
-    expect(createReadStream).not.toHaveBeenCalled()
-  })
-
-  it('reads records', async () => {
-    const reader = buildCsvReader('test.csv')
-    const records = []
-    for await (const record of reader) {
-      records.push(record)
-    }
-    expect(records).toEqual([
-      { timestamp: '1', text: 'abc' },
-      { timestamp: '2', text: 'hello world' },
-      { timestamp: '3', text: 'abc\td' }
-    ])
-  })
-})

package/src/csv-writer.spec.js

@@ -1,77 +0,0 @@
-const { buildCsvWriter } = require('./csv-writer')
-const { writeFile } = require('fs/promises')
-
-jest.mock('fs/promises')
-
-describe('src/csv-writer', () => {
-  const now = Date.now()
-
-  beforeAll(() => {
-    jest.spyOn(Date, 'now').mockImplementation(() => now)
-  })
-
-  beforeEach(() => {
-    writeFile.mockReset()
-  })
-
-  it('allocates an object', () => {
-    const writer = buildCsvWriter('test.csv')
-    expect(writer).not.toBeUndefined()
-    expect(writeFile).not.toHaveBeenCalled()
-  })
-
-  it('starts writing the file on first record', async () => {
-    const writer = buildCsvWriter('test.csv')
-    writer.append({ text: 'test' })
-    await writer.ready
-    expect(writeFile.mock.calls).toEqual([
-      ['test.csv', 'timestamp\ttext\n', { flag: 'a+' }],
-      ['test.csv', `${now}\ttest\n`, { flag: 'a+' }]
-    ])
-  })
-
-  it('ignores any additional field not used on the first append', async () => {
-    const writer = buildCsvWriter('test.csv')
-    writer.append({ text: 'test 1' })
-    writer.append({ text: 'test 2', ignored: true })
-    await writer.ready
-    expect(writeFile.mock.calls).toEqual([
-      ['test.csv', 'timestamp\ttext\n', { flag: 'a+' }],
-      ['test.csv', `${now}\ttest 1\n`, { flag: 'a+' }],
-      ['test.csv', `${now}\ttest 2\n`, { flag: 'a+' }]
-    ])
-  })
-
-  it('escapes automatically complex values', async () => {
-    const writer = buildCsvWriter('test.csv')
-    writer.append({ number: 1, text: 'test\t1\n' })
-    await writer.ready
-    expect(writeFile.mock.calls).toEqual([
-      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
-      ['test.csv', `${now}\t1\t"test\\t1\\n"\n`, { flag: 'a+' }]
-    ])
-  })
-
-  it('handles provided timestamp', async () => {
-    const writer = buildCsvWriter('test.csv')
-    writer.append({ timestamp: 456, number: 1, text: 'test\t1\n' })
-    await writer.ready
-    expect(writeFile.mock.calls).toEqual([
-      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
-      ['test.csv', '456\t1\t"test\\t1\\n"\n', { flag: 'a+' }]
-    ])
-  })
-
-  it('handles record array', async () => {
-    const writer = buildCsvWriter('test.csv')
-    await writer.append([
-      { number: 1, text: 'test\t1\n' },
-      { number: 2, text: 'test\t2\n' }
-    ])
-    await writer.ready
-    expect(writeFile.mock.calls).toEqual([
-      ['test.csv', 'timestamp\tnumber\ttext\n', { flag: 'a+' }],
-      ['test.csv', `${now}\t1\t"test\\t1\\n"\n${now}\t2\t"test\\t2\\n"\n`, { flag: 'a+' }]
-    ])
-  })
-})

package/src/error.spec.js

@@ -1,17 +0,0 @@
-const { UTRError } = require('./error')
-
-describe('src/errors', () => {
-  it('generates a fully documented error', () => {
-    const error = UTRError.NPM_FAILED('test')
-    expect(error.name).toStrictEqual('UTRError:NPM_FAILED')
-    expect(error.code).toBeLessThan(0)
-    expect(error.message).toStrictEqual('test')
-  })
-
-  it('generates a generic error', () => {
-    const error = UTRError.NPM_FAILED()
-    expect(error.name).toStrictEqual('UTRError:NPM_FAILED')
-    expect(error.code).toBeLessThan(0)
-    expect(error.message).toStrictEqual('NPM_FAILED')
-  })
-})

package/src/get-job-progress.spec.js

@@ -1,175 +0,0 @@
-const { getJobProgress } = require('./get-job-progress')
-const { Response } = require('reserve')
-
-describe('src/get-job-progress', () => {
-  const url = 'https://localhost:8080/tests/unitTests.qunit.html'
-  const id = 'abcdef'
-  const firstTestId = '8ef4ee8b'
-
-  const job = {
-    cwd: '.',
-    port: 8080,
-    ui5: 'https://ui5.sap.com',
-    testPageUrls: [url],
-    qunitPages: {
-      [url]: {
-        id,
-        start: '2023-01-09T12:49:34.255Z',
-        failed: 0,
-        passed: 2,
-        count: 3,
-        modules: [{
-          name: 'module',
-          tests: [{
-            name: 'First test',
-            testId: firstTestId,
-            logs: ['whatever it contains'],
-            report: {
-              skipped: false,
-              todo: false,
-              failed: 0,
-              passed: 1,
-              total: 1,
-              runtime: 3
-            }
-          }, {
-            name: 'Second test',
-            testId: '35d36b9d',
-            logs: [],
-            report: {
-              skipped: false,
-              todo: false,
-              failed: 0,
-              passed: 1,
-              total: 1,
-              runtime: 5
-            }
-          }, {
-            name: 'Third test',
-            testId: 'e32c4c98',
-            logs: [],
-            report: {
-              skipped: false,
-              todo: false,
-              failed: 1,
-              passed: 0,
-              total: 1,
-              runtime: 3
-            }
-          }]
-        }]
-      }
-    }
-  }
-
-  it('returns job without modules', async () => {
-    const response = new Response()
-    await getJobProgress(job, {}, response)
-    await response.waitForFinish()
-    const json = JSON.parse(response.toString())
-    expect(json).toStrictEqual({
-      cwd: '.',
-      port: 8080,
-      ui5: 'https://ui5.sap.com',
-      testPageUrls: [url],
-      qunitPages: {
-        [url]: {
-          id,
-          start: '2023-01-09T12:49:34.255Z',
-          failed: 0,
-          passed: 2,
-          count: 3
-        }
-      }
-    })
-  })
-
-  it('returns page without logs from page id', async () => {
-    const response = new Response()
-    await getJobProgress(job, {}, response, id)
-    await response.waitForFinish()
-    const json = JSON.parse(response.toString())
-    expect(json).toStrictEqual({
-      url,
-      id,
-      start: '2023-01-09T12:49:34.255Z',
-      failed: 0,
-      passed: 2,
-      count: 3,
-      modules: [{
-        name: 'module',
-        tests: [{
-          name: 'First test',
-          testId: '8ef4ee8b',
-          report: {
-            skipped: false,
-            todo: false,
-            failed: 0,
-            passed: 1,
-            total: 1,
-            runtime: 3
-          }
-        }, {
-          name: 'Second test',
-          testId: '35d36b9d',
-          report: {
-            skipped: false,
-            todo: false,
-            failed: 0,
-            passed: 1,
-            total: 1,
-            runtime: 5
-          }
-        }, {
-          name: 'Third test',
-          testId: 'e32c4c98',
-          report: {
-            skipped: false,
-            todo: false,
-            failed: 1,
-            passed: 0,
-            total: 1,
-            runtime: 3
-          }
-        }]
-      }]
-    })
-  })
-
-  it('returns 404 if page id is unknown', async () => {
-    const response = new Response()
-    await getJobProgress(job, {}, response, 'unknown')
-    await response.waitForFinish()
-    expect(response.statusCode).toBe(404)
-  })
-
-  it('returns test page and test id', async () => {
-    const response = new Response()
-    await getJobProgress(job, {}, response, id, firstTestId)
-    await response.waitForFinish()
-    const json = JSON.parse(response.toString())
-    expect(json).toStrictEqual({
-      url,
-      pageId: id,
-      module: 'module',
-      name: 'First test',
-      testId: firstTestId,
-      logs: ['whatever it contains'],
-      report: {
-        skipped: false,
-        todo: false,
-        failed: 0,
-        passed: 1,
-        total: 1,
-        runtime: 3
-      }
-    })
-  })
-
-  it('returns 404 if test id is unknown', async () => {
-    const response = new Response()
-    await getJobProgress(job, {}, response, id, 'unknown')
-    await response.waitForFinish()
-    expect(response.statusCode).toBe(404)
-  })
-})

package/src/inject/post.spec.js

@@ -1,147 +0,0 @@
-class UI5Object {}
-global.window = {
-  sap: {
-    ui: {
-      base: {
-        Object: UI5Object
-      }
-    }
-  }
-}
-
-require('./post')
-
-describe('src/inject/post', () => {
-  describe('stringify', () => {
-    const stringify = window['ui5-test-runner/stringify']
-
-    describe('simple values', () => {
-      const simpleValues = [
-        null,
-        '',
-        'Hello World !',
-        0,
-        1,
-        false,
-        true,
-        [],
-        [1, 2],
-        { a: 'a' },
-        { a: 'a', b: { b: 'b' } },
-        [{ a: 'a' }, { a: 'a', b: { b: 'b' } }]
-      ]
-
-      simpleValues.forEach(simpleValue => {
-        it(JSON.stringify(simpleValue), () => {
-          expect(stringify(simpleValue)).toBe(JSON.stringify(simpleValue))
-        })
-      })
-    })
-
-    describe('UI5 objects', () => {
-      it('reduces UI5 objects to their simplest form (no ID)', () => {
-        const obj = new UI5Object()
-        obj.getMetadata = () => ({
-          getName: () => 'sap.m.Button'
-        })
-        expect(JSON.parse(stringify(obj))).toStrictEqual({
-          'ui5:class': 'sap.m.Button'
-        })
-      })
-
-      it('reduces UI5 objects to their simplest form (with ID)', () => {
-        const obj = new UI5Object()
-        obj.getId = () => 'test'
-        obj.getMetadata = () => ({
-          getName: () => 'sap.m.Button'
-        })
-        expect(JSON.parse(stringify(obj))).toStrictEqual({
-          'ui5:id': 'test',
-          'ui5:class': 'sap.m.Button'
-        })
-      })
-
-      it('works on a complex object', () => {
-        const obj = new UI5Object()
-        obj.getId = () => 'test'
-        obj.getMetadata = () => ({
-          getName: () => 'sap.m.Button'
-        })
-        expect(JSON.parse(stringify({
-          complex: obj
-        }))).toStrictEqual({
-          complex: {
-            'ui5:id': 'test',
-            'ui5:class': 'sap.m.Button'
-          }
-        })
-      })
-    })
-
-    describe('circular references', () => {
-      it('converts simple circular reference (object)', () => {
-        const a = { a: 'a' }
-        const b = { b: 'b' }
-        a.b = b
-        b.a = a
-        expect(JSON.parse(stringify(a))).toStrictEqual({
-          'circular:id': 0,
-          a: 'a',
-          b: {
-            b: 'b',
-            a: {
-              'circular:ref': 0
-            }
-          }
-        })
-      })
-
-      it('converts deep circular reference', () => {
-        const a = {
-          a: 'a',
-          b: {
-            b: 'b',
-            c: ['c'],
-            d: {
-              d: 'd'
-            }
-          }
-        }
-        a.b.c.push(a.b)
-        a.b.d.a = a
-        expect(JSON.parse(stringify(a))).toStrictEqual({
-          'circular:id': 0,
-          a: 'a',
-          b: {
-            'circular:id': 1,
-            b: 'b',
-            c: ['c', { 'circular:ref': 1 }],
-            d: {
-              d: 'd',
-              a: {
-                'circular:ref': 0
-              }
-            }
-          }
-        })
-      })
-
-      it('converts simple circular reference (array)', () => {
-        const a = ['a']
-        const b = ['b']
-        a.push(b)
-        b.push(a)
-        expect(JSON.parse(stringify(a))).toStrictEqual({
-          'circular:id': 0,
-          'circular:array': [
-            'a',
-            [
-              'b',
-              { 'circular:ref': 0 }
-            ]
-          ]
-        })
-      })
-    })
-  })
-})