Function createSuite

packages/runner/src/suite.ts:584–742

()

}

function createSuite() {
  function suiteFn(
    this: Record<string, boolean | undefined>,
    name: string | Function,
    factoryOrOptions?: SuiteFactory | SuiteOptions,
    optionsOrFactory?: number | SuiteFactory,
  ) {
    if (getCurrentTest()) {
      throw new Error(
        'Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.',
      )
    }

    const currentSuite: SuiteCollector | undefined = collectorContext.currentSuite || defaultSuite

    let { options, handler: factory } = parseArguments(
      factoryOrOptions,
      optionsOrFactory,
    ) as { options: SuiteOptions; handler: SuiteFactory | undefined }

    const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false
    const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false

    const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {}
    // inherit options from current suite
    options = {
      ...parentOptions,
      ...options,
    }

    const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle
    if (shuffle != null) {
      options.shuffle = shuffle
    }

    let mode: RunMode = (this.only ?? options.only)
      ? 'only'
      : (this.skip ?? options.skip)
          ? 'skip'
          : (this.todo ?? options.todo)
              ? 'todo'
              : 'run'

    // passed as test(name), assume it's a "todo"
    if (mode === 'run' && !factory) {
      mode = 'todo'
    }

    // inherit concurrent / sequential from suite
    const isConcurrent = isConcurrentSpecified || (options.concurrent && !isSequentialSpecified)
    const isSequential = isSequentialSpecified || (options.sequential && !isConcurrentSpecified)
    if (isConcurrent != null) {
      options.concurrent = isConcurrent && !isSequential
    }
    if (isSequential != null) {
      options.sequential = isSequential && !isConcurrent
    }