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, config: QuadSerializationConfiguration) => string);
      };
      processor: ((_results: unknown, input: Partial<ParseRequiredInput>) => Promise<ParseStepOutput>);
      requiredInput: ParseRequiredInput;
  } | {
      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<ParentInformation, RNode<ParentInformation>>) => string);
          3: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>) => string);
          4: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>) => string);
          5: ((ast: NormalizedAst<ParentInformation, RNode<ParentInformation>>, config: QuadSerializationConfiguration) => string);
      };
      processor: ((results: {
          parse?: ParseStepOutput;
      }, 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: {
          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)