import type { Services, Capabilities } from '@wdio/types'
import logger from '@wdio/logger'
import initializePlugin from './initializePlugin.js'
const log = logger('@wdio/utils:initializeServices')
type IntialisedService = (
[Services.ServiceClass | { default: Function }, WebdriverIO.ServiceOption, string] |
[Services.HookFunctions, Record<string, unknown>] |
[Services.ServiceClass, WebdriverIO.ServiceOption]
)
type Service = Services.ServiceEntry | Services.ServiceClass
type ServiceWithOptions = [Service, WebdriverIO.ServiceOption]
* Maps list of services of a config file into a list of actionable objects
* @param {Object} config config of running session
* @param {Object} caps capabilities of running session
* @return {[(Object|Class), Object][]} list of services with their config objects
*/
async function initializeServices (services: ServiceWithOptions[]): Promise<IntialisedService[]> {
const initializedServices: IntialisedService[] = []
for (const [serviceName, serviceConfig = {}] of services) {
* allow custom services that are already initialized, e.g.
*
* ```
* services: [
* [{ beforeTest: () => { ... } }]
* ]
* ```
*/
if (typeof serviceName === 'object') {
log.debug('initialize custom initiated service')
initializedServices.push([serviceName as Services.HookFunctions, {}])
continue
}
* allow custom service classes, e.g.
*
* ```
* class MyService { ... }
* ```
*
* in wdio.conf.js:
*
* ```
* services: [MyService]
* ```
*/
if (typeof serviceName === 'function') {
log.debug(`initialize custom service "${serviceName.name}"`)
initializedServices.push([serviceName as Services.ServiceClass, serviceConfig])
continue
}
* services as NPM packages
*
* ```
* services: ['@wdio/lighthouse-service']
* ```
*/
log.debug(`initialize service "${serviceName}" as NPM package`)
const service = await initializePlugin(serviceName, 'service')
initializedServices.push([service as Services.ServiceClass, serviceConfig, serviceName])
}
return initializedServices
}
* formats service array into proper structure which is an array with
* the service object as first parameter and the service option as
* second parameter
* @param {[Any]} service list of services from config file
* @return {[service, serviceConfig][]} formatted list of services
*/
function sanitizeServiceArray (service: Services.ServiceEntry): ServiceWithOptions {
return Array.isArray(service) ? service : [service, {}]
}
* initialize service for launcher process
* @param {Object} config wdio config
* @param {Object[]} caps list of capabilities
* @return {Object} containing a list of launcher services as well
* as a list of services that don't need to be
* required in the worker
*/
export async function initializeLauncherService (
config: Omit<WebdriverIO.Config, 'capabilities' | keyof Services.HookFunctions>,
caps: Capabilities.TestrunnerCapabilities
): Promise<{
ignoredWorkerServices: string[];
launcherServices: Services.ServiceInstance[];
}> {
const ignoredWorkerServices = []
const launcherServices: Services.ServiceInstance[] = []
let serviceLabelToBeInitialised = 'unknown'
try {
const services = await initializeServices(config.services!.map(sanitizeServiceArray))
for (const [service, serviceConfig, serviceName] of services) {
* add custom services as object or function
*/
if (typeof service === 'object' && !serviceName) {
serviceLabelToBeInitialised = 'object'
launcherServices.push(service as object)
continue
}
* add class service from imported package
*/
const Launcher = (service as Services.ServicePlugin).launcher
if (typeof Launcher === 'function' && serviceName) {
serviceLabelToBeInitialised = `"${serviceName}"`
launcherServices.push(new Launcher(serviceConfig, caps as Capabilities.ResolvedTestrunnerCapabilities, config))
}
* add class service from passed in class
*/
if (typeof service === 'function' && !serviceName) {
serviceLabelToBeInitialised = `"${service.constructor?.name || service.toString()}"`
launcherServices.push(new service(serviceConfig, caps as Capabilities.ResolvedTestrunnerCapabilities, config))
}
* check if service has a default export, if not we can later filter it out so the
* service module is not even loaded in the worker process
*/
if (
serviceName &&
typeof (service as { default: Function }).default !== 'function' &&
typeof service !== 'function'
) {
ignoredWorkerServices.push(serviceName)
}
}
} catch (err) {
throw new Error(`Failed to initialise launcher service ${serviceLabelToBeInitialised}: ${(err as Error).stack}`)
}
return { ignoredWorkerServices, launcherServices }
}
* initialize services for worker instance
* @param {Object} config wdio config
* @param {Object} caps worker capabilities
* @param {object} ignoredWorkerServices list of services that don't need to be required in a worker
* as they don't export a service for it
* @return {Object[]} list if worker initiated worker services
*/
export async function initializeWorkerService (
config: WebdriverIO.Config,
caps: WebdriverIO.Capabilities,
ignoredWorkerServices: string[] = []
): Promise<Services.ServiceInstance[]> {
let serviceLabelToBeInitialised = 'unknown'
const initializedServices: Services.ServiceInstance[] = []
const workerServices = config.services!
.map(sanitizeServiceArray)
.filter(([serviceName]) => !ignoredWorkerServices.includes(serviceName as string))
try {
const services = await initializeServices(workerServices)
for (const [service, serviceConfig, serviceName] of services) {
* add object service
*/
if (typeof service === 'object' && !serviceName) {
serviceLabelToBeInitialised = 'object'
initializedServices.push(service as Services.ServiceInstance)
continue
}
const Service = (service as Services.ServicePlugin).default || service as Services.ServiceClass
if (typeof Service === 'function') {
serviceLabelToBeInitialised = serviceName || Service.constructor?.name || Service.toString()
initializedServices.push(new Service(serviceConfig, caps, config))
continue
}
}
return initializedServices
} catch (err) {
throw new Error(`Failed to initialise service ${serviceLabelToBeInitialised}: ${(err as Error).stack}`)
}
}
