@dereekb/util 12.6.21 → 13.0.0

package/test/index.esm.js

@@ -0,0 +1,664 @@
+import { promiseReference, forwardFunction, mapObjectMap, isPromise, build } from '@dereekb/util';
+
+/**
+ * Passes the error to the TestDoneCallback.
+ * @param done
+ * @param e
+ */
+function failWithTestDoneCallback(done, e = new Error('failed test')) {
+  if (done.fail != null) {
+    done.fail(e);
+  } else {
+    done(e);
+  }
+}
+/**
+ * Creates a new TestDoneCallbackRef.
+ *
+ * Used to create a promise reference that can be used to assert that a test function was called.
+ */
+function testDoneCallbackRef() {
+  const _promise = promiseReference();
+  const done = e => {
+    if (e) {
+      _promise.reject(e);
+    } else {
+      _promise.resolve();
+    }
+  };
+  done.fail = done;
+  return {
+    _promise,
+    done
+  };
+}
+/**
+ * Wraps a callback-based test (using done) for Vitest compatibility.
+ * Converts the callback pattern to a Promise-based pattern.
+ *
+ * This also supports calling the input test with async, but still only returns when done is called.
+ *
+ * @example
+ *
+ * // Before (Jasmine/Jest style):
+ * it('test name', (done) => {
+ *   // async test code
+ *   done();
+ * });
+ *
+ * // After (Vitest compatible):
+ * it('test name', callbackTest((done) => {
+ *   // async test code
+ *   done();
+ * }));
+ */
+function callbackTest(testFn) {
+  return async () => {
+    const done = testDoneCallbackRef();
+    await testFn(done.done);
+    return done._promise.promise;
+  };
+}
+/**
+ * Abstract TestContextFixture instance.
+ */
+class AbstractTestContextFixture {
+  constructor() {
+    this._instance = void 0;
+  }
+  get instance() {
+    return this._instance;
+  }
+  setInstance(instance) {
+    if (this._instance != null) {
+      throw new Error(`The testing fixture is locked. Don't call setInstance() directly.`);
+    }
+    this._instance = instance;
+    return () => {
+      delete this._instance;
+    };
+  }
+}
+/**
+ * Abstract TestContextFixture instance with a parent.
+ */
+class AbstractChildTestContextFixture extends AbstractTestContextFixture {
+  constructor(parent) {
+    super();
+    this.parent = void 0;
+    this.parent = parent;
+  }
+}
+/**
+ * Creates a TestContextBuilderFunction given the input builder.
+ *
+ * @param builder
+ * @returns
+ */
+function testContextBuilder(builder) {
+  return inputConfig => {
+    const config = builder.buildConfig(inputConfig);
+    return buildTests => {
+      const fixture = builder.buildFixture(config);
+      // add before each
+      if (builder.beforeEach != null) {
+        beforeEach(builder.beforeEach);
+      }
+      // add tests
+      useTestContextFixture({
+        fixture,
+        /**
+         * Build tests by passing the fixture to the testing functions.
+         *
+         * This will inject all tests and sub lifecycle items.
+         */
+        buildTests,
+        initInstance: () => builder.setupInstance(config),
+        destroyInstance: instance => builder.teardownInstance(instance, config)
+      });
+      // add after each
+      if (builder.afterEach != null) {
+        afterEach(builder.afterEach);
+      }
+    };
+  };
+}
+/**
+ * Creates a test context and configurations that will initialize an instance
+ */
+function useTestContextFixture(config) {
+  const {
+    buildTests,
+    fixture,
+    initInstance,
+    destroyInstance
+  } = config;
+  let clearInstance;
+  let instance;
+  // Create an instance
+  beforeEach(async () => {
+    try {
+      instance = await initInstance();
+      clearInstance = fixture.setInstance(instance);
+    } catch (e) {
+      console.error('Failed building a test instance due to an error in buildInstance(). Error: ', e);
+      if (clearInstance) {
+        clearInstance();
+      }
+      throw e;
+    }
+  });
+  // Declare tests
+  buildTests(fixture);
+  // Cleanup
+  afterEach(async () => {
+    if (clearInstance) {
+      clearInstance();
+    }
+    if (fixture.instance != null) {
+      console.warn('Expected instance to be set on fixture for cleanup but was set to something else.');
+    }
+    if (destroyInstance) {
+      try {
+        await destroyInstance(instance);
+        instance = undefined;
+      } catch (e) {
+        console.error('Failed due to error in destroyInstance()');
+        throw e;
+      }
+    }
+  });
+}
+
+class AbstractWrappedFixture {
+  constructor(fixture) {
+    this.fixture = void 0;
+    this.fixture = fixture;
+  }
+}
+class AbstractWrappedFixtureWithInstance extends AbstractTestContextFixture {
+  constructor(parent) {
+    super();
+    this.parent = void 0;
+    this.parent = parent;
+  }
+}
+/**
+ * Wraps the input TestContextFactory to emit another type of Fixture for tests.
+ *
+ * @returns
+ */
+function wrapTestContextFactory(config) {
+  return factory => {
+    return buildTests => {
+      factory(inputFixture => {
+        const wrap = config.wrapFixture(inputFixture);
+        let effect;
+        // add before each
+        if (config.setupWrap != null) {
+          beforeEach(async () => {
+            effect = await config.setupWrap(wrap);
+          });
+        }
+        // add tests
+        buildTests(wrap);
+        // add after each
+        if (config.teardownWrap != null) {
+          afterEach(async () => {
+            await config.teardownWrap(wrap, effect);
+          });
+        }
+      });
+    };
+  };
+}
+function instanceWrapTestContextFactory(config) {
+  return wrapTestContextFactory({
+    wrapFixture: config.wrapFixture,
+    setupWrap: async wrap => {
+      const instance = await config.makeInstance(wrap);
+      const effect = wrap.setInstance(instance);
+      if (config.setupInstance) {
+        await config.setupInstance(instance, wrap);
+      }
+      return effect;
+    },
+    teardownWrap: async (wrap, deleteInstanceEffect) => {
+      deleteInstanceEffect?.();
+      if (config.teardownInstance) {
+        await config.teardownInstance(wrap.instance);
+      }
+    }
+  });
+}
+
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */
+function useTestFunctionFixture(config, buildTests) {
+  const {
+    fn
+  } = config;
+  const forward = forwardFunction(fn);
+  buildTests(forward);
+}
+/**
+ * Creates a test context and configurations that provides a function to build tests based on the configuration.
+ */
+function useTestFunctionMapFixture(config, buildTests) {
+  const forwardedFunctions = mapObjectMap(config.fns, fn => forwardFunction(fn));
+  buildTests(forwardedFunctions);
+}
+
+var makeError = {exports: {}};
+
+(function (module, exports$1) {
+
+	// ===================================================================
+
+	var construct = typeof Reflect !== "undefined" ? Reflect.construct : undefined;
+	var defineProperty = Object.defineProperty;
+
+	// -------------------------------------------------------------------
+
+	var captureStackTrace = Error.captureStackTrace;
+	if (captureStackTrace === undefined) {
+	  captureStackTrace = function captureStackTrace(error) {
+	    var container = new Error();
+
+	    defineProperty(error, "stack", {
+	      configurable: true,
+	      get: function getStack() {
+	        var stack = container.stack;
+
+	        // Replace property with value for faster future accesses.
+	        defineProperty(this, "stack", {
+	          configurable: true,
+	          value: stack,
+	          writable: true,
+	        });
+
+	        return stack;
+	      },
+	      set: function setStack(stack) {
+	        defineProperty(error, "stack", {
+	          configurable: true,
+	          value: stack,
+	          writable: true,
+	        });
+	      },
+	    });
+	  };
+	}
+
+	// -------------------------------------------------------------------
+
+	function BaseError(message) {
+	  if (message !== undefined) {
+	    defineProperty(this, "message", {
+	      configurable: true,
+	      value: message,
+	      writable: true,
+	    });
+	  }
+
+	  var cname = this.constructor.name;
+	  if (cname !== undefined && cname !== this.name) {
+	    defineProperty(this, "name", {
+	      configurable: true,
+	      value: cname,
+	      writable: true,
+	    });
+	  }
+
+	  captureStackTrace(this, this.constructor);
+	}
+
+	BaseError.prototype = Object.create(Error.prototype, {
+	  // See: https://github.com/JsCommunity/make-error/issues/4
+	  constructor: {
+	    configurable: true,
+	    value: BaseError,
+	    writable: true,
+	  },
+	});
+
+	// -------------------------------------------------------------------
+
+	// Sets the name of a function if possible (depends of the JS engine).
+	var setFunctionName = (function() {
+	  function setFunctionName(fn, name) {
+	    return defineProperty(fn, "name", {
+	      configurable: true,
+	      value: name,
+	    });
+	  }
+	  try {
+	    var f = function() {};
+	    setFunctionName(f, "foo");
+	    if (f.name === "foo") {
+	      return setFunctionName;
+	    }
+	  } catch (_) {}
+	})();
+
+	// -------------------------------------------------------------------
+
+	function makeError(constructor, super_) {
+	  if (super_ == null || super_ === Error) {
+	    super_ = BaseError;
+	  } else if (typeof super_ !== "function") {
+	    throw new TypeError("super_ should be a function");
+	  }
+
+	  var name;
+	  if (typeof constructor === "string") {
+	    name = constructor;
+	    constructor =
+	      construct !== undefined
+	        ? function() {
+	            return construct(super_, arguments, this.constructor);
+	          }
+	        : function() {
+	            super_.apply(this, arguments);
+	          };
+
+	    // If the name can be set, do it once and for all.
+	    if (setFunctionName !== undefined) {
+	      setFunctionName(constructor, name);
+	      name = undefined;
+	    }
+	  } else if (typeof constructor !== "function") {
+	    throw new TypeError("constructor should be either a string or a function");
+	  }
+
+	  // Also register the super constructor also as `constructor.super_` just
+	  // like Node's `util.inherits()`.
+	  //
+	  // eslint-disable-next-line dot-notation
+	  constructor.super_ = constructor["super"] = super_;
+
+	  var properties = {
+	    constructor: {
+	      configurable: true,
+	      value: constructor,
+	      writable: true,
+	    },
+	  };
+
+	  // If the name could not be set on the constructor, set it on the
+	  // prototype.
+	  if (name !== undefined) {
+	    properties.name = {
+	      configurable: true,
+	      value: name,
+	      writable: true,
+	    };
+	  }
+	  constructor.prototype = Object.create(super_.prototype, properties);
+
+	  return constructor;
+	}
+	exports$1 = module.exports = makeError;
+	exports$1.BaseError = BaseError; 
+} (makeError, makeError.exports));
+
+var makeErrorExports = makeError.exports;
+
+/**
+ * Testing utilities for handling expected failures and errors.
+ */
+// MARK: Errors
+/**
+ * Error thrown by fail() and used by expectError()
+ */
+class ExpectedFailError extends makeErrorExports.BaseError {}
+function failSuccessfullyError(message) {
+  return new ExpectedFailError(message);
+}
+function failSuccessfully(message) {
+  throw failSuccessfullyError(message);
+}
+/**
+ * Error thrown when success occurs when it should not have.
+ */
+class UnexpectedSuccessFailureError extends makeErrorExports.BaseError {}
+function failDueToSuccessError(message) {
+  return new UnexpectedSuccessFailureError(message ?? 'expected an error to occur but was successful instead');
+}
+/**
+ * Error thrown when the error type was different than the expected type.
+ */
+class ExpectedErrorOfSpecificTypeError extends makeErrorExports.BaseError {
+  constructor(encounteredType, expectedType) {
+    super(`The error encountered was not of the expected type. Expected: ${expectedType ?? 'n/a'}, but encountered: ${encounteredType} `);
+    this.encounteredType = void 0;
+    this.expectedType = void 0;
+    this.encounteredType = encounteredType;
+    this.expectedType = expectedType;
+  }
+}
+function failTest(message) {
+  throw failDueToSuccessError(message);
+}
+function failDueToSuccess() {
+  throw failDueToSuccessError();
+}
+function EXPECT_ERROR_DEFAULT_HANDLER(e) {
+  if (e instanceof ExpectedFailError) ; else {
+    throw e;
+  }
+}
+/**
+ * Creates an ExpectFailAssertionFunction that asserts the encountered error is of the expected type using the instanceof keyword.
+ *
+ * Throws an ExpectedErrorOfSpecificTypeError on failures.
+ *
+ * @param expectedType
+ * @returns
+ */
+function expectFailAssertErrorType(expectedType) {
+  return error => {
+    if (!(error instanceof expectedType)) {
+      throw new ExpectedErrorOfSpecificTypeError(error, expectedType);
+    }
+  };
+}
+function expectFail(errorFn, assertFailType) {
+  function handleError(e) {
+    if (e instanceof UnexpectedSuccessFailureError) {
+      throw e;
+    } else {
+      const assertionResult = assertFailType?.(e);
+      if (assertionResult === false) {
+        throw new ExpectedErrorOfSpecificTypeError(e);
+      }
+      failSuccessfully();
+    }
+  }
+  try {
+    const result = errorFn();
+    if (isPromise(result)) {
+      return result.then(failDueToSuccess).catch(handleError);
+    } else {
+      failDueToSuccess();
+    }
+  } catch (e) {
+    handleError(e);
+  }
+}
+function expectSuccessfulFail(errorFn, handleError = EXPECT_ERROR_DEFAULT_HANDLER) {
+  try {
+    const result = errorFn();
+    if (isPromise(result)) {
+      return result.then(failDueToSuccess).catch(handleError);
+    } else {
+      failDueToSuccess();
+    }
+  } catch (e) {
+    handleError(e);
+  }
+}
+/**
+ * Used to wrap a testing function and watch for ExpectedFailError errors in order to pass the test. Other exceptions are treated normally as failures.
+ *
+ * This is typically used in conjunction with failSuccessfully(), expectSuccessfulFail(), or expectFail().
+ *
+ * @param fn
+ * @param strict
+ * @returns
+ */
+function shouldFail(fn) {
+  const usesDoneCallback = fn.length > 0;
+  // Return a function that checks arguments at runtime to avoid done callback deprecation warning
+  return async function () {
+    const {
+      done,
+      _promise
+    } = testDoneCallbackRef();
+    function handleError(e) {
+      if (!(e instanceof ExpectedFailError)) {
+        failWithTestDoneCallback(done, e);
+      } else {
+        done();
+      }
+    }
+    try {
+      const result = expectSuccessfulFail(() => {
+        let result;
+        if (usesDoneCallback) {
+          const fakeDone = build({
+            base: fakeDoneHandler(),
+            build: x => {
+              x.failSuccessfully = () => {
+                fakeDone(failSuccessfullyError());
+              };
+            }
+          });
+          const callbackWithDoneResult = fn(fakeDone);
+          if (isPromise(callbackWithDoneResult)) {
+            fakeDone.reject(new Error('Configured to use "done" value while returning a promise. Configure your test to use one or the other.'));
+          }
+          // return the fake done promise. Done/fail will resolve as a promise.
+          result = fakeDone._ref.promise;
+        } else {
+          result = fn();
+        }
+        return result;
+      }, handleError);
+      // If expectSuccessfulFail returns a promise, handle it
+      if (isPromise(result)) {
+        result.catch(handleError);
+      }
+    } catch (e) {
+      // Handle synchronous errors
+      handleError(e);
+    }
+    return _promise.promise;
+  };
+}
+function itShouldFail(describeOrFn, fn) {
+  let description;
+  if (typeof describeOrFn === 'string') {
+    description = `should fail ${describeOrFn}`;
+  } else {
+    fn = describeOrFn;
+    description = 'should fail';
+  }
+  it(description, shouldFail(fn));
+}
+function fakeDoneHandler() {
+  const promiseRef = promiseReference();
+  const doneHandler = promiseRef.resolve;
+  const failHandler = e => {
+    promiseRef.reject(e);
+  };
+  const fakeDone = error => {
+    if (error) {
+      failHandler(error);
+    } else {
+      doneHandler(0);
+    }
+  };
+  fakeDone.fail = error => {
+    failHandler(error);
+  };
+  fakeDone._ref = promiseRef;
+  fakeDone.promise = promiseRef.promise;
+  fakeDone.resolve = promiseRef.resolve;
+  fakeDone.reject = promiseRef.reject;
+  return fakeDone;
+}
+
+/**
+ * @deprecated Use AbstractTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+class AbstractJestTestContextFixture extends AbstractTestContextFixture {}
+/**
+ * @deprecated Use AbstractChildTestContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+class AbstractChildJestTestContextFixture extends AbstractChildTestContextFixture {}
+/**
+ * @deprecated Use testContextBuilder from shared instead. This is kept for backwards compatibility.
+ */
+const jestTestContextBuilder = testContextBuilder;
+/**
+ * @deprecated Use useContextFixture from shared instead. This is kept for backwards compatibility.
+ */
+const useJestContextFixture = useTestContextFixture;
+
+/**
+ * https://github.com/facebook/jest/issues/11698
+ *
+ * Since fail() was silently removed, we redefine it.
+ */
+/**
+ * @deprecated Use failWithTestDoneCallback from shared instead. This is kept for backwards compatibility.
+ */
+const failWithJestDoneCallback = failWithTestDoneCallback;
+// MARK: Errors
+/**
+ * @deprecated Use ExpectedFailError from shared instead. This is kept for backwards compatibility.
+ */
+class JestExpectedFailError extends ExpectedFailError {}
+/**
+ * @deprecated Use UnexpectedSuccessFailureError from shared instead. This is kept for backwards compatibility.
+ */
+class JestUnexpectedSuccessFailureError extends UnexpectedSuccessFailureError {}
+/**
+ * @deprecated Use ExpectedErrorOfSpecificTypeError from shared instead. This is kept for backwards compatibility.
+ */
+class JestExpectedErrorOfSpecificTypeError extends ExpectedErrorOfSpecificTypeError {}
+/**
+ * @deprecated Use failWithTestDoneCallback with failDueToSuccessError from shared instead. This is kept for backwards compatibility.
+ */
+function failWithDoneDueToSuccess(done) {
+  failWithTestDoneCallback(done, failDueToSuccessError());
+}
+/**
+ * @deprecated Use expectFailAssertErrorType from shared instead. This is kept for backwards compatibility.
+ */
+const jestExpectFailAssertErrorType = expectFailAssertErrorType;
+
+/**
+ * Wraps the input JestTestContextFactory to emit another type of Fixture for tests.
+ *
+ * @deprecated Use wrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ * @returns
+ */
+const wrapJestTestContextFactory = wrapTestContextFactory;
+/**
+ * @deprecated Use instanceWrapTestContextFactory from shared instead. This is kept for backwards compatibility.
+ */
+const instanceWrapJestTestContextFactory = instanceWrapTestContextFactory;
+
+/**
+ * @deprecated Use useTestFunctionFixture from shared instead. This is kept for backwards compatibility.
+ */
+const useJestFunctionFixture = useTestFunctionFixture;
+/**
+ * @deprecated Use useTestFunctionMapFixture from shared instead. This is kept for backwards compatibility.
+ */
+const useJestFunctionMapFixture = useTestFunctionMapFixture;
+
+export { AbstractChildJestTestContextFixture, AbstractChildTestContextFixture, AbstractJestTestContextFixture, AbstractTestContextFixture, AbstractWrappedFixture, AbstractWrappedFixtureWithInstance, EXPECT_ERROR_DEFAULT_HANDLER, ExpectedErrorOfSpecificTypeError, ExpectedFailError, JestExpectedErrorOfSpecificTypeError, JestExpectedFailError, JestUnexpectedSuccessFailureError, UnexpectedSuccessFailureError, callbackTest, expectFail, expectFailAssertErrorType, expectSuccessfulFail, failDueToSuccess, failDueToSuccessError, failSuccessfully, failSuccessfullyError, failTest, failWithDoneDueToSuccess, failWithJestDoneCallback, failWithTestDoneCallback, fakeDoneHandler, instanceWrapJestTestContextFactory, instanceWrapTestContextFactory, itShouldFail, jestExpectFailAssertErrorType, jestTestContextBuilder, shouldFail, testContextBuilder, testDoneCallbackRef, useJestContextFixture, useJestFunctionFixture, useJestFunctionMapFixture, useTestContextFixture, useTestFunctionFixture, useTestFunctionMapFixture, wrapJestTestContextFactory, wrapTestContextFactory };

package/test/package.json

@@ -1,10 +1,24 @@
 {
   "name": "@dereekb/util/test",
-  "version": "12.6.21",
-  "type": "commonjs",
-  "peerDependencies": {
-    "@dereekb/util": "*"
-  },
+  "version": "13.0.0",
   "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "node": {
+        "require": "./index.cjs.js"
+      },
+      "browser": {
+        "require": "./index.cjs.js",
+        "import": "./index.esm.js"
+      },
+      "default": "./index.cjs.js"
+    }
+  },
+  "peerDependencies": {
+    "@dereekb/util": "13.0.0",
+    "core-js": "^3.0.0"
+  }
 }

package/test/src/lib/index.d.ts

@@ -1,4 +1,2 @@
+export * from './shared';
 export * from './jest';
-export * from './jest.fail';
-export * from './jest.wrap';
-export * from './jest.function';

package/test/src/lib/jest/index.d.ts

@@ -0,0 +1,4 @@
+export * from './jest';
+export * from './jest.fail';
+export * from './jest.wrap';
+export * from './jest.function';