@molgenis/vip-report-template 6.2.0 → 7.0.1

package/src/mocks/MockApiClient.ts

@@ -1,415 +1,422 @@
-import { ApiClient, ReportData } from "@molgenis/vip-report-api/src/ApiClient";
-import { parseVcf } from "@molgenis/vip-report-vcf/src/VcfParser";
 import {
   Api,
+  ApiClient,
   AppMetadata,
   Cram,
   DecisionTree,
   HtsFileMetadata,
   Item,
+  Json,
   Metadata,
   PagedItems,
   Params,
   Phenotype,
+  ReportData,
   Sample,
-} from "@molgenis/vip-report-api/src/Api";
+} from "@molgenis/vip-report-api";
+import { parseVcf, VcfMetadata, VcfRecord } from "@molgenis/vip-report-vcf";
+import configCram from "./config_cram.json";
+import configVcf from "./config_vcf.json";
 import { samples1, samples100 } from "./static";
 import {
-  cram as cramGRCh37,
-  crai as craiGRCh37,
   decisionTree as decisionTreeGRCh37,
-  sampleTree as sampleTreeGRCh37,
-  fastaGz as fastaGzGRCh37,
-  genesGz as genesGzGRCh37,
+  fetchCrai as fetchCraiGRCh37,
+  fetchCram as fetchCramGRCh37,
+  fetchFastaGz as fetchFastaGzGRCh37,
+  fetchGenesGz as fetchGenesGzGRCh37,
+  fetchVcfFamily as fetchVcfFamilyGRCh37,
   samplesFamily as samplesFamilyGRCh37,
+  sampleTree as sampleTreeGRCh37,
   vcfMeta as vcfMetaGRCh37,
-  vcfFamily as vcfFamilyGRCh37,
-  vcfNoVep as vcfNoVepGRCh37,
-  vcfSamples0 as vcfSamples0GRCh37,
-  vcfSamples1 as vcfSamples1GRCh37,
-  vcfSamples100 as vcfSamples100GRCh37,
-  samplesFamilyDuoPlusSister as samplesFamilyDuoPlusSisterGRCh37,
 } from "./GRCh37/static";
 import {
-  cram as cramGRCh38,
-  crai as craiGRCh38,
   decisionTree as decisionTreeGRCh38,
-  fastaGz as fastaGzGRCh38,
-  genesGz as genesGzGRCh38,
+  decisionTreeStr as decisionTreeStrGRCh38,
+  fetchCrai as fetchCraiGRCh38,
+  fetchCram as fetchCramGRCh38,
+  fetchFastaGz as fetchFastaGzGRCh38,
+  fetchGenesGz as fetchGenesGzGRCh38,
+  fetchStrCrai as fetchStrCraiGRCh38,
+  fetchStrCram as fetchStrCramGRCh38,
+  fetchVcfFamily as fetchVcfFamilyGRCh38,
+  fetchVcfNoVep as fetchVcfNoVepGRCh38,
+  fetchVcfSamples0 as fetchVcfSamples0GRCh38,
+  fetchVcfSamples1 as fetchVcfSamples1GRCh38,
+  fetchVcfSamples100 as fetchVcfSamples100GRCh38,
+  fetchVcfStr as fetchVcfStrGRCh38,
   samplesFamily as samplesFamilyGRCh38,
+  samplesStr,
+  sampleTree as sampleTreeGRCh38,
   vcfMeta as vcfMetaGRCh38,
-  vcfFamily as vcfFamilyGRCh38,
-  vcfNoVep as vcfNoVepGRCh38,
-  vcfSamples0 as vcfSamples0GRCh38,
-  vcfSamples1 as vcfSamples1GRCh38,
-  vcfSamples100 as vcfSamples100GRCh38,
 } from "./GRCh38/static";
