smartexpect/ts/smartexpect.classes.assertion.ts

import * as plugins from './smartexpect.plugins.js';

export type TExecutionType = 'sync' | 'async';

export class Assertion {
  executionMode: TExecutionType;
  baseReference: any;
  propertyDrillDown: string[] = [];
  private notSetting = false;
  private timeoutSetting = 0;
  constructor(baseReferenceArg: any, executionModeArg: TExecutionType) {
    this.baseReference = baseReferenceArg;
    this.executionMode = executionModeArg;
  }

  private getObjectToTestReference() {
    let returnObjectToTestReference = this.baseReference;
    for (const property of this.propertyDrillDown) {
      returnObjectToTestReference = returnObjectToTestReference[property];
    }
    return returnObjectToTestReference;
  }

  public get not() {
    this.notSetting = true;
    return this;
  }

  public timeout(millisArg: number) {
    this.timeoutSetting = millisArg;
    return this;
  }

  private runCheck(checkFunction: () => any) {
    const runDirectOrNegated = (checkFunction: () => any) => {
      if (!this.notSetting) {
        return checkFunction();
      } else {
        let isOk = false;
        try {
          runDirectOrNegated(checkFunction());
        } catch (e) {
          isOk = true;
        }
        if (!isOk) {
          throw new Error('Negated assertion is not ok!');
        }
      }
    };

    if (this.executionMode === 'async') {
      const done = plugins.smartpromise.defer();
      if (!(this.baseReference instanceof Promise)) {
        done.reject(new Error(`${this.baseReference} is not of type promise.`));
      } else {
        if (this.timeoutSetting) {
          plugins.smartdelay.delayFor(this.timeoutSetting).then(() => {
            if (done.status === 'pending') {
              done.reject(new Error(`${this.baseReference} timed out at ${this.timeoutSetting}!`));
            }
          });
        }
        this.baseReference.then((promiseResultArg) => {
          this.baseReference = promiseResultArg;
          done.resolve(runDirectOrNegated(checkFunction));
        });
      }
      return done.promise;
    } else {
      return runDirectOrNegated(checkFunction);
    }
  }

  public toBeTypeofString() {
    return this.runCheck(() => {
      if (typeof this.getObjectToTestReference() !== 'string') {
        throw new Error(
          `Assertion failed: ${this.baseReference} with drill down ${
            this.propertyDrillDown
          } is not of type string, but typeof ${typeof this.baseReference}`
        );
      }
    });
  }

  public toBeTypeofNumber() {
    return this.runCheck(() => {
      if (typeof this.getObjectToTestReference() !== 'number') {
        throw new Error(
          `Assertion failed: ${this.baseReference} with drill down ${
            this.propertyDrillDown
          } is not of type string, but typeof ${typeof this.baseReference}`
        );
      }
    });
  }

  public toBeTypeofBoolean() {
    return this.runCheck(() => {
      if (typeof this.getObjectToTestReference() !== 'boolean') {
        throw new Error(
          `Assertion failed: ${this.baseReference} with drill down ${
            this.propertyDrillDown
          } is not of type string, but typeof ${typeof this.baseReference}`
        );
      }
    });
  }

