@tutao/tutanota-test-utils 3.89.24 → 3.91.2-beta.0

package/README.md

@@ -3,9 +3,4 @@
 This is a collection of common test utils we use across multiple projects/modules internally. As creating this module
 really is just an intermediate step towards re-organising some of the dependency structure of our software, it is most
 likely going to change a lot in the future and might even disappear altogether. For these reasons **we strongly
-discourage anyone outside of our organisation to directly depend on this module**.
-
-For now we only provide this as a flow-typed source module and not compiled for ES6 or CJS. The reason is that our
-current tooling (flow, rollup, webstorm) will not allow us to use the compiled version directly without putting a lot of
-effort into restructuring the way we build tutanota and/or changing some of our tools or losing some convenient IDE
-features such as usage search.
+discourage anyone outside of our organisation to directly depend on this module**.

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,20 +1,19 @@
 {
 	"name": "@tutao/tutanota-test-utils",
-	"version": "3.89.24",
+	"version": "3.91.2-beta.0",
 	"license": "GPL-3.0",
-	"main": "./lib/index.js",
+	"main": "./dist/index.js",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/tutao/tutanota.git",
 		"directory": "packages/tutanota-test-utils"
 	},
 	"scripts": {
-		"flow": "flow; test $? -eq 0 -o $? -eq 2",
-		"test": "echo \"No tests defined for module\""
+		"build": "rm -r dist; tsc"
 	},
 	"type": "module",
 	"files": [
-		"lib/*",
+		"dist/*",
 		"README.md",
 		"LICENSE.txt"
 	],
@@ -22,6 +21,6 @@
 		"ospec": "https://github.com/tutao/ospec.git#0472107629ede33be4c4d19e89f237a6d7b0cb11"
 	},
 	"devDependencies": {
-		"flow-bin": "0.152.0"
+		"typescript": "4.5.4"
 	}
-}
+}

package/lib/TestUtils.js

@@ -1,141 +0,0 @@
-// @flow
-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: Object, attributeOnObject: Function | Object, attributeMock: Function | Object): Object {
-	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: Object) {
-	mock._originalObject[mock._attributeName] = mock._originalAttribute
-}
-
-export type Spy = ((...any) => any) & {invocations: any[]}
-
-export function spy(producer?: (...any) => any): Spy {
-	const invocations = []
-	const s = (...args: any[]) => {
-		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 = <T>(obj: T, mocker: any => any): T => {
-	mocker(obj)
-	return obj
-}
-
-export function mapToObject<K, V>(map: Map<K, V>): {[K]: V} {
-	const obj: {[K]: V} = {}
-	map.forEach((value, key) => {
-		obj[key] = value
-	})
-	return obj
-}
-
-export function mapObject<K, V, R>(mapper: (V) => R, obj: {[K]: V}): {[K]: R} {
-	const newObj = {}
-	for (let key of Object.keys(obj)) {
-		newObj[key] = mapper(obj[key])
-	}
-	return newObj
-}
-
-export function replaceAllMaps(toReplace: any): any {
-	return toReplace instanceof Map
-		? replaceAllMaps(mapToObject(toReplace))
-		: toReplace instanceof Array
-			? toReplace.map(replaceAllMaps)
-			: toReplace != null && Object.getPrototypeOf(toReplace) === (Object: any).prototype // plain object
-				? mapObject(replaceAllMaps, toReplace)
-				: toReplace
-}
-
-/** Catch error and return either value or error */
-export async function asResult<T>(p: Promise<T>): Promise<T | Error> {
-	return p.catch((e) => e)
-}
-
-export async function assertThrows<T: Error>(expected: Class<T>, fn: () => Promise<mixed>): Promise<T> {
-	try {
-		await fn()
-	} catch (e) {
-		o(e instanceof expected).equals(true)("AssertThrows failed: Expected a " + (expected: any) + " to be thrown, but got a "
-			+ e.constructor)
-		return e
-	}
-	throw new Error("AssertThrows failed: Expected a " + (expected: any) + " to be thrown, but nothing was")
-}
-
-
-export async function assertResolvedIn(ms: number, ...promises: $ReadOnlyArray<Promise<*>>): Promise<*> {
-	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: number, ...promises: $ReadOnlyArray<Promise<*>>): Promise<*> {
-	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 interface TimeoutMock {
-	(fn: () => mixed, time: number): TimeoutID,
-
-	next(): void
-
-}
-
-export function makeTimeoutMock(): TimeoutMock {
-	let timeoutId = 1
-	let scheduledFn
-	const timeoutMock = function (fn: () => mixed) {
-		scheduledFn = fn
-		timeoutId++
-		return timeoutId
-	}
-	const spiedMock = o.spy(timeoutMock)
-
-	spiedMock.next = function () {
-		scheduledFn && scheduledFn()
-	}
-	return (spiedMock: any)
-}
-
-function delay(ms: number): Promise<void> {
-	return new Promise((resolve) => {
-		setTimeout(resolve, ms)
-	})
-}

package/lib/index.js

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