-import { Metadata as RecordMetadata, Record } from "@molgenis/vip-report-vcf/src/Vcf";
+import AsyncLock from "async-lock";
+
+const lock = new AsyncLock();
 
 /**
  * API client that uses mocked data as data source.
  */
 export class MockApiClient implements Api {
-  private apiClient: Api;
-  private readonly datasets: { [key: string]: ReportData };
+  private static dataSetIds = [
+    "GRCh37 Family",
+    "GRCh38 Family",
+    "GRCh38 Family no VEP",
+    "GRCh38 Samples 0",
+    "GRCh38 Samples 1",
+    "GRCh38 Samples 100",
+    "GRCh38 Samples 1 STR",
+  ];
+
+  private dataSetId: string;
+  private apiClient: Api | undefined;
 
   constructor() {
-    this.datasets = MockApiClient.createDatasets();
-    this.apiClient = this.createApiClient(this.getDatasetIds()[0]);
+    this.dataSetId = MockApiClient.dataSetIds[0]!;
   }
 
-  getFastaGz(contig: string, pos: number): Promise<Uint8Array | null> {
-    return this.apiClient.getFastaGz(contig, pos);
+  async getConfig(): Promise<Json | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getConfig();
   }
 
-  getGenesGz(): Promise<Uint8Array | null> {
-    return this.apiClient.getGenesGz();
+  async getFastaGz(contig: string, pos: number): Promise<Uint8Array | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getFastaGz(contig, pos);
   }
 
-  getCram(sampleId: string): Promise<Cram | null> {
-    return this.apiClient.getCram(sampleId);
+  async getGenesGz(): Promise<Uint8Array | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getGenesGz();
   }
 
-  getDecisionTree(): Promise<DecisionTree | null> {
-    return this.apiClient.getDecisionTree();
+  async getCram(sampleId: string): Promise<Cram | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getCram(sampleId);
   }
 
-  getSampleTree(): Promise<DecisionTree | null> {
-    return this.apiClient.getSampleTree();
+  async getDecisionTree(): Promise<DecisionTree | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getDecisionTree();
   }
 
-  getHtsFileMetadata(): Promise<HtsFileMetadata> {
-    return this.apiClient.getHtsFileMetadata();
+  async getSampleTree(): Promise<DecisionTree | null> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getSampleTree();
   }
 
-  getAppMetadata(): Promise<AppMetadata> {
-    return this.apiClient.getAppMetadata();
+  async getHtsFileMetadata(): Promise<HtsFileMetadata> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getHtsFileMetadata();
   }
 
-  getPhenotypes(params: Params): Promise<PagedItems<Phenotype>> {
-    return this.apiClient.getPhenotypes(params);
+  async getAppMetadata(): Promise<AppMetadata> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getAppMetadata();
   }
 
-  getRecordById(id: number): Promise<Item<Record>> {
-    return this.apiClient.getRecordById(id);
+  async getPhenotypes(params: Params): Promise<PagedItems<Phenotype>> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getPhenotypes(params);
   }
 
-  getRecords(params: Params): Promise<PagedItems<Record>> {
-    return this.apiClient.getRecords(params);
+  async getRecordById(id: number): Promise<Item<VcfRecord>> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getRecordById(id);
   }
 
-  getRecordsMeta(): Promise<RecordMetadata> {
-    return this.apiClient.getRecordsMeta();
+  async getRecords(params: Params): Promise<PagedItems<VcfRecord>> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getRecords(params);
   }
 
-  getSampleById(id: number): Promise<Item<Sample>> {
-    return this.apiClient.getSampleById(id);
+  async getRecordsMeta(): Promise<VcfMetadata> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getRecordsMeta();
   }
 
-  getSamples(params: Params): Promise<PagedItems<Sample>> {
-    return this.apiClient.getSamples(params);
+  async getSampleById(id: number): Promise<Item<Sample>> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getSampleById(id);
   }
 
-  isDatasetSupport(): boolean {
-    return true;
+  async getSamples(params: Params): Promise<PagedItems<Sample>> {
+    const apiClient = await this.getApiClient();
+    return apiClient.getSamples(params);
   }
 
   getDatasetIds(): string[] {
-    return Object.keys(this.datasets);
+    return MockApiClient.dataSetIds;
   }
 
   selectDataset(id: string): void {
-    this.apiClient = this.createApiClient(id);
+    this.dataSetId = id;
+    this.apiClient = undefined;
   }
 
-  private static createDatasets() {
-    const mockReportData: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b37_vip.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "/path/to/testdata_b37_vip.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh37",
-        },
-      } as Metadata,
-      data: samplesFamilyGRCh37,
-      binary: {
-        vcf: vcfFamilyGRCh37,
-        fastaGz: fastaGzGRCh37,
-        genesGz: genesGzGRCh37,
-        cram: {
-          Patient: {
-            cram: cramGRCh37,
-            crai: craiGRCh37,
-          },
-        },
+  private async getApiClient(): Promise<Api> {
+    if (this.apiClient === undefined) {
+      await lock.acquire("apiClient", async () => {
+        if (this.apiClient === undefined) {
+          this.apiClient = await createApiClient(this.dataSetId);
+        }
+      });
+    }
+
+    if (this.apiClient === undefined) throw new Error();
+    return this.apiClient;
+  }
+}
+
+async function createApiClient(id: string): Promise<Api> {
+  let reportData: ReportData;
+  switch (id) {
+    case "GRCh37 Family":
+      reportData = await fetchReportDataGRCh37Family();
+      break;
+    case "GRCh38 Family":
+      reportData = await fetchReportDataGRCh38Family();
+      break;
+    case "GRCh38 Family no VEP":
+      reportData = await fetchReportDataGRCh38FamilyNoVep();
+      break;
+    case "GRCh38 Samples 0":
+      reportData = await fetchReportDataGRCh38NoSample();
+      break;
+    case "GRCh38 Samples 1":
+      reportData = await fetchReportDataGRCh38Data1Sample();
+      break;
+    case "GRCh38 Samples 100":
+      reportData = await fetchReportDataGRCh38Data100Samples();
+      break;
+    case "GRCh38 Samples 1 STR":
+      reportData = await fetchReportDataGRCh38Str();
+      break;
+    default:
+      throw new Error(`unknown dataset id '${id}'`);
+  }
+
+  const vcf = parseVcf(new TextDecoder().decode(reportData.binary.vcf), reportData.vcfMeta);
+  reportData.metadata.records = vcf.metadata;
+  reportData.data.records = vcf.data;
+
+  return new ApiClient(reportData);
+}
+
+async function fetchReportDataGRCh37Family(): Promise<ReportData> {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b37_vip.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
       },
-      decisionTree: decisionTreeGRCh37,
-      sampleTree: sampleTreeGRCh37,
-      vcfMeta: vcfMetaGRCh37,
-    };
-
-    const mockReportDataNoVep: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b37.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b37.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh37",
-        },
-      } as Metadata,
-      data: samplesFamilyDuoPlusSisterGRCh37,
-      binary: {
-        vcf: vcfNoVepGRCh37,
-        fastaGz: fastaGzGRCh37,
-        genesGz: genesGzGRCh37,
-        cram: {
-          Patient: {
-            cram: cramGRCh37,
-            crai: craiGRCh37,
-          },
-        },
+      htsFile: {
+        uri: "/path/to/testdata_b37_vip.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh37",
       },
-      decisionTree: decisionTreeGRCh37,
-      vcfMeta: vcfMetaGRCh37,
-    };
-
-    const mockReportData1Sample: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b37_1Sample.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b37_1Sample.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh37",
-        },
-      } as Metadata,
-      data: samples1,
-      binary: {
-        vcf: vcfSamples1GRCh37,
-        fastaGz: fastaGzGRCh37,
-        genesGz: genesGzGRCh37,
-        cram: {
-          SAMPLE1: {
-            cram: cramGRCh37,
-            crai: craiGRCh37,
-          },
+    } as Metadata,
+    data: samplesFamilyGRCh37,
+    binary: {
+      vcf: await fetchVcfFamilyGRCh37(),
+      fastaGz: await fetchFastaGzGRCh37(),
+      genesGz: await fetchGenesGzGRCh37(),
+      cram: {
+        Patient: {
+          cram: await fetchCramGRCh37(),
+          crai: await fetchCraiGRCh37(),
         },
       },
-      decisionTree: decisionTreeGRCh37,
-      vcfMeta: vcfMetaGRCh37,
-    };
-
-    const mockReportData100Samples: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b37_100Samples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b37_100Samples.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh37",
-        },
-      } as Metadata,
-      data: samples100,
-      binary: {
-        vcf: vcfSamples100GRCh37,
-        fastaGz: fastaGzGRCh37,
-        genesGz: genesGzGRCh37,
+    },
+    decisionTree: decisionTreeGRCh37,
+    sampleTree: sampleTreeGRCh37,
+    vcfMeta: vcfMetaGRCh37,
+  };
+}
+
+async function fetchReportDataGRCh38Family(): Promise<ReportData> {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38_vip.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
       },