  public toEqual(comparisonObject: any) {
    return this.runCheck(() => {
      const result = plugins.fastDeepEqual(this.getObjectToTestReference(), comparisonObject);
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not equal ${comparisonObject}`
        );
      }
    });
  }

  public toMatch(comparisonObject: RegExp) {
    return this.runCheck(() => {
      const result = comparisonObject.test(this.getObjectToTestReference());
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not equal ${comparisonObject}`
        );
      }
    });
  }

  public toBeTrue() {
    return this.runCheck(() => {
      const result =
        typeof this.getObjectToTestReference() === 'boolean' &&
        this.getObjectToTestReference() === true;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not true or not of type boolean`
        );
      }
    });
  }

  public toBeFalse() {
    return this.runCheck(() => {
      const result =
        typeof this.getObjectToTestReference() === 'boolean' &&
        this.getObjectToTestReference() === false;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not false or not of type boolean`
        );
      }
    });
  }

  public toBeInstanceOf(classArg: any) {
    return this.runCheck(() => {
      const result = this.getObjectToTestReference() instanceof classArg;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not an instance of ${classArg}`
        );
      }
    });
  }

  public toHaveProperty(propertyArg: string, equalsArg?: any) {
    return this.runCheck(() => {
      const result = !!this.getObjectToTestReference()[propertyArg];
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not have property ${propertyArg}`
        );
      }
      if (equalsArg) {
        if (result !== equalsArg) {
          throw new Error(
            `${this.baseReference} with drill down ${this.propertyDrillDown} does have property ${propertyArg}, but it does not equal ${equalsArg}`
          );
        }
      }
    });
  }

  public toBeGreaterThan(numberArg: number) {
    return this.runCheck(() => {
      const result = this.getObjectToTestReference() > numberArg;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not greater than ${numberArg}`
        );
      }
    });
  }

  public toBeLessThan(numberArg: number) {
    return this.runCheck(() => {
      const result = this.getObjectToTestReference() < numberArg;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not less than ${numberArg}`
        );
      }
    });
  }

  public toBeNull() {
    return this.runCheck(() => {
      const result = this.getObjectToTestReference() === null;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not null`
        );
      }
    });
  }

  public toBeUndefined() {
    return this.runCheck(() => {
      const result = this.getObjectToTestReference() === undefined;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not undefined`
        );
      }
    });
  }

  public toBeNullOrUndefined() {
    return this.runCheck(() => {
      const result =
        this.getObjectToTestReference() === null || this.getObjectToTestReference() === undefined;
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not null or undefined`
        );
      }
    });
  }

  public toContain(itemArg: any) {
    return this.runCheck(() => {
      const result =
        this.getObjectToTestReference() instanceof Array &&
        this.getObjectToTestReference().includes(itemArg);
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
        );
      }
    });
  }

  public toStartWith(itemArg: any) {
    return this.runCheck(() => {
      const testObject = this.getObjectToTestReference();
      const result = typeof testObject === 'string' && testObject.startsWith(itemArg);
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
        );
      }
    });
  }

  public toEndWith(itemArg: any) {
    return this.runCheck(() => {
      const testObject = this.getObjectToTestReference();
      const result = typeof testObject === 'string' && testObject.endsWith(itemArg);
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not contain ${itemArg}`
        );
      }
    });
  }

  // ... previous code ...

  public toBeOneOf(values: any[]) {
    return this.runCheck(() => {
      const result = values.includes(this.getObjectToTestReference());
      if (!result) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not one of ${values}`
        );
      }
    });
  }

  public toHaveLength(length: number) {
    return this.runCheck(() => {
      const obj = this.getObjectToTestReference();
      if (typeof obj.length !== 'number' || obj.length !== length) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length of ${length}`
        );
      }
    });
  }

  public toBeCloseTo(value: number, precision = 2) {
    return this.runCheck(() => {
      const difference = Math.abs(this.getObjectToTestReference() - value);
      if (difference > Math.pow(10, -precision) / 2) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not close to ${value} up to ${precision} decimal places`
        );
      }
    });
  }

  public toThrow(expectedError?: any) {
    return this.runCheck(() => {
      let thrown = false;
      try {
        this.getObjectToTestReference()();
      } catch (e) {
        thrown = true;
        if (expectedError && !(e instanceof expectedError)) {
          throw new Error(
            `Expected function to throw ${expectedError.name}, but it threw ${e.name}`
          );
        }
      }
      if (!thrown) {
        throw new Error(`Expected function to throw, but it didn't.`);
      }
    });
  }

  public toBeTruthy() {
    return this.runCheck(() => {
      if (!this.getObjectToTestReference()) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not truthy`
        );
      }
    });
  }

  public toBeFalsy() {
    return this.runCheck(() => {
      if (this.getObjectToTestReference()) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not falsy`
        );
      }
    });
  }

  public toBeGreaterThanOrEqual(numberArg: number) {
    return this.runCheck(() => {
      if (this.getObjectToTestReference() <= numberArg) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not greater than or equal to ${numberArg}`
        );
      }
    });
  }

  public toBeLessThanOrEqual(numberArg: number) {
    return this.runCheck(() => {
      if (this.getObjectToTestReference() >= numberArg) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not less than or equal to ${numberArg}`
        );
      }
    });
  }

  public toMatchObject(objectArg: object) {
    return this.runCheck(() => {
      function deepEqual(obj1: any, obj2: any): boolean {
        // If both are of primitive types and are equal
        if (obj1 === obj2) {
          return true;
        }

        // If either of them is null or not an object
        if (
          typeof obj1 !== 'object' ||
          obj1 === null ||
          typeof obj2 !== 'object' ||
          obj2 === null
        ) {
          return false;
        }

        const keys1 = Object.keys(obj1);
        const keys2 = Object.keys(obj2);

        // If their properties' count doesn't match
        if (keys1.length !== keys2.length) {
          return false;
        }

        // Checking if every property in obj1 has a counterpart in obj2
        for (const key of keys1) {
          if (!keys2.includes(key)) {
            return false;
          }
          if (!deepEqual(obj1[key], obj2[key])) {
            return false;
          }
        }

        return true;
      }
      const partialMatch = deepEqual(this.getObjectToTestReference(), objectArg); // Note: Implement a deep comparison function or use one from a library
      if (!partialMatch) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not match the object ${objectArg}`
        );
      }
    });
  }

  public toContainEqual(value: any) {
    return this.runCheck(() => {
      const arr = this.getObjectToTestReference();
      const found = arr.some((item: any) => plugins.fastDeepEqual(item, value)); // Assuming fastDeepEqual checks deep equality
      if (!found) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not contain the value ${value}`
        );
      }
    });
  }

  public toBeArray() {
    return this.runCheck(() => {
      if (!Array.isArray(this.getObjectToTestReference())) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not an array`
        );
      }
    });
  }

  public toInclude(substring: string) {
    return this.runCheck(() => {
      if (!this.getObjectToTestReference().includes(substring)) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not include the substring ${substring}`
        );
      }
    });
  }

  public toHaveLengthGreaterThan(length: number) {
    return this.runCheck(() => {
      const obj = this.getObjectToTestReference();
      if (typeof obj.length !== 'number' || obj.length <= length) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length greater than ${length}`
        );
      }
    });
  }

  public toHaveLengthLessThan(length: number) {
    return this.runCheck(() => {
      const obj = this.getObjectToTestReference();
      if (typeof obj.length !== 'number' || obj.length >= length) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} does not have a length less than ${length}`
        );
      }
    });
  }

  public toBeDate() {
    return this.runCheck(() => {
      if (!(this.getObjectToTestReference() instanceof Date)) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not a date`
        );
      }
    });
  }

  public toBeBeforeDate(date: Date) {
    return this.runCheck(() => {
      if (!(this.getObjectToTestReference() < date)) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not before ${date}`
        );
      }
    });
  }

  public toBeAfterDate(date: Date) {
    return this.runCheck(() => {
      if (!(this.getObjectToTestReference() > date)) {
        throw new Error(
          `${this.baseReference} with drill down ${this.propertyDrillDown} is not after ${date}`
        );
      }
    });
  }

  public property(propertyNameArg: string) {
    this.propertyDrillDown.push(propertyNameArg);
    return this;
  }
}