@codeguide/core 0.0.27 → 0.0.29

package/docs/testsprite_tests/TC001_Homepage_Load_and_Hero_Section_Display.py

@@ -0,0 +1,70 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        await expect(frame.locator('text=Complete TypeScript SDK for integrating CodeGuide functionality into your applications').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=Get Started').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=🔑 Multiple Authentication Methods').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=📝 Project Management').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=🤖 Codespace Tasks').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=🎯 Model Management').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=🔐 Security Keys').first).to_be_visible(timeout=2000)
+        await expect(frame.locator('text=🛡️ TypeScript Support').first).to_be_visible(timeout=2000)
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC002_Sidebar_Navigation_ExpandCollapse_Functionality.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Click on a collapsible section in the sidebar to expand it and show nested links
+        frame = context.pages[-1]
+        # Click on 'Getting Started' collapsible section in the sidebar to expand it
+        elem = frame.locator('xpath=html/body/div/div/header/div/div/div/div[2]/div/nav/a[2]').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Sidebar Navigation Expanded Successfully').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: The hierarchical sidebar navigation did not expand or collapse correctly, or did not route to the correct documentation pages as expected.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC003_Full_Text_Local_Search_with_Keyboard_Shortcut.py

@@ -0,0 +1,90 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Try to locate the search input field visually or by other means and input the search query
+        frame = context.pages[-1]
+        # Click on the 'Search' button or area to focus the search input
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/div[2]/button').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        await expect(frame.locator('text=Search').first).to_be_visible(timeout=30000)
+        await frame.keyboard.press('Control+K')  # For Windows/Linux
+        await expect(frame.locator('input[type="search"]')).to_be_focused(timeout=30000)
+        search_query = 'Codespace Service Documentation'
+        await frame.locator('input[type="search"]').fill(search_query)
+        await frame.wait_for_timeout(1000)  # Wait for search results to update
+        await expect(frame.locator(f'text={search_query}').first).to_be_visible(timeout=30000)
+        await expect(frame.locator(f'text={search_query}').first).to_contain_text(search_query)
+        # Check that query terms are highlighted in the search results
+        await expect(frame.locator('text=Codespace Service Documentation').first).to_be_visible(timeout=30000)
+        # Navigate search results using keyboard arrows
+        await frame.keyboard.press('ArrowDown')
+        await frame.keyboard.press('ArrowUp')
+        # Check that focused search result is visually distinct
+        # (Assuming focused element has aria-selected or similar attribute)
+        focused_result = frame.locator('aria-selected=true')
+        await expect(focused_result).to_be_visible(timeout=30000)
+        # Select the focused search result
+        await frame.keyboard.press('Enter')
+        # Verify navigation to the correct documentation page with highlights
+        await expect(frame.locator('text=Codespace Service Documentation').first).to_be_visible(timeout=30000)
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC004_Dark_Mode_Toggle_and_Persistence.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Click the dark mode toggle button to enable dark mode
+        frame = context.pages[-1]
+        # Click the dark mode toggle button to enable dark mode
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/ul[2]/li/strong/a').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Dark Mode Enabled Successfully')).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: The dark mode toggle did not work as expected. The site did not switch to dark mode appearance immediately or persist user choice across sessions.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC005_Mobile_Responsiveness_and_Touch_Navigation.py

@@ -0,0 +1,113 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        await page.mouse.wheel(0, 100)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # -> Resize viewport to 320px width and check layout for horizontal scrolling and responsiveness.
+        await page.goto('http://localhost:5174/', timeout=10000)
+        await asyncio.sleep(3)
+        
+
+        # --> Assertions to verify final state
+        try:
+            await expect(page.locator('text=Mobile Navigation Menu Opened Successfully').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test plan execution failed: The mobile navigation menu did not open smoothly or sections could not be expanded/collapsed as expected.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC006_GitHub_Integration_Edit_this_page_Links.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Navigate to a specific documentation page (e.g., 'Getting Started') to locate and verify 'Edit this page' link.
+        frame = context.pages[-1]
+        # Click on 'Getting Started' link to navigate to a documentation page where 'Edit this page' link might be present.
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/ul/li/strong/a').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Edit this page link is broken or incorrect').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError("Test case failed: The 'Edit this page' link does not correctly direct to the corresponding markdown file on GitHub repository as per the test plan.")
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC007_Syntax_Highlighting_and_Code_Copy_Functionality.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Click the copy-to-clipboard button on the first TypeScript code block to test copy functionality
+        frame = context.pages[-1]
+        # Click the copy-to-clipboard button on the first TypeScript code block
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/div[2]/button').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Syntax highlighting failed for TypeScript and JavaScript code samples').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: Syntax highlighting, line numbers, or copy-to-clipboard functionality did not work as expected for TypeScript and JavaScript code samples.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+    

package/docs/testsprite_tests/TC008_Auto_Generated_Table_of_Contents_Accuracy.py

@@ -0,0 +1,73 @@
+import asyncio
+from playwright import async_api
+from playwright.async_api import expect
+
+async def run_test():
+    pw = None
+    browser = None
+    context = None
+    
+    try:
+        # Start a Playwright session in asynchronous mode
+        pw = await async_api.async_playwright().start()
+        
+        # Launch a Chromium browser in headless mode with custom arguments
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[
+                "--window-size=1280,720",         # Set the browser window size
+                "--disable-dev-shm-usage",        # Avoid using /dev/shm which can cause issues in containers
+                "--ipc=host",                     # Use host-level IPC for better stability
+                "--single-process"                # Run the browser in a single process mode
+            ],
+        )
+        
+        # Create a new browser context (like an incognito window)
+        context = await browser.new_context()
+        context.set_default_timeout(5000)
+        
+        # Open a new page in the browser context
+        page = await context.new_page()
+        
+        # Navigate to your target URL and wait until the network request is committed
+        await page.goto("http://localhost:5174", wait_until="commit", timeout=10000)
+        
+        # Wait for the main page to reach DOMContentLoaded state (optional for stability)
+        try:
+            await page.wait_for_load_state("domcontentloaded", timeout=3000)
+        except async_api.Error:
+            pass
+        
+        # Iterate through all iframes and wait for them to load as well
+        for frame in page.frames:
+            try:
+                await frame.wait_for_load_state("domcontentloaded", timeout=3000)
+            except async_api.Error:
+                pass
+        
+        # Interact with the page elements to simulate user flow
+        # -> Click on a table of contents entry to verify navigation to the correct section
+        frame = context.pages[-1]
+        # Click 'Quick Start' in the table of contents to verify navigation
+        elem = frame.locator('xpath=html/body/div/div/div/div/div[3]/div/div/h2/a').nth(0)
+        await page.wait_for_timeout(3000); await elem.click(timeout=5000)
+        
+
+        # --> Assertions to verify final state
+        frame = context.pages[-1]
+        try:
+            await expect(frame.locator('text=Table of Contents Not Found').first).to_be_visible(timeout=1000)
+        except AssertionError:
+            raise AssertionError('Test case failed: The table of contents is not auto-generated correctly or navigation links do not work as expected.')
+        await asyncio.sleep(5)
+    
+    finally:
+        if context:
+            await context.close()
+        if browser:
+            await browser.close()
+        if pw:
+            await pw.stop()
+            
+asyncio.run(run_test())
+