-      decisionTree: decisionTreeGRCh37,
-      vcfMeta: vcfMetaGRCh37,
-    };
-
-    const mockReportDataNoSample: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b37_1NoSamples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b37_NoSamples.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh37",
-        },
-      } as Metadata,
-      data: { samples: [], phenotypes: [] },
-      binary: {
-        vcf: vcfSamples0GRCh37,
-        fastaGz: fastaGzGRCh37,
-        genesGz: genesGzGRCh37,
+      htsFile: {
+        uri: "testdata_b38_vip.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
       },
-      decisionTree: decisionTreeGRCh37,
-      vcfMeta: vcfMetaGRCh37,
-    };
-
-    const mockReportDataFamilyGRCh38: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b38_vip.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b38_vip.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh38",
-        },
-      } as Metadata,
-      data: samplesFamilyGRCh38,
-      binary: {
-        vcf: vcfFamilyGRCh38,
-        fastaGz: fastaGzGRCh38,
-        genesGz: genesGzGRCh38,
-        cram: {
-          Patient: {
-            cram: cramGRCh38,
-            crai: craiGRCh38,
-          },
+    } as Metadata,
+    data: samplesFamilyGRCh38,
+    binary: {
+      vcf: await fetchVcfFamilyGRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+      cram: {
+        Patient: {
+          cram: await fetchCramGRCh38(),
+          crai: await fetchCraiGRCh38(),
         },
       },
-      decisionTree: decisionTreeGRCh38,
-      vcfMeta: vcfMetaGRCh38,
-    };
-
-    const mockReportDataNoVepGRCh38: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b38.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b38.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh38",
-        },
-      } as Metadata,
-      data: samplesFamilyGRCh38,
-      binary: {
-        vcf: vcfNoVepGRCh38,
-        fastaGz: fastaGzGRCh38,
-        genesGz: genesGzGRCh38,
-        cram: {
-          Patient: {
-            cram: cramGRCh38,
-            crai: craiGRCh38,
-          },
-        },
+    },
+    decisionTree: decisionTreeGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
+}
+
+async function fetchReportDataGRCh38FamilyNoVep() {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
       },
