feat(betterer ✨): change goal and constraint of BettererFileTest (#683)

goldens/api/@betterer/betterer.d.ts

@@ -103,12 +103,14 @@ export declare class BettererFileResolver {
 
 export declare type BettererFilesDiff = Record<string, BettererFileDiff>;
 
-export declare class BettererFileTest implements BettererTestBase<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff> {
-    get config(): BettererTestConfig<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff>;
+export declare class BettererFileTest implements BettererFileTestBase {
+    get config(): BettererFileTestConfig;
     get isOnly(): boolean;
     get isSkipped(): boolean;
     constructor(resolver: BettererFileResolver, fileTest: BettererFileTestFunction);
+    constraint(constraintOverride: BettererTestConstraint<BettererFileTestResult>): this;
     exclude(...excludePatterns: BettererFilePatterns): this;
+    goal(goalOverride: BettererTestGoal<BettererFileTestResult>): this;
     include(...includePatterns: BettererFileGlobs): this;
     only(): this;
     skip(): this;
@@ -120,7 +122,8 @@ export declare type BettererFileTestFunction = (filePaths: BettererFilePaths, fi
 
 export declare type BettererFileTestResult = {
     addFile(absolutePath: string, fileText: string): BettererFile;
-    getIssues(absolutePath: string): BettererFileIssues;
+    getFilePaths(): BettererFilePaths;
+    getIssues(absolutePath?: string): BettererFileIssues;
 };
 
 export declare type BettererOptionsBase = Partial<{
@@ -274,6 +277,8 @@ export declare class BettererTest<DeserialisedType, SerialisedType, DiffType> im
     get isOnly(): boolean;
     get isSkipped(): boolean;
     constructor(options: BettererTestOptions<DeserialisedType, SerialisedType, DiffType>);
+    constraint(constraintOverride: BettererTestConstraint<DeserialisedType>): this;
+    goal(goalOverride: BettererTestGoal<DeserialisedType>): this;
     only(): this;
     skip(): this;
 }
@@ -285,7 +290,7 @@ export declare type BettererTestConfig<DeserialisedType = unknown, SerialisedTyp
     test: BettererTestFunction<DeserialisedType>;
     differ: BettererDiffer<DeserialisedType, DiffType>;
     printer: BettererPrinter<SerialisedType>;
-    progress: BettererProgress<DeserialisedType> | null;
+    progress: BettererProgress<DeserialisedType>;
     serialiser: BettererSerialiser<DeserialisedType, SerialisedType>;
     type: BettererTestType;
 };

packages/betterer/src/context/run.ts

@@ -74,8 +74,8 @@ export class BettererRunΩ implements BettererRun {
 
   public get timestamp(): number {
     assert.notStrictEqual(this._status, BettererRunStatus.pending);
-    assert.notStrictEqual(this._timestamp, null);
-    return this._timestamp as number;
+    assert(this._timestamp !== null);
+    return this._timestamp;
   }
 
   public get isBetter(): boolean {
@@ -142,11 +142,9 @@ export class BettererRunΩ implements BettererRun {
     this._timestamp = startTime;
 
     const end = async () => {
-      if (this._test.progress) {
-        const baselineValue = this._baseline.isNew ? null : this._baseline.value;
-        const resultValue = !this._result ? null : this._result.value;
-        this._delta = await this._test.progress(baselineValue, resultValue);
-      }
+      const baselineValue = this._baseline.isNew ? null : this._baseline.value;
+      const resultValue = !this._result ? null : this._result.value;
+      this._delta = await this._test.progress(baselineValue, resultValue);
       this._lifecycle.resolve();
       await reportRunStart;
       await this._reporter.runEnd(this);

packages/betterer/src/test/config.ts

@@ -15,7 +15,7 @@ import {
 export function createTestConfig<DeserialisedType, SerialisedType, DiffType>(
   options: BettererTestOptions<DeserialisedType, SerialisedType, DiffType>,
   type = BettererTestType.Unknown
-): BettererTestConfig<DeserialisedType, SerialisedType, DiffType> | BettererTestConfig<unknown> {
+): BettererTestConfig<DeserialisedType, SerialisedType, DiffType> | BettererTestConfig {
   if (options.constraint == null) {
     throw new BettererError('for a test to work, it must have a `constraint` function. ❌');
   }
@@ -29,7 +29,8 @@ export function createTestConfig<DeserialisedType, SerialisedType, DiffType>(
 
   if (isComplex(options)) {
     return {
-      printer: options.printer || defaultPrinter,
+      printer: defaultPrinter,
+      progress: defaultProgress,
       ...options,
       goal,
       deadline,
@@ -41,14 +42,15 @@ export function createTestConfig<DeserialisedType, SerialisedType, DiffType>(
     ...options,
     differ: defaultDiffer,
     printer: defaultPrinter,
+    progress: defaultProgress,
     serialiser: {
       deserialise: defaultDeserialiser,
       serialise: defaultSerialiser
     },
     goal,
     deadline,
     type
-  } as BettererTestConfig<unknown>;
+  } as BettererTestConfig;
 }
 
 function createDeadline<DeserialisedType, SerialisedType, DiffType>(
@@ -79,13 +81,11 @@ function createGoal<DeserialisedType, SerialisedType, DiffType>(
 function isComplex<DeserialisedType, SerialisedType, DiffType>(
   options: BettererTestOptions<DeserialisedType, SerialisedType, DiffType>
 ): options is BettererTestOptionsComplex<DeserialisedType, SerialisedType, DiffType> {
-  return !!(
-    (options as BettererTestOptionsComplex<DeserialisedType, SerialisedType, DiffType>).differ &&
-    (options as BettererTestOptionsComplex<DeserialisedType, SerialisedType, DiffType>).serialiser
-  );
+  const maybeComplex = options as BettererTestOptionsComplex<DeserialisedType, SerialisedType, DiffType>;
+  return !!maybeComplex.differ && !!maybeComplex.serialiser;
 }
 
-export function defaultDiffer(expected: unknown, result: unknown): BettererDiff<unknown, null> {
+export function defaultDiffer(expected: unknown, result: unknown): BettererDiff<unknown, unknown> {
   return {
     expected,
     result,
@@ -103,6 +103,10 @@ function defaultPrinter(serialised: unknown): string {
   return format(JSON.stringify(serialised), { parser: 'json' });
 }
 
+function defaultProgress(): null {
+  return null;
+}
+
 function defaultDeserialiser(serialised: unknown): unknown {
   return serialised;
 }

packages/betterer/src/test/file-test/file-test-result.ts

@@ -1,6 +1,7 @@
 import assert from 'assert';
 
 import { createHash } from '../../hasher';
+import { BettererFilePaths } from '../../runner';
 import { BettererFileΩ } from './file';
 import { BettererFileResolverΩ } from './file-resolver';
 import { BettererFileTestResult, BettererFileIssues, BettererFile, BettererFileBase } from './types';
@@ -35,7 +36,14 @@ export class BettererFileTestResultΩ implements BettererFileTestResult {
     this._fileMap[file.absolutePath] = file;
   }
 
-  public getIssues(absolutePath: string): BettererFileIssues {
+  public getFilePaths(): BettererFilePaths {
+    return Object.keys(this._fileMap);
+  }
+
+  public getIssues(absolutePath?: string): BettererFileIssues {
+    if (!absolutePath) {
+      return this.files.flatMap((files) => files.issues);
+    }
     return this.getFile(absolutePath).issues;
   }
 }

packages/betterer/src/test/file-test/file-test.ts

@@ -1,7 +1,7 @@
 import { BettererRun } from '../../context';
 import { createTestConfig } from '../config';
 import { BettererTestType } from '../type';
-import { BettererTestBase, BettererTestConfig, BettererTestFunction } from '../types';
+import { BettererTestConstraint, BettererTestFunction, BettererTestGoal } from '../types';
 import { constraint } from './constraint';
 import { differ } from './differ';
 import { BettererFileResolver, BettererFileResolverΩ } from './file-resolver';
@@ -12,16 +12,15 @@ import { progress } from './progress';
 import { deserialise, serialise } from './serialiser';
 import {
   BettererFileGlobs,
-  BettererFileIssuesMapSerialised,
   BettererFilePatterns,
-  BettererFilesDiff,
+  BettererFileTestBase,
+  BettererFileTestConfig,
   BettererFileTestFunction,
   BettererFileTestResult
 } from './types';
 
-export class BettererFileTest
-  implements BettererTestBase<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff> {
-  private _config: BettererTestConfig<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff>;
+export class BettererFileTest implements BettererFileTestBase {
+  private _config: BettererFileTestConfig;
   private _isOnly = false;
   private _isSkipped = false;
   private _resolver: BettererFileResolverΩ;
@@ -40,10 +39,10 @@ export class BettererFileTest
         progress
       },
       BettererTestType.File
-    ) as BettererTestConfig<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff>;
+    ) as BettererFileTestConfig;
   }
 
-  public get config(): BettererTestConfig<BettererFileTestResult, BettererFileIssuesMapSerialised, BettererFilesDiff> {
+  public get config(): BettererFileTestConfig {
     return this._config;
   }
 
@@ -55,11 +54,21 @@ export class BettererFileTest
     return this._isSkipped;
   }
 
+  public constraint(constraintOverride: BettererTestConstraint<BettererFileTestResult>): this {
+    this.config.constraint = constraintOverride;
+    return this;
+  }
+
   public exclude(...excludePatterns: BettererFilePatterns): this {
     this._resolver.excludeΔ(...excludePatterns);
     return this;
   }
 
+  public goal(goalOverride: BettererTestGoal<BettererFileTestResult>): this {
+    this.config.goal = goalOverride;
+    return this;
+  }
+
   public include(...includePatterns: BettererFileGlobs): this {
     this._resolver.includeΔ(...includePatterns);
     return this;

packages/betterer/src/test/file-test/types.ts

@@ -1,6 +1,7 @@
 import { BettererFilePaths } from '../../runner';
 import { BettererDiff } from '../../test';
 import { MaybeAsync } from '../../types';
+import { BettererTestBase, BettererTestConfig } from '../types';
 
 export type BettererFileIssueSerialised = [line: number, column: number, length: number, message: string, hash: string];
 export type BettererFileIssuesMapSerialised = Record<string, ReadonlyArray<BettererFileIssueSerialised>>;
@@ -46,5 +47,18 @@ export type BettererFile = BettererFileBase & {
 
 export type BettererFileTestResult = {
   addFile(absolutePath: string, fileText: string): BettererFile;
-  getIssues(absolutePath: string): BettererFileIssues;
+  getFilePaths(): BettererFilePaths;
+  getIssues(absolutePath?: string): BettererFileIssues;
 };
+
+export type BettererFileTestBase = BettererTestBase<
+  BettererFileTestResult,
+  BettererFileIssuesMapSerialised,
+  BettererFilesDiff
+>;
+
+export type BettererFileTestConfig = BettererTestConfig<
+  BettererFileTestResult,
+  BettererFileIssuesMapSerialised,
+  BettererFilesDiff
+>;

packages/betterer/src/test/test.ts

@@ -1,6 +1,12 @@
 import { createTestConfig } from './config';
 import { BettererTestType } from './type';
-import { BettererTestBase, BettererTestConfig, BettererTestOptions } from './types';
+import {
+  BettererTestBase,
+  BettererTestConfig,
+  BettererTestConstraint,
+  BettererTestGoal,
+  BettererTestOptions
+} from './types';
 
 export class BettererTest<DeserialisedType, SerialisedType, DiffType>
   implements BettererTestBase<DeserialisedType, SerialisedType, DiffType> {
@@ -28,6 +34,16 @@ export class BettererTest<DeserialisedType, SerialisedType, DiffType>
     return this._isSkipped;
   }
 
+  public constraint(constraintOverride: BettererTestConstraint<DeserialisedType>): this {
+    this.config.constraint = constraintOverride;
+    return this;
+  }
+
+  public goal(goalOverride: BettererTestGoal<DeserialisedType>): this {
+    this.config.goal = goalOverride;
+    return this;
+  }
+
   public only(): this {
     this._isOnly = true;
     return this;

packages/betterer/src/test/types.ts

@@ -71,7 +71,7 @@ export type BettererTestConfig<DeserialisedType = unknown, SerialisedType = Dese
   test: BettererTestFunction<DeserialisedType>;
   differ: BettererDiffer<DeserialisedType, DiffType>;
   printer: BettererPrinter<SerialisedType>;
-  progress: BettererProgress<DeserialisedType> | null;
+  progress: BettererProgress<DeserialisedType>;
   serialiser: BettererSerialiser<DeserialisedType, SerialisedType>;
   type: BettererTestType;
 };
@@ -80,6 +80,8 @@ export interface BettererTestBase<DeserialisedType = unknown, SerialisedType = D
   config: BettererTestConfig<DeserialisedType, SerialisedType, DiffType>;
   isOnly: boolean;
   isSkipped: boolean;
+  constraint(constraintOverride: BettererTestConstraint<DeserialisedType>): this;
+  goal(goalOverride: BettererTestGoal<DeserialisedType>): this;
   only(): this;
   skip(): this;
 }