@tutao/tutanota-test-utils 3.91.2 → 3.91.3

package/dist/TestUtils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Mocks an attribute (function or object) on an object and makes sure that it can be restored to the original attribute by calling unmockAttribute() later.
+ * Additionally creates a spy for the attribute if the attribute is a function.
+ * @param object The object on which the attribute exists.
+ * @param attributeOnObject The attribute to mock.
+ * @param attributeMock The attribute mock.
+ * @returns An object to be passed to unmockAttribute() in order to restore the original attribute.
+ */
+export declare function mockAttribute(object: Record<string, any>, attributeOnObject: ((...args: Array<any>) => any) | Record<string, any>, attributeMock: ((...args: Array<any>) => any) | Record<string, any>): Record<string, any>;
+export declare function unmockAttribute(mock: Record<string, any>): void;
+export declare type Spy = ((...args: any) => any) & {
+    invocations: any[];
+};
+export declare function spy(producer?: (...args: any) => any): Spy;
+/**
+ * Create partial mock, i.e. allows mocking attributes or functions on actual instances
+ * @param obj The base mock object on which mocker may overwrite attributes or functions
+ * @param mocker This function receives obj and can overwrite attributes or functions.
+ * @returns {T}
+ */
+export declare const mock: <T>(obj: T, mocker: (arg0: any) => any) => T;
+export declare function mapToObject<K extends string | number | symbol, V>(map: Map<K, V>): Record<K, V>;
+export declare function mapObject<K extends string | number | symbol, V, R>(mapper: (arg0: V) => R, obj: Record<K, V>): Record<K, R>;
+export declare function replaceAllMaps(toReplace: any): any;
+/** Catch error and return either value or error */
+export declare function asResult<T>(p: Promise<T>): Promise<T | Error>;
+export declare function assertThrows<T extends Error>(expected: Class<T>, fn: () => Promise<unknown>): Promise<T>;
+export declare function assertResolvedIn(ms: number, ...promises: ReadonlyArray<Promise<any>>): Promise<any>;
+export declare function assertNotResolvedIn(ms: number, ...promises: ReadonlyArray<Promise<any>>): Promise<any>;
+export interface TimeoutMock {
+    (fn: () => unknown, time: number): ReturnType<typeof setTimeout>;
+    next(): void;
+}
+export declare function makeTimeoutMock(): TimeoutMock;

package/dist/TestUtils.js

@@ -0,0 +1,114 @@
+import o from "ospec";
+/**
+ * Mocks an attribute (function or object) on an object and makes sure that it can be restored to the original attribute by calling unmockAttribute() later.
+ * Additionally creates a spy for the attribute if the attribute is a function.
+ * @param object The object on which the attribute exists.
+ * @param attributeOnObject The attribute to mock.
+ * @param attributeMock The attribute mock.
+ * @returns An object to be passed to unmockAttribute() in order to restore the original attribute.
+ */
+export function mockAttribute(object, attributeOnObject, attributeMock) {
+    if (attributeOnObject == null)
+        throw new Error("attributeOnObject is undefined");
+    let attributeName = Object.getOwnPropertyNames(object).find(key => object[key] === attributeOnObject);
+    if (!attributeName) {
+        attributeName = Object.getOwnPropertyNames(Object.getPrototypeOf(object)).find(key => object[key] === attributeOnObject);
+    }
+    if (!attributeName) {
+        throw new Error("attribute not found on object");
+    }
+    object[attributeName] = typeof attributeOnObject == "function" ? o.spy(attributeMock) : attributeMock;
+    return {
+        _originalObject: object,
+        _originalAttribute: attributeOnObject,
+        _attributeName: attributeName,
+    };
+}
+export function unmockAttribute(mock) {
+    mock._originalObject[mock._attributeName] = mock._originalAttribute;
+}
+export function spy(producer) {
+    const invocations = [];
+    const s = (...args) => {
+        invocations.push(args);
+        return producer && producer(...args);
+    };
+    s.invocations = invocations;
+    return s;
+}
+/**
+ * Create partial mock, i.e. allows mocking attributes or functions on actual instances
+ * @param obj The base mock object on which mocker may overwrite attributes or functions
+ * @param mocker This function receives obj and can overwrite attributes or functions.
+ * @returns {T}
+ */
+export const mock = (obj, mocker) => {
+    mocker(obj);
+    return obj;
+};
+export function mapToObject(map) {
+    const obj = {};
+    map.forEach((value, key) => {
+        obj[key] = value;
+    });
+    return obj;
+}
+export function mapObject(mapper, obj) {
+    const newObj = {};
+    for (let key of Object.keys(obj)) {
+        newObj[key] = mapper(obj[key]);
+    }
+    return newObj;
+}
+export function replaceAllMaps(toReplace) {
+    return toReplace instanceof Map
+        ? replaceAllMaps(mapToObject(toReplace))
+        : toReplace instanceof Array
+            ? toReplace.map(replaceAllMaps)
+            : toReplace != null && Object.getPrototypeOf(toReplace) === Object.prototype // plain object
+                ? mapObject(replaceAllMaps, toReplace)
+                : toReplace;
+}
+/** Catch error and return either value or error */
+export async function asResult(p) {
+    return p.catch(e => e);
+}
+export async function assertThrows(expected, fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        o(e instanceof expected).equals(true)("AssertThrows failed: Expected a " + expected + " to be thrown, but got a " + e.constructor);
+        return e;
+    }
+    throw new Error("AssertThrows failed: Expected a " + expected + " to be thrown, but nothing was");
+}
+export async function assertResolvedIn(ms, ...promises) {
+    const allP = [delay(ms).then(() => "timeout")].concat(promises.map((p, i) => p.then(() => `promise ${i} is resolved`)));
+    const result = await Promise.race(allP);
+    o(result).notEquals("timeout");
+}
+export async function assertNotResolvedIn(ms, ...promises) {
+    const allP = [delay(ms).then(() => "timeout")].concat(promises.map((p, i) => p.then(() => `promise ${i} is resolved`)));
+    const result = await Promise.race(allP);
+    o(result).equals("timeout");
+}
+export function makeTimeoutMock() {
+    let timeoutId = 1;
+    let scheduledFn;
+    const timeoutMock = function (fn) {
+        scheduledFn = fn;
+        timeoutId++;
+        return timeoutId;
+    };
+    const spiedMock = o.spy(timeoutMock);
+    spiedMock.next = function () {
+        scheduledFn && scheduledFn();
+    };
+    return spiedMock;
+}
+function delay(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { mockAttribute, unmockAttribute, spy, mock, mapToObject, mapObject, replaceAllMaps, asResult, assertThrows, assertResolvedIn, assertNotResolvedIn, makeTimeoutMock, } from "./TestUtils.js";
+export type { Spy, TimeoutMock } from "./TestUtils.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { mockAttribute, unmockAttribute, spy, mock, mapToObject, mapObject, replaceAllMaps, asResult, assertThrows, assertResolvedIn, assertNotResolvedIn, makeTimeoutMock, } from "./TestUtils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tutao/tutanota-test-utils",
-	"version": "3.91.2",
+	"version": "3.91.3",
 	"license": "GPL-3.0",
 	"main": "./dist/index.js",
 	"repository": {