@toptal/davinci-qa 13.1.3-alpha-fix-wrong-data-structure-in-analytics-e998b099.7 → 13.1.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 13.1.3
+
+### Patch Changes
+
+- Updated dependencies [[`1457314e`](https://github.com/toptal/davinci/commit/1457314e7f449146077753dcc467565e6ce4d3d2)]:
+  - @toptal/davinci-cli-shared@1.10.2
+
 ## 13.1.2
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-qa",
-  "version": "13.1.3-alpha-fix-wrong-data-structure-in-analytics-e998b099.7+e998b099",
+  "version": "13.1.3",
   "description": "QA package to test your application",
   "publishConfig": {
     "access": "public"
@@ -16,13 +16,17 @@
     "davinci-qa": "./bin/davinci-qa.js"
   },
   "main": "./src/index.js",
+  "files": [
+    "src",
+    "bin",
+    "docs",
+    "CHANGELOG.md"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toptal/davinci.git"
   },
   "scripts": {
-    "build:package": "../../bin/build-package.js",
-    "prepublishOnly": "../../bin/prepublish.js",
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "bugs": {
@@ -37,7 +41,7 @@
     "@cypress/webpack-preprocessor": "^5.12.0",
     "@testing-library/jest-dom": "^5.16.4",
     "@testing-library/react": "^13.3.0",
-    "@toptal/davinci-cli-shared": "1.10.2-alpha-fix-wrong-data-structure-in-analytics-e998b099.7+e998b099",
+    "@toptal/davinci-cli-shared": "1.10.2",
     "@types/jest": "^27.5.1",
     "babel-jest": "^28.1.3",
     "cypress": "^10.6.0",
@@ -58,11 +62,10 @@
     "semver": "^7.3.2"
   },
   "devDependencies": {
-    "json5": "^2.2.1",
+    "json5": "^2.2.3",
     "mocha": "^10.0.0"
   },
   "peerDependencies": {
     "@toptal/davinci-engine": "3 - 9"
-  },
-  "gitHead": "e998b09949b7b22fd1305544729bb6665fcfe092"
+  }
 }

package/src/commands/integration-run.test.js

@@ -0,0 +1,119 @@
+/* eslint-disable import/order -- changing the order messes up with jest mocking */
+const fs = require('fs')
+
+const originalExistsSync = fs.existsSync
+
+const getPackageFilePathMock = jest.fn()
+const getProjectRootFilePathMock = jest.fn(path => `mock:${path}`)
+const fsExistsSyncSpy = jest.spyOn(fs, 'existsSync')
+
+jest.mock('@toptal/davinci-cli-shared', () => ({
+  ...jest.requireActual('@toptal/davinci-cli-shared'),
+  runSync: jest.fn(),
+  print: {
+    red: jest.fn(),
+    green: jest.fn(),
+  },
+  files: {
+    getPackageFilePath: getPackageFilePathMock,
+    getProjectRootFilePath: getProjectRootFilePathMock,
+  },
+  packageUtils: {
+    checkPrerequirement: jest.fn(),
+    getPackagePackageJson: jest.fn(() => ({ peerDependencies: {} })),
+  },
+}))
+
+const { runSync } = require('@toptal/davinci-cli-shared')
+
+const { action } = require('./integration-run')
+
+describe('integrationRunCommand', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('runs cypress with default options', () => {
+    const localConfig = 'mock:cypress.config.js'
+    const davinciConfig = 'packages/qa/src/configs/cypress.config.js'
+
+    getPackageFilePathMock.mockReturnValueOnce(davinciConfig)
+
+    // fs.existsSync is used in a lot of places, even internally by jest
+    // we want to only mock when asking for our files
+    fsExistsSyncSpy.mockImplementation((path, ...rest) =>
+      path === localConfig ? false : originalExistsSync(path, ...rest)
+    )
+
+    action({ options: {} })
+
+    expect(runSync).toHaveBeenCalledWith('yarn', [
+      'cypress',
+      'run',
+      '--config-file',
+      davinciConfig,
+    ])
+
+    expect(getPackageFilePathMock).toHaveBeenCalledWith(
+      '@toptal/davinci-qa',
+      'src/configs/cypress.config.js'
+    )
+  })
+
+  it('run cypress with local config, if present', () => {
+    const localConfig = 'mock:cypress.config.js'
+    const davinciConfig = 'packages/qa/src/configs/cypress.config.js'
+
+    getPackageFilePathMock.mockReturnValueOnce(davinciConfig)
+
+    // fs.existsSync is used in a lot of places, even internally by jest
+    // we want to only mock when asking for our files
+    fsExistsSyncSpy.mockImplementation((path, ...rest) =>
+      path === localConfig ? true : originalExistsSync(path, ...rest)
+    )
+
+    action({ options: {} })
+
+    expect(runSync).toHaveBeenCalledWith('yarn', [
+      'cypress',
+      'run',
+      '--config-file',
+      localConfig,
+    ])
+
+    expect(getPackageFilePathMock).not.toHaveBeenCalledWith(
+      '@toptal/davinci-qa',
+      'src/configs/cypress.config.js'
+    )
+  })
+
+  it('runs cypress with custom options', () => {
+    const localConfig = 'mock:cypress.config.js'
+    const davinciConfig = 'packages/qa/src/configs/cypress.config.js'
+    const spec = 'cypress/integration/activation_flow.spec.ts'
+
+    getPackageFilePathMock.mockReturnValueOnce(davinciConfig)
+
+    // fs.existsSync is used in a lot of places, even internally by jest
+    // we want to only mock when asking for our files
+    fsExistsSyncSpy.mockImplementation((path, ...rest) =>
+      path === localConfig ? false : originalExistsSync(path, ...rest)
+    )
+
+    action({ options: { spec } })
+
+    expect(runSync).toHaveBeenCalledWith('yarn', [
+      'cypress',
+      'run',
+      '--config-file',
+      davinciConfig,
+      '--spec',
+      spec,
+    ])
+
+    expect(getPackageFilePathMock).toHaveBeenCalledWith(
+      '@toptal/davinci-qa',
+      'src/configs/cypress.config.js'
+    )
+  })
+})

