@rimori/playwright-testing 0.2.2 → 0.2.3-next.1

package/dist/core/RimoriTestEnvironment.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RimoriTestEnvironment = void 0;
 const default_user_info_1 = require("../fixtures/default-user-info");
 const MessageChannelSimulator_1 = require("./MessageChannelSimulator");
+const SettingsStateManager_1 = require("./SettingsStateManager");
 class RimoriTestEnvironment {
     constructor(options) {
         this.backendRoutes = {};
@@ -10,57 +11,45 @@ class RimoriTestEnvironment {
         this.messageChannelSimulator = null;
         this.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.
+             * Manually set the settings state (useful for test setup).
+             * This directly modifies the internal settings state.
+             * @param settings - The settings to set, or null to clear settings
              */
-            mockSetSettings: (response, options) => {
-                console.log('Mocking set settings for mockSetSettings', response, options);
-                console.warn('mockSetSettings is not tested');
-                // PATCH request returns array of updated rows
-                // Empty array means no rows matched (will trigger INSERT)
-                // Array with items means update succeeded
-                const defaultResponse = response ?? [];
-                this.addSupabaseRoute('plugin_settings', defaultResponse, { ...options, method: 'PATCH' });
+            setSettings: (settings) => {
+                this.settingsManager.setSettings(settings);
+            },
+            /**
+             * Get the current settings state (useful for assertions).
+             * @returns The current settings or null if no settings exist
+             */
+            getSettings: () => {
+                return this.settingsManager.getSettings();
             },
             /**
-             * 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).
+             * Override the GET handler for plugin_settings (rarely needed).
+             * By default, GET returns the current state from SettingsStateManager.
              */
             mockGetSettings: (settingsRow, options) => {
-                console.log('Mocking get settings for mockGetSettings', settingsRow, options);
-                console.warn('mockGetSettings is not tested');
-                // GET request returns the full row or null (from maybeSingle())
-                // null means no settings exist, which triggers setSettings() -> INSERT
-                this.addSupabaseRoute('plugin_settings', settingsRow, options);
+                this.addSupabaseRoute('plugin_settings', settingsRow, { ...options, method: 'GET' });
+            },
+            /**
+             * Override the PATCH handler for plugin_settings (rarely needed).
+             * By default, PATCH updates the state in SettingsStateManager.
+             */
+            mockSetSettings: (response, options) => {
+                this.addSupabaseRoute('plugin_settings', response, { ...options, method: 'PATCH' });
             },
             /**
-             * Mocks POST request for inserting plugin_settings.
-             * @param response - The response for POST. Defaults to success response with inserted row.
+             * Override the POST handler for plugin_settings (rarely needed).
+             * By default, POST inserts/updates the state in SettingsStateManager.
              */
             mockInsertSettings: (response, options) => {
-                console.log('Mocking insert settings for mockInsertSettings', response, options);
-                console.warn('mockInsertSettings is not tested');
-                // TODO this function should not exist and possibly be combined with the mockSetSettings function
-                // POST request returns the inserted row or success response
-                // Default to an object representing successful insert
-                const defaultResponse = response ?? {
-                    id: 'mock-settings-id',
-                    plugin_id: this.pluginId,
-                    guild_id: this.rimoriInfo.guild.id,
-                };
-                this.addSupabaseRoute('plugin_settings', defaultResponse, { ...options, method: 'POST' });
+                this.addSupabaseRoute('plugin_settings', response, { ...options, method: 'POST' });
             },
             mockGetUserInfo: (userInfo, options) => {
-                console.log('Mocking get user info for mockGetUserInfo', userInfo, options);
-                console.warn('mockGetUserInfo is not tested');
                 this.addSupabaseRoute('/user-info', { ...this.rimoriInfo.profile, ...userInfo }, { ...options, delay: 0 });
             },
             mockGetPluginInfo: (pluginInfo, options) => {
-                console.log('Mocking get plugin info for mockGetPluginInfo', pluginInfo, options);
-                console.warn('mockGetPluginInfo is not tested');
                 this.addSupabaseRoute('/plugin-info', pluginInfo, options);
             },
         };
@@ -81,21 +70,87 @@ class RimoriTestEnvironment {
              * @param options - Mock options including HTTP method (defaults to 'GET' if not specified)
              */
             mockFrom: (tableName, value, options) => {
-                console.log('Mocking db.from for table:', tableName, 'method:', options?.method ?? 'GET', value, options);
+                // console.log('Mocking db.from for table:', tableName, 'method:', options?.method ?? 'GET', value, options);
                 const fullTableName = `${this.pluginId}_${tableName}`;
                 this.addSupabaseRoute(fullTableName, value, options);
             },
-            mockTable: () => { },
         };
         this.event = {
-            mockEmit: () => { },
-            mockRequest: () => { },
-            mockOn: () => { },
+            /**
+             * Emit an event into the plugin as if it came from Rimori main or another plugin.
+             *
+             * Note: This does NOT currently reach worker listeners such as those in
+             * `worker/listeners/decks.ts` or `worker/listeners/flascards.ts` – those run in a
+             * separate process. This helper is intended for UI‑side events only.
+             */
+            mockEmit: async (topic, data, sender = 'test') => {
+                if (!this.messageChannelSimulator) {
+                    throw new Error('MessageChannelSimulator not initialized. Call setup() first.');
+                }
+                await this.messageChannelSimulator.emit(topic, data, sender);
+            },
+            /**
+             * Registers a one-time auto-responder for request/response style events.
+             *
+             * When the plugin calls `plugin.event.request(topic, data)`, this registered responder
+             * will automatically return the provided response value. The responder is automatically
+             * removed after the first request, ensuring it only responds once.
+             *
+             * Example:
+             * ```ts
+             * // Register a responder that will return deck summaries when requested
+             * env.event.mockRequest('deck.requestOpenToday', [
+             *   { id: 'deck-1', name: 'My Deck', total_new: 5, total_learning: 2, total_review: 10 }
+             * ]);
+             *
+             * // Now when the plugin calls: plugin.event.request('deck.requestOpenToday', {})
+             * // It will receive the deck summaries array above
+             * ```
+             *
+             * @param topic - The event topic to respond to (e.g., 'deck.requestOpenToday')
+             * @param response - The response value to return, or a function that receives the event and returns the response
+             * @returns A function to manually remove the responder before it's used
+             */
+            mockRequest: (topic, response) => {
+                if (!this.messageChannelSimulator) {
+                    throw new Error('MessageChannelSimulator not initialized. Call setup() first.');
+                }
+                return this.messageChannelSimulator.respondOnce(topic, response);
+            },
+            /**
+             * Listen for events emitted by the plugin.
+             * @param topic - The event topic to listen for (e.g., 'global.accomplishment.triggerMicro')
+             * @param handler - The handler function that receives the event data
+             * @returns A function to unsubscribe from the event
+             */
+            on: (topic, handler) => {
+                if (!this.messageChannelSimulator) {
+                    throw new Error('MessageChannelSimulator not initialized. Call setup() first.');
+                }
+                return this.messageChannelSimulator.on(topic, (event) => {
+                    handler(event.data);
+                });
+            },
             mockOnce: () => { },
             mockRespond: () => { },
             mockEmitAccomplishment: () => { },
             mockOnAccomplishment: () => { },
-            mockEmitSidebarAction: () => { },
+            /**
+             * Emits a sidebar action event into the plugin as if Rimori main had triggered it.
+             * This is useful for testing sidebar-driven flows like flashcard creation from selected text.
+             *
+             * It sends a message on the 'global.sidebar.triggerAction' topic, which plugins can listen to via:
+             *   plugin.event.on<{ action: string; text: string }>('global.sidebar.triggerAction', ...)
+             *
+             * @param payload - The payload forwarded to the plugin, typically including an `action` key and optional `text`.
+             */
+            triggerSidebarAction: async (payload) => {
+                if (!this.messageChannelSimulator) {
+                    throw new Error('MessageChannelSimulator not initialized. Call setup() first.');
+                }
+                // Simulate Rimori main emitting the sidebar trigger event towards the plugin
+                await this.messageChannelSimulator.emit('global.sidebar.triggerAction', payload, 'sidebar');
+            },
             /**
              * 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.
@@ -156,24 +211,137 @@ class RimoriTestEnvironment {
              * @param options - Optional mock options.
              */
             mockGetSteamedText: (text, options) => {
-                console.log('Mocking get steamed text for mockGetSteamedText', text, options);
                 this.addBackendRoute('/ai/llm', text, { ...options, isStreaming: true });
             },
             mockGetVoice: (values, options) => {
-                console.log('Mocking get voice for mockGetVoice', values, options);
-                console.warn('mockGetVoice is not tested');
                 this.addBackendRoute('/voice/tts', values, options);
             },
             mockGetTextFromVoice: (text, options) => {
-                console.log('Mocking get text from voice for mockGetTextFromVoice', text, options);
-                console.warn('mockGetTextFromVoice is not tested');
                 this.addBackendRoute('/voice/stt', text, options);
             },
             mockGetObject: (value, options) => {
-                console.log('Mocking get object for mockGetObject', value, options);
                 this.addBackendRoute('/ai/llm-object', value, { ...options, method: 'POST' });
             },
         };
+        /**
+         * Helpers for tracking browser audio playback in tests.
+         *
+         * This is useful for components like the AudioPlayer in @rimori/react-client which:
+         *  1) Fetch audio data from the backend (mocked via `env.ai.mockGetVoice`)
+         *  2) Create `new Audio(url)` and call `.play()`
+         *
+         * With tracking enabled you can assert how many times audio playback was attempted:
+         *
+         * ```ts
+         * await env.audio.enableTracking();
+         * await env.ai.mockGetVoice(Buffer.from('dummy'), { method: 'POST' });
+         * await env.setup();
+         * // ...navigate and trigger audio...
+         * const counts = await env.audio.getPlayCounts();
+         * expect(counts.mediaPlayCalls).toBeGreaterThan(0);
+         * ```
+         *
+         * **Counter Types:**
+         * - `mediaPlayCalls`: Tracks calls to `.play()` on any `HTMLMediaElement` instance
+         *   (including `<audio>`, `<video>` elements, or any element that inherits from `HTMLMediaElement`).
+         *   This counter increments whenever `HTMLMediaElement.prototype.play()` is invoked.
+         * - `audioPlayCalls`: Tracks calls to `.play()` specifically on instances created via the `Audio` constructor
+         *   (e.g., `new Audio(url).play()`). This is a subset of `mediaPlayCalls` but provides more specific
+         *   tracking for programmatically created audio elements.
+         *
+         * **Note**: Since `Audio` instances are also `HTMLMediaElement` instances, calling `.play()` on an
+         * `Audio` object will increment **both** counters. For most use cases, checking `mediaPlayCalls`
+         * is sufficient as it captures all audio playback attempts.
+         */
+        this.audio = {
+            /**
+             * Injects tracking hooks for HTMLMediaElement.play and the Audio constructor.
+             * Must be called before the plugin code runs (ideally before env.setup()).
+             */
+            enableTracking: async () => {
+                await this.page.addInitScript(() => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const w = window;
+                    if (!w.__rimoriAudio) {
+                        w.__rimoriAudio = {
+                            mediaPlayCalls: 0,
+                            audioPlayCalls: 0,
+                        };
+                    }
+                    const proto = (w.HTMLMediaElement && w.HTMLMediaElement.prototype) || undefined;
+                    if (proto && !proto.__rimoriPatched) {
+                        const originalPlay = proto.play;
+                        proto.play = function (...args) {
+                            w.__rimoriAudio.mediaPlayCalls += 1;
+                            return originalPlay.apply(this, args);
+                        };
+                        Object.defineProperty(proto, '__rimoriPatched', {
+                            value: true,
+                            configurable: false,
+                            enumerable: false,
+                            writable: false,
+                        });
+                    }
+                    const OriginalAudio = w.Audio;
+                    if (OriginalAudio && !OriginalAudio.__rimoriPatched) {
+                        const PatchedAudio = function (...args) {
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            const audio = new OriginalAudio(...args);
+                            const originalPlay = audio.play.bind(audio);
+                            audio.play = () => {
+                                w.__rimoriAudio.audioPlayCalls += 1;
+                                return originalPlay();
+                            };
+                            return audio;
+                        };
+                        PatchedAudio.prototype = OriginalAudio.prototype;
+                        Object.defineProperty(PatchedAudio, '__rimoriPatched', {
+                            value: true,
+                            configurable: false,
+                            enumerable: false,
+                            writable: false,
+                        });
+                        w.Audio = PatchedAudio;
+                    }
+                });
+            },
+            /**
+             * Returns current audio play counters from the browser context.
+             *
+             * @returns An object with two counters:
+             *   - `mediaPlayCalls`: Total number of `.play()` calls on any `HTMLMediaElement` (includes all audio/video elements)
+             *   - `audioPlayCalls`: Number of `.play()` calls on instances created via `new Audio()` (subset of `mediaPlayCalls`)
+             *
+             * **Note**: Since `Audio` extends `HTMLMediaElement`, calling `.play()` on an `Audio` instance increments both counters.
+             * For general audio playback tracking, use `mediaPlayCalls` as it captures all playback attempts.
+             */
+            getPlayCounts: async () => {
+                return this.page.evaluate(() => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const w = window;
+                    if (!w.__rimoriAudio) {
+                        return { mediaPlayCalls: 0, audioPlayCalls: 0 };
+                    }
+                    return {
+                        mediaPlayCalls: Number(w.__rimoriAudio.mediaPlayCalls || 0),
+                        audioPlayCalls: Number(w.__rimoriAudio.audioPlayCalls || 0),
+                    };
+                });
+            },
+            /**
+             * Resets the audio play counters to zero.
+             */
+            resetPlayCounts: async () => {
+                await this.page.evaluate(() => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const w = window;
+                    if (w.__rimoriAudio) {
+                        w.__rimoriAudio.mediaPlayCalls = 0;
+                        w.__rimoriAudio.audioPlayCalls = 0;
+                    }
+                });
+            },
+        };
         this.runtime = {
             mockFetchBackend: () => { },
         };
