fix: pr feedback

Author: kylewalke

.github/workflows/e2e-tests.yml

@@ -2,9 +2,10 @@ name: E2E Tests
 
 on:
   push:
-    branches: [main, kyledev/e2eTesting]
+    branches: [main, kyledev/e2eTests]
   pull_request:
     branches: [main]
+  workflow_dispatch:
 
 jobs:
   e2e-tests:

build-config/tsup.shared.ts

@@ -15,7 +15,7 @@ export const COMMON_EXTERNAL = [
   'vscode',
   'vscode-languageserver',
   'vscode-languageserver/node',
-  'vscode-languageserver/browser', 
+  'vscode-languageserver/browser',
   'vscode-languageserver-protocol',
   'vscode-jsonrpc',
   'vscode-jsonrpc/node',
@@ -45,17 +45,14 @@ export const nodeBaseConfig: Partial<Options> = {
   minify: false,
   dts: false,
   splitting: false,
-  external: [
-    ...COMMON_EXTERNAL,
-    'crypto', 'fs', 'path', 'url', 'os', 'stream',
-  ],
+  external: [...COMMON_EXTERNAL, 'crypto', 'fs', 'path', 'url', 'os', 'stream'],
 };
 
 /**
  * Base configuration for browser/web builds
  */
 export const browserBaseConfig: Partial<Options> = {
-  platform: 'browser', 
+  platform: 'browser',
   target: 'es2022',
   format: ['cjs'],
   sourcemap: true,
@@ -70,11 +67,11 @@ export const browserBaseConfig: Partial<Options> = {
  * Browser polyfill aliases - simplified from complex esbuild setup
  */
 export const BROWSER_ALIASES = {
-  'path': 'path-browserify',
-  'crypto': 'crypto-browserify', 
-  'stream': 'stream-browserify',
-  'fs': 'memfs',
-  'url': 'url-browserify',
-  'os': 'os-browserify/browser',
+  path: 'path-browserify',
+  crypto: 'crypto-browserify',
+  stream: 'stream-browserify',
+  fs: 'memfs',
+  url: 'url-browserify',
+  os: 'os-browserify/browser',
   'vscode-languageclient/node': 'vscode-languageclient/browser',
-};
+};

e2e-tests/README.md

@@ -1,252 +1,97 @@
 # E2E Tests for Apex Language Server Extension
 
-This directory contains end-to-end tests for the Apex Language Server VSCode extension running in a web environment. The tests use Playwright to automate browser interactions with VSCode Web and verify that the extension works correctly.
+This package provides comprehensive end-to-end testing for the Apex Language Server Extension in VS Code Web environments. The test suite validates that the extension correctly integrates with VS Code's language server protocol and provides essential Apex language features.
 
-## 📁 Project Structure
+## Purpose
 
-```
-e2e-tests/
-├── fixtures/                   # Test data and sample files
-│   └── apex-samples.ts         # Sample Apex files for testing
-├── tests/                      # Test files
-│   └── apex-extension-core.spec.ts  # Core functionality tests
-├── types/                      # TypeScript type definitions
-│   └── test.types.ts          # Test-related interfaces
-├── utils/                      # Utility functions and helpers
-│   ├── constants.ts           # Test constants and selectors
-│   ├── test-helpers.ts        # Core test helper functions
-│   ├── outline-helpers.ts     # Outline view specific helpers
-│   └── global.ts              # Global setup and teardown functions
-├── test-server.js             # VS Code Web test server
-├── playwright.config.ts       # Playwright configuration
-├── tsconfig.json              # TypeScript configuration
-└── README.md                  # This file
-```
+The e2e test suite ensures the Apex Language Server Extension works correctly in real-world browser environments by testing:
+
+- **Extension Activation**: Verifies the extension properly activates when Apex files are opened
+- **Language Server Integration**: Confirms the LSP worker starts and initializes without errors
+- **Symbol Parsing**: Validates that Apex code is correctly parsed and symbols are identified
+- **Outline View**: Tests that the VS Code outline view displays Apex class structure
+- **Workspace Integration**: Ensures Apex files are recognized and handled in the workspace
+- **Stability**: Confirms the extension doesn't cause VS Code crashes or performance issues
+
+## Test Philosophy
 
-## Overview
+These tests focus on critical user-facing functionality rather than internal implementation details. They simulate real user interactions with the extension in a browser environment, providing confidence that the extension will work correctly when published.
 
-The e2e test suite verifies core extension functionality in VS Code Web:
+The test suite prioritizes:
 
-- **VS Code Web startup** - Verifies the web environment loads correctly
-- **Extension activation** - Confirms the extension activates when opening Apex files
-- **LSP worker loading** - Ensures the language server starts without critical errors
-- **File recognition** - Validates Apex files are detected in the workspace
-- **Outline view** - Tests symbol parsing and outline generation
-- **Stability** - Checks that VS Code remains responsive after extension activation
+- **Reliability**: Tests are designed to be stable across different environments
+- **Performance**: Fast execution with parallel test runs where possible
+- **Maintainability**: Clean abstractions and reusable utilities
+- **Comprehensive Coverage**: Core functionality is thoroughly validated
 
 ## Prerequisites
 
-1. Node.js >= 20.0.0
-2. npm packages installed (`npm install` from root)
-3. Extension built (`npm run compile && npm run bundle` in `packages/apex-lsp-vscode-extension`)
+- Node.js >= 20.0.0
+- Extension must be built before running tests
+- VS Code Web test server capability
 
 ## Running Tests
 
-### Quick Start
-
 ```bash
-# Run all e2e tests (recommended - headless, parallel, fast)
+# Run all tests (recommended)
 npm run test:e2e
 
-# Run tests in debug mode with Playwright inspector and headed browser
+# Debug mode with browser UI
 npm run test:e2e:debug
 
-# Run tests visually (headed browser, slower execution for watching)
+# Visual mode for test development
 npm run test:e2e:visual
 ```
 
-### Current Test Status
-
-✅ **Core Tests (`apex-extension-core.spec.ts`):**
-
-**Test 1: Core Extension Functionality**
-
-- VS Code Web startup and loading
-- Apex file recognition in workspace (2+ files)
-- Extension activation when opening .cls files
-- Monaco editor integration
-- Language server worker initialization
-- Critical error monitoring
-- Extension stability verification
-
-**Test 2: Outline View Integration**
-
-- Opens Apex (.cls) file in editor
-- Verifies outline view loads and is accessible
-- Confirms LSP parses file and generates outline structure
-- Validates specific Apex symbols (HelloWorld class, sayHello/add methods) appear
-- Ensures outline view functionality works correctly
-
-**Test 3: Complex Symbol Hierarchy**
-
-- Opens ComplexExample.cls with advanced structure
-- Tests parsing of static fields, instance fields, methods, and inner classes
-- Validates proper symbol nesting and hierarchy display
-- Comprehensive LSP symbol recognition testing
-
-**Browser Support:** Chromium (primary)
-
-### Manual Testing
-
-```bash
-# Start the test server manually (for development)
-npm run test:web:server
-
-# In another terminal, run specific tests
-cd e2e-tests
-npx playwright test apex-extension-core.spec.ts
-```
-
-## Configuration
-
-### Environment Configuration
-
-- **Development**: Fast retries, parallel execution
-- **CI/CD**: Conservative settings, sequential execution
-- **Browser**: Chromium with debugging features enabled
-- **Timeouts**: Environment-specific values
-
-### Test Server (`test-server.js`)
-
-Starts a VS Code Web instance with:
-
-- Extension loaded from `../packages/apex-lsp-vscode-extension`
-- Test workspace with sample Apex files
-- Debug options enabled
-- Fixed port (3000) for Playwright
-
-## Test Architecture
+## Test Environment
 
-### Core Components
+The tests run against a real VS Code Web instance with the extension pre-loaded. This provides high confidence that the extension will work correctly in production browser environments.
 
-#### **Utilities (`utils/`)**
+**Supported Browsers**: Chromium (primary testing target)
 
-- `test-helpers.ts` - Core test functions (startup, activation, monitoring)
-- `outline-helpers.ts` - Outline view specific functionality  
-- `constants.ts` - Centralized configuration and selectors
-- `global.ts` - Combined setup/teardown logic (extension building, workspace creation)
+**Environment Support**:
 
-#### **Types (`types/`)**
+- Local development with detailed debugging
+- CI/CD with stability optimizations
+- Debug modes for test development
 
-- Strong TypeScript typing for all test interfaces
-- Console error tracking types
-- Test metrics and environment configurations
-- Sample file definitions
+## Architecture
 
-#### **Fixtures (`fixtures/`)**
+The test suite uses Playwright for browser automation and is structured with:
 
-- Sample Apex classes, triggers, and SOQL queries
-- Follows Apex language rules (no imports, namespace resolution)
-- Comprehensive examples for testing parsing and outline generation
+- **Utilities**: Reusable functions for common test operations
+- **Test Helpers**: Specialized functions for extension-specific testing
+- **Configuration**: Centralized settings and selectors
+- **Type Safety**: Full TypeScript support throughout
 
-#### **Configuration**
+## Debugging and Development
 
-- Global setup/teardown combined in `utils/global.ts` - builds extension and creates test workspace  
-- Main Playwright configuration in `playwright.config.ts` with environment detection
-- Test server (`test-server.js`) - VS Code Web instance with pre-loaded extension
+The test suite includes comprehensive debugging capabilities:
 
-### Design Principles
+- Console error monitoring with intelligent filtering
+- Network failure tracking
+- Screenshot and video capture on failures
+- Detailed logging for test analysis
 
-Following `.cursor` TypeScript guidelines:
-
-- ✅ Strong typing with `readonly` properties
-- ✅ Arrow functions for consistency
-- ✅ Descriptive naming conventions (camelCase, kebab-case)
-- ✅ No enums (using string unions)
-- ✅ Import type for type-only imports
-- ✅ JSDoc documentation following Google Style Guide
-- ✅ Error handling with proper filtering
-- ✅ Constants for magic numbers
-- ✅ Modular, maintainable code structure
-
-## Test Data
-
-The global setup creates a test workspace with sample files from `fixtures/apex-samples.ts`:
-
-- **`HelloWorld.cls`**: Basic Apex class with static methods (sayHello, add)
-- **`ComplexExample.cls`**: Advanced class with fields, methods, and inner Configuration class  
-- **`AccountTrigger.trigger`**: Sample trigger with validation logic
-
-## Debugging
-
-### Console Errors
-
-Tests monitor browser console for errors. Non-critical errors (favicon, sourcemaps) are filtered out using centralized patterns.
-
-### Network Issues
-
-Tests check for worker file loading failures and report network issues with detailed logging.
-
-### Screenshots and Videos
-
-- Screenshots taken on test failures
-- Videos recorded on retry
-- Traces captured for failed tests
-- Debug screenshots in `test-results/` directory
-
-### Manual Debugging
-
-1. Start server: `npm run test:web:server`
-2. Open browser to `http://localhost:3000`
-3. Open Developer Tools
-4. Monitor console and network tabs
-5. Interact with the extension manually
+For manual debugging, tests can be run against a standalone VS Code Web server with full developer tools access.
 
 ## CI/CD Integration
 
-The tests are configured for CI environments:
+Tests are configured for continuous integration with:
 
-- **Retries**: 2 attempts on CI
-- **Workers**: 1 (sequential execution on CI)
-- **Reporting**: HTML report generated
-- **Headless**: Default on CI
-- **Timeout**: Extended for CI stability
-
-## Troubleshooting
-
-### Extension Won't Activate
-
-1. Verify extension is built: `npm run bundle` in extension directory
-2. Check `dist/` directory exists with bundled files
-3. Look for console errors in browser DevTools
-
-### Tests Timeout
-
-1. Check timeout configuration in `playwright.config.ts`
-2. Verify VS Code Web server is responding
-3. Ensure network connectivity
-
-### Worker Loading Errors
-
-1. Check worker files exist in `dist/` directory
-2. Verify file URLs are accessible
-3. Look for CORS or security policy issues
-
-### Port Conflicts
-
-- Change port in `playwright.config.ts`
-- Ensure port is not in use by other services
+- Retry logic for flaky test handling
+- Environment-specific timeouts and worker configuration
+- Comprehensive reporting and artifact collection
+- Headless execution with debugging artifact generation
 
 ## Contributing
 
 When adding new tests:
 
-1. Follow existing patterns using utilities from `utils/`
-2. Add proper TypeScript types
-3. Use centralized constants and selectors
-4. Add JSDoc documentation
-5. Update this README if needed
-6. Follow `.cursor` TypeScript guidelines
-
-## Scripts Summary
-
-- **`test:e2e`**: Main test runner (headless, parallel)
-- **`test:e2e:debug`**: Interactive debugging with Playwright inspector
-- **`test:e2e:visual`**: Headed browser with slower execution for watching tests
-- **`test:web:server`**: Start VS Code Web server manually for debugging
-
-## Known Limitations
+1. Use existing test utilities and patterns
+2. Focus on user-facing functionality
+3. Ensure tests are reliable across environments
+4. Include proper error handling and logging
+5. Follow TypeScript best practices
 
-- VS Code Web has some differences from desktop VS Code
-- Extension debugging capabilities are limited in web context  
-- Network-dependent features may be unreliable in test environments
+The test suite is designed to grow with the extension while maintaining reliability and performance.