package/src/commands/unit-tests.test.js

@@ -0,0 +1,217 @@
+const jestRunCLIMock = jest
+  .fn()
+  .mockResolvedValue({ results: { success: true } })
+const getPackageFilePathMock = jest.fn()
+const getProjectRootFilePathMock = jest.fn()
+const getProjectRootFileContentMock = jest.fn().mockReturnValue({
+  devDependencies: {},
+  dependencies: {},
+})
+
+jest.mock('@toptal/davinci-cli-shared', () => ({
+  runSync: jest.fn(),
+  print: {
+    green: jest.fn(),
+    grey: jest.fn(),
+    red: jest.fn(),
+  },
+  files: {
+    getPackageFilePath: getPackageFilePathMock,
+    getProjectRootFileContent: getProjectRootFileContentMock,
+    getProjectRootFilePath: getProjectRootFilePathMock,
+  },
+}))
+
+jest.mock('jest', () => ({
+  runCLI: jestRunCLIMock,
+}))
+
+const { action } = require('./unit-tests')
+const originalEnv = process.env
+
+describe('unitTestsCommand', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  describe('when running locally', () => {
+    beforeEach(() => {
+      delete process.env.CI
+    })
+
+    it('calls the jest CLI without additional reporters', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+
+      await action({})
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        { config: davinciJestConfigPath, testPathPattern: [] },
+        expect.anything()
+      )
+    })
+  })
+
+  describe('when running on CI', () => {
+    beforeEach(() => {
+      process.env.CI = true
+    })
+
+    it('calls the jest CLI with default Davinci reporters', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+
+      await action({})
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reporters: [
+            [
+              'jest-silent-reporter',
+              {
+                useDots: true,
+                showPaths: true,
+                showWarnings: true,
+              },
+            ],
+            [
+              'jest-junit',
+              {
+                outputDirectory: 'reports',
+              },
+            ],
+            [
+              'jest-html-reporters',
+              {
+                publicPath: './reports',
+                inlineSource: true,
+                failureMessageOnly: 2,
+              },
+            ],
+          ],
+        }),
+        expect.anything()
+      )
+    })
+
+    it('returns the anvil reporter when anvilTag is set', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+
+      await action({ options: { anvilTag: 'platform' } })
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reporters: [
+            [
+              'jest-silent-reporter',
+              {
+                useDots: true,
+                showPaths: true,
+                showWarnings: true,
+              },
+            ],
+            [
+              'jest-junit',
+              {
+                outputDirectory: 'reports',
+              },
+            ],
+            [
+              'jest-html-reporters',
+              {
+                publicPath: './reports',
+                inlineSource: true,
+                failureMessageOnly: 2,
+              },
+            ],
+            [
+              expect.stringContaining(
+                'davinci/packages/qa/src/reporters/jest-anvil-reporter.js'
+              ),
+              {
+                anvilTag: 'platform',
+              },
+            ],
+          ],
+        }),
+        expect.anything()
+      )
+    })
+
+    it('allows overriding of the default Davinci reporters via custom configuration', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+      const customCLIReporter = 'My-CLI-Reporter'
+
+      await action({
+        options: {
+          anvilTag: 'MyTag',
+          reporters: customCLIReporter,
+        },
+      })
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reporters: [customCLIReporter],
+        }),
+        expect.anything()
+      )
+    })
+
+    it('allows overriding the default Davinci reporters via custom jest config', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+      const customJestConfigReporter = 'My-Jest-Config-Reporter'
+
+      getProjectRootFileContentMock.mockReturnValue({
+        reporters: customJestConfigReporter,
+      })
+
+      await action({ options: { config: {} } })
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reporters: [customJestConfigReporter],
+        }),
+        expect.anything()
+      )
+    })
+
+    it('prioritizes the CLI reporters over the custom jest config or the default Davinci reporters', async () => {
+      const davinciJestConfigPath = 'packages/qa/src/configs/jest.config.js'
+
+      getPackageFilePathMock.mockReturnValueOnce(davinciJestConfigPath)
+      const customCLIReporter = 'My-CLI-Reporter'
+      const customJestConfigReporter = 'My-Jest-Config-Reporter'
+
+      getProjectRootFileContentMock.mockReturnValue({
+        reporters: customJestConfigReporter,
+      })
+
+      await action({
+        options: {
+          anvilTag: 'MyTag',
+          reporters: customCLIReporter,
+          config: {},
+        },
+      })
+
+      expect(jestRunCLIMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          reporters: [customCLIReporter],
+        }),
+        expect.anything()
+      )
+    })
+  })
+})

