export async function expandTestPreset()

in src/preset.ts [1281:1371]
82 lines of code
21 McCabe index (conditional complexity)

export async function expandTestPreset(folder: string,
    name: string,
    workspaceFolder: string,
    sourceDir: string,
    preferredGeneratorName: string | undefined,
    allowUserPreset: boolean = false,
    configurePreset?: string): Promise<TestPreset | null> {
    const refs = referencedTestPresets.get(folder);
    if (!refs) {
        referencedTestPresets.set(folder, new Set());
    } else {
        refs.clear();
    }

    const preset = await expandTestPresetImpl(folder, name, workspaceFolder, sourceDir, preferredGeneratorName, allowUserPreset, configurePreset);
    if (!preset) {
        return null;
    }

    const expandedPreset: TestPreset = { name };
    const expansionOpts: ExpansionOptions = await getExpansionOptions(folder, workspaceFolder, sourceDir, preset);

    // Expand environment vars first since other fields may refer to them
    if (preset.environment) {
        expandedPreset.environment = EnvironmentUtils.createPreserveNull();
        for (const key in preset.environment) {
            if (preset.environment[key]) {
                expandedPreset.environment[key] = await expandString(preset.environment[key]!, expansionOpts);
            }
        }
    }

    expansionOpts.envOverride = expandedPreset.environment;

    // Expand other fields
    if (preset.overwriteConfigurationFile) {
        expandedPreset.overwriteConfigurationFile = [];
        for (let index = 0; index < preset.overwriteConfigurationFile.length; index++) {
            expandedPreset.overwriteConfigurationFile[index] = await expandString(preset.overwriteConfigurationFile[index], expansionOpts);
        }
    }
    if (preset.output?.outputLogFile) {
        expandedPreset.output = { outputLogFile: util.lightNormalizePath(await expandString(preset.output.outputLogFile, expansionOpts)) };
        merge(expandedPreset.output, preset.output);
    }
    if (preset.filter) {
        expandedPreset.filter = {};
        if (preset.filter.include) {
            expandedPreset.filter.include = {};
            if (preset.filter.include.name) {
                expandedPreset.filter.include.name = await expandString(preset.filter.include.name, expansionOpts);
            }
            if (util.isString(preset.filter.include.index)) {
                expandedPreset.filter.include.index = await expandString(preset.filter.include.index, expansionOpts);
            }
            merge(expandedPreset.filter.include, preset.filter.include);
        }
        if (preset.filter.exclude) {
            expandedPreset.filter.exclude = {};
            if (preset.filter.exclude.label) {
                expandedPreset.filter.exclude.label = await expandString(preset.filter.exclude.label, expansionOpts);
            }
            if (preset.filter.exclude.name) {
                expandedPreset.filter.exclude.name = await expandString(preset.filter.exclude.name, expansionOpts);
            }
            if (preset.filter.exclude.fixtures) {
                expandedPreset.filter.exclude.fixtures = {};
                if (preset.filter.exclude.fixtures.any) {
                    expandedPreset.filter.exclude.fixtures.any = await expandString(preset.filter.exclude.fixtures.any, expansionOpts);
                }
                if (preset.filter.exclude.fixtures.setup) {
                    expandedPreset.filter.exclude.fixtures.setup = await expandString(preset.filter.exclude.fixtures.setup, expansionOpts);
                }
                if (preset.filter.exclude.fixtures.cleanup) {
                    expandedPreset.filter.exclude.fixtures.cleanup = await expandString(preset.filter.exclude.fixtures.cleanup, expansionOpts);
                }
                merge(expandedPreset.filter.exclude.fixtures, preset.filter.exclude.fixtures);
            }
            merge(expandedPreset.filter.exclude, preset.filter.exclude);
        }
        merge(expandedPreset.filter, preset.filter);
    }
    if (preset.execution?.resourceSpecFile) {
        expandedPreset.execution = { resourceSpecFile: util.lightNormalizePath(await expandString(preset.execution.resourceSpecFile, expansionOpts)) };
        merge(expandedPreset.execution, preset.execution);
    }

    merge(expandedPreset, preset);

    return expandedPreset;
}