@tutao/tutanota-test-utils 3.89.23 → 3.91.1

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/package.json

@@ -1,20 +1,19 @@
 {
 	"name": "@tutao/tutanota-test-utils",
-	"version": "3.89.23",
+	"version": "3.91.1",
 	"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"