package/src/configs/cypress/plugins/parallelization.test.js

@@ -0,0 +1,112 @@
+const glob = require('glob')
+const fs = require('fs')
+
+const parallelization = require('./parallelization')
+
+const mockedConfig = {
+  specPattern: '**.test.js',
+}
+const mockedTestFiles = [
+  'test1.test.js',
+  'test2.test.js',
+  'test3.test.js',
+  'test4.test.js',
+]
+const mockedSizes = {
+  'test1.test.js': 128,
+  'test2.test.js': 256,
+  'test3.test.js': 512,
+  'test4.test.js': 1024,
+}
+
+jest.mock('test-project/test1.test.js', () => {}, {
+  virtual: true,
+})
+jest.mock('test-project/test2.test.js', () => {}, {
+  virtual: true,
+})
+jest.mock('test-project/test3.test.js', () => {}, {
+  virtual: true,
+})
+jest.mock('test-project/test4.test.js', () => {}, {
+  virtual: true,
+})
+
+describe('Cypress CI parallelization', () => {
+  const env = process.env
+  let config = mockedConfig
+  let globSyncMock
+
+  beforeEach(() => {
+    process.env = { ...env }
+    config = { ...mockedConfig }
+
+    globSyncMock = jest.spyOn(glob, 'sync')
+    jest.spyOn(fs, 'statSync').mockImplementation(fileName => ({
+      size: mockedSizes[fileName],
+    }))
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe('Sort files by size and split in two parallel groups', () => {
+    it('returns first half', () => {
+      process.env.GROUP_INDEX = 0
+      process.env.PARALLEL_GROUPS = 2
+
+      globSyncMock.mockImplementation(() => mockedTestFiles.slice(0))
+
+      parallelization(config)
+
+      expect(config.specPattern).toEqual(['test4.test.js', 'test2.test.js'])
+    })
+
+    it('returns second half', () => {
+      process.env.GROUP_INDEX = 1
+      process.env.PARALLEL_GROUPS = 2
+
+      globSyncMock.mockImplementation(() => mockedTestFiles.slice(0))
+
+      parallelization(config)
+
+      expect(config.specPattern).toEqual(['test3.test.js', 'test1.test.js'])
+    })
+  })
+
+  describe('When there is only 1 parallel group', () => {
+    it('returns spec pattern', () => {
+      process.env.GROUP_INDEX = 0
+      process.env.PARALLEL_GROUPS = 1
+
+      parallelization(config)
+
+      expect(config.specPattern).toBe('**.test.js')
+    })
+  })
+
+  describe('When group index is lower than 0', () => {
+    it('returns spec pattern', () => {
+      process.env.GROUP_INDEX = -1
+      process.env.PARALLEL_GROUPS = 3
+
+      parallelization(config)
+
+      expect(config.specPattern).toBe('**.test.js')
+    })
+  })
+
+  describe('When there are less test files than testing groups', () => {
+    it('returns empty array for a group', () => {
+      process.env.GROUP_INDEX = 1
+      process.env.PARALLEL_GROUPS = 2
+
+      globSyncMock.mockImplementation(() => mockedTestFiles.slice(0, 1))
+
+      parallelization(config)
+
+      expect(config.specPattern).toEqual([])
+    })
+  })
+})

package/src/reporters/anvil-results-helper.test.js

@@ -0,0 +1,131 @@
+const fs = require('fs-extra')
+const { print } = require('@toptal/davinci-cli-shared')
+
+const { anvilMapper, generateAnvilResults } = require('./anvil-results-helper')
+
+describe('Anvil results helper', () => {
+  beforeEach(() => {
+    jest.resetModules()
+    jest.resetAllMocks()
+  })
+
+  describe('anvilMapper', () => {
+    it('outputs an Anvil-compatible object', () => {
+      const mappedValue = anvilMapper({
+        fileName:
+          '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+        backtrace: null,
+        description: '1 + 1 returns 2',
+        durationInSeconds: 0.003,
+        error: null,
+        lineNumber: 2,
+        pendingMessage: null,
+        scenarioName: 'Example test suite/1 + 1 returns 2',
+        status: 'passed',
+        tag: 'platform',
+        testType: 'unit',
+      })
+
+      expect(mappedValue).toEqual({
+        file_name:
+          '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+        line_number: 2,
+        status: 'passed',
+        duration: 0.003,
+        scenario_name: 'Example test suite/1 + 1 returns 2',
+        description: '1 + 1 returns 2',
+        error: null,
+        backtrace: null,
+        test_type: 'unit',
+        pending_message: null,
+        tag: 'platform',
+      })
+    })
+
+    it('converts "todo" status to pending', () => {
+      const mappedValue = anvilMapper({ status: 'todo' })
+
+      expect(mappedValue.status).toBe('pending')
+    })
+  })
+
+  describe('generateAnvilResults', () => {
+    beforeEach(() => {
+      // To avoid creating files
+      jest.spyOn(fs, 'writeJsonSync').mockImplementation(() => {})
+      jest.spyOn(fs, 'outputJsonSync').mockImplementation(() => {})
+      jest
+        .spyOn(fs, 'readJsonSync')
+        .mockImplementation(() => ({ test_results: [] }))
+    })
+
+    it('creates a report with the data passed in', () => {
+      const writeJsonMock = jest.spyOn(fs, 'writeJsonSync')
+      const printMock = jest.spyOn(print, 'green')
+
+      generateAnvilResults('anvil_cypress_test_results.json', [{ test: 123 }])
+
+      expect(writeJsonMock).toHaveBeenCalledWith(
+        './reports/anvil_cypress_test_results.json',
+        { test_results: [{ test: 123 }] }
+      )
+      expect(printMock).toHaveBeenCalledWith(
+        '[anvil-reporter] Anvil reports generated successfully!'
+      )
+    })
+
+    it('throws an error when unable to create report', () => {
+      const mockError = new Error('My error!')
+
+      jest.spyOn(fs, 'existsSync').mockImplementation(() => {
+        throw mockError
+      })
+      const printMock = jest.spyOn(print, 'red')
+
+      expect(() =>
+        generateAnvilResults('anvil_cypress_test_results.json', [{ test: 123 }])
+      ).toThrow()
+
+      expect(printMock).toHaveBeenCalledTimes(1)
+      expect(printMock).toHaveBeenCalledWith(
+        '[anvil-reporter] Failed to create Anvil test results!',
+        mockError
+      )
+    })
+
+    it('merges test results when previous reports exist', () => {
+      const writeJsonMock = jest.spyOn(fs, 'writeJsonSync')
+
+      jest.spyOn(fs, 'existsSync').mockImplementation(() => true)
+      jest
+        .spyOn(fs, 'readJsonSync')
+        .mockImplementation(() => ({ test_results: [{ name: 'my_results' }] }))
+
+      generateAnvilResults('anvil_cypress_test_results.json', [
+        { name: 'my_new_results' },
+      ])
+
+      expect(writeJsonMock).toHaveBeenCalledWith(
+        './reports/anvil_cypress_test_results.json',
+        {
+          test_results: [{ name: 'my_results' }, { name: 'my_new_results' }],
+        }
+      )
+    })
+
+    it('creates a new file with empty results when one does not exist', () => {
+      const outputJsonMock = jest.spyOn(fs, 'outputJsonSync')
+
+      jest.spyOn(fs, 'existsSync').mockImplementation(() => false)
+
+      generateAnvilResults('anvil_cypress_test_results.json', [
+        { name: 'my_new_results' },
+      ])
+
+      expect(outputJsonMock).toHaveBeenCalledWith(
+        './reports/anvil_cypress_test_results.json',
+        { test_results: [] }
+      )
+    })
+  })
+})

package/src/reporters/cypress-anvil-reporter.test.js

@@ -0,0 +1,263 @@
+/* eslint-disable jest/no-done-callback */
+// If you need to extend these tests, have a look at these other reporters for inspiration:
+// - https://github.com/adamgruber/mochawesome/blob/963f073fe3f4522070788a702329dd6b61014df3/test/reporter.test.js
+// - https://github.com/michaelleeallen/mocha-junit-reporter/blob/3b65764449f6f3a0ec6f54da5842a2a21d788382/test/mocha-junit-reporter-spec.js#L176
+const generateAnvilResultsMock = jest.fn()
+
+jest.mock('./anvil-results-helper', () => ({
+  ...jest.requireActual('./anvil-results-helper'),
+  generateAnvilResults: generateAnvilResultsMock,
+}))
+const { print } = require('@toptal/davinci-cli-shared')
+const Mocha = require('mocha')
+const { AssertionError } = require('assert')
+
+const CypressAnvilReporter = require('./cypress-anvil-reporter')
+
+const { Runner, Suite, Test } = Mocha
+
+const createRunner = suite => {
+  const runner = new Runner(suite)
+
+  runner.stats = {
+    passes: 0,
+    duration: 0,
+  }
+
+  return runner
+}
+
+const configureReporter = (runner, reporter, options = {}) => {
+  const mocha = new Mocha({
+    reporter: reporter,
+    allowUncaught: true,
+  })
+
+  new mocha._reporter(runner, {
+    reporterOptions: options,
+  })
+}
+
+describe('Cypress Anvil reporter', () => {
+  const rootSuiteName = 'my root suite'
+  const testName = 'my test'
+  const anvilTag = 'talent_portal'
+
+  beforeEach(() => {
+    jest.resetModules()
+    jest.resetAllMocks()
+  })
+
+  it('generates an Anvil-compatible report when anvilTag is set', done => {
+    const suite = new Suite(rootSuiteName, 'root').addTest(
+      new Test(testName, () => {})
+    )
+    const runner = createRunner(suite)
+
+    configureReporter(runner, CypressAnvilReporter, { anvilTag })
+
+    runner.run(failures => {
+      expect(failures).toBe(0)
+      expect(generateAnvilResultsMock).toHaveBeenCalledWith(
+        'anvil_cypress_test_results.json',
+        [
+          {
+            status: 'passed',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${testName}`,
+            description: testName,
+            error: null,
+            backtrace: null,
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+        ]
+      )
+
+      done()
+    })
+  })
+
+  it('does not generate a report if anvilTag is not specified', done => {
+    const printSpy = jest.spyOn(print, 'yellow')
+    const suite = new Suite(rootSuiteName, 'root').addTest(
+      new Test(testName, () => {})
+    )
+    const runner = createRunner(suite)
+
+    configureReporter(runner, CypressAnvilReporter)
+
+    runner.run(() => {
+      expect(printSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "[anvil-reporter] --anvilTag option is missing! anvil_cypress_test_results.json won't be generated."
+        )
+      )
+      expect(generateAnvilResultsMock).not.toHaveBeenCalled()
+
+      done()
+    })
+  })
+
+  it('returns the scenario name with all parents listed', done => {
+    const grandchildSuiteName = 'my grandchild suite'
+    const childSuiteName = 'my child suite'
+
+    const grandchildSuite = new Suite(grandchildSuiteName, 'root').addTest(
+      new Test(testName, () => {})
+    )
+    const childSuite = new Suite(childSuiteName, 'root').addSuite(
+      grandchildSuite
+    )
+
+    new Suite(rootSuiteName, 'root').addSuite(childSuite)
+
+    const runner = createRunner(grandchildSuite)
+
+    configureReporter(runner, CypressAnvilReporter, { anvilTag })
+
+    runner.run(failures => {
+      expect(failures).toBe(0)
+      expect(generateAnvilResultsMock).toHaveBeenCalledWith(
+        'anvil_cypress_test_results.json',
+        [
+          {
+            status: 'passed',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${childSuiteName}/${grandchildSuiteName}/${testName}`,
+            description: testName,
+            error: null,
+            backtrace: null,
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+        ]
+      )
+
+      done()
+    })
+  })
+
+  it('returns errors and backtrace when tests fail', done => {
+    const errorMessage = 'Expected foo, got bar'
+    const suite = new Suite(rootSuiteName, 'root').addTest(
+      new Test(testName, callback => {
+        callback(new AssertionError({ message: errorMessage }))
+      })
+    )
+    const runner = createRunner(suite)
+
+    configureReporter(runner, CypressAnvilReporter, { anvilTag })
+
+    runner.run(failures => {
+      expect(failures).toBe(1)
+      expect(generateAnvilResultsMock).toHaveBeenCalledWith(
+        'anvil_cypress_test_results.json',
+        [
+          {
+            status: 'failed',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${testName}`,
+            description: testName,
+            error: errorMessage,
+            backtrace: expect.arrayContaining([
+              expect.stringMatching(
+                new RegExp(
+                  `AssertionError.*${errorMessage}.*at new AssertionError`,
+                  'gms'
+                )
+              ),
+            ]),
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+        ]
+      )
+
+      done()
+    })
+  })
+
+  it('supports retried tests', done => {
+    const suite = new Suite(rootSuiteName, 'root').retries(2).addTest(
+      new Test(testName, callback => {
+        expect(1).toBe(2)
+
+        callback()
+      })
+    )
+    const runner = createRunner(suite)
+
+    configureReporter(runner, CypressAnvilReporter, { anvilTag })
+
+    runner.run(failures => {
+      expect(failures).toBe(1)
+      expect(generateAnvilResultsMock).toHaveBeenCalledWith(
+        'anvil_cypress_test_results.json',
+        [
+          {
+            status: 'retried',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${testName}`,
+            description: testName,
+            error: null,
+            backtrace: null,
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+          {
+            status: 'retried',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${testName}`,
+            description: testName,
+            error: null,
+            backtrace: null,
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+          {
+            status: 'failed',
+            duration: expect.any(Number),
+            scenario_name: `${rootSuiteName}/${testName}`,
+            description: testName,
+            error: expect.anything(),
+            backtrace: expect.anything(),
+            test_type: 'integration',
+            pending_message: null,
+            tag: anvilTag,
+          },
+        ]
+      )
+
+      done()
+    })
+  })
+
+  it('calls the anvil test result mapper', done => {
+    const anvilMapperSpy = jest.fn()
+
+    jest.mock('./anvil-results-helper', () => ({
+      anvilMapper: anvilMapperSpy,
+      generateAnvilResults: jest.fn(),
+    }))
+    const newCypressAnvilReporter = require('./cypress-anvil-reporter')
+
+    const suite = new Suite('My suite', 'root').addTest(
+      new Test('My test', () => {})
+    )
+    const runner = createRunner(suite)
+
+    configureReporter(runner, newCypressAnvilReporter, { anvilTag })
+
+    runner.run(() => {
+      expect(anvilMapperSpy).toHaveBeenCalledTimes(1)
+
+      done()
+    })
+  })
+})

package/src/reporters/jest-anvil-reporter.test.js

@@ -0,0 +1,213 @@
+const generateAnvilResultsMock = jest.fn()
+
+jest.mock('./anvil-results-helper', () => ({
+  ...jest.requireActual('./anvil-results-helper'),
+  generateAnvilResults: generateAnvilResultsMock,
+}))
+
+const { print } = require('@toptal/davinci-cli-shared')
+
+const JestAnvilReporter = require('./jest-anvil-reporter')
+const {
+  passedTestResults,
+  failedTestResults,
+  skippedTestResults,
+  combinedTestResults,
+  toDoTestResults,
+} = require('./test-result-mocks')
+
+describe('Jest Anvil reporter', () => {
+  const expectedPassedTestResults = [
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 2,
+      status: 'passed',
+      duration: 0.003,
+      scenario_name: 'Example test suite/1 + 1 returns 2',
+      description: '1 + 1 returns 2',
+      error: null,
+      backtrace: null,
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+  ]
+
+  const expectedFailedTestResults = [
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 2,
+      status: 'failed',
+      duration: 0.006,
+      scenario_name: 'Example test suite/1 + 1 returns 3',
+      description: '1 + 1 returns 3',
+      error:
+        'Error: \u001b[2mexpect(\u001b[22m\u001b[31mreceived\u001b[39m\u001b[2m).\u001b[22mtoBe\u001b[2m(\u001b[22m\u001b[32mexpected\u001b[39m\u001b[2m) // Object.is equality\u001b[22m\n\nExpected: \u001b[32m3\u001b[39m\nReceived: \u001b[31m2\u001b[39m\n    at Object.<anonymous> (/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js:3:17)\n    at Object.asyncJestTest (/davinci/node_modules/jest-jasmine2/build/jasmineAsyncInstall.js:106:37)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:45:12\n    at new Promise (<anonymous>)\n    at mapper (/davinci/node_modules/jest-jasmine2/build/queueRunner.js:28:19)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:75:41',
+      backtrace: [
+        'Error: \u001b[2mexpect(\u001b[22m\u001b[31mreceived\u001b[39m\u001b[2m).\u001b[22mtoBe\u001b[2m(\u001b[22m\u001b[32mexpected\u001b[39m\u001b[2m) // Object.is equality\u001b[22m\n\nExpected: \u001b[32m3\u001b[39m\nReceived: \u001b[31m2\u001b[39m\n    at Object.<anonymous> (/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js:3:17)\n    at Object.asyncJestTest (/davinci/node_modules/jest-jasmine2/build/jasmineAsyncInstall.js:106:37)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:45:12\n    at new Promise (<anonymous>)\n    at mapper (/davinci/node_modules/jest-jasmine2/build/queueRunner.js:28:19)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:75:41',
+      ],
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+  ]
+
+  const expectedSkippedTestResults = [
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 2,
+      status: 'pending',
+      duration: 0,
+      scenario_name: 'Example test suite/1 + 1 returns 2',
+      description: '1 + 1 returns 2',
+      error: null,
+      backtrace: null,
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+  ]
+
+  const expectedToDoTestResults = [
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: null,
+      status: 'pending',
+      duration: 0,
+      scenario_name: 'Example test suite/1+1 returns 2',
+      description: '1+1 returns 2',
+      error: null,
+      backtrace: null,
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+  ]
+
+  const expectedCombinedTestResults = [
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 2,
+      status: 'passed',
+      duration: 0.005,
+      scenario_name: 'Example test suite/1 + 1 returns 2 (passed)',
+      description: '1 + 1 returns 2 (passed)',
+      error: null,
+      backtrace: null,
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 6,
+      status: 'failed',
+      duration: 0.007,
+      scenario_name: 'Example test suite/1 + 1 returns 3 (failed)',
+      description: '1 + 1 returns 3 (failed)',
+      error:
+        'Error: \u001b[2mexpect(\u001b[22m\u001b[31mreceived\u001b[39m\u001b[2m).\u001b[22mtoBe\u001b[2m(\u001b[22m\u001b[32mexpected\u001b[39m\u001b[2m) // Object.is equality\u001b[22m\n\nExpected: \u001b[32m3\u001b[39m\nReceived: \u001b[31m2\u001b[39m\n    at Object.<anonymous> (/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js:7:17)\n    at Object.asyncJestTest (/davinci/node_modules/jest-jasmine2/build/jasmineAsyncInstall.js:106:37)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:45:12\n    at new Promise (<anonymous>)\n    at mapper (/davinci/node_modules/jest-jasmine2/build/queueRunner.js:28:19)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:75:41',
+      backtrace: [
+        'Error: \u001b[2mexpect(\u001b[22m\u001b[31mreceived\u001b[39m\u001b[2m).\u001b[22mtoBe\u001b[2m(\u001b[22m\u001b[32mexpected\u001b[39m\u001b[2m) // Object.is equality\u001b[22m\n\nExpected: \u001b[32m3\u001b[39m\nReceived: \u001b[31m2\u001b[39m\n    at Object.<anonymous> (/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js:7:17)\n    at Object.asyncJestTest (/davinci/node_modules/jest-jasmine2/build/jasmineAsyncInstall.js:106:37)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:45:12\n    at new Promise (<anonymous>)\n    at mapper (/davinci/node_modules/jest-jasmine2/build/queueRunner.js:28:19)\n    at /davinci/node_modules/jest-jasmine2/build/queueRunner.js:75:41',
+      ],
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+    {
+      file_name:
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js',
+      line_number: 10,
+      status: 'pending',
+      duration: 0,
+      scenario_name: 'Example test suite/1 + 1 returns 2 (skipped)',
+      description: '1 + 1 returns 2 (skipped)',
+      error: null,
+      backtrace: null,
+      test_type: 'unit',
+      pending_message: null,
+      tag: 'platform',
+    },
+  ]
+
+  beforeEach(() => {
+    jest.resetModules()
+    jest.resetAllMocks()
+  })
+
+  it.each`
+    input                  | expectedOutput                 | testType
+    ${passedTestResults}   | ${expectedPassedTestResults}   | ${'passing tests'}
+    ${failedTestResults}   | ${expectedFailedTestResults}   | ${'failing tests'}
+    ${skippedTestResults}  | ${expectedSkippedTestResults}  | ${'skipped tests'}
+    ${toDoTestResults}     | ${expectedToDoTestResults}     | ${'todo tests'}
+    ${combinedTestResults} | ${expectedCombinedTestResults} | ${'a combination of test results'}
+  `(
+    'calls generateAnvilResults with a payload matching Anvil for $testType',
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    ({ input, expectedOutput, testType }) => {
+      const jestAnvilReporter = new JestAnvilReporter(undefined, {
+        anvilTag: 'platform',
+      })
+
+      jestAnvilReporter.onRunComplete(undefined, input)
+
+      expect(generateAnvilResultsMock).toHaveBeenCalledWith(
+        'anvil_jest_test_results.json',
+        expectedOutput
+      )
+    }
+  )
+
+  it('prints warning and exits when anvilTag is not defined', () => {
+    const printSpy = jest.spyOn(print, 'yellow')
+    const jestAnvilReporter = new JestAnvilReporter(undefined, {
+      anvilTag: undefined,
+    })
+
+    jestAnvilReporter.onRunComplete(undefined, passedTestResults)
+
+    expect(printSpy).toHaveBeenCalledWith(
+      'Missing --anvilTag value! Anvil test results will be skipped.'
+    )
+    expect(generateAnvilResultsMock).not.toHaveBeenCalled()
+  })
+
+  it('calls the anvil mapper', () => {
+    const anvilMapperSpy = jest.fn()
+
+    jest.mock('./anvil-results-helper', () => ({
+      anvilMapper: anvilMapperSpy,
+      generateAnvilResults: jest.fn(),
+    }))
+    const newJestAnvilReporter = require('./jest-anvil-reporter')
+
+    const jestAnvilReporter = new newJestAnvilReporter(undefined, {
+      anvilTag: 'platform',
+    })
+
+    jestAnvilReporter.onRunComplete(undefined, passedTestResults)
+
+    expect(anvilMapperSpy).toHaveBeenCalledWith({
+      backtrace: null,
+      description: '1 + 1 returns 2',
+      durationInSeconds: expect.any(Number),
+      error: null,
+      fileName: expect.stringContaining(
+        '/davinci/packages/qa/src/reporters/jest-anvil-reporter-mocker.test.js'
+      ),
+      lineNumber: expect.any(Number),
+      pendingMessage: null,
+      scenarioName: 'Example test suite/1 + 1 returns 2',
+      status: 'passed',
+      tag: 'platform',
+      testType: 'unit',
+    })
+  })
+})

package/src/utils/jest-args-to-cli-converters.test.js

@@ -0,0 +1,59 @@
+const getPackageFileContentMock = jest.fn()
+
+jest.mock('@toptal/davinci-cli-shared', () => ({
+  files: {
+    getPackageFileContent: getPackageFileContentMock,
+  },
+}))
+
+const jestArgsToCLIRules = require('./jest-args-to-cli-converters')
+
+describe('jestArgsToCLIRules "reporters"', () => {
+  const reportersRule = jestArgsToCLIRules['reporters']
+
+  it('converts correctly arrays', () => {
+    expect(reportersRule(['reporter1', 'reporter2'])).toEqual([
+      'reporter1',
+      'reporter2',
+    ])
+  })
+
+  it('converts correctly string', () => {
+    expect(reportersRule('reporter1')).toEqual(['reporter1'])
+  })
+})
+
+describe('jestArgsToCLIRules "setupFilesAfterEnv"', () => {
+  const setupFilesAfterEnvRule = jestArgsToCLIRules['setupFilesAfterEnv']
+
+  it('takes default values from the davinci jest.config.js file', () => {
+    getPackageFileContentMock.mockReturnValueOnce({
+      setupFilesAfterEnv: ['davinci-setup-files'],
+    })
+
+    expect(setupFilesAfterEnvRule()).toEqual(['davinci-setup-files'])
+  })
+
+  it('merges default values with passed setup files', () => {
+    getPackageFileContentMock.mockReturnValueOnce({
+      setupFilesAfterEnv: ['davinci-setup-files'],
+    })
+
+    expect(setupFilesAfterEnvRule(['file1', 'file2'])).toEqual([
+      'davinci-setup-files',
+      'file1',
+      'file2',
+    ])
+  })
+
+  it('merges default values with single passed setup file', () => {
+    getPackageFileContentMock.mockReturnValueOnce({
+      setupFilesAfterEnv: ['davinci-setup-files'],
+    })
+
+    expect(setupFilesAfterEnvRule('file1')).toEqual([
+      'davinci-setup-files',
+      'file1',
+    ])
+  })
+})

package/src/utils/styled-components-version-check.test.js

@@ -0,0 +1,81 @@
+/* eslint jest/expect-expect: ["error", { "assertFunctionNames": ["expect", "errorTest", "successTest"] }] */
+const styledComponentsVersionCheck = require('./styled-components-version-check')
+
+const successTest = (styledComponentsVersion, dependenciesKeys) => {
+  const packageJson = {}
+
+  dependenciesKeys.forEach(dependenciesKey => {
+    packageJson[dependenciesKey] = {
+      'styled-components': styledComponentsVersion,
+    }
+  })
+
+  let error = null
+
+  try {
+    styledComponentsVersionCheck(packageJson)
+  } catch (e) {
+    error = e
+  }
+
+  expect(error).toBeNull()
+}
+
+const errorTest = (styledComponentsVersion, dependenciesKeys) => {
+  const packageJson = {}
+
+  dependenciesKeys.forEach(dependenciesKey => {
+    packageJson[dependenciesKey] = {
+      'styled-components': styledComponentsVersion,
+    }
+  })
+
+  let error = null
+
+  try {
+    styledComponentsVersionCheck(packageJson)
+  } catch (e) {
+    error = e
+  }
+
+  expect(error).not.toBeNull()
+  expect(error.message).toContain(styledComponentsVersion)
+}
+
+describe('styled-components version check', () => {
+  describe('has wrong (^4.4.1) SC version in dependencies', () => {
+    it('should throw an error', () => {
+      errorTest('^4.4.1', ['dependencies'])
+    })
+  })
+
+  describe('has correct (^5.0.1) SC version in dependencies', () => {
+    it('should NOT throw an error', () => {
+      successTest('^5.0.1', ['dependencies'])
+    })
+  })
+
+  describe('has wrong (^4.4.1) SC version in devDependencies and peerDependencies', () => {
+    it('should throw an error', () => {
+      errorTest('^4.4.1', ['devDependencies', 'peerDependencies'])
+    })
+  })
+
+  describe('has correct (^5.0.1) SC version in devDependencies and peerDependencies', () => {
+    it('should NOT throw an error', () => {
+      successTest('^5.0.1', ['devDependencies', 'peerDependencies'])
+    })
+  })
+
+  describe('has wrong (^4.4.1) SC version in devDependencies', () => {
+    it('should throw an error', () => {
+      errorTest('^4.4.1', ['devDependencies'])
+    })
+  })
+
+  describe('has correct (^5.0.1) SC version in devDependencies', () => {
+    it('should NOT throw an error', () => {
+      successTest('^5.0.1', ['devDependencies'])
+    })
+  })
+})

package/src/utils/to-jest-cli-arguments.test.js

@@ -0,0 +1,32 @@
+const toJestCLIArguments = require('./to-jest-cli-arguments')
+
+const EXAMPLE_REPORTER = 'some-jest-reporter'
+const ARGS_TO_CLI_RESULT = [EXAMPLE_REPORTER]
+
+jest.mock('./jest-args-to-cli-converters.js', () => ({
+  reporters: () => ARGS_TO_CLI_RESULT,
+}))
+
+describe('toJestCLIArguments', () => {
+  it('converts boolean strings to booleans correctly', () => {
+    expect(
+      toJestCLIArguments({
+        cache: 'false',
+        ci: 'true',
+      })
+    ).toEqual({
+      cache: false,
+      ci: true,
+    })
+  })
+
+  it('converts some rules by using args-to-cli rules', () => {
+    expect(
+      toJestCLIArguments({
+        reporters: EXAMPLE_REPORTER,
+      })
+    ).toEqual({
+      reporters: ARGS_TO_CLI_RESULT,
+    })
+  })
+})