-      decisionTree: decisionTreeGRCh38,
-      vcfMeta: vcfMetaGRCh38,
-    };
-
-    const mockReportData1SampleGRCh38: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b38_1Sample.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b38_1Sample.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh38",
-        },
-      } as Metadata,
-      data: samples1,
-      binary: {
-        vcf: vcfSamples1GRCh38,
-        fastaGz: fastaGzGRCh38,
-        genesGz: genesGzGRCh38,
-        cram: {
-          SAMPLE1: {
-            cram: cramGRCh38,
-            crai: craiGRCh38,
-          },
-        },
+      htsFile: {
+        uri: "testdata_b38.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
       },
-      decisionTree: decisionTreeGRCh38,
-      vcfMeta: vcfMetaGRCh38,
-    };
-
-    const mockReportData100SamplesGRCh38: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b38_100Samples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b38_100Samples.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh38",
+    } as Metadata,
+    data: samplesFamilyGRCh38,
+    binary: {
+      vcf: await fetchVcfNoVepGRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+      cram: {
+        Patient: {
+          cram: await fetchCramGRCh38(),
+          crai: await fetchCraiGRCh38(),
         },
-      } as Metadata,
-      data: samples100,
-      binary: {
-        vcf: vcfSamples100GRCh38,
-        fastaGz: fastaGzGRCh38,
-        genesGz: genesGzGRCh38,
       },
-      decisionTree: decisionTreeGRCh38,
-      vcfMeta: vcfMetaGRCh38,
-    };
-
-    const mockReportDataNoSampleGRCh38: ReportData = {
-      metadata: {
-        app: {
-          name: "vcf-report",
-          version: "0.0.8",
-          args: "-i testdata_b38_1NoSamples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
-        },
-        htsFile: {
-          uri: "testdata_b38_NoSamples.vcf",
-          htsFormat: "VCF",
-          genomeAssembly: "GRCh38",
+    },
+    decisionTree: decisionTreeGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
+}
+
+async function fetchReportDataGRCh38Data1Sample(): Promise<ReportData> {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38_1Sample.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
+      },
+      htsFile: {
+        uri: "testdata_b38_1Sample.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
+      },
+    } as Metadata,
+    data: samples1,
+    binary: {
+      vcf: await fetchVcfSamples1GRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+      cram: {
+        SAMPLE1: {
+          cram: await fetchCramGRCh38(),
+          crai: await fetchCraiGRCh38(),
         },
-      } as Metadata,
-      data: { samples: [], phenotypes: [] },
-      binary: {
-        vcf: vcfSamples0GRCh38,
-        fastaGz: fastaGzGRCh38,
-        genesGz: genesGzGRCh38,
       },
-      decisionTree: decisionTreeGRCh38,
-      vcfMeta: vcfMetaGRCh38,
-    };
-
-    const datasets: { [key: string]: ReportData } = {};
-    datasets["GRCh37 Family"] = mockReportData;
-    datasets["GRCh37 Family no VEP"] = mockReportDataNoVep;
-    datasets["GRCh37 Samples 0"] = mockReportDataNoSample;
-    datasets["GRCh37 Samples 1"] = mockReportData1Sample;
-    datasets["GRCh37 Samples 100"] = mockReportData100Samples;
-    datasets["GRCh38 Family"] = mockReportDataFamilyGRCh38;
-    datasets["GRCh38 Family no VEP"] = mockReportDataNoVepGRCh38;
-    datasets["GRCh38 Samples 0"] = mockReportDataNoSampleGRCh38;
-    datasets["GRCh38 Samples 1"] = mockReportData1SampleGRCh38;
-    datasets["GRCh38 Samples 100"] = mockReportData100SamplesGRCh38;
-    return datasets;
-  }
+    },
+    decisionTree: decisionTreeGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
+}
 
