@google/gemini-cli 0.12.0-preview.4 → 0.13.0-nightly.20251031.c89bc30d

package/dist/src/ui/AppContainer.test.js

@@ -5,7 +5,9 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * SPDX-License-Identifier: Apache-2.0
  */
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import { render, cleanup } from 'ink-testing-library';
+import { render } from '../test-utils/render.js';
+import { cleanup } from 'ink-testing-library';
+import { act, useContext } from 'react';
 import { AppContainer } from './AppContainer.js';
 import { makeFakeConfig, CoreEvent, } from '@google/gemini-cli-core';
 // Mock coreEvents
@@ -25,7 +27,6 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
 import { useQuotaAndFallback } from './hooks/useQuotaAndFallback.js';
 import { UIStateContext } from './contexts/UIStateContext.js';
 import { UIActionsContext, } from './contexts/UIActionsContext.js';
-import { useContext } from 'react';
 // Mock useStdout to capture terminal title writes
 let mockStdout;
 vi.mock('ink', async (importOriginal) => {
@@ -277,27 +278,33 @@ describe('AppContainer State Management', () => {
         cleanup();
     });
     describe('Basic Rendering', () => {
-        it('renders without crashing with minimal props', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('renders without crashing with minimal props', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('renders with startup warnings', () => {
+        it('renders with startup warnings', async () => {
             const startupWarnings = ['Warning 1', 'Warning 2'];
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, startupWarnings: startupWarnings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, startupWarnings: startupWarnings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('State Initialization', () => {
-        it('initializes with theme error from initialization result', () => {
+        it('initializes with theme error from initialization result', async () => {
             const initResultWithError = {
                 ...mockInitResult,
                 themeError: 'Failed to load theme',
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: initResultWithError }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: initResultWithError }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
         it('handles debug mode state', () => {
             const debugConfig = makeFakeConfig();
@@ -308,29 +315,38 @@ describe('AppContainer State Management', () => {
         });
     });
     describe('Context Providers', () => {
-        it('provides AppContext with correct values', () => {
+        it('provides AppContext with correct values', async () => {
             const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "2.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Should render and unmount cleanly
             expect(() => unmount()).not.toThrow();
         });
-        it('provides UIStateContext with state management', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides UIStateContext with state management', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('provides UIActionsContext with action handlers', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides UIActionsContext with action handlers', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('provides ConfigContext with config object', () => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it('provides ConfigContext with config object', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Settings Integration', () => {
-        it('handles settings with all display options disabled', () => {
+        it('handles settings with all display options disabled', async () => {
             const settingsAllHidden = {
                 merged: {
                     hideBanner: true,
@@ -339,11 +355,13 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: false,
                 },
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: settingsAllHidden, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsAllHidden, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('handles settings with memory usage enabled', () => {
+        it('handles settings with memory usage enabled', async () => {
             const settingsWithMemory = {
                 merged: {
                     hideBanner: false,
@@ -352,36 +370,44 @@ describe('AppContainer State Management', () => {
                     showMemoryUsage: true,
                 },
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: settingsWithMemory, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: settingsWithMemory, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Version Handling', () => {
-        it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', (version) => {
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: version, initializationResult: mockInitResult }));
-            }).not.toThrow();
+        it.each(['1.0.0', '2.1.3-beta', '3.0.0-nightly'])('handles version format: %s', async (version) => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: version, initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Error Handling', () => {
-        it('handles config methods that might throw', () => {
+        it('handles config methods that might throw', async () => {
             const errorConfig = makeFakeConfig();
             vi.spyOn(errorConfig, 'getModel').mockImplementation(() => {
                 throw new Error('Config error');
             });
             // Should still render without crashing - errors should be handled internally
-            expect(() => {
-                render(_jsx(AppContainer, { config: errorConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: errorConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
-        it('handles undefined settings gracefully', () => {
+        it('handles undefined settings gracefully', async () => {
             const undefinedSettings = {
                 merged: {},
             };
-            expect(() => {
-                render(_jsx(AppContainer, { config: mockConfig, settings: undefinedSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            }).not.toThrow();
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: undefinedSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
+            unmount();
         });
     });
     describe('Provider Hierarchy', () => {
@@ -393,13 +419,17 @@ describe('AppContainer State Management', () => {
         });
     });
     describe('Quota and Fallback Integration', () => {
-        it('passes a null proQuotaRequest to UIStateContext by default', () => {
+        it('passes a null proQuotaRequest to UIStateContext by default', async () => {
             // The default mock from beforeEach already sets proQuotaRequest to null
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert that the context value is as expected
             expect(capturedUIState.proQuotaRequest).toBeNull();
+            unmount();
         });
-        it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', () => {
+        it('passes a valid proQuotaRequest to UIStateContext when provided by the hook', async () => {
             // Arrange: Create a mock request object that a UI dialog would receive
             const mockRequest = {
                 failedModel: 'gemini-pro',
@@ -411,11 +441,15 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: vi.fn(),
             });
             // Act: Render the container
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The mock request is correctly passed through the context
             expect(capturedUIState.proQuotaRequest).toEqual(mockRequest);
+            unmount();
         });
-        it('passes the handleProQuotaChoice function to UIActionsContext', () => {
+        it('passes the handleProQuotaChoice function to UIActionsContext', async () => {
             // Arrange: Create a mock handler function
             const mockHandler = vi.fn();
             mockedUseQuotaAndFallback.mockReturnValue({
@@ -423,12 +457,18 @@ describe('AppContainer State Management', () => {
                 handleProQuotaChoice: mockHandler,
             });
             // Act: Render the container
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The action in the context is the mock handler we provided
             expect(capturedUIActions.handleProQuotaChoice).toBe(mockHandler);
             // You can even verify that the plumbed function is callable
-            capturedUIActions.handleProQuotaChoice('auth');
+            act(() => {
+                capturedUIActions.handleProQuotaChoice('auth');
+            });
             expect(mockHandler).toHaveBeenCalledWith('auth');
+            unmount();
         });
     });
     describe('Terminal Title Update Feature', () => {
@@ -677,37 +717,59 @@ describe('AppContainer State Management', () => {
             vi.useRealTimers();
         });
         it('should set and clear the queue error message after a timeout', async () => {
-            const { rerender } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
             expect(capturedUIState.queueErrorMessage).toBeNull();
-            capturedUIActions.setQueueErrorMessage('Test error');
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('Test error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Test error');
-            vi.advanceTimersByTime(3000);
+            act(() => {
+                vi.advanceTimersByTime(3000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBeNull();
+            unmount();
         });
         it('should reset the timer if a new error message is set', async () => {
-            const { rerender } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            capturedUIActions.setQueueErrorMessage('First error');
+            const { rerender, unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('First error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('First error');
-            vi.advanceTimersByTime(1500);
-            capturedUIActions.setQueueErrorMessage('Second error');
+            act(() => {
+                vi.advanceTimersByTime(1500);
+            });
+            act(() => {
+                capturedUIActions.setQueueErrorMessage('Second error');
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Second error');
-            vi.advanceTimersByTime(2000);
+            act(() => {
+                vi.advanceTimersByTime(2000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBe('Second error');
             // 5. Advance time past the 3 second timeout from the second message
-            vi.advanceTimersByTime(1000);
+            act(() => {
+                vi.advanceTimersByTime(1000);
+            });
             rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
             expect(capturedUIState.queueErrorMessage).toBeNull();
+            unmount();
         });
     });
     describe('Terminal Height Calculation', () => {
         const mockedMeasureElement = measureElement;
         const mockedUseTerminalSize = useTerminalSize;
-        it('should prevent terminal height from being less than 1', () => {
+        it('should prevent terminal height from being less than 1', async () => {
             const resizePtySpy = vi.spyOn(ShellExecutionService, 'resizePty');
             // Arrange: Simulate a small terminal and a large footer
             mockedUseTerminalSize.mockReturnValue({ columns: 80, rows: 5 });
@@ -721,13 +783,17 @@ describe('AppContainer State Management', () => {
                 cancelOngoingRequest: vi.fn(),
                 activePtyId: 'some-id',
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Assert: The shell should be resized to a minimum height of 1, not a negative number.
             // The old code would have tried to set a negative height.
             expect(resizePtySpy).toHaveBeenCalled();
             const lastCall = resizePtySpy.mock.calls[resizePtySpy.mock.calls.length - 1];
             // Check the height argument specifically
             expect(lastCall[2]).toBe(1);
+            unmount();
         });
     });
     describe('Keyboard Input Handling (CTRL+C / CTRL+D)', () => {
@@ -735,19 +801,26 @@ describe('AppContainer State Management', () => {
         let mockHandleSlashCommand;
         let mockCancelOngoingRequest;
         let rerender;
+        let unmount;
         // Helper function to reduce boilerplate in tests
-        const setupKeypressTest = () => {
-            const { rerender: inkRerender } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
-            rerender = () => inkRerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+        const setupKeypressTest = async () => {
+            const renderResult = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                vi.advanceTimersByTime(0);
+            });
+            rerender = () => renderResult.rerender(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            unmount = renderResult.unmount;
         };
         const pressKey = (key, times = 1) => {
             for (let i = 0; i < times; i++) {
-                handleGlobalKeypress({
-                    name: 'c',
-                    ctrl: false,
-                    meta: false,
-                    shift: false,
-                    ...key,
+                act(() => {
+                    handleGlobalKeypress({
+                        name: 'c',
+                        ctrl: false,
+                        meta: false,
+                        shift: false,
+                        ...key,
+                    });
                 });
                 rerender();
             }
@@ -788,7 +861,7 @@ describe('AppContainer State Management', () => {
             vi.useRealTimers();
         });
         describe('CTRL+C', () => {
-            it('should cancel ongoing request on first press', () => {
+            it('should cancel ongoing request on first press', async () => {
                 mockedUseGeminiStream.mockReturnValue({
                     streamingState: 'responding',
                     submitQuery: vi.fn(),
@@ -797,89 +870,119 @@ describe('AppContainer State Management', () => {
                     thought: null,
                     cancelOngoingRequest: mockCancelOngoingRequest,
                 });
-                setupKeypressTest();
+                await setupKeypressTest();
                 pressKey({ name: 'c', ctrl: true });
                 expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(1);
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
             });
-            it('should quit on second press', () => {
-                setupKeypressTest();
+            it('should quit on second press', async () => {
+                await setupKeypressTest();
                 pressKey({ name: 'c', ctrl: true }, 2);
                 expect(mockCancelOngoingRequest).toHaveBeenCalledTimes(2);
                 expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit');
+                unmount();
             });
-            it('should reset press count after a timeout', () => {
-                setupKeypressTest();
+            it('should reset press count after a timeout', async () => {
+                await setupKeypressTest();
                 pressKey({ name: 'c', ctrl: true });
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
                 // Advance timer past the reset threshold
-                vi.advanceTimersByTime(1001);
+                act(() => {
+                    vi.advanceTimersByTime(1001);
+                });
                 pressKey({ name: 'c', ctrl: true });
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
             });
         });
         describe('CTRL+D', () => {
-            it('should do nothing if text buffer is not empty', () => {
+            it('should do nothing if text buffer is not empty', async () => {
                 mockedUseTextBuffer.mockReturnValue({
                     text: 'some text',
                     setText: vi.fn(),
                 });
-                setupKeypressTest();
+                await setupKeypressTest();
                 pressKey({ name: 'd', ctrl: true }, 2);
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
             });
-            it('should quit on second press if buffer is empty', () => {
-                setupKeypressTest();
+            it('should quit on second press if buffer is empty', async () => {
+                await setupKeypressTest();
                 pressKey({ name: 'd', ctrl: true }, 2);
                 expect(mockHandleSlashCommand).toHaveBeenCalledWith('/quit');
+                unmount();
             });
-            it('should reset press count after a timeout', () => {
-                setupKeypressTest();
+            it('should reset press count after a timeout', async () => {
+                await setupKeypressTest();
                 pressKey({ name: 'd', ctrl: true });
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
                 // Advance timer past the reset threshold
-                vi.advanceTimersByTime(1001);
+                act(() => {
+                    vi.advanceTimersByTime(1001);
+                });
                 pressKey({ name: 'd', ctrl: true });
                 expect(mockHandleSlashCommand).not.toHaveBeenCalled();
+                unmount();
             });
         });
     });
     describe('Model Dialog Integration', () => {
-        it('should provide isModelDialogOpen in the UIStateContext', () => {
+        it('should provide isModelDialogOpen in the UIStateContext', async () => {
             mockedUseModelCommand.mockReturnValue({
                 isModelDialogOpen: true,
                 openModelDialog: vi.fn(),
                 closeModelDialog: vi.fn(),
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             expect(capturedUIState.isModelDialogOpen).toBe(true);
+            unmount();
         });
-        it('should provide model dialog actions in the UIActionsContext', () => {
+        it('should provide model dialog actions in the UIActionsContext', async () => {
             const mockCloseModelDialog = vi.fn();
             mockedUseModelCommand.mockReturnValue({
                 isModelDialogOpen: false,
                 openModelDialog: vi.fn(),
                 closeModelDialog: mockCloseModelDialog,
             });
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Verify that the actions are correctly passed through context
-            capturedUIActions.closeModelDialog();
+            act(() => {
+                capturedUIActions.closeModelDialog();
+            });
             expect(mockCloseModelDialog).toHaveBeenCalled();
+            unmount();
         });
     });
     describe('CoreEvents Integration', () => {
-        it('subscribes to UserFeedback and drains backlog on mount', () => {
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+        it('subscribes to UserFeedback and drains backlog on mount', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             expect(mockCoreEvents.on).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
             expect(mockCoreEvents.drainFeedbackBacklog).toHaveBeenCalledTimes(1);
+            unmount();
         });
-        it('unsubscribes from UserFeedback on unmount', () => {
+        it('unsubscribes from UserFeedback on unmount', async () => {
             const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             unmount();
             expect(mockCoreEvents.off).toHaveBeenCalledWith(CoreEvent.UserFeedback, expect.any(Function));
         });
-        it('adds history item when UserFeedback event is received', () => {
-            render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+        it('adds history item when UserFeedback event is received', async () => {
+            const { unmount } = render(_jsx(AppContainer, { config: mockConfig, settings: mockSettings, version: "1.0.0", initializationResult: mockInitResult }));
+            await act(async () => {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            });
             // Get the registered handler
             const handler = mockCoreEvents.on.mock.calls.find((call) => call[0] === CoreEvent.UserFeedback)?.[1];
             expect(handler).toBeDefined();
@@ -888,11 +991,14 @@ describe('AppContainer State Management', () => {
                 severity: 'error',
                 message: 'Test error message',
             };
-            handler(payload);
+            act(() => {
+                handler(payload);
+            });
             expect(mockedUseHistory().addItem).toHaveBeenCalledWith(expect.objectContaining({
                 type: 'error',
                 text: 'Test error message',
             }), expect.any(Number));
+            unmount();
         });
     });
 });