@rimori/playwright-testing 0.2.0

package/dist/core/MessageChannelSimulator.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageChannelSimulator = void 0;
+const node_crypto_1 = require("node:crypto");
+const default_user_info_1 = require("../fixtures/default-user-info");
+class MessageChannelSimulator {
+    /**
+     * Creates a simulator that mimics the Rimori host for plugin tests.
+     * @param param
+     * @param param.page - Playwright page hosting the plugin iframe.
+     * @param param.pluginId - Target plugin identifier.
+     * @param param.queryParams - Query parameters forwarded to the plugin init.
+     */
+    constructor({ page, pluginId, queryParams, rimoriInfo }) {
+        this.listeners = new Map();
+        this.autoResponders = new Map();
+        this.pendingOutbound = [];
+        this.currentRimoriInfo = null;
+        this.isReady = false;
+        this.instanceId = (0, node_crypto_1.randomUUID)();
+        this.page = page;
+        this.pluginId = pluginId;
+        this.queryParams = queryParams ?? {};
+        this.baseUserInfo = this.cloneUserInfo(default_user_info_1.DEFAULT_USER_INFO);
+        this.currentUserInfo = this.cloneUserInfo(default_user_info_1.DEFAULT_USER_INFO);
+        this.providedInfo = rimoriInfo ? this.cloneRimoriInfo(rimoriInfo) : undefined;
+        this.registerAutoResponders();
+    }
+    get defaultUserInfo() {
+        return this.cloneUserInfo(this.baseUserInfo);
+    }
+    get userInfo() {
+        return this.cloneUserInfo(this.currentUserInfo);
+    }
+    /**
+     * Injects the handshake shims so the plugin talks to this simulator.
+     */
+    async initialize() {
+        await this.page.exposeBinding('__rimoriSimulator_onHello', async () => {
+            await this.setupMessageChannel();
+        }, { handle: false });
+        await this.page.exposeBinding('__rimoriSimulator_onPortMessage', async (_source, payload) => {
+            await this.handlePortMessage(payload);
+        }, { handle: false });
+        await this.page.addInitScript(({ pluginId }) => {
+            // Create a fake parent window object to simulate iframe environment
+            // This ensures window !== window.parent (so standalone mode is NOT triggered)
+            const fakeParent = {
+                postMessage: (message, targetOriginOrOptions, transfer) => {
+                    const payload = (message ?? {});
+                    // Intercept rimori:hello messages
+                    if (payload.type === 'rimori:hello' && payload.pluginId === pluginId) {
+                        // @ts-expect-error binding injected at runtime
+                        window.__rimoriSimulator_onHello();
+                        return;
+                    }
+                    // Intercept rimori:acknowledged messages (plugin finished initialization)
+                    if (payload.type === 'rimori:acknowledged' && payload.pluginId === pluginId) {
+                        // Plugin has acknowledged init completion - no action needed, just intercept
+                        return;
+                    }
+                    // For all other messages, allow normal postMessage behavior
+                    // This handles cases where the plugin might send other messages
+                    // Handle both string targetOrigin and WindowPostMessageOptions object
+                    if (typeof targetOriginOrOptions === 'object' && targetOriginOrOptions !== null) {
+                        window.postMessage(message, targetOriginOrOptions);
+                    }
+                    else {
+                        window.postMessage(message, targetOriginOrOptions ?? '*', transfer);
+                    }
+                },
+                // Add other Window properties that might be accessed
+                location: window.location,
+                top: window.top,
+                frames: window.frames,
+                length: window.length,
+                closed: false,
+                opener: null,
+                frameElement: null,
+                self: window.self,
+                window: window,
+                document: window.document,
+                navigator: window.navigator,
+                history: window.history,
+                screen: window.screen,
+                outerHeight: window.outerHeight,
+                outerWidth: window.outerWidth,
+                innerHeight: window.innerHeight,
+                innerWidth: window.innerWidth,
+                scrollX: window.scrollX,
+                scrollY: window.scrollY,
+                pageXOffset: window.pageXOffset,
+                pageYOffset: window.pageYOffset,
+                // Make it NOT equal to window
+                toString: () => '[object Window] (parent)',
+            };
+            // Override window.parent to return our fake parent
+            // This makes window !== window.parent (iframe mode, not standalone)
+            Object.defineProperty(window, 'parent', {
+                get: () => fakeParent,
+                configurable: true, // Allow reconfiguration if needed
+                enumerable: true,
+            });
+        }, {
+            pluginId: this.pluginId,
+        });
+    }
+    /**
+     * Sends an event into the plugin as though the Rimori parent emitted it.
+     */
+    async emit(topic, data, sender = 'global') {
+        const message = {
+            event: {
+                timestamp: new Date().toISOString(),
+                sender,
+                topic,
+                data,
+                debug: false,
+            },
+        };
+        if (!this.isReady) {
+            this.pendingOutbound.push(message);
+            return;
+        }
+        await this.sendToPlugin(message);
+    }
+    /**
+     * Registers a handler for events emitted from the plugin.
+     */
+    on(topic, handler) {
+        const handlers = this.listeners.get(topic) ?? new Set();
+        handlers.add(handler);
+        this.listeners.set(topic, handlers);
+        return () => {
+            const existing = this.listeners.get(topic);
+            if (!existing) {
+                return;
+            }
+            existing.delete(handler);
+            if (existing.size === 0) {
+                this.listeners.delete(topic);
+            }
+        };
+    }
+    /**
+     * Overrides the default profile returned by the auto responders.
+     */
+    setUserInfo(overrides) {
+        this.currentUserInfo = this.mergeUserInfo(this.currentUserInfo, overrides);
+        if (this.currentRimoriInfo) {
+            this.currentRimoriInfo.profile = this.cloneUserInfo(this.currentUserInfo);
+        }
+    }
+    getRimoriInfo() {
+        return this.currentRimoriInfo ? this.cloneRimoriInfo(this.currentRimoriInfo) : null;
+    }
+    async setupMessageChannel() {
+        if (this.isReady) {
+            return;
+        }
+        const rimoriInfo = this.buildRimoriInfo();
+        this.currentRimoriInfo = rimoriInfo;
+        const serialized = this.serializeRimoriInfo(rimoriInfo);
+        await this.page.evaluate(({ pluginId, queryParams, instanceId, rimoriInfo: info, }) => {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = (event) => {
+                // @ts-expect-error binding injected via exposeBinding
+                window.__rimoriSimulator_onPortMessage(event.data);
+            };
+            window.__rimoriSimulator_sendToPlugin = (payload) => {
+                channel.port1.postMessage(payload);
+            };
+            const initEvent = new MessageEvent('message', {
+                data: {
+                    type: 'rimori:init',
+                    pluginId,
+                    instanceId,
+                    queryParams,
+                    rimoriInfo: {
+                        ...info,
+                        expiration: new Date(info.expiration),
+                    },
+                },
+                ports: [channel.port2],
+            });
+            window.dispatchEvent(initEvent);
+        }, {
+            pluginId: this.pluginId,
+            queryParams: this.queryParams,
+            instanceId: this.instanceId,
+            rimoriInfo: serialized,
+        });
+        this.isReady = true;
+        await this.flushPending();
+    }
+    async sendToPlugin(message) {
+        await this.page.evaluate((payload) => {
+            const bridge = window.__rimoriSimulator_sendToPlugin;
+            if (!bridge) {
+                throw new Error('Simulator bridge unavailable');
+            }
+            bridge(payload);
+        }, message);
+    }
+    async flushPending() {
+        if (!this.pendingOutbound.length) {
+            return;
+        }
+        for (const message of this.pendingOutbound.splice(0)) {
+            await this.sendToPlugin(message);
+        }
+    }
+    async handlePortMessage(payload) {
+        if (!payload) {
+            return;
+        }
+        if ('event' in payload && payload.event) {
+            console.log('[MessageChannelSimulator] handlePortMessage - received event:', payload.event.topic, 'from:', payload.event.sender);
+            await this.dispatchEvent(payload.event);
+            await this.maybeRespond(payload.event);
+            return;
+        }
+    }
+    async dispatchEvent(event) {
+        console.log('[MessageChannelSimulator] dispatchEvent - topic:', event.topic, 'sender:', event.sender, 'listeners:', this.listeners.has(event.topic) ? this.listeners.get(event.topic)?.size : 0);
+        const handlers = this.listeners.get(event.topic);
+        if (!handlers?.size) {
+            console.log('[MessageChannelSimulator] No handlers found for topic:', event.topic);
+            console.log('[MessageChannelSimulator] Available topics:', Array.from(this.listeners.keys()));
+            return;
+        }
+        console.log('[MessageChannelSimulator] Calling', handlers.size, 'handler(s) for topic:', event.topic);
+        for (const handler of handlers) {
+            await handler(event);
+        }
+    }
+    async maybeRespond(event) {
+        if (!event.eventId) {
+            return;
+        }
+        const responder = this.autoResponders.get(event.topic);
+        if (!responder) {
+            return;
+        }
+        const data = await responder(event);
+        await this.sendToPlugin({
+            type: 'response',
+            eventId: event.eventId,
+            response: {
+                topic: event.topic,
+                data,
+            },
+        });
+    }
+    buildRimoriInfo() {
+        if (this.providedInfo) {
+            const clone = this.cloneRimoriInfo(this.providedInfo);
+            clone.profile = this.cloneUserInfo(this.currentUserInfo);
+            clone.pluginId = this.pluginId;
+            clone.tablePrefix = clone.tablePrefix || `${this.pluginId}_`;
+            return clone;
+        }
+        return {
+            url: 'http://localhost:3500',
+            key: 'rimori-sdk-key',
+            backendUrl: 'http://localhost:3501',
+            token: 'rimori-token',
+            expiration: new Date(Date.now() + 60 * 60 * 1000),
+            tablePrefix: `${this.pluginId}_`,
+            pluginId: this.pluginId,
+            guild: {
+                id: 'guild-test',
+                longTermGoalOverride: '',
+                allowUserPluginSettings: true,
+            },
+            installedPlugins: [
+                {
+                    id: this.pluginId,
+                    title: 'Test Plugin',
+                    description: 'Playwright testing plugin',
+                    logo: '',
+                    url: 'https://plugins.rimori.localhost',
+                },
+            ],
+            profile: this.cloneUserInfo(this.currentUserInfo),
+        };
+    }
+    serializeRimoriInfo(info) {
+        return {
+            ...info,
+            expiration: info.expiration.toISOString(),
+        };
+    }
+    cloneUserInfo(input) {
+        return JSON.parse(JSON.stringify(input));
+    }
+    mergeUserInfo(current, overrides) {
+        const clone = this.cloneUserInfo(current);
+        if (overrides.mother_tongue) {
+            clone.mother_tongue = {
+                ...clone.mother_tongue,
+                ...overrides.mother_tongue,
+            };
+        }
+        if (overrides.target_language) {
+            clone.target_language = {
+                ...clone.target_language,
+                ...overrides.target_language,
+            };
+        }
+        if (overrides.study_buddy) {
+            clone.study_buddy = {
+                ...clone.study_buddy,
+                ...overrides.study_buddy,
+            };
+        }
+        const { mother_tongue, target_language, study_buddy, ...rest } = overrides;
+        for (const [key, value] of Object.entries(rest)) {
+            if (value === undefined) {
+                continue;
+            }
+            clone[key] = value;
+        }
+        return clone;
+    }
+    registerAutoResponders() {
+        this.autoResponders.set('global.supabase.requestAccess', () => this.buildRimoriInfo());
+        this.autoResponders.set('global.profile.requestUserInfo', () => this.cloneUserInfo(this.currentUserInfo));
+        this.autoResponders.set('global.profile.getUserInfo', () => this.cloneUserInfo(this.currentUserInfo));
+    }
+    cloneRimoriInfo(info) {
+        return {
+            ...info,
+            expiration: new Date(info.expiration),
+            guild: { ...info.guild },
+            installedPlugins: info.installedPlugins.map((plugin) => ({ ...plugin })),
+            profile: this.cloneUserInfo(info.profile),
+        };
+    }
+}
+exports.MessageChannelSimulator = MessageChannelSimulator;

