diff --git a/backend/src/core/startup.py b/backend/src/core/startup.py
index 5b5abd1..3b0bc4c 100644
--- a/backend/src/core/startup.py
+++ b/backend/src/core/startup.py
@@ -17,6 +17,16 @@ async def initialize_database(self):
         """Initialize the database schema and seed data."""
         try:
             db_manager = self.container.db_manager()
+
+            # In test mode, clean up the database on startup
+            # This ensures tests don't affect each other
+            if APP_ENV == "test":
+                try:
+                    logger.info("Test mode detected: Cleaning up database on startup")
+                    await db_manager.drop_all()
+                    logger.info("Test database cleaned up")
+                except Exception as e:
+                    logger.error(f"Failed to clean up test database: {str(e)}")
             
             await db_manager.create_all()
             await initialize_data()
@@ -55,17 +65,6 @@ async def shutdown(self):
             billing_worker.stop()
             logger.info("Billing worker stopped")
         
-        # In test mode, clean up the database on shutdown
-        # This ensures tests don't affect each other
-        if APP_ENV == "test":
-            try:
-                logger.info("Test mode detected: Cleaning up database on shutdown")
-                db_manager = self.container.db_manager()
-                await db_manager.drop_all()
-                logger.info("Test database cleaned up")
-            except Exception as e:
-                logger.error(f"Failed to clean up test database: {str(e)}")
-        
         # Close database connections
         try:
             db_manager = self.container.db_manager()
