export async function recoverTestCaseSeeds()

in apps/firelens-stability/lib/helpers/start-execution-stages.ts [31:166]
101 lines of code
1 McCabe index (conditional complexity)

export async function recoverTestCaseSeeds(executionContext: IExecutionContext):
                                           Promise<ITestCaseSeed[]> {
    const executionConfigSeed = await getStringFromFile(PathProvider.executionJson());
    const collectionConfigSeed = await getStringFromFile(Constants.paths.collectionConfig);
    const collectionsAll = await getSubFolders(Constants.paths.collections);
    const collections = collectionsAll.filter(c => executionContext.execution.executeCollections.includes(path.basename(c)));

    /* Basic managed variables */
    const managedVariablesDefaults = {
        executionId: executionContext.executionId,
        executionName: executionContext.execution.executionName,
    }

    /* Managed context variables - execution */
    const executionCollectionNames = [];
    const executionSuiteNames = [];
    const executionCaseNames = [];
    const executionCaseNamesUnique = [];

    /* Expand each test collection */
    const testCaseSeeds =
    await Promise.all(collections.map(
        
        async (c) => {
            const suites = await getSubFolders(c);
            const suiteConfigSeed = await getStringFromFile(Path.join(c, Constants.fileNames.suiteConfig));

            /* Managed context variables - collection */
            const collectionSuiteNames = [];
            const collectionCaseNames = [];
            const collectionCaseNamesUnique = [];

            /* Set collection context */
            const collectionName = Path.basename(c);
            executionCollectionNames.push(collectionName)

            /* Expand each test suite */
            const testCaseSeeds =
            await Promise.all(suites.map(async (s) => {
                const cases = await getSubFiles(Path.join(s, Constants.folderNames.cases));
                const caseConfigSeed = await getStringFromFile(Path.join(s, Constants.fileNames.caseConfig));

                /* Managed context variables - suite */
                const suiteCaseNames = [];
                const suiteCaseNamesUnique = [];

                /* Set suite context */
                const suiteName = Path.basename(s);
                executionSuiteNames.push(suiteName)
                collectionSuiteNames.push(suiteName)
                
                const testCaseSeeds =
                await Promise.all(cases.map(async (tc) => {
                    const caseSeed = await getStringFromFile(tc);

                    /* Get managed variable names for templating */
                    const caseName = Path.basename(tc).split(".")[0];
                    const caseNameUnique = `${collectionName}-${suiteName}-${caseName}`;

                    /* Determine the upload destinations for templates */
                    const s3ResourcesArn = Path.join(
                        executionContext.executionConfig.s3ArchivesArn,
                        managedVariablesDefaults.executionId,
                        collectionName,
                        suiteName,
                        caseName);

                    const {
                        s3Bucket: s3ResourcesBucket,
                        s3Path: s3ResourcesPath,
                    } = s3ArnToBucketAndPath(s3ResourcesArn);

                    /* Output execution folders */
                    const s3OutputExecutionArn = Path.join(
                        executionContext.executionConfig.s3OutputArn,
                        managedVariablesDefaults.executionId);
                    
                    const {
                        s3Bucket: s3OutputBucket,
                        s3Path: s3OutputExecutionPath,
                    } = s3ArnToBucketAndPath(s3OutputExecutionArn);

                    /* Set case context variables */
                    executionCaseNames.push(caseName)
                    collectionCaseNames.push(caseName)
                    suiteCaseNames.push(caseName)

                    executionCaseNamesUnique.push(caseNameUnique)
                    collectionCaseNamesUnique.push(caseNameUnique)
                    suiteCaseNamesUnique.push(caseNameUnique)
     
                    /* Create managed variable set */
                    const managedVariables = {
                        ...managedVariablesDefaults,
                        collectionName,
                        suiteName,
                        caseName,
                        caseNameUnique: caseNameUnique,
                        s3ResourcesArn,
                        s3ResourcesBucket,
                        s3ResourcesPath,
                        s3OutputExecutionArn,
                        s3OutputBucket,
                        s3OutputExecutionPath,

                        /* Context variables */
                        executionCollectionNames,
                        executionSuiteNames,
                        executionCaseNames,
                        executionCaseNamesUnique,
                        collectionSuiteNames,
                        collectionCaseNames,
                        collectionCaseNamesUnique,
                        suiteCaseNames,
                        suiteCaseNamesUnique,
                    }

                    /* Define the test case seed */
                    return {
                        executionConfigSeed,
                        collectionConfigSeed,
                        suiteConfigSeed,
                        caseConfigSeed,
                        caseSeed,
                        managedVariables,
                        seedDefinitions: executionContext.execution.definitions ?? {},
                        seedConfig: executionContext.execution.config ?? {} as ICaseConfig,
                    }
                }));
                return testCaseSeeds;
            }));
            return testCaseSeeds;
        }
    ));
    return testCaseSeeds.flat(10);
}