package/dist/core/RimoriTestEnvironment.d.ts

@@ -0,0 +1,168 @@
+import { Page, Request } from '@playwright/test';
+import { UserInfo } from '@rimori/client/dist/controller/SettingsController';
+import { MainPanelAction, Plugin } from '@rimori/client/dist/fromRimori/PluginTypes';
+interface RimoriTestEnvironmentOptions {
+    page: Page;
+    pluginId: string;
+    queryParams?: Record<string, string>;
+    userInfo?: Record<string, unknown>;
+    installedPlugins?: Plugin[];
+    guildOverrides?: Record<string, unknown>;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+interface MockOptions {
+    error?: 'aborted' | 'accessdenied' | 'addressunreachable' | 'blockedbyclient' | 'blockedbyresponse' | 'connectionaborted' | 'connectionclosed' | 'connectionfailed' | 'connectionrefused' | 'connectionreset' | 'internetdisconnected' | 'namenotresolved' | 'timedout';
+    /**
+     * The delay in milliseconds before the response is returned.
+     */
+    delay?: number;
+    /**
+     * Optional matcher function to determine if this mock should be used for the request.
+     * If provided, the mock will only be used if the matcher returns true.
+     * If multiple mocks match, the first one in the array will be used.
+     */
+    matcher?: (request: Request) => boolean;
+    /**
+     * The HTTP method for the route. If not provided, defaults will be used based on the route type.
+     */
+    method?: HttpMethod;
+}
+export declare class RimoriTestEnvironment {
+    private readonly page;
+    private readonly pluginId;
+    private rimoriInfo;
+    private backendRoutes;
+    private supabaseRoutes;
+    private messageChannelSimulator;
+    constructor(options: RimoriTestEnvironmentOptions);
+    private interceptRoutes;
+    setup(): Promise<void>;
+    /**
+     * Formats text as SSE (Server-Sent Events) response.
+     * Since Playwright's route.fulfill() requires complete body, we format as SSE without delays.
+     */
+    private formatAsSSE;
+    /**
+     * Normalizes a URL by removing query parameters and fragments for consistent matching.
+     */
+    private normalizeUrl;
+    /**
+     * Creates a route key combining HTTP method and normalized URL.
+     */
+    private createRouteKey;
+    private handleRoute;
+    /**
+     * Adds a supabase route to the supabase routes object.
+     * @param path - The path of the route.
+     * @param values - The values to return in the response.
+     * @param options - The options for the route. Method defaults to 'GET' if not specified.
+     */
+    private addSupabaseRoute;
+    /**
+     * Adds a backend route to the backend routes object.
+     * @param path - The path of the route.
+     * @param values - The values to return in the response.
+     * @param options - The options for the route. Method defaults to 'POST' if not specified.
+     * @param isStreaming - Optional flag to mark this as a streaming response.
+     */
+    private addBackendRoute;
+    readonly plugin: {
+        /**
+         * Mocks PATCH request for updating plugin_settings.
+         * @param response - The response for PATCH. Defaults to empty array (no rows updated).
+         *                   Should return array with updated row(s) like [{ id: '...' }] if update succeeds.
+         */
+        mockSetSettings: (response?: unknown, options?: MockOptions) => void;
+        /**
+         * Mocks GET request for fetching plugin_settings.
+         * @param settingsRow - The full row object from plugin_settings table, or null if not found.
+         *                      Should include: { id, plugin_id, guild_id, settings, is_guild_setting, user_id }.
+         *                      If null, simulates no settings exist (triggers INSERT flow).
+         */
+        mockGetSettings: (settingsRow: {
+            id?: string;
+            plugin_id?: string;
+            guild_id?: string;
+            settings?: Record<string, unknown>;
+            is_guild_setting?: boolean;
+            user_id?: string | null;
+        } | null, options?: MockOptions) => void;
+        /**
+         * Mocks POST request for inserting plugin_settings.
+         * @param response - The response for POST. Defaults to success response with inserted row.
+         */
+        mockInsertSettings: (response?: unknown, options?: MockOptions) => void;
+        mockGetUserInfo: (userInfo: Partial<UserInfo>, options?: MockOptions) => void;
+        mockGetPluginInfo: (pluginInfo: Plugin, options?: MockOptions) => void;
+    };
+    readonly db: {
+        mockFrom: () => void;
+        mockTable: () => void;
+    };
+    readonly event: {
+        mockEmit: () => void;
+        mockRequest: () => void;
+        mockOn: () => void;
+        mockOnce: () => void;
+        mockRespond: () => void;
+        mockEmitAccomplishment: () => void;
+        mockOnAccomplishment: () => void;
+        mockEmitSidebarAction: () => void;
+        /**
+         * Triggers a side panel action event as the parent application would.
+         * This simulates how rimori-main's SidebarPluginHandler responds to plugin's 'action.requestSidebar' events.
+         * @param payload - The action payload containing plugin_id, action_key, and action parameters
+         */
+        triggerOnSidePanelAction: (payload: MainPanelAction) => Promise<void>;
+        /**
+         * Triggers a main panel action event as the parent application would.
+         * This simulates how rimori-main's MainPluginHandler uses EventBus.respond to respond
+         * to plugin's 'action.requestMain' events. When the plugin calls onMainPanelAction(),
+         * it emits '{pluginId}.action.requestMain' and listens for the response.
+         * This method sets up a responder that automatically responds when the plugin emits this event.
+         * @param payload - The main panel action payload containing plugin_id, action_key, and action parameters
+         */
+        triggerOnMainPanelAction: (payload: MainPanelAction) => Promise<void>;
+    };
+    readonly ai: {
+        mockGetText: (values: unknown, options?: MockOptions) => void;
+        /**
+         * Mocks a streaming text response from the LLM endpoint.
+         * The text will be formatted as SSE (Server-Sent Events) to simulate streaming.
+         *
+         * **Note**: Due to Playwright's route.fulfill() requiring a complete response body,
+         * all SSE chunks are sent at once (no delays). The client will still parse it as SSE correctly.
+         *
+         * @param text - The text to stream. Will be formatted as SSE chunks.
+         * @param options - Optional mock options.
+         */
+        mockGetSteamedText: (text: string, options?: MockOptions) => void;
+        mockGetVoice: (values: Buffer, options?: MockOptions) => void;
+        mockGetTextFromVoice: (text: string, options?: MockOptions) => void;
+        mockGetObject: (value: unknown, options?: MockOptions) => void;
+    };
+    readonly runtime: {
+        mockFetchBackend: () => void;
+    };
+    readonly community: {
+        sharedContent: {
+            mockGet: () => void;
+            mockGetList: () => void;
+            mockGetNew: () => void;
+            mockCreate: () => void;
+            mockUpdate: () => void;
+            mockComplete: () => void;
+            mockUpdateState: () => void;
+            mockRemove: () => void;
+        };
+    };
+    readonly exercise: {
+        mockView: () => void;
+        mockAdd: () => void;
+        mockDelete: () => void;
+    };
+    readonly navigation: {
+        mockToDashboard: () => void;
+    };
+}
+export {};