Make update backward compatible

Author: RubenEschauzier

bin/sparql-benchmark-runner.ts

@@ -110,7 +110,7 @@ async function main(): Promise<void> {
     invalidateCacheBetweenSetExecutions: args.invalidateCacheAfterQuerySet,
   });
 
-  const results: IRunResult = await runner.run();
+  const results: IRunResult = await runner.runWithRawResults();
   await serializeResults(args.output, results.aggregateResults);
   const outputRaw = args.outputRaw ?? (args.metadata ? resolve('./output-raw.json') : undefined);
   if (results.rawResults && outputRaw) {

lib/SparqlBenchmarkRunner.ts

@@ -3,7 +3,7 @@ import type * as RDF from '@rdfjs/types';
 import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
 import { termToString } from 'rdf-string';
 import type { IQuerySetMetadata } from './QueryLoader';
-import type { IResult, IResultMetadata, IRunResult } from './Result';
+import type { IAggregateResult, IResult, IResultMetadata, IRunResult } from './Result';
 import type { IResultAggregator } from './ResultAggregator';
 import { ResultAggregatorComunica } from './ResultAggregatorComunica';
 
@@ -51,7 +51,15 @@ export class SparqlBenchmarkRunner {
    * execute all query sets against the SPARQL endpoint.
    * Afterwards, all results are collected and averaged.
    */
-  public async run(options: IRunOptions = {}): Promise<IRunResult> {
+  public async run(options: IRunOptions = {}): Promise<IAggregateResult[]> {
+    const result = await this.runWithRawResults(options);
+    return result.aggregateResults;
+  }
+
+  /**
+   * Runs the queries and return aggregated and raw results
+   */
+  public async runWithRawResults(options: IRunOptions = {}): Promise<IRunResult> {
     // Execute queries in warmup
     if (this.warmup > 0) {
       await this.executeAllQueries(this.warmup, true, options.onQuery);

test/SparqlBenchmarkRunner-test.ts

@@ -82,6 +82,7 @@ describe('SparqlBenchmarkRunner', () => {
       });
 
       const results = await runner.run();
+      const resultsRaw = await runner.runWithRawResults();
 
       const expectedResults: IAggregateResult[] = [
         {
@@ -178,15 +179,23 @@ describe('SparqlBenchmarkRunner', () => {
         },
       ];
 
-      // Calls: (warmup + replication) * queryset size
-      const expectedCalls = Object.values(querySets).flatMap(qs => qs).length * (replication + warmup);
+      // Calls: (warmup + replication) * queryset size * 2 (accounting for both test executions)
+      const expectedCalls = Object.values(querySets).flatMap(qs => qs).length * (replication + warmup) * 2;
       expect(fetcher.fetchBindings).toHaveBeenCalledTimes(expectedCalls);
       expect(fetch).toHaveBeenCalledTimes(expectedCalls);
 
-      expect(Array.isArray(results)).toBe(false);
-      expect((<{ 0?: IAggregateResult }><unknown>results)[0]).toBeUndefined();
-      expect(results.aggregateResults).toEqual(expectedResults);
-      expect(results.rawResults).toHaveLength(Object.values(querySets).flatMap(qs => qs).length * replication);
+      // Validate run()
+      expect(Array.isArray(results)).toBe(true);
+      expect((<{ rawResults?: any }><unknown>results).rawResults).toBeUndefined();
+      expect(results).toEqual(expectedResults);
+
+      // Validate runWithRawResults() structure and lengths
+      expect(resultsRaw).toHaveProperty('aggregateResults');
+      expect(resultsRaw).toHaveProperty('rawResults');
+      expect(Array.isArray(resultsRaw.aggregateResults)).toBe(true);
+      expect(Array.isArray(resultsRaw.rawResults)).toBe(true);
+      expect(resultsRaw.aggregateResults).toHaveLength(expectedResults.length);
+      expect(resultsRaw.rawResults).toHaveLength(Object.values(querySets).flatMap(qs => qs).length * replication);
     });
 
     it('waits until endpoint is up', async() => {