Function parseTestFiles

src/apptesting/parseTestFiles.ts:9–77

(
  dir: string,
  targetUri?: string,
  filePattern?: string,
  namePattern?: string,
)

import { fromYamlStep, YamlStep } from "../appdistribution/yaml_helper";

export async function parseTestFiles(
  dir: string,
  targetUri?: string,
  filePattern?: string,
  namePattern?: string,
): Promise<TestCaseInvocation[]> {
  if (targetUri) {
    try {
      new URL(targetUri);
    } catch (ex) {
      const errMsg =
        "Invalid URL" + (targetUri.startsWith("http") ? "" : " (must include protocol)");
      throw new FirebaseError(errMsg, { original: getError(ex) });
    }
  }

  const files = await parseTestFilesRecursive({ testDir: dir, targetUri });
  const idToInvocation = files
    .flatMap((file) => file.invocations)
    .reduce(
      (accumulator, invocation) => {
        if (invocation.testCase.id) {
          accumulator[invocation.testCase.id] = invocation;
        }
        return accumulator;
      },
      {} as Record<string, TestCaseInvocation>,
    );

  const fileFilterFn = createFilter(filePattern, "file pattern");
  const nameFilterFn = createFilter(namePattern, "test name pattern");
  const filteredInvocations = files
    .filter((file) => fileFilterFn(file.path))
    .flatMap((file) => file.invocations)
    .filter((invocation) => nameFilterFn(invocation.testCase.displayName));

  return filteredInvocations.map((invocation) => {
    let prerequisiteTestCaseId = invocation.testCase.prerequisiteTestCaseId;
    if (prerequisiteTestCaseId === undefined) {
      return invocation;
    }

    const prerequisiteSteps: TestStep[] = [];
    const previousTestCaseIds = new Set<string>();
    while (prerequisiteTestCaseId) {
      if (previousTestCaseIds.has(prerequisiteTestCaseId)) {
        throw new FirebaseError(`Detected a cycle in prerequisite test cases.`);
      }
      previousTestCaseIds.add(prerequisiteTestCaseId);
      const prerequisiteTestCaseInvocation: TestCaseInvocation | undefined =
        idToInvocation[prerequisiteTestCaseId];
      if (prerequisiteTestCaseInvocation === undefined) {
        throw new FirebaseError(
          `Invalid prerequisiteTestCaseId. There is no test case with id ${prerequisiteTestCaseId}`,
        );
      }
      prerequisiteSteps.unshift(...prerequisiteTestCaseInvocation.testCase.steps);
      prerequisiteTestCaseId = prerequisiteTestCaseInvocation.testCase.prerequisiteTestCaseId;