refactor: update postwomanTesting to typescript

helpers/postwomanTesting.ts

@@ -0,0 +1,263 @@
+import { HoppRESTResponse } from "./types/HoppRESTResponse"
+
+const styles = {
+  PASS: { icon: "check", class: "success-response" },
+  FAIL: { icon: "close", class: "cl-error-response" },
+  ERROR: { icon: "close", class: "cl-error-response" },
+}
+
+type TestScriptVariables = {
+  response: HoppRESTResponse
+}
+
+type TestReportStartBlock = {
+  startBlock: string
+}
+
+type TestReportEndBlock = {
+  endBlock: true
+}
+
+type TestReportEntry = {
+  styles: {
+    icon: string
+  }
+} & ({ result: "PASS" } | { result: "FAIL" | "ERROR"; message: string })
+type TestReport = TestReportStartBlock | TestReportEntry | TestReportEndBlock
+
+export default function runTestScriptWithVariables(
+  script: string,
+  variables: TestScriptVariables
+) {
+  const pw = {
+    _errors: [],
+    _testReports: [] as TestReport[],
+    _report: "",
+    expect(value: any) {
+      try {
+        return expect(value, this._testReports)
+      } catch (e) {
+        pw._testReports.push({
+          result: "ERROR",
+          message: e.toString(),
+          styles: styles.ERROR,
+        })
+      }
+    },
+    test: (descriptor: string, func: () => void) =>
+      test(descriptor, func, pw._testReports),
+    // globals that the script is allowed to have access to.
+  }
+  Object.assign(pw, variables)
+
+  // run pre-request script within this function so that it has access to the pw object.
+  // eslint-disable-next-line no-new-func
+  new Function("pw", script)(pw)
+
+  return {
+    report: pw._report,
+    errors: pw._errors,
+    testResults: pw._testReports,
+  }
+}
+
+function test(
+  descriptor: string,
+  func: () => void,
+  _testReports: TestReport[]
+) {
+  _testReports.push({ startBlock: descriptor })
+  try {
+    func()
+  } catch (e) {
+    _testReports.push({ result: "ERROR", message: e, styles: styles.ERROR })
+  }
+  _testReports.push({ endBlock: true })
+
+  // TODO: Organize and generate text report of each {descriptor: true} section in testReports.
+  // add checkmark or x depending on if each testReport is pass=true or pass=false
+}
+
+function expect(expectValue: any, _testReports: TestReport[]) {
+  return new Expectation(expectValue, null, _testReports)
+}
+
+class Expectation {
+  private expectValue: any
+  private not: true | Expectation
+  private _testReports: TestReport[]
+
+  constructor(
+    expectValue: any,
+    _not: boolean | null,
+    _testReports: TestReport[]
+  ) {
+    this.expectValue = expectValue
+    this.not = _not || new Expectation(this.expectValue, true, _testReports)
+    this._testReports = _testReports // this values is used within Test.it, which wraps Expectation and passes _testReports value.
+  }
+
+  private _satisfies(expectValue: any, targetValue?: any): boolean {
+    // Used for testing if two values match the expectation, which could be === OR !==, depending on if not
+    // was used. Expectation#_satisfies prevents the need to have an if(this.not) branch in every test method.
+    // Signature is _satisfies([expectValue,] targetValue): if only one argument is given, it is assumed the targetValue, and expectValue is set to this.expectValue
+    if (!targetValue) {
+      targetValue = expectValue
+      expectValue = this.expectValue
+    }
+    if (this.not === true) {
+      // test the inverse. this.not is always truthly, but an Expectation that is inverted will always be strictly `true`
+      return expectValue !== targetValue
+    } else {
+      return expectValue === targetValue
+    }
+  }
+
+  _fmtNot(message: string) {
+    // given a string with "(not)" in it, replaces with "not" or "", depending if the expectation is expecting the positive or inverse (this._not)
+    if (this.not === true) {
+      return message.replace("(not)", "not ")
+    } else {
+      return message.replace("(not)", "")
+    }
+  }
+
+  _fail(message: string) {
+    return this._testReports.push({
+      result: "FAIL",
+      message,
+      styles: styles.FAIL,
+    })
+  }
+
+  _pass() {
+    return this._testReports.push({ result: "PASS", styles: styles.PASS })
+  }
+
+  // TEST METHODS DEFINED BELOW
+  // these are the usual methods that would follow expect(...)
+  toBe(value: any) {
+    return this._satisfies(value)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(`Expected ${this.expectValue} (not)to be ${value}`)
+        )
+  }
+
+  toHaveProperty(value: string) {
+    return this._satisfies(
+      Object.prototype.hasOwnProperty.call(this.expectValue, value),
+      true
+    )
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected object ${this.expectValue} to (not)have property ${value}`
+          )
+        )
+  }
+
+  toBeLevel2xx() {
+    const code = parseInt(this.expectValue, 10)
+    if (Number.isNaN(code)) {
+      return this._fail(
+        `Expected 200-level status but could not parse value ${this.expectValue}`
+      )
+    }
+    return this._satisfies(code >= 200 && code < 300, true)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected ${this.expectValue} to (not)be 200-level status`
+          )
+        )
+  }
+
+  toBeLevel3xx() {
+    const code = parseInt(this.expectValue, 10)
+    if (Number.isNaN(code)) {
+      return this._fail(
+        `Expected 300-level status but could not parse value ${this.expectValue}`
+      )
+    }
+    return this._satisfies(code >= 300 && code < 400, true)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected ${this.expectValue} to (not)be 300-level status`
+          )
+        )
+  }
+
+  toBeLevel4xx() {
+    const code = parseInt(this.expectValue, 10)
+    if (Number.isNaN(code)) {
+      return this._fail(
+        `Expected 400-level status but could not parse value ${this.expectValue}`
+      )
+    }
+    return this._satisfies(code >= 400 && code < 500, true)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected ${this.expectValue} to (not)be 400-level status`
+          )
+        )
+  }
+
+  toBeLevel5xx() {
+    const code = parseInt(this.expectValue, 10)
+    if (Number.isNaN(code)) {
+      return this._fail(
+        `Expected 500-level status but could not parse value ${this.expectValue}`
+      )
+    }
+    return this._satisfies(code >= 500 && code < 600, true)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected ${this.expectValue} to (not)be 500-level status`
+          )
+        )
+  }
+
+  toHaveLength(expectedLength: number) {
+    const actualLength = this.expectValue.length
+    return this._satisfies(actualLength, expectedLength)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected length to be ${expectedLength} but actual length was ${actualLength}`
+          )
+        )
+  }
+
+  toBeType(expectedType: string) {
+    const actualType = typeof this.expectValue
+    if (
+      ![
+        "string",
+        "boolean",
+        "number",
+        "object",
+        "undefined",
+        "bigint",
+        "symbol",
+        "function",
+      ].includes(expectedType)
+    ) {
+      return this._fail(
+        this._fmtNot(
+          `Argument for toBeType should be "string", "boolean", "number", "object", "undefined", "bigint", "symbol" or "function"`
+        )
+      )
+    }
+    return this._satisfies(actualType, expectedType)
+      ? this._pass()
+      : this._fail(
+          this._fmtNot(
+            `Expected type to be "${expectedType}" but actual type was "${actualType}"`
+          )
+        )
+  }
+}