-  private createApiClient(id: string): Api {
-    const reportData = this.datasets[id];
-    const vcf = parseVcf(new TextDecoder().decode(reportData.binary.vcf), reportData.vcfMeta);
-    reportData.metadata.records = vcf.metadata;
-    reportData.data.records = vcf.data;
+async function fetchReportDataGRCh38Data100Samples(): Promise<ReportData> {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38_100Samples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
+      },
+      htsFile: {
+        uri: "testdata_b38_100Samples.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
+      },
+    } as Metadata,
+    data: samples100,
+    binary: {
+      vcf: await fetchVcfSamples100GRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+    },
+    decisionTree: decisionTreeGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
+}
 
-    return new ApiClient(reportData);
-  }
+async function fetchReportDataGRCh38Str(): Promise<ReportData> {
+  return {
+    config: configCram as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38_100Samples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
+      },
+      htsFile: {
+        uri: "testdata_b38_100Samples.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
+      },
+    } as Metadata,
+    data: samplesStr,
+    binary: {
+      vcf: await fetchVcfStrGRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+      cram: {
+        Patient: {
+          cram: await fetchStrCramGRCh38(),
+          crai: await fetchStrCraiGRCh38(),
+        },
+      },
+    },
+    decisionTree: decisionTreeStrGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
+}
+
+async function fetchReportDataGRCh38NoSample(): Promise<ReportData> {
+  return {
+    config: configVcf as unknown as Json,
+    metadata: {
+      app: {
+        name: "vcf-report",
+        version: "0.0.8",
+        args: "-i testdata_b38_1NoSamples.vcf -t /Users/user/vip-report-template/dist/vip-report-template.html -f",
+      },
+      htsFile: {
+        uri: "testdata_b38_NoSamples.vcf",
+        htsFormat: "VCF",
+        genomeAssembly: "GRCh38",
+      },
+    } as Metadata,
+    data: { samples: [], phenotypes: [] },
+    binary: {
+      vcf: await fetchVcfSamples0GRCh38(),
+      fastaGz: await fetchFastaGzGRCh38(),
+      genesGz: await fetchGenesGzGRCh38(),
+    },
+    decisionTree: decisionTreeGRCh38,
+    sampleTree: sampleTreeGRCh38,
+    vcfMeta: vcfMetaGRCh38,
+  };
 }