@@ -199,8 +367,84 @@ class RimoriTestEnvironment {
         };
         this.page = options.page;
         this.pluginId = options.pluginId;
-        // TODO move to a function
-        this.rimoriInfo = {
+        this.rimoriInfo = this.getRimoriInfo(options);
+        // Initialize settings state manager
+        this.settingsManager = new SettingsStateManager_1.SettingsStateManager(options.settings || null, options.pluginId, this.rimoriInfo.guild.id);
+        this.interceptRoutes(options.pluginUrl);
+    }
+    interceptRoutes(pluginUrl) {
+        // Intercept all /locales requests and fetch from the dev server
+        this.page.route(`${pluginUrl}/locales/**`, async (route) => {
+            const request = route.request();
+            const url = new URL(request.url());
+            const devServerUrl = `http://${url.host}/locales/en.json`;
+            // console.log('Fetching locales from: ' + devServerUrl);
+            // throw new Error('Test: ' + devServerUrl);
+            try {
+                // Fetch from the dev server
+                const response = await fetch(devServerUrl);
+                const body = await response.text();
+                await route.fulfill({
+                    status: response.status,
+                    headers: { 'Content-Type': 'application/json' },
+                    body,
+                });
+            }
+            catch (error) {
+                console.error(`Error fetching translation from ${devServerUrl}:`, error);
+                await route.fulfill({
+                    status: 500,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ error: 'Failed to load translations' }),
+                });
+            }
+        });
+        this.page.route(`${this.rimoriInfo.backendUrl}/**`, (route) => this.handleRoute(route, this.backendRoutes));
+        this.page.route(`${this.rimoriInfo.url}/**`, (route) => this.handleRoute(route, this.supabaseRoutes));
+    }
+    async setup() {
+        // console.log('Setting up RimoriTestEnvironment');
+        this.page.on('console', (msg) => {
+            const logLevel = msg.type();
+            const logMessage = msg.text();
+            if (logLevel === 'debug')
+                return;
+            if (logMessage.includes('Download the React DevTools'))
+                return;
+            if (logMessage.includes('languageChanged en'))
+                return;
+            if (logMessage.includes('i18next: initialized {debug: true'))
+                return;
+            console.log(`[browser:${logLevel}]`, logMessage);
+        });
+        // Set up default handlers for plugin_settings routes using SettingsStateManager
+        this.setupSettingsRoutes();
+        // Initialize MessageChannelSimulator to simulate parent-iframe communication
+        // This makes the plugin think it's running in an iframe (not standalone mode)
+        // Convert RimoriInfo from CommunicationHandler format to MessageChannelSimulator format
+        this.messageChannelSimulator = new MessageChannelSimulator_1.MessageChannelSimulator({
+            page: this.page,
+            pluginId: this.pluginId,
+            queryParams: {},
+            rimoriInfo: this.rimoriInfo,
+        });
+        // Initialize the simulator - this injects the necessary shims
+        // to intercept window.parent.postMessage calls and set up MessageChannel communication
+        await this.messageChannelSimulator.initialize();
+        // Set up a no-op handler for pl454583483.session.triggerUrlChange
+        // This prevents errors if the plugin emits this event
+        this.messageChannelSimulator.on(`${this.pluginId}.session.triggerUrlChange`, () => {
+            // No-op handler - does nothing
+        });
+        this.messageChannelSimulator.on('global.accomplishment.triggerMicro', () => {
+            // No-op handler - does nothing
+        });
+        this.messageChannelSimulator.on('global.accomplishment.triggerMacro', () => {
+            // No-op handler - does nothing
+        });
+    }
+    getRimoriInfo(options) {
+        return {
             key: 'rimori-testing-key',
             token: 'rimori-testing-token',
             url: 'http://localhost:3500',
@@ -231,80 +475,54 @@ class RimoriTestEnvironment {
             profile: default_user_info_1.DEFAULT_USER_INFO,
             mainPanelPlugin: undefined,
             sidePanelPlugin: undefined,
+            interfaceLanguage: default_user_info_1.DEFAULT_USER_INFO.mother_tongue.code, // Set interface language from user's mother tongue
         };
-        this.interceptRoutes();
     }
-    interceptRoutes() {
-        this.page.route(`${this.rimoriInfo.backendUrl}/**`, (route) => this.handleRoute(route, this.backendRoutes));
-        this.page.route(`${this.rimoriInfo.url}/**`, (route) => this.handleRoute(route, this.supabaseRoutes));
-    }
-    async setup() {
-        console.log('Setting up RimoriTestEnvironment');
-        this.page.on('console', (msg) => {
-            console.log(`[browser:${msg.type()}]`, msg.text());
+    /**
+     * Sets up the plugin_settings routes to use the SettingsStateManager.
+     * GET returns current state, PATCH updates state, POST creates/updates state.
+     */
+    setupSettingsRoutes() {
+        // GET: Return current settings state
+        this.addSupabaseRoute('plugin_settings', () => this.settingsManager.getSettings(), {
+            method: 'GET',
         });
-        // Add default handlers for common routes that plugins typically access
-        // These can be overridden by explicit mock calls
-        if (!this.supabaseRoutes[this.createRouteKey('GET', `${this.rimoriInfo.url}/rest/v1/plugin_settings`)]) {
-            // Default: no settings exist (null) - triggers INSERT flow
-            // Can be overridden with mockGetSettings() to return existing settings
-            this.plugin.mockGetSettings(null);
-        }
-        if (!this.supabaseRoutes[this.createRouteKey('PATCH', `${this.rimoriInfo.url}/rest/v1/plugin_settings`)]) {
-            // Default PATCH handler for plugin_settings - returns empty array (no rows updated)
-            // This triggers INSERT (POST) flow
-            // Can be overridden with mockSetSettings() to simulate successful update
-            this.plugin.mockSetSettings([]);
-        }
-        if (!this.supabaseRoutes[this.createRouteKey('POST', `${this.rimoriInfo.url}/rest/v1/plugin_settings`)]) {
-            // Default POST handler for plugin_settings - simulates successful insert
-            // Can be overridden with mockInsertSettings() to customize response
-            this.plugin.mockInsertSettings();
-        }
-        // Initialize MessageChannelSimulator to simulate parent-iframe communication
-        // This makes the plugin think it's running in an iframe (not standalone mode)
-        // Convert RimoriInfo from CommunicationHandler format to MessageChannelSimulator format
-        this.messageChannelSimulator = new MessageChannelSimulator_1.MessageChannelSimulator({
-            page: this.page,
-            pluginId: this.pluginId,
-            queryParams: {},
-            rimoriInfo: {
-                ...this.rimoriInfo,
-                guild: {
-                    id: this.rimoriInfo.guild.id,
-                    longTermGoalOverride: 'longTermGoalOverride' in this.rimoriInfo.guild ? this.rimoriInfo.guild.longTermGoalOverride : '',
-                    allowUserPluginSettings: this.rimoriInfo.guild.allowUserPluginSettings,
-                },
-                installedPlugins: this.rimoriInfo.installedPlugins.map((p) => ({
-                    id: p.id,
-                    title: p.info?.title || '',
-                    description: p.info?.description || '',
-                    logo: p.info?.logo || '',
-                    url: p.pages?.external_hosted_url || '',
-                })),
-                mainPanelPlugin: this.rimoriInfo.mainPanelPlugin
-                    ? {
-                        id: this.rimoriInfo.mainPanelPlugin.id,
-                        title: this.rimoriInfo.mainPanelPlugin.info?.title || '',
-                        description: this.rimoriInfo.mainPanelPlugin.info?.description || '',
-                        logo: this.rimoriInfo.mainPanelPlugin.info?.logo || '',
-                        url: this.rimoriInfo.mainPanelPlugin.pages?.external_hosted_url || '',
-                    }
-                    : undefined,
-                sidePanelPlugin: this.rimoriInfo.sidePanelPlugin
-                    ? {
-                        id: this.rimoriInfo.sidePanelPlugin.id,
-                        title: this.rimoriInfo.sidePanelPlugin.info?.title || '',
-                        description: this.rimoriInfo.sidePanelPlugin.info?.description || '',
-                        logo: this.rimoriInfo.sidePanelPlugin.info?.logo || '',
-                        url: this.rimoriInfo.sidePanelPlugin.pages?.external_hosted_url || '',
-                    }
-                    : undefined,
-            },
+        // PATCH: Update settings based on request body
+        this.addSupabaseRoute('plugin_settings', async (request) => {
+            try {
+                const postData = request.postData();
+                if (postData) {
+                    const updates = JSON.parse(postData);
+                    return this.settingsManager.updateSettings(updates);
+                }
+                // If no body, return empty array (no update)
+                return this.settingsManager.updateSettings({});
+            }
+            catch {
+                // If parsing fails, return empty array
+                return this.settingsManager.updateSettings({});
+            }
+        }, {
+            method: 'PATCH',
+        });
+        // POST: Insert/update settings based on request body
+        this.addSupabaseRoute('plugin_settings', async (request) => {
+            try {
+                const postData = request.postData();
+                if (postData) {
+                    const newSettings = JSON.parse(postData);
+                    return this.settingsManager.insertSettings(newSettings);
+                }
+                // If no body, insert with defaults
+                return this.settingsManager.insertSettings({});
+            }
+            catch {
+                // If parsing fails, insert with defaults
+                return this.settingsManager.insertSettings({});
+            }
+        }, {
+            method: 'POST',
         });
-        // Initialize the simulator - this injects the necessary shims
-        // to intercept window.parent.postMessage calls and set up MessageChannel communication
-        await this.messageChannelSimulator.initialize();
     }
     /**
      * Formats text as SSE (Server-Sent Events) response.
@@ -359,15 +577,15 @@ class RimoriTestEnvironment {
         }
     }
     async handleRoute(route, routes) {
-        console.warn('handleRoute is not tested');
         const request = route.request();
         const requestUrl = request.url();
         const method = request.method().toUpperCase();
         const routeKey = this.createRouteKey(method, requestUrl);
-        console.log('Handling route', routeKey);
+        // console.log('Handling route', routeKey);
         const mocks = routes[routeKey];
         if (!mocks || mocks.length === 0) {
             console.error('No route handler found for route', routeKey);
+            throw new Error('No route handler found for route: ' + routeKey);
             route.abort('not_found');
             return;
         }
@@ -407,10 +625,15 @@ class RimoriTestEnvironment {
         if (options?.error) {
             return await route.abort(options.error);
         }
+        // Handle function-based mocks (for stateful responses like settings)
+        let responseValue = matchingMock.value;
+        if (typeof matchingMock.value === 'function') {
+            responseValue = await matchingMock.value(request);
+        }
         // Handle streaming responses (for mockGetSteamedText)
         // Since Playwright requires complete body, we format as SSE without delays
-        if (matchingMock.isStreaming && typeof matchingMock.value === 'string') {
-            const body = this.formatAsSSE(matchingMock.value);
+        if (matchingMock.isStreaming && typeof responseValue === 'string') {
+            const body = this.formatAsSSE(responseValue);
             return await route.fulfill({
                 status: 200,
                 headers: { 'Content-Type': 'text/event-stream' },
@@ -418,7 +641,7 @@ class RimoriTestEnvironment {
             });
         }
         // Regular JSON response
-        const responseBody = JSON.stringify(matchingMock.value);
+        const responseBody = JSON.stringify(responseValue);
         route.fulfill({
             status: 200,
             body: responseBody,
@@ -431,7 +654,6 @@ class RimoriTestEnvironment {
      * @param options - The options for the route. Method defaults to 'GET' if not specified.
      */
     addSupabaseRoute(path, values, options) {
-        console.warn('addSupabaseRoute is not tested');
         const method = options?.method ?? 'GET';
         const fullPath = `${this.rimoriInfo.url}/rest/v1/${path}`;
         const routeKey = this.createRouteKey(method, fullPath);
@@ -452,7 +674,6 @@ class RimoriTestEnvironment {
      * @param isStreaming - Optional flag to mark this as a streaming response.
      */
     addBackendRoute(path, values, options) {
-        console.warn('addBackendRoute is not tested');
         const method = options?.method ?? 'POST';
         const fullPath = `${this.rimoriInfo.backendUrl}${path.startsWith('/') ? path : '/' + path}`;
         const routeKey = this.createRouteKey(method, fullPath);
@@ -470,4 +691,3 @@ class RimoriTestEnvironment {
 }
 exports.RimoriTestEnvironment = RimoriTestEnvironment;
 // Todo: How to test if the event was received by the parent?
-// TODO: The matcher option of RimoriTestEnvironment v1 might be useful to use

package/dist/core/SettingsStateManager.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Manages plugin settings state for test environment.
+ * Provides a single source of truth for settings that can be modified by mocked API calls.
+ */
+export interface PluginSettings {
+    id?: string;
+    plugin_id?: string;
+    guild_id?: string;
+    settings?: Record<string, unknown>;
+    is_guild_setting?: boolean;
+    user_id?: string | null;
+}
+export declare class SettingsStateManager {
+    private settings;
+    constructor(initialSettings: PluginSettings | null, pluginId: string, guildId: string);
+    /**
+     * Get current settings state (for GET requests)
+     * Returns null if no settings exist, otherwise returns the full settings object
+     */
+    getSettings(): PluginSettings | null;
+    /**
+     * Update settings (for PATCH requests)
+     * @param updates - Partial settings to update
+     * @returns Array with updated row if settings exist, empty array if no settings exist
+     */
+    updateSettings(updates: Partial<PluginSettings>): PluginSettings[];
+    /**
+     * Insert new settings (for POST requests)
+     * @param newSettings - Settings to insert
+     * @returns The inserted settings object
+     */
+    insertSettings(newSettings: Partial<PluginSettings>): PluginSettings;
+    /**
+     * Manually set settings (useful for test setup)
+     */
+    setSettings(settings: PluginSettings | null): void;
+    /**
+     * Check if settings exist
+     */
+    hasSettings(): boolean;
+}