diff --git a/frontend/src/components/Instance/Setting/AccessMenu.tsx b/frontend/src/components/Instance/Setting/AccessMenu.tsx
index 847d17a..fb4ec1b 100644
--- a/frontend/src/components/Instance/Setting/AccessMenu.tsx
+++ b/frontend/src/components/Instance/Setting/AccessMenu.tsx
@@ -78,6 +78,7 @@ const AccessMenu: React.FC = () => {
             endIcon={showPassword ? <EyeSlashIcon className="w-5 h-5" /> : <EyeIcon className="w-5 h-5" />}
             onEndIconClick={togglePasswordVisibility}
             disabled={!isInstanceRunning}
+            data-testid="reset-root-password"
           />
         </div>
 
@@ -97,6 +98,7 @@ const AccessMenu: React.FC = () => {
           variant="outline"
           icon={<KeyIcon className="w-5 h-5" />}
           disabled={!isInstanceRunning || !isPasswordValid(password)}
+          data-testid="reset-root-password"
         />
       </Section>
     )
@@ -119,6 +121,7 @@ const AccessMenu: React.FC = () => {
         tabs={accessTabs}
         activeTab={accessType}
         setActiveTab={(id) => setAccessType(id as 'terminal' | 'console')}
+        data-testid="instance-access"
       />
       
       <div className="bg-[#12203c] rounded-lg overflow-hidden shadow-lg border border-blue-900/20">
diff --git a/frontend/src/components/Instance/Setting/DestroyMenu.tsx b/frontend/src/components/Instance/Setting/DestroyMenu.tsx
index 5920f5b..7dac1e7 100644
--- a/frontend/src/components/Instance/Setting/DestroyMenu.tsx
+++ b/frontend/src/components/Instance/Setting/DestroyMenu.tsx
@@ -4,6 +4,7 @@ import { ExclamationTriangleIcon, TrashIcon } from "@heroicons/react/24/outline"
 import Section from "../../../components/Common/Section"
 import Button from "../../../components/Common/Button/Button"
 import { useInstanceSetting } from "../../../hooks/Instance/useInstanceSetting"
+import InputField from "../../Common/InputField"
 
 const DestroyMenu: React.FC = () => {
     const [confirmText, setConfirmText] = useState("")
@@ -47,12 +48,12 @@ const DestroyMenu: React.FC = () => {
                     <label className="block text-gray-300 mb-2 text-sm">
                         To confirm, type the instance name: <span className="font-bold">{instanceName}</span>
                     </label>
-                    <input
+                    <InputField
                         type="text"
                         value={confirmText}
-                        onChange={(e) => setConfirmText(e.target.value)}
-                        className="bg-[#23375F] border border-blue-800/30 text-white px-3 py-2 rounded w-full focus:outline-none focus:ring-2 focus:ring-red-500"
+                        onChange={setConfirmText}
                         placeholder={`Type ${instanceName} to confirm`}
+                        data-testid="destroy-instance-input"
                     />
                 </div>
 
@@ -63,6 +64,7 @@ const DestroyMenu: React.FC = () => {
                         icon={<TrashIcon className="w-5 h-5" />}
                         variant="purple" 
                         disabled={!isDeleteConfirmed || isLoading}
+                        data-testid="destroy-instance"
                     />
                 </div>
             </Section>
diff --git a/frontend/src/components/Instance/Setting/InstanceConsole.tsx b/frontend/src/components/Instance/Setting/InstanceConsole.tsx
index 71d1067..4bb0f86 100644
--- a/frontend/src/components/Instance/Setting/InstanceConsole.tsx
+++ b/frontend/src/components/Instance/Setting/InstanceConsole.tsx
@@ -1,7 +1,6 @@
 import React, { useEffect } from 'react'
 import { useConsoleWebSocket } from '../../../hooks/Instance/useConsoleConnection'
 import { useXTerm } from '../../../hooks/useXTerm'
-import { ArrowPathIcon } from '@heroicons/react/24/outline'
 import { WS_URL } from '../../../config/api'
 import 'xterm/css/xterm.css'
 import { StatusHeader, StatusMessage, StatusFooter } from './InstanceStatus'
@@ -79,6 +78,7 @@ const InstanceConsole: React.FC<InstanceConsoleProps> = ({ instanceName, isRunni
                 <div
                     ref={terminalRef}
                     className="p-2"
+                    data-testid="instance-console-container"
                 />
             </div>
 
diff --git a/frontend/src/components/Instance/Setting/InstanceTerminal.tsx b/frontend/src/components/Instance/Setting/InstanceTerminal.tsx
index f056fb3..03cb22b 100644
--- a/frontend/src/components/Instance/Setting/InstanceTerminal.tsx
+++ b/frontend/src/components/Instance/Setting/InstanceTerminal.tsx
@@ -74,6 +74,7 @@ const InstanceTerminal: React.FC<InstanceTerminalProps> = ({ instanceName, isRun
                 <div
                     ref={terminalRef}
                     className="p-2"
+                    data-testid="instance-terminal-container"
                 />
             </div>
 
diff --git a/frontend/src/components/Instance/Setting/MonitorMenu.tsx b/frontend/src/components/Instance/Setting/MonitorMenu.tsx
index f347723..dccf3ce 100644
--- a/frontend/src/components/Instance/Setting/MonitorMenu.tsx
+++ b/frontend/src/components/Instance/Setting/MonitorMenu.tsx
@@ -43,7 +43,7 @@ const MonitorMenu: React.FC = () => {
                         </div>
                         <div className="flex justify-between text-sm">
                             <span className="text-white">{cpu.usage.toFixed(1)}%</span>
-                            <span className="text-gray-400">{cpu.cores} core{cpu.cores !== 1 ? 's' : ''}</span>
+                            <span className="text-gray-400" data-testid="cpu-cores">{cpu.cores} core{cpu.cores !== 1 ? 's' : ''}</span>
                         </div>
                     </div>
                 </div>
@@ -62,7 +62,7 @@ const MonitorMenu: React.FC = () => {
                         </div>
                         <div className="flex justify-between text-sm">
                             <span className="text-white">{memory.percentage.toFixed(1)}%</span>
-                            <span className="text-gray-400">
+                            <span className="text-gray-400" data-testid="memory-used">
                                 {formatBytes(memory.used)} / {formatBytes(memory.total)}
                             </span>
                         </div>
diff --git a/frontend/src/components/Instance/Setting/PowerMenu.tsx b/frontend/src/components/Instance/Setting/PowerMenu.tsx
index 7dd3364..3d34086 100644
--- a/frontend/src/components/Instance/Setting/PowerMenu.tsx
+++ b/frontend/src/components/Instance/Setting/PowerMenu.tsx
@@ -38,6 +38,7 @@ const PowerMenu: React.FC = () => {
                             onClick={startInstance}
                             variant="primary"
                             icon={<PowerIcon className="w-5 h-5" />}
+                            data-testid="start-instance"
                         />
                     ) : (
                         <Button
@@ -45,6 +46,7 @@ const PowerMenu: React.FC = () => {
                             onClick={stopInstance}
                             variant="primary"
                             icon={<PowerIcon className="w-5 h-5" />}
+                            data-testid="stop-instance"
                         />
                     )}
 
@@ -54,6 +56,7 @@ const PowerMenu: React.FC = () => {
                         variant="outline"
                         icon={<ArrowPathIcon className="w-5 h-5" />}
                         disabled={!isInstanceRunning}
+                        data-testid="restart-instance"
                     />
                 </div>
             </Section>
diff --git a/frontend/src/hooks/useXTerm.ts b/frontend/src/hooks/useXTerm.ts
index f2b3e3e..4e6ba70 100644
--- a/frontend/src/hooks/useXTerm.ts
+++ b/frontend/src/hooks/useXTerm.ts
@@ -62,11 +62,9 @@ export const useXTerm = () => {
     }, [])
 
     const setTerminalDataHandlerV2 = useCallback((handler: (data: string) => void) => {
-        if (xtermRef.current) {
-            xtermRef.current.onData((data) => {
-                handler(data)
-            })
-        }
+        xtermRef.current?.onData((data) => {
+            handler(data)
+        })
     }, [])
 
     // Get current terminal dimensions
diff --git a/frontend/src/pages/Instance/InstanceListPage.tsx b/frontend/src/pages/Instance/InstanceListPage.tsx
index 6b6894e..e5cbc03 100644
--- a/frontend/src/pages/Instance/InstanceListPage.tsx
+++ b/frontend/src/pages/Instance/InstanceListPage.tsx
@@ -79,6 +79,7 @@ const InstanceListPage: React.FC = () => {
                             handleViewInstance(instance)
                         }}
                         variant="secondary"
+                        data-testid={`view-instance-${instance.instance_name}`}
                     />
                     <Button
                         icon={<EllipsisVerticalIcon className="w-5 h-5" />}
diff --git a/frontend/src/pages/Instance/InstanceSettingPage.tsx b/frontend/src/pages/Instance/InstanceSettingPage.tsx
index e339495..a9d4e85 100644
--- a/frontend/src/pages/Instance/InstanceSettingPage.tsx
+++ b/frontend/src/pages/Instance/InstanceSettingPage.tsx
@@ -69,6 +69,7 @@ const InstanceSettingPage: React.FC = () => {
               tabs={tabs}
               activeTab={activeTab}
               setActiveTab={setActiveTab}
+              data-testid="instance-setting"
             />
             <InstanceSettingContent active={activeTab} />
           </>
diff --git a/test/e2e/api/client.py b/test/e2e/api/client.py
index 7106d7c..935ecd3 100644
--- a/test/e2e/api/client.py
+++ b/test/e2e/api/client.py
@@ -122,6 +122,14 @@ def login_user(self, user: UserData) -> Optional[APIResponse]:
         return self.make_request("user/login", data, action_name="Login")
         
     # Instance Management API Methods
+    def start_instance(self, hostname: str) -> Optional[APIResponse]:
+        """Start an instance by hostname"""
+        return self.make_request(f"instance/{hostname}/start", method="post", action_name="Start Instance")
+    
+    def stop_instance(self, hostname: str) -> Optional[APIResponse]:
+        """Stop an instance by hostname"""
+        return self.make_request(f"instance/{hostname}/stop", method="post", action_name="Stop Instance")
+
     def delete_instance(self, hostname: str) -> Optional[APIResponse]:
         """Delete an instance by hostname"""
         return self.make_request(f"instance/{hostname}/delete", method="post", action_name="Delete Instance")
@@ -153,4 +161,4 @@ def create_instance(self, instance_data: UserInstanceData) -> Optional[APIRespon
                 "cost_hour": instance_data.instance_plan.cost_hour
             }
         }
-        return self.make_request("instance/create", data, action_name="Create Instance") 
\ No newline at end of file
+        return self.make_request("instance/create", data, action_name="Create Instance")
\ No newline at end of file
diff --git a/test/e2e/conftest.py b/test/e2e/conftest.py
index f9a85b0..b8af279 100644
--- a/test/e2e/conftest.py
+++ b/test/e2e/conftest.py
@@ -246,10 +246,41 @@ def test_lifecycle(action_registry: ActionRegistry, page: Page, backend_url: str
         "api_client": api_client
     }
     test_data = action_registry.run_before_actions(**action_context)
+    page.wait_for_load_state("load", timeout=10000)
     
     # Return the test data (results from before actions)
     yield test_data
     
     # Run after actions - using load state instead of the discouraged networkidle
     page.wait_for_load_state("load", timeout=10000)
-    action_registry.run_after_actions(**action_context)
\ No newline at end of file
+    action_registry.run_after_actions(**action_context)
+
+
+@pytest.fixture(scope="class")
+def test_class_lifecycle(browser: Browser, browser_context_args: Dict[str, Any], action_registry: ActionRegistry, backend_url: str, request: pytest.FixtureRequest) -> Generator[TestData, None, None]:
+    """
+    Fixture that runs before_all actions once at the beginning of a test class 
+    and after_all actions once at the end of a test class.
+    
+    This fixture must be explicitly included in test classes that need class-level setup/teardown.
+    """
+    context = browser.new_context(**browser_context_args)
+    page = context.new_page()
+    
+    # Create API client
+    api_client = ApiClient(page, backend_url)
+
+    # Run before_all actions once at the beginning of the class
+    action_context = {
+        "page": page,
+        "backend_url": backend_url,
+        "request": request,
+        "api_client": api_client
+    }
+    test_data = action_registry.run_before_all_actions(**action_context)
+    
+    # Return the test data (results from before_all actions)
+    yield test_data
+    
+    # Run after_all actions once at the end of the class
+    action_registry.run_after_all_actions(**action_context)
\ No newline at end of file
diff --git a/test/e2e/pages/base_class.py b/test/e2e/pages/base_class.py
index acbe8cf..84e44ac 100644
--- a/test/e2e/pages/base_class.py
+++ b/test/e2e/pages/base_class.py
@@ -61,6 +61,12 @@ def wait_for_page_load(self) -> None:
         # This method is kept for backward compatibility
         # Use wait_for_locator or wait_for_event instead
         self.page.wait_for_load_state("load")
+    
+    def wait_for_document_ready(self) -> None:
+        """
+        Wait for the document to be ready.
+        """
+        self.page.wait_for_load_state("domcontentloaded")
         
     def wait_for_locator(self, locator: Locator, state: str = "visible", timeout: int = 30000) -> Locator:
         """
@@ -120,6 +126,12 @@ def wait_for_navigation(self, url_pattern: Optional[str] = None, timeout: int =
             self.page.wait_for_url(url_pattern, timeout=timeout)
         else:
             self.page.wait_for_load_state("load", timeout=timeout)
+    
+    def wait_for_timeout(self, timeout: int = 10000) -> None:
+        """
+        Wait for a timeout.
+        """
+        self.page.wait_for_timeout(timeout)
             
     def wait_for_toast(self, toast_type: str = "success", timeout: int = 10000) -> Locator:
         """
diff --git a/test/e2e/pages/instance/__init__.py b/test/e2e/pages/instance/__init__.py
index c17f9b0..4760373 100644
--- a/test/e2e/pages/instance/__init__.py
+++ b/test/e2e/pages/instance/__init__.py
@@ -5,8 +5,10 @@
 
 from .instance_list_page import InstanceListPage
 from .instance_create_page import InstanceCreatePage
+from .instance_setting_page import InstanceSettingPage
 
 __all__ = [
     'InstanceListPage',
-    'InstanceCreatePage'
+    'InstanceCreatePage',
+    'InstanceSettingPage'
 ]
diff --git a/test/e2e/pages/instance/instance_list_page.py b/test/e2e/pages/instance/instance_list_page.py
index ab078ea..ae0bff0 100644
--- a/test/e2e/pages/instance/instance_list_page.py
+++ b/test/e2e/pages/instance/instance_list_page.py
@@ -17,3 +17,9 @@ def click_create_instance_button(self):
         
     def should_navigate_to_instance_create_page(self):
         expect(self.page).to_have_url(f"/user/{self.username}/instance/create")
+    
+    def click_row_view_button(self, hostname: str):
+        self.page.get_by_test_id(f"view-instance-{hostname}-button").click()
+        
+    def should_navigate_to_instance_setting_page(self, hostname: str):
+        expect(self.page).to_have_url(f"/user/{self.username}/instance/{hostname}")
diff --git a/test/e2e/pages/instance/instance_setting_page.py b/test/e2e/pages/instance/instance_setting_page.py
new file mode 100644
index 0000000..ab22cd3
--- /dev/null
+++ b/test/e2e/pages/instance/instance_setting_page.py
@@ -0,0 +1,133 @@
+from playwright.sync_api import Page, expect
+
+from ..base_class import BasePage
+from ..common.side_nav_bar import SideNavBar
+
+class InstanceSettingPage(BasePage):
+    path: str = "/user/{username}/instance/{instance_name}"
+    
+    def __init__(self, page: Page, username: str, instance_name: str):
+        self.instance_name = instance_name
+        super().__init__(page)
+        
+        self.side_nav = SideNavBar(page)
+        self.path = self.path.format(username=username, instance_name=instance_name)
+        self.instance_status = {
+            "running": page.get_by_test_id("status-badge-Running"),
+            "stopped": page.get_by_test_id("status-badge-Stopped"),
+        }
+        
+        self.tab_navigation = {
+            "access": page.get_by_test_id("instance-setting-tab-button-AccessMenu"),
+            "power": page.get_by_test_id("instance-setting-tab-button-PowersMenu"),
+            "networking": page.get_by_test_id("instance-setting-tab-button-NetworkingMenu"),
+            "monitor": page.get_by_test_id("instance-setting-tab-button-MonitorMenu"),
+            "destroy": page.get_by_test_id("instance-setting-tab-button-DestroyMenu"),
+        }
+        
+        self.access_menu = {
+            "terminal": page.get_by_test_id("instance-terminal-container"),
+            "console": page.get_by_test_id("instance-console-container"),
+            "input_textbox": page.get_by_role("textbox", name="Terminal input"),
+            "reset_root_password": page.get_by_test_id("reset-root-password-input-field"),
+            "reset_root_password_button": page.get_by_test_id("reset-root-password-button"),
+        }
+        self.access_menu_tab = {
+            "terminal": page.get_by_test_id("instance-access-tab-button-terminal"),
+            "console": page.get_by_test_id("instance-access-tab-button-console"),
+        }
+
+        self.power_menu = {
+            "start": page.get_by_test_id("start-instance-button"),
+            "stop": page.get_by_test_id("stop-instance-button"),
+            "restart": page.get_by_test_id("restart-instance-button"),
+        }
+
+        self.monitor_menu = {
+            "cpu_cores": page.get_by_test_id("cpu-cores"),
+            "memory_used": page.get_by_test_id("memory-used"),
+        }
+        
+        self.destroy_menu = {
+            "destroy_instance": page.get_by_test_id("destroy-instance-button"),
+            "destroy_instance_input": page.get_by_test_id("destroy-instance-input-input-field"),
+        }
+    
+    def navigate_to_menu(self, menu: str):
+        self.tab_navigation[menu].click()
+    
+    def click_access_menu_tab(self, tab: str):
+        self.access_menu_tab[tab].click()
+        
+    def input_to_terminal(self, text: str):
+        # Add debounce to prevent spamming the input
+        self.wait_for_timeout(500)
+        self.access_menu["input_textbox"].fill(text)
+        self.access_menu["input_textbox"].press("Enter")
+
+    def logout_console(self):
+        self.access_menu["input_textbox"].press("ControlOrMeta+d")
+    
+    def wait_for_terminal_prompt(self):
+        expect_prompt = self.access_menu["terminal"].get_by_text(f"root@{self.instance_name}:~#")
+        self.wait_for_locator(expect_prompt, state="visible", timeout=20000)
+        self.wait_for_timeout(3000) # Wait for websocket connection to stabilize
+    
+    def wait_for_console_prompt(self):
+        # Wait for the console to be visible first
+        self.wait_for_locator(self.access_menu["console"], state="visible", timeout=20000)
+        
+        # Try different potential patterns that could indicate console is ready
+        try:
+            # Check for login prompt with instance name
+            login_prompt = self.access_menu["console"].get_by_text(f"{self.instance_name} login:", exact=False)
+            self.wait_for_locator(login_prompt, state="visible", timeout=10000)
+        except:
+            self.access_menu["input_textbox"].press("Enter")
+            self.access_menu["input_textbox"].press("Enter")
+        
+        self.wait_for_timeout(5000)  # Wait for websocket connection to stabilize
+        self.access_menu["input_textbox"].press("ControlOrMeta+u")  # Clear the current line
+    
+    def should_have_output_access_menu(self, text: str, terminal_type: str):
+        expect_output = self.access_menu[terminal_type].get_by_text(text, exact=False)
+        expect(expect_output).to_be_visible()
+    
+    def access_menu_should_not_be_available(self):
+        self.navigate_to_menu("access")
+        terminal_text = "Terminal unavailable - Instance not running"
+        console_text = "Console unavailable - Instance not running"
+        expect(self.page.get_by_text(terminal_text)).to_be_visible()
+        self.click_access_menu_tab("console")
+        expect(self.page.get_by_text(console_text)).to_be_visible()
+
+    def fill_reset_root_password(self, text: str):
+        self.access_menu["reset_root_password"].fill(text)
+    
+    def click_reset_root_password(self):
+        self.access_menu["reset_root_password_button"].click()
+
+    def should_disable_reset_root_password(self):
+        expect(self.access_menu["reset_root_password_button"]).to_be_disabled()
+    
+    def click_power_button(self, power_type: str):
+        self.power_menu[power_type].click()
+
+    def should_have_instance_status(self, status: str):
+        expect(self.instance_status[status]).to_be_visible()
+
+    def should_disable_restart_instance(self):
+        expect(self.power_menu["restart"]).to_be_disabled()
+    
+    def should_have_same_monitoring_data(self, cpu_cores: str, memory_used: str):
+        expect(self.monitor_menu["cpu_cores"]).to_contain_text(cpu_cores)
+        expect(self.monitor_menu["memory_used"]).to_contain_text(memory_used)
+    
+    def fill_destroy_instance_input(self, text: str):
+        self.destroy_menu["destroy_instance_input"].fill(text)
+    
+    def click_destroy_instance_button(self):
+        self.destroy_menu["destroy_instance"].click()
+    
+    def should_disable_destroy_instance_button(self):
+        expect(self.destroy_menu["destroy_instance"]).to_be_disabled()
\ No newline at end of file
diff --git a/test/e2e/registry/actions.py b/test/e2e/registry/actions.py
index 33e7930..41a76b7 100644
--- a/test/e2e/registry/actions.py
+++ b/test/e2e/registry/actions.py
@@ -18,6 +18,15 @@ class AfterActionFn(Protocol):
     def __call__(self, page: Page, backend_url: str, request: pytest.FixtureRequest, api_client: ApiClient, **kwargs: Any) -> None:
         ...
 
+# Define Protocols for class-level (all) action functions
+class BeforeAllActionFn(Protocol):
+    def __call__(self, page: Page, backend_url: str, request: pytest.FixtureRequest, api_client: ApiClient, **kwargs: Any) -> Any:
+        ...
+
+class AfterAllActionFn(Protocol):
+    def __call__(self, page: Page, backend_url: str, request: pytest.FixtureRequest, api_client: ApiClient, **kwargs: Any) -> None:
+        ...
+
 # Alias for test data returned from actions
 TestData = List[Any]
 
@@ -30,9 +39,17 @@ class ActionRegistry:
     This allows for a more flexible way to configure test setup/teardown.
     """
     def __init__(self) -> None:
+        # Per-test actions (run before/after each test)
         self.before_actions: List[BeforeActionFn] = []
         self.after_actions: List[AfterActionFn] = []
         
+        # Class-level actions (run once before/after all tests in a class)
+        self.before_all_actions: List[BeforeAllActionFn] = []
+        self.after_all_actions: List[AfterAllActionFn] = []
+        
+        # Track if before_all has been executed
+        self.before_all_executed = False
+        
     def register_before(self, action_fn: BeforeActionFn) -> BeforeActionFn:
         """Register a function to run before each test"""
         self.before_actions.append(action_fn)
@@ -43,19 +60,37 @@ def register_after(self, action_fn: AfterActionFn) -> AfterActionFn:
         self.after_actions.append(action_fn)
         return action_fn  # Return for use as decorator
     
-    def action(self, is_before: bool = True) -> Callable[[F], F]:
+    def register_before_all(self, action_fn: BeforeAllActionFn) -> BeforeAllActionFn:
+        """Register a function to run once before all tests in a class"""
+        self.before_all_actions.append(action_fn)
+        return action_fn  # Return for use as decorator
+        
+    def register_after_all(self, action_fn: AfterAllActionFn) -> AfterAllActionFn:
+        """Register a function to run once after all tests in a class"""
+        self.after_all_actions.append(action_fn)
+        return action_fn  # Return for use as decorator
+    
+    def action(self, is_before: bool = True, is_all: bool = False) -> Callable[[F], F]:
         """
         Flexible decorator for registering actions with specific parameters.
         Will automatically extract only the parameters that the decorated function needs.
         
         Usage:
-            @action_registry.action()  # Default is before action
+            @action_registry.action()  # Default is before action (before each)
             def my_action(page: Page, api_client: ApiClient):
                 # Only gets page and api_client, other parameters are ignored
                 
-            @action_registry.action(is_before=False)  # Register as after action
+            @action_registry.action(is_before=False)  # Register as after action (after each)
             def my_cleanup(backend_url: str):
                 # Only gets backend_url
+                
+            @action_registry.action(is_all=True)  # Register as before all action
+            def my_setup_once(api_client: ApiClient):
+                # Runs once before all tests in the class
+                
+            @action_registry.action(is_before=False, is_all=True)  # Register as after all action
+            def my_teardown_once(api_client: ApiClient):
+                # Runs once after all tests in the class
         """
         def decorator(fn: F) -> F:
             # Get parameter names from the function signature
@@ -68,23 +103,37 @@ def wrapper(**kwargs: Any) -> Any:
                 filtered_kwargs = {k: v for k, v in kwargs.items() if k in param_names}
                 return fn(**filtered_kwargs)
             
-            # Add to the appropriate list
-            if is_before:
-                self.before_actions.append(cast(BeforeActionFn, wrapper))
+            # Add to the appropriate list based on is_before and is_all
+            if is_all:
+                if is_before:
+                    self.before_all_actions.append(cast(BeforeAllActionFn, wrapper))
+                else:
+                    self.after_all_actions.append(cast(AfterAllActionFn, wrapper))
             else:
-                self.after_actions.append(cast(AfterActionFn, wrapper))
+                if is_before:
+                    self.before_actions.append(cast(BeforeActionFn, wrapper))
+                else:
+                    self.after_actions.append(cast(AfterActionFn, wrapper))
                 
             return cast(F, fn)  # Return original function for use as decorator
         
         return decorator
     
     def before(self) -> Callable[[F], F]:
-        """Shorthand for action(is_before=True)"""
-        return self.action(is_before=True)
+        """Shorthand for action(is_before=True, is_all=False)"""
+        return self.action(is_before=True, is_all=False)
     
     def after(self) -> Callable[[F], F]:
-        """Shorthand for action(is_before=False)"""
-        return self.action(is_before=False)
+        """Shorthand for action(is_before=False, is_all=False)"""
+        return self.action(is_before=False, is_all=False)
+    
+    def before_all(self) -> Callable[[F], F]:
+        """Shorthand for action(is_before=True, is_all=True)"""
+        return self.action(is_before=True, is_all=True)
+    
+    def after_all(self) -> Callable[[F], F]:
+        """Shorthand for action(is_before=False, is_all=True)"""
+        return self.action(is_before=False, is_all=True)
         
     def run_before_actions(self, **kwargs: Any) -> TestData:
         """Run all registered before actions"""
@@ -103,4 +152,31 @@ def run_after_actions(self, **kwargs: Any) -> None:
             try:
                 action(**kwargs)
             except Exception as e:
-                print(f"Error in after action {action.__name__}: {str(e)}") 
\ No newline at end of file
+                print(f"Error in after action {action.__name__}: {str(e)}")
+                
+    def run_before_all_actions(self, **kwargs: Any) -> TestData:
+        """Run all registered before_all actions once"""
+        if self.before_all_executed:
+            return []  # Skip if already executed
+            
+        results: TestData = []
+        for action in self.before_all_actions:
+            try:
+                result = action(**kwargs)
+                results.append(result)
+            except Exception as e:
+                print(f"Error in before_all action {action.__name__}: {str(e)}")
+                
+        self.before_all_executed = True
+        return results
+        
+    def run_after_all_actions(self, **kwargs: Any) -> None:
+        """Run all registered after_all actions once"""
+        # Reset the before_all flag so the actions can run again if needed
+        self.before_all_executed = False
+        
+        for action in reversed(self.after_all_actions):
+            try:
+                action(**kwargs)
+            except Exception as e:
+                print(f"Error in after_all action {action.__name__}: {str(e)}") 
\ No newline at end of file
diff --git a/test/e2e/scenarios/test_instance_create.py b/test/e2e/scenarios/test_instance_create.py
index ba3aaed..3ff1581 100644
--- a/test/e2e/scenarios/test_instance_create.py
+++ b/test/e2e/scenarios/test_instance_create.py
@@ -78,7 +78,7 @@ def test_valid_data_create_instance(self, page: Page, test_user_instance: UserIn
         instance_create_page.should_disable_create_instance_button() # Check that create button is disabled
         
         # Wait for success toast to appear
-        instance_create_page.wait_for_toast("success")
+        instance_create_page.wait_for_toast("success", timeout=20000)
         instance_create_page.toast.should_show_success_toast()
         instance_create_page.should_navigate_to_instance_dashboard()
     
diff --git a/test/e2e/scenarios/test_instance_setting.py b/test/e2e/scenarios/test_instance_setting.py
new file mode 100644
index 0000000..c211eb6
--- /dev/null
+++ b/test/e2e/scenarios/test_instance_setting.py
@@ -0,0 +1,198 @@
+from datetime import datetime
+import pytest
+from typing import Dict, Any
+from playwright.sync_api import Page, expect, Browser
+
+from ..pages.auth import RegisterPage, LoginPage
+from ..pages.instance import InstanceListPage, InstanceSettingPage
+from ..data.models import InstancePlanData, OsTypeData, UserData, UserInstanceData
+from ..registry.actions import ActionRegistry, TestData
+from ..api.client import ApiClient
+
+@pytest.fixture(scope="module")
+def test_instance_plan() -> InstancePlanData:
+    return InstancePlanData(
+        instance_plan_id=1,
+        instance_package_name="nano-1",
+        vcpu_amount=1,
+        ram_amount=1,
+        storage_amount=10,
+        cost_hour=0.005
+    )
+
+@pytest.fixture(scope="module")
+def test_os_type() -> OsTypeData:
+    return OsTypeData(
+        os_type_id=11,
+        os_image_name="Debian",
+        os_image_version="bookworm"
+    )
+
+@pytest.fixture(scope="module")
+def test_user_instance(
+    test_instance_plan: InstancePlanData,
+    test_os_type: OsTypeData
+) -> UserInstanceData:
+    return UserInstanceData(
+        instance_plan=test_instance_plan,
+        os_type=test_os_type,
+        hostname="test-hostname",
+        lxd_node_name="test-lxd-node-name",
+        status="running",
+        root_password="Password123!",
+        created_at=datetime.now(),
+        last_updated_at=datetime.now()
+    )
+
+# Using before_all and after_all for class-level setup and teardown
+@pytest.fixture(scope="module", autouse=True)
+def setup_class_actions(action_registry: ActionRegistry, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+    # This action runs once before all tests in the class
+    @action_registry.before_all()
+    def create_instance_once(api_client: ApiClient) -> None:
+        print("Creating instance once before all tests")
+        api_client.login_user(test_user)
+        api_client.create_instance(test_user_instance)
+    
+    # This action runs once after all tests in the class    
+    @action_registry.after_all()
+    def delete_instance_once(api_client: ApiClient) -> None:
+        print("Deleting instance once after all tests")
+        api_client.delete_instance(test_user_instance.hostname)
+
+        
+@pytest.mark.usefixtures("test_class_lifecycle")  # Add this fixture to use class-level actions
+class TestInstanceSetting:
+    def test_access_menu_terminal(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+        # We use a function-scoped page for each test, but the instance was created once by before_all
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.wait_for_terminal_prompt()
+        instance_setting_page.input_to_terminal("echo $(( (17*19) + (23*3) - (5*6) ))")
+        instance_setting_page.should_have_output_access_menu("362", "terminal")
+
+    def test_access_menu_console_login_success(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.click_access_menu_tab("console")
+        instance_setting_page.wait_for_console_prompt()
+        instance_setting_page.input_to_terminal("root")
+        instance_setting_page.input_to_terminal(test_user_instance.root_password)
+        instance_setting_page.should_have_output_access_menu(f"root@{test_user_instance.hostname}:~#", "console")
+        instance_setting_page.input_to_terminal("echo $(( (17*19) + (23*3) - (5*6) ))")
+        instance_setting_page.should_have_output_access_menu("362", "console")
+        instance_setting_page.logout_console()
+
+    def test_access_menu_console_login_failed(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.click_access_menu_tab("console")
+        instance_setting_page.wait_for_console_prompt()
+        instance_setting_page.input_to_terminal("root")
+        instance_setting_page.input_to_terminal("wrong-password")
+        instance_setting_page.should_have_output_access_menu("Login incorrect", "console")
+
+    def test_access_menu_reset_root_password(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.should_disable_reset_root_password()
+        instance_setting_page.fill_reset_root_password("123Password!")
+        instance_setting_page.click_reset_root_password()
+        
+        instance_setting_page.click_access_menu_tab("console")
+        instance_setting_page.wait_for_console_prompt()
+        instance_setting_page.input_to_terminal("root")
+        instance_setting_page.input_to_terminal("123Password!")
+        instance_setting_page.should_have_output_access_menu(f"root@{test_user_instance.hostname}:~#", "console")
+        instance_setting_page.logout_console()
+
+    def test_power_menu_stop_instance(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData, api_client: ApiClient) -> None:
+        # Make sure the instance is running
+        api_client.start_instance(test_user_instance.hostname)
+
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.navigate_to_menu("power")
+        instance_setting_page.click_power_button("stop")
+        instance_setting_page.wait_for_toast("success")
+        instance_setting_page.should_have_instance_status("stopped")
+        instance_setting_page.should_disable_restart_instance()
+        instance_setting_page.access_menu_should_not_be_available()
+        
+    def test_power_menu_start_instance(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData, api_client: ApiClient) -> None:
+        # Make sure the instance is stopped
+        api_client.stop_instance(test_user_instance.hostname)
+        
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.navigate_to_menu("power")
+        instance_setting_page.click_power_button("start")
+        instance_setting_page.wait_for_toast("success")
+        instance_setting_page.should_have_instance_status("running")
+        
+    def test_power_menu_restart_instance(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData, api_client: ApiClient) -> None:
+        # Make sure the instance is running
+        api_client.start_instance(test_user_instance.hostname)
+        
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.navigate_to_menu("power")
+        instance_setting_page.click_power_button("restart")
+        instance_setting_page.wait_for_toast("success")
+        instance_setting_page.should_have_instance_status("running")
+
+    def test_monitoring_menu(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData, api_client: ApiClient) -> None:
+        # Make sure the instance is running
+        api_client.start_instance(test_user_instance.hostname)
+        
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.navigate_to_menu("monitor")
+        cpu_cores = f"{test_user_instance.instance_plan.vcpu_amount} core"
+        ram_amount = f"{test_user_instance.instance_plan.ram_amount} GB"
+        instance_setting_page.should_have_same_monitoring_data(cpu_cores, ram_amount)
+    
+    def test_destroy_menu(self, page: Page, test_user_instance: UserInstanceData, test_user: UserData) -> None:
+        instance_list_page = InstanceListPage(page, test_user.username)
+        instance_list_page.navigate()
+        instance_list_page.click_row_view_button(test_user_instance.hostname)
+        instance_list_page.should_navigate_to_instance_setting_page(test_user_instance.hostname)
+        
+        instance_setting_page = InstanceSettingPage(page, test_user.username, test_user_instance.hostname)
+        instance_setting_page.navigate_to_menu("destroy")
+        instance_setting_page.should_disable_destroy_instance_button()
+        instance_setting_page.fill_destroy_instance_input(test_user_instance.hostname)
+        instance_setting_page.click_destroy_instance_button()
+        instance_setting_page.wait_for_toast("success")
\ No newline at end of file