sm-utility 2.0.0 → 2.1.0

package/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./general"), exports);
 __exportStar(require("./infrastructure"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./request"), exports);
+__exportStar(require("./stubs"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sm-utility",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "reusable utility codes for sm projects",
   "main": "index.js",
   "types": "./index.d.ts",

package/stubs/index.d.ts

@@ -0,0 +1,46 @@
+declare type GenericClass<T> = (new (...args: any[]) => T);
+declare type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+declare type TypesByMethodNames<T> = {
+    [K in keyof T]?: T[K] extends (...args: any[]) => infer R ? R : never;
+};
+declare type ResolvedTypesByMethodNames<T> = {
+    [K in keyof T]?: T[K] extends (...args: any[]) => infer R ? UnwrapPromise<R> : never;
+};
+/**
+ * Creates a mock instance of a given class with customized method implementations,
+ * where method return values are automatically unwrapped if they are promises.
+ * @example
+ * const userRepository = mockResolvedClass(UserRepository, {
+ *   findUserByToken: { token: 'adhf753', name: 'John' },
+ * });
+ * @param Class - The class to mock.
+ * @param givenMethods - An object containing customized key-value pairs where the key
+ * is the method name and the value is the resolved method value.
+ * @returns A mocked instance of the provided class with overridden methods.
+ */
+export declare function mockResolvedClass<T>(Class: GenericClass<T>, givenMethods?: ResolvedTypesByMethodNames<T>): T;
+/**
+ * Creates a mock instance of a given class with customized method implementations.
+ * @example
+ * const userRepository = mockClass(UserRepository, {
+ *   findUserByToken: Promise.resolve({ token: 'adhf753', name: 'John' }),
+ * });
+ * @param Class - The class to mock.
+ * @param methods - An object containing customized key-value pairs where the key
+ * is the method name and the value is the returned method value.
+ * @returns A mocked instance of the provided class with overridden methods.
+ */
+export declare function mockClass<T>(Class: GenericClass<T>, givenMethods?: TypesByMethodNames<T>): T;
+/**
+ * Creates a raw mock instance of a given class with no method implementations.
+ * This function is intended for use with testing frameworks like jest (spyOn) when
+ * you want to set up **manual** method spies. Alternatively, consider using
+ * {@link mockClass} or {@link mockResolvedClass} for more comprehensive method mocking.
+ * @example
+ * const rawUserRepository = rawInstance(UserRepository);
+ * jest.spyOn(rawUserRepository, 'findUserByToken').mockRejectedValue(new Error('Token expired'));
+ * @param Class - The class to mock.
+ * @returns A raw mocked instance of the provided class with no implemented methods.
+ */
+export declare function rawInstance<T>(Class: GenericClass<T>): T;
+export {};

package/stubs/index.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawInstance = exports.mockClass = exports.mockResolvedClass = void 0;
+class MockedClassInstance {
+}
+;
+/**
+ * Creates a mock instance of a given class with customized method implementations,
+ * where method return values are automatically unwrapped if they are promises.
+ * @example
+ * const userRepository = mockResolvedClass(UserRepository, {
+ *   findUserByToken: { token: 'adhf753', name: 'John' },
+ * });
+ * @param Class - The class to mock.
+ * @param givenMethods - An object containing customized key-value pairs where the key
+ * is the method name and the value is the resolved method value.
+ * @returns A mocked instance of the provided class with overridden methods.
+ */
+function mockResolvedClass(Class, givenMethods) {
+    const MockedClass = rawInstance(Class);
+    if (!givenMethods)
+        return MockedClass;
+    for (const classMethod in givenMethods) {
+        const methodName = classMethod;
+        const mockImplementation = () => givenMethods[methodName];
+        MockedClass[methodName] = mockImplementation;
+    }
+    return MockedClass;
+}
+exports.mockResolvedClass = mockResolvedClass;
+/**
+ * Creates a mock instance of a given class with customized method implementations.
+ * @example
+ * const userRepository = mockClass(UserRepository, {
+ *   findUserByToken: Promise.resolve({ token: 'adhf753', name: 'John' }),
+ * });
+ * @param Class - The class to mock.
+ * @param methods - An object containing customized key-value pairs where the key
+ * is the method name and the value is the returned method value.
+ * @returns A mocked instance of the provided class with overridden methods.
+ */
+function mockClass(Class, givenMethods) {
+    const MockedClass = rawInstance(Class);
+    if (!givenMethods)
+        return MockedClass;
+    for (const classMethod in givenMethods) {
+        const methodName = classMethod;
+        const mockImplementation = () => givenMethods[methodName];
+        MockedClass[methodName] = mockImplementation;
+    }
+    return MockedClass;
+}
+exports.mockClass = mockClass;
+/**
+ * Creates a raw mock instance of a given class with no method implementations.
+ * This function is intended for use with testing frameworks like jest (spyOn) when
+ * you want to set up **manual** method spies. Alternatively, consider using
+ * {@link mockClass} or {@link mockResolvedClass} for more comprehensive method mocking.
+ * @example
+ * const rawUserRepository = rawInstance(UserRepository);
+ * jest.spyOn(rawUserRepository, 'findUserByToken').mockRejectedValue(new Error('Token expired'));
+ * @param Class - The class to mock.
+ * @returns A raw mocked instance of the provided class with no implemented methods.
+ */
+function rawInstance(Class) {
+    const MockedClass = new MockedClassInstance();
+    const classMethods = Object.getOwnPropertyNames(Class.prototype).filter(methodName => methodName !== 'constructor' &&
+        typeof Class.prototype[methodName] === 'function');
+    for (const classMethod of classMethods) {
+        const methodName = classMethod;
+        const mockImplementation = () => {
+            throw new Error(`Method ${classMethod} not implemented`);
+        };
+        MockedClass[methodName] = mockImplementation;
+    }
+    return MockedClass;
+}
+exports.rawInstance = rawInstance;