mirror of
https://github.com/bitwarden/browser.git
synced 2024-10-30 08:10:34 +01:00
fd85d13b18
* Add a small default time to limit timing failures * Handle subscription race conditions * Add Symbols to tracked emission types This is a bit of a cheat, but Symbols can't be cloned, so we need to nudge them to something we can handle. They are rare enough that anyone hitting this is likely to expect some special handling. * Ref count state listeners to minimize storage activity * Ensure statuses are updated * Remove notes * Use `test` when gramatically more proper * Copy race and subscription improvements to single user * Simplify observer initialization * Correct parameter names * Simplify update promises test we don't accidentally deadlock along the `getFromState` path * Fix save mock * WIP: most tests working * Avoid infinite update loop * Avoid potential deadlocks with awaiting assigned promises We were awaiting a promise assigned in a thenable. It turns out that assignment occurs before all thenables are concatenated, which can cause deadlocks. Likely, these were not showing up in tests because we're using very quick memory storage. * Fix update deadlock test * Add user update tests * Assert no double emit for multiple observers * Add use intent to method name * Ensure new subscriptions receive only newest data TODO: is this worth doing for active user state? * Remove unnecessary design requirement We don't need to await an executing update promise, we can support two emissions as long as the observable is guaranteed to get the new data. * Cleanup await spam * test cleanup option behavior * Remove unnecessary typecast * Throw over coerce for definition options * Fix state$ observable durability on cleanup
99 lines
2.5 KiB
TypeScript
99 lines
2.5 KiB
TypeScript
import { mock, MockProxy } from "jest-mock-extended";
|
|
import { Observable } from "rxjs";
|
|
|
|
import { EncString } from "@bitwarden/common/platform/models/domain/enc-string";
|
|
|
|
function newGuid() {
|
|
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
|
|
const r = (Math.random() * 16) | 0;
|
|
const v = c === "x" ? r : (r & 0x3) | 0x8;
|
|
return v.toString(16);
|
|
});
|
|
}
|
|
|
|
export function GetUniqueString(prefix = "") {
|
|
return prefix + "_" + newGuid();
|
|
}
|
|
|
|
export function BuildTestObject<T, K extends keyof T = keyof T>(
|
|
def: Partial<Pick<T, K>> | T,
|
|
constructor?: new () => T,
|
|
): T {
|
|
return Object.assign(constructor === null ? {} : new constructor(), def) as T;
|
|
}
|
|
|
|
export function mockEnc(s: string): MockProxy<EncString> {
|
|
const mocked = mock<EncString>();
|
|
mocked.decrypt.mockResolvedValue(s);
|
|
|
|
return mocked;
|
|
}
|
|
|
|
export function makeStaticByteArray(length: number, start = 0) {
|
|
const arr = new Uint8Array(length);
|
|
for (let i = 0; i < length; i++) {
|
|
arr[i] = start + i;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
/**
|
|
* Use to mock a return value of a static fromJSON method.
|
|
*/
|
|
export const mockFromJson = (stub: any) => (stub + "_fromJSON") as any;
|
|
|
|
/**
|
|
* Tracks the emissions of the given observable.
|
|
*
|
|
* Call this function before you expect any emissions and then use code that will cause the observable to emit values,
|
|
* then assert after all expected emissions have occurred.
|
|
* @param observable
|
|
* @returns An array that will be populated with all emissions of the observable.
|
|
*/
|
|
export function trackEmissions<T>(observable: Observable<T>): T[] {
|
|
const emissions: T[] = [];
|
|
observable.subscribe((value) => {
|
|
switch (value) {
|
|
case undefined:
|
|
case null:
|
|
emissions.push(value);
|
|
return;
|
|
default:
|
|
// process by type
|
|
break;
|
|
}
|
|
|
|
switch (typeof value) {
|
|
case "string":
|
|
case "number":
|
|
case "boolean":
|
|
emissions.push(value);
|
|
break;
|
|
case "symbol":
|
|
// Cheating types to make symbols work at all
|
|
emissions.push(value.toString() as T);
|
|
break;
|
|
default: {
|
|
emissions.push(clone(value));
|
|
}
|
|
}
|
|
});
|
|
return emissions;
|
|
}
|
|
|
|
function clone(value: any): any {
|
|
if (global.structuredClone != undefined) {
|
|
return structuredClone(value);
|
|
} else {
|
|
return JSON.parse(JSON.stringify(value));
|
|
}
|
|
}
|
|
|
|
export async function awaitAsync(ms = 1) {
|
|
if (ms < 1) {
|
|
await Promise.resolve();
|
|
} else {
|
|
await new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
}
|