import path from 'node:path'
import { describe, test, expect, vi, afterAll } from 'vitest'
import { wrapGlobalTestMethod } from '@wdio/utils'
import { loadModule, formatMessage, setupEnv, requireExternalModules } from '../src/common.js'
declare global {
var foo: string | undefined
}
vi.mock('randomModule', () => import(path.join(process.cwd(), '__mocks__', 'randomModule')))
vi.mock('@wdio/utils')
describe('formatMessage', () => {
test('should do nothing if no error or params are given', () => {
const params = { type: 'foobar' }
const message = formatMessage(params as any)
expect(message).toMatchSnapshot()
})
test('should format an error message', () => {
const params = { type: 'foobar', err: new Error('uups') }
const message = formatMessage(params as any)
delete message.error.stack
expect(message).toMatchSnapshot()
})
test('should format an error message with timeout error', () => {
const params = {
type: 'foobar',
payload: {
title: 'barfoo',
parent: { title: 'parentfoo' }
},
err: new Error('For async tests and hooks, ensure "done()" is called; if returning a Promise, ensure it resolves.')
}
const message = formatMessage(params as any)
delete message.error.stack
expect(message).toMatchSnapshot()
})
test('should format payload', () => {
const params = { type: 'foobar', payload: {
title: 'barfoo',
parent: { title: 'parentfoo' },
context: 'some context',
ctx: { currentTest: { title: 'current test' } },
file: '/foo/bar.test.js'
} }
const message = formatMessage(params as any)
expect(message).toMatchSnapshot()
})
test('should format parent title', () => {
const params = { type: 'foobar', payload: {
title: 'barfoo',
parent: { title: '', suites: [{ title: 'first suite' }] }
} }
const message = formatMessage(params as any)
expect(message.parent).toEqual('')
})
test('should format fullTitle', () => {
const params = { type: 'foobar', payload: {
title: 'barfoo',
parent: {
title: 'Parent 2',
parent: {
title: 'Parent 1'
}
}
} }
const message = formatMessage(params as any)
expect(message.fullTitle).toEqual('Parent 1.Parent 2.barfoo')
})
test('should format test status', () => {
const params = { type: 'afterTest', payload: {
title: 'barfoo',
parent: {},
state: 'failed',
duration: 123
} }
const message = formatMessage(params as any)
expect(message.passed).toBe(false)
expect(message.duration).toBe(123)
})
test('should format title for mocha beforeAll hook if parent title is present', () => {
const params = { type: 'beforeAll', payload: {
title: '"before all" hook',
parent: {
title: 'WebdriverIO'
},
state: 'failed',
duration: 123
} }
const message = formatMessage(params as any)
expect(message.title).toBe('"before all" hook for WebdriverIO')
})
test('should not format title for mocha beforeAll hook if parent title is not present', () => {
const params = { type: 'beforeAll', payload: {
title: '"before all" hook',
parent: {},
state: 'failed',
duration: 123
} }
const message = formatMessage(params as any)
expect(message.title).toBe('"before all" hook')
})
test('should format title for mocha afterAll hook if parent title is present', () => {
const params = { type: 'afterAll', payload: {
title: '"after all" hook',
parent: {
title: 'WebdriverIO'
},
state: 'failed',
duration: 123
} }
const message = formatMessage(params as any)
expect(message.title).toBe('"after all" hook for WebdriverIO')
})
test('should not format title for mocha afterAll hook if parent title is not present', () => {
const params = { type: 'afterAll', payload: {
title: '"after all" hook',
parent: {},
state: 'failed',
duration: 123
} }
const message = formatMessage(params as any)
expect(message.title).toBe('"after all" hook')
})
})
describe('loadModule', () => {
test('loadModule with existing package', async () => {
await loadModule('randomModule')
expect(global.foo).toBe('bar')
})
test('loadModule with non existing package', async () => {
await expect(() => loadModule('nonExistingModule'))
.rejects.toThrow('Module nonExistingModule can\'t get loaded')
})
})
test('requireExternalModules', () => {
const loader = vi.fn()
requireExternalModules(['/foo/bar.js', null, './bar/foo.js'], loader)
expect(loader).toBeCalledTimes(2)
})
describe('setupEnv', () => {
test('setupEnv - TDD', () => {
const hooks = {
beforeHook: 'beforeHook123' as any,
afterHook: 'afterHook123' as any,
beforeTest: 'beforeTest234' as any,
afterTest: 'afterTest234' as any
}
const mochaOpts = { foo: 'bar', ui: 'tdd' as const }
setupEnv('0-2', mochaOpts, hooks.beforeTest, hooks.beforeHook, hooks.afterTest, hooks.afterHook)
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'suiteSetup', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'setup', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
true, 'beforeTest234', expect.any(Function), 'afterTest234', expect.any(Function), 'test', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'suiteTeardown', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'teardown', '0-2')
const hookArgsFn = vi.mocked(wrapGlobalTestMethod).mock.calls[0][2]
expect(hookArgsFn({ test: { foo: 'bar', parent: { title: 'parent' } } }))
.toEqual([{ foo: 'bar', parent: 'parent' }, { test: { foo: 'bar', parent: { title: 'parent' } } }])
})
test('setupEnv - BDD', () => {
const hooks = {
beforeHook: 'beforeHook123' as any,
afterHook: 'afterHook123' as any,
beforeTest: 'beforeTest234' as any,
afterTest: 'afterTest234' as any
}
const mochaOpts = { foo: 'bar', ui: 'bdd' as const }
setupEnv('0-2', mochaOpts, hooks.beforeTest, hooks.beforeHook, hooks.afterTest, hooks.afterHook)
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'before', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'beforeEach', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
true, 'beforeTest234', expect.any(Function), 'afterTest234', expect.any(Function), 'it', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
true, 'beforeTest234', expect.any(Function), 'afterTest234', expect.any(Function), 'specify', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'after', '0-2')
expect(wrapGlobalTestMethod).toBeCalledWith(
false, 'beforeHook123', expect.any(Function), 'afterHook123', expect.any(Function), 'afterEach', '0-2')
const hookArgsFn = vi.mocked(wrapGlobalTestMethod).mock.calls[0][2]
expect(hookArgsFn({ test: { foo: 'bar', parent: { title: 'parent' } } }))
.toEqual([{ foo: 'bar', parent: 'parent' }, { test: { foo: 'bar', parent: { title: 'parent' } } }])
})
})
afterAll(() => {
delete global.foo
})
