Function assertQuery

Parameters

• name: string | TestLabel

  Name of the test case to generate
• shell: RShell

  R Shell Session to use
• code: string

  R code to execute the query on
• queries: readonly (
      | Queries
      | VirtualQueryArgumentsWithType<Queries["type"], VirtualArguments>
  )[]

  Queries to execute
• expected:
      | OmitFromValues<Omit<QueryResults<Queries["type"]>, ".meta">, ".meta">
      | (
          info: PipelineOutput<
              Pipeline<
                  | {
                      dependencies: readonly [];
                      description: "Parse the given R code into an AST";
                      executed: OncePerFile;
                      humanReadableName: "parse with R shell";
                      name: "parse";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": {
                              (
                                  value: any,
                                  replacer?: (this: any, key: string, value: any) => any,
                                  space?: string | number,
                              ): string;
                              (
                                  value: any,
                                  replacer?: null | ((...) | (...))[],
                                  space?: string | number,
                              ): string;
                          };
                          "5": (
                              __namedParameters: ParseStepOutput<string>,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          _results: unknown,
                          input: Partial<ParseRequiredInput<string>>,
                      ) => Promise<ParseStepOutput<string>>;
                      requiredInput: ParseRequiredInput<string>;
                  }
                  | {
                      dependencies: readonly ["parse"];
                      description: "Normalize the AST to flowR's AST";
                      executed: OncePerFile;
                      humanReadableName: "normalize";
                      name: "normalize";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (ast: NormalizedAst) => string;
                          "3": (ast: NormalizedAst) => string;
                          "4": (ast: NormalizedAst) => string;
                          "5": (
                              ast: NormalizedAst,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: { parse?: ParseStepOutput<string> },
                          input: Partial<NormalizeRequiredInput>,
                      ) => NormalizedAst<ParentInformation, RNode<ParentInformation>>;
                      requiredInput: NormalizeRequiredInput;
                  }
                  | {
                      dependencies: readonly ["normalize"];
                      description: "Construct the dataflow graph";
                      executed: OncePerFile;
                      humanReadableName: "dataflow";
                      name: "dataflow";
                      printer: {
                          "0": <Input>(input: Input) => Input;
                          "2": (df: DataflowInformation) => string;
                          "3": (df: DataflowInformation) => string;
                          "4": (df: DataflowInformation) => string;
                          "5": (
                              df: DataflowInformation,
                              config: QuadSerializationConfiguration,
                          ) => string;
                      };
                      processor: (
                          results: {
                              normalize?: NormalizedAst<ParentInformation, RNode<(...)>>;
                          },
                          input: { parser?: Parser<KnownParserType>; request?: RParseRequests },
                      ) => DataflowInformation;
                      requiredInput: {};
                  },
              >,
          >,
      ) => | OmitFromValues<
          Omit<QueryResults<Queries["type"]>, ".meta">,
          ".meta",
      >
      | Promise<
          OmitFromValues<Omit<QueryResults<Queries["type"]>, ".meta">, ".meta">,
      >

  Expected result of the queries (without attached meta-information like timing)