snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/client/stories/contexts/ServerContextMock.tsx

@@ -0,0 +1,184 @@
+import type { Serialized } from '@rocket.chat/core-typings';
+import type { ServerMethodName, ServerMethodParameters, ServerMethodReturn } from '@rocket.chat/ddp-client';
+import type { Method, OperationParams, OperationResult, PathFor, PathPattern } from '@rocket.chat/rest-typings';
+import type { UploadResult } from '@rocket.chat/ui-contexts';
+import { ServerContext } from '@rocket.chat/ui-contexts';
+import type { ContextType, ReactNode } from 'react';
+import { useContext, useMemo } from 'react';
+import { action } from 'storybook/actions';
+
+const logAction = action('ServerContext');
+
+const randomDelay = (): Promise<UploadResult> => new Promise((resolve) => setTimeout(resolve, Math.random() * 1000));
+
+const uploadToEndpoint = (endpoint: PathFor<'POST'>, formData: any): Promise<UploadResult> =>
+	Promise.resolve(logAction('uploadToEndpoint', endpoint, formData)).then(randomDelay);
+
+const getStream = (
+	streamName: string,
+	options: {
+		retransmit?: boolean | undefined;
+		retransmitToSelf?: boolean | undefined;
+	} = {},
+): (<TEvent extends unknown[]>(eventName: string, callback: (...event: TEvent) => void) => () => void) => {
+	logAction('getStream', streamName, options);
+
+	return (eventName: string, callback: () => void): (() => void) => {
+		const subId = Math.random().toString(16).slice(2);
+		logAction('getStream.subscribe', streamName, eventName, subId);
+
+		randomDelay().then(() => callback());
+
+		return (): void => {
+			logAction('getStream.unsubscribe', streamName, eventName, subId);
+		};
+	};
+};
+
+type Operations = {
+	[
+		TOperation in Method extends infer TMethod
+			? TMethod extends Method
+				? PathPattern extends infer TPathPattern
+					? TPathPattern extends PathPattern
+						? {
+								id: `${TMethod} ${TPathPattern extends `/${string}` ? TPathPattern : `/v1/${TPathPattern}`}`;
+								fn: (
+									params: void extends OperationParams<TMethod, TPathPattern> ? void : OperationParams<TMethod, TPathPattern>,
+								) => Promise<
+									void extends OperationResult<TMethod, TPathPattern> ? Serialized<OperationResult<TMethod, TPathPattern>> : void
+								>;
+							}
+						: never
+					: never
+				: never
+			: never as TOperation['id']
+	]: TOperation['fn'];
+};
+
+export type ServerContextMockProps = Omit<Partial<ContextType<typeof ServerContext>>, 'callEndpoint' | 'callMethod'> & {
+	children: ReactNode;
+	baseURL?: string | URL;
+	callEndpoint?: {
+		[TOperationID in keyof Operations]?: Operations[TOperationID] | 'infinite' | 'errored';
+	};
+	callMethod?: {
+		[TMethodName in ServerMethodName]?:
+			((...args: ServerMethodParameters<TMethodName>) => Promise<ServerMethodReturn<TMethodName>>) | 'infinite' | 'errored';
+	};
+};
+
+const ServerContextMock = ({ children, baseURL, callEndpoint = {}, callMethod = {}, ...overrides }: ServerContextMockProps) => {
+	const parent = useContext(ServerContext);
+
+	const value = useMemo((): ContextType<typeof ServerContext> => {
+		type ServerContextValue = ContextType<typeof ServerContext>;
+
+		const absoluteURL: ServerContextValue['absoluteUrl'] = (path): string => {
+			logAction('absoluteUrl', path);
+			try {
+				return new URL(path, baseURL).toString();
+			} catch (e) {
+				return path;
+			}
+		};
+
+		const mockedEndpoints = Object.entries(callEndpoint).map(
+			([operationID, handler]): {
+				match: (method: string, path: string) => boolean;
+				handler: ((params: any) => Promise<unknown>) | 'infinite' | 'errored' | undefined;
+			} => {
+				const [_method, _pathPattern] = operationID.split(' ');
+				return {
+					match: (method: string, pathPattern: string): boolean => _method === method && _pathPattern === pathPattern,
+					handler: handler as any,
+				};
+			},
+		);
+
+		const _callEndpoint: ServerContextValue['callEndpoint'] = async <TMethod extends Method, TPathPattern extends PathPattern>({
+			method,
+			pathPattern,
+			params,
+		}: {
+			method: TMethod;
+			pathPattern: TPathPattern;
+			params: OperationParams<TMethod, TPathPattern>;
+		}): Promise<Serialized<OperationResult<TMethod, TPathPattern>>> => {
+			const mockedEndpoint = mockedEndpoints.find((endpoint) => endpoint.match(method, pathPattern));
+			const handler = mockedEndpoint?.handler;
+
+			if (!handler) {
+				logAction('callEndpoint (undefined)', method, pathPattern, params);
+				return undefined as any;
+			}
+
+			if (handler === 'infinite') {
+				logAction('callEndpoint (infinite)', method, pathPattern, params);
+				return new Promise(() => undefined);
+			}
+
+			if (handler === 'errored') {
+				logAction('callEndpoint (errored)', method, pathPattern, params);
+				throw new Error(`${method} ${pathPattern} failed`);
+			}
+
+			logAction('callEndpoint (intercepted)', method, pathPattern, params);
+			return handler(params) as Promise<Serialized<OperationResult<TMethod, TPathPattern>>>;
+		};
+
+		const _callMethod: ServerContextValue['callMethod'] = async <MethodName extends ServerMethodName>(
+			methodName: MethodName,
+			...args: ServerMethodParameters<MethodName>
+		): Promise<ServerMethodReturn<MethodName>> => {
+			const handler = callMethod[methodName];
+			if (!handler) {
+				logAction('callMethod (undefined)', methodName, ...args);
+				return undefined as any;
+			}
+
+			if (handler === 'infinite') {
+				logAction('callMethod (infinite)', methodName, ...args);
+				return new Promise<any>(() => undefined);
+			}
+
+			if (handler === 'errored') {
+				logAction('callMethod (errored)', methodName, ...args);
+				throw new Error(`${methodName} failed`);
+			}
+
+			logAction('callMethod (intercepted)', methodName, ...args);
+			return handler(...args);
+		};
+
+		return {
+			...parent,
+			info: {
+				version: 'x.y.z',
+				build: {
+					platform: 'storybook',
+					arch: 'storybook cpu',
+					cpus: 1,
+					date: new Date().toLocaleDateString(),
+					nodeVersion: 'lts',
+					osRelease: 'x',
+					freeMemory: 639 * 1024,
+					totalMemory: 640 * 1024,
+				},
+				commit: {},
+				marketplaceApiVersion: 'x.y.z',
+			},
+			absoluteUrl: absoluteURL,
+			callEndpoint: _callEndpoint,
+			callMethod: _callMethod,
+			uploadToEndpoint,
+			getStream,
+			getStreamAll: () => () => () => undefined,
+			...overrides,
+		};
+	}, [baseURL, callEndpoint, callMethod, overrides, parent]);
+
+	return <ServerContext.Provider value={value}>{children}</ServerContext.Provider>;
+};
+
+export default ServerContextMock;