refactor(electron): move esm / cjs testing from e2es to package tests (#38)

* refactor: move esm / cjs testing from e2es to package tests

* chore: fix workflow

* chore: update workspace

* chore: use matrix for package tests

* chore: update lockfile

* fix: update vite confs

Author: goosewobbler

.github/workflows/_ci-e2e.reusable.yml

@@ -1,5 +1,5 @@
 name: E2E Tests
-description: 'Runs end-to-end tests across different scenarios and JavaScript module types'
+description: 'Runs end-to-end tests across different scenarios (ESM only)'
 
 on:
   workflow_call:
@@ -22,10 +22,6 @@ on:
         description: 'Test scenario (forge, builder, or no-binary)'
         required: true
         type: string
-      type:
-        description: 'JavaScript module type (esm, cjs, or * for both)'
-        type: string
-        default: '*'
       build_id:
         description: 'Build ID from the build job'
         type: string
@@ -47,7 +43,7 @@ jobs:
   # This job runs E2E tests for a specific combination of:
   # - Operating system (Linux, Windows, macOS)
   # - Test scenario (builder, forge, no-binary)
-  # - Module type (ESM, CJS, or both)
+  # - E2E tests use ESM only (CJS/ESM testing is done in package tests)
   e2e:
     name: E2E Tests
     runs-on: ${{ inputs.os }}
@@ -86,20 +82,20 @@ jobs:
           echo "::notice::Build artifact: ID=${{ inputs.build_id }}, Size=${{ inputs.artifact_size }} bytes"
 
       # Dynamically generate the Turbo filter for building test applications
-      # This converts the scenario and type inputs into Turbo filter syntax
+      # This converts the scenario input into Turbo filter syntax
       - name: 🪄 Generate Build Filter for Test Apps
         id: gen-build
         uses: actions/github-script@v8
         with:
           result-encoding: string
           script: |
-            const generateBuildFilter = (scenario, type) => {
+            const generateBuildFilter = (scenario) => {
               return scenario
                 .split(',')
-                .map((s) => `--filter=electron-${s.trim()}-${type}-e2e-app`)
+                .map((s) => `--filter=electron-${s.trim()}-e2e-app`)
                 .join(' ');
             };
-            return generateBuildFilter('${{ inputs.scenario }}', '${{ inputs.type }}');
+            return generateBuildFilter('${{ inputs.scenario }}');
 
       # Build the test applications using Turbo with the generated filter
       # This builds only the necessary test apps for the current test configuration
@@ -108,25 +104,23 @@ jobs:
         run: pnpm exec turbo run ${{ inputs.build-command }} ${{ steps.gen-build.outputs.result }} --only --parallel
 
       # Dynamically generate the test commands to run
-      # This handles both single and multiple scenarios, and ESM/CJS/both
+      # This handles both single and multiple scenarios
       - name: 🪄 Generate Test Execution Plan
         id: gen-test
         uses: actions/github-script@v8
         with:
           result-encoding: string
           script: |
-            const generateTestCommand = (scenario, type) => {
+            const generateTestCommand = (scenario) => {
               return scenario
                 .split(',')
-                .flatMap((s) => {
+                .map((s) => {
                   const scenarioTrimmed = s.trim();
-                  return type === '*'
-                    ? [`test:e2e:electron-${scenarioTrimmed}-esm`, `test:e2e:electron-${scenarioTrimmed}-cjs`]
-                    : [`test:e2e:electron-${scenarioTrimmed}-${type}`];
+                  return `test:e2e:electron-${scenarioTrimmed}`;
                 })
                 .join(' ');
             };
-            return generateTestCommand('${{ inputs.scenario }}', '${{ inputs.type }}');
+            return generateTestCommand('${{ inputs.scenario }}');
 
       # Run the E2E tests using Turbo with the generated test commands
       # Each test builds its own apps with correct environment context
@@ -146,8 +140,8 @@ jobs:
         uses: ./.github/workflows/actions/upload-archive
         if: failure()
         with:
-          name: e2e-logs-${{ inputs.os }}${{ contains(inputs.build-command, 'mac-universal') && '-u' || '' }}-${{ inputs.scenario }}${{ inputs.type != '*' && format('-{0}',inputs.type) || '' }}
-          output: e2e-logs-${{ inputs.os }}${{ contains(inputs.build-command, 'mac-universal') && '-u' || '' }}-${{ inputs.scenario }}${{ inputs.type != '*' && format('-{0}',inputs.type) || '' }}.zip
+          name: e2e-logs-${{ inputs.os }}${{ contains(inputs.build-command, 'mac-universal') && '-u' || '' }}-${{ inputs.scenario }}
+          output: e2e-logs-${{ inputs.os }}${{ contains(inputs.build-command, 'mac-universal') && '-u' || '' }}-${{ inputs.scenario }}.zip
           paths: e2e/logs/**/*.log
 
       # Provide an interactive debugging session on failure

.github/workflows/_ci-package.reusable.yml

@@ -15,6 +15,11 @@ on:
         type: string
         required: false
         default: 'both'
+      module-type:
+        description: 'Module type for Electron package tests (cjs, esm, or both)'
+        type: string
+        required: false
+        default: 'both'
       build_id:
         description: 'Build ID from the build job'
         type: string
@@ -160,7 +165,8 @@ jobs:
           case "${{ inputs.service }}" in
             electron)
               echo "Running Electron package tests (apps built in isolated environments)"
-              pnpm run test:package:electron
+              echo "Module type: ${{ inputs.module-type }}"
+              pnpm run test:package:electron -- --module-type=${{ inputs.module-type }}
               ;;
             tauri)
               if [ "${{ inputs.os }}" == "macos-latest" ]; then
@@ -178,11 +184,13 @@ jobs:
             both)
               if [ "${{ inputs.os }}" == "macos-latest" ]; then
                 echo "⚠️  Skipping Tauri package tests on macOS (not supported)"
-                pnpm run test:package:electron
+                echo "Module type: ${{ inputs.module-type }}"
+                pnpm run test:package:electron -- --module-type=${{ inputs.module-type }}
               else
                 echo "Running all package tests (Electron built in isolated environments, Tauri using pre-built binaries)"
+                echo "Module type: ${{ inputs.module-type }}"
                 # Electron: build in isolated environments (no --skip-build)
-                pnpm run test:package:electron
+                pnpm run test:package:electron -- --module-type=${{ inputs.module-type }}
                 # Tauri: use --skip-build for pre-built binaries from separate build job
                 if [ "${{ inputs.os }}" == "ubuntu-latest" ]; then
                   xvfb-run -a pnpm run test:package:tauri -- --skip-build

.github/workflows/ci.yml

@@ -87,35 +87,20 @@ jobs:
   # Split Electron and Tauri tests across separate jobs for better parallelization and clarity
   # Electron apps are built inline on the test runner (faster builds, Turbo caching handles it)
   # Tauri apps are built separately due to longer build times and system dependencies
-  package-electron-linux:
-    name: Package - Electron [Linux]
-    needs: [build, lint]
-    uses: ./.github/workflows/_ci-package.reusable.yml
-    with:
-      os: 'ubuntu-latest'
-      service: 'electron'
-      build_id: ${{ needs.build.outputs.build_id }}
-      artifact_size: ${{ needs.build.outputs.artifact_size }}
-      cache_key: ${{ needs.build.outputs.cache_key }}
-
-  package-electron-windows:
-    name: Package - Electron [Windows]
-    needs: [build, lint]
-    uses: ./.github/workflows/_ci-package.reusable.yml
-    with:
-      os: 'windows-latest'
-      service: 'electron'
-      build_id: ${{ needs.build.outputs.build_id }}
-      artifact_size: ${{ needs.build.outputs.artifact_size }}
-      cache_key: ${{ needs.build.outputs.cache_key }}
-
-  package-electron-macos:
-    name: Package - Electron [macOS]
+  # Electron package tests are split by module type (CJS/ESM) for better error isolation
+  package-electron-matrix:
+    name: Package - Electron [${{ matrix.os == 'ubuntu-latest' && 'Linux' || matrix.os == 'windows-latest' && 'Windows' || 'macOS' }}] - ${{ matrix.module-type }}
     needs: [build, lint]
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
+        module-type: ['cjs', 'esm']
     uses: ./.github/workflows/_ci-package.reusable.yml
     with:
-      os: 'macos-latest'
+      os: ${{ matrix.os }}
       service: 'electron'
+      module-type: ${{ matrix.module-type }}
       build_id: ${{ needs.build.outputs.build_id }}
       artifact_size: ${{ needs.build.outputs.artifact_size }}
       cache_key: ${{ needs.build.outputs.cache_key }}
@@ -159,10 +144,10 @@ jobs:
   # E2E test matrix strategy:
   # - Run tests across 3 operating systems (Linux, Windows, macOS)
   # - Test 3 scenarios (builder, forge, no-binary)
-  # - Test 2 module types (ESM, CJS)
+  # - E2E tests use ESM only (CJS/ESM testing is done in package tests)
   # - Optimize for GitHub Actions concurrency limits
   e2e-matrix:
-    name: E2E - Electron [${{ matrix.os == 'ubuntu-latest' && 'Linux' || matrix.os == 'windows-latest' && 'Windows' || 'macOS' }}] - ${{ matrix.scenario }}${{ matrix.type != '*' && format(' ({0})', matrix.type) || '' }}
+    name: E2E - Electron [${{ matrix.os == 'ubuntu-latest' && 'Linux' || matrix.os == 'windows-latest' && 'Windows' || 'macOS' }}] - ${{ matrix.scenario }}
     needs: [build]
     strategy:
       fail-fast: false
@@ -171,23 +156,11 @@ jobs:
         os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
         # Test all application scenarios
         scenario: ['builder', 'forge', 'no-binary']
-        # Test both module types and wildcard for combined tests
-        type: ['esm', 'cjs', '*']
-        exclude:
-          # Optimization: All platforms run ESM and CJS separately for consistent resource management
-          # This prevents individual jobs from running too many test variants simultaneously
-          - os: 'ubuntu-latest'
-            type: '*'
-          - os: 'windows-latest'
-            type: '*'
-          - os: 'macos-latest'
-            type: '*'
     uses: ./.github/workflows/_ci-e2e.reusable.yml
     with:
       os: ${{ matrix.os }}
       node-version: '20'
       scenario: ${{ matrix.scenario }}
-      type: ${{ matrix.type }}
       build_id: ${{ needs.build.outputs.build_id }}
       artifact_size: ${{ needs.build.outputs.artifact_size }}
       cache_key: ${{ needs.build.outputs.cache_key }}
@@ -258,28 +231,19 @@ jobs:
   # Mac Universal builds require special handling
   # These are separate from regular macOS tests because they use a different build command
   e2e-mac-universal-matrix:
-    name: E2E [macOS-U] - ${{ matrix.scenario }}${{ matrix.type != '*' && format(' ({0})', matrix.type) || '' }}
+    name: E2E [macOS-U] - ${{ matrix.scenario }}
     needs: [build]
     strategy:
       fail-fast: false
       matrix:
         # Test both application scenarios
         scenario: ['forge', 'builder']
-        # Test both module types and wildcard for combined tests
-        type: ['esm', 'cjs', '*']
-        exclude:
-          # Optimization: Both forge and builder tests run ESM and CJS separately for better error isolation
-          - scenario: 'forge'
-            type: '*'
-          - scenario: 'builder'
-            type: '*'
     uses: ./.github/workflows/_ci-e2e.reusable.yml
     with:
       os: 'macos-latest'
       node-version: '20'
       build-command: 'build:mac-universal'
       scenario: ${{ matrix.scenario }}
-      type: ${{ matrix.type }}
       build_id: ${{ needs.build.outputs.build_id }}
       artifact_size: ${{ needs.build.outputs.artifact_size }}
       cache_key: ${{ needs.build.outputs.cache_key }}

e2e/README.md

@@ -55,7 +55,6 @@ The testing framework uses environment variables to control test execution:
 - **`APP`**: Application type
   - For Electron: `builder` | `forge` | `no-binary`
   - For Tauri: `basic` | `advanced`
-- **`MODULE_TYPE`**: Module system (`cjs` | `esm`)
 - **`TEST_TYPE`**: Test execution mode (`standard` | `window` | `multiremote` | `standalone`)
 - **`BINARY`**: Binary mode (`true` | `false`)
 
@@ -113,14 +112,7 @@ pnpm e2e:multiremote
 pnpm e2e:standalone
 ```
 
-#### Module Type-Specific
-```bash
-# CommonJS tests
-pnpm e2e:cjs
-
-# ES Module tests
-pnpm e2e:esm
-```
+**Note**: E2E tests use ESM only. CJS/ESM module system testing is done in package tests (see `fixtures/package-tests/`).
 
 ### Test Matrix Script
 
@@ -251,15 +243,16 @@ tsx scripts/build-apps.ts --clean
 ## Test Applications
 
 ### Electron Test Apps
-Located in `../fixtures/electron-apps/`:
-- `builder-cjs` / `builder-esm`: Electron Builder apps
-- `forge-cjs` / `forge-esm`: Electron Forge apps
-- `no-binary-cjs` / `no-binary-esm`: Development mode apps
+Located in `../fixtures/e2e-apps/`:
+- `electron-builder`: Electron Builder app (ESM only)
+- `electron-forge`: Electron Forge app (ESM only)
+- `electron-no-binary`: Development mode app (ESM only)
+
+**Note**: E2E tests use ESM-only apps. CJS/ESM variants are tested in package tests.
 
 ### Tauri Test Apps
-Located in `../fixtures/tauri-apps/`:
-- `basic`: Basic Tauri app with core functionality
-- `advanced`: Advanced Tauri app with complex features
+Located in `../fixtures/e2e-apps/`:
+- `tauri`: Tauri app with core functionality
 
 ## CI/CD Integration
 
@@ -281,7 +274,7 @@ Tests are integrated with Turborepo for efficient execution:
 
 ```bash
 # Run specific test combinations
-turbo run test:e2e:electron-builder-cjs
+turbo run test:e2e:electron-builder
 turbo run test:e2e:tauri
 ```
 

e2e/config/envSchema.ts

@@ -10,7 +10,7 @@ export const EnvSchema = z.object({
   // Core test configuration
   FRAMEWORK: z.enum(['electron', 'tauri']).default('electron'),
   APP: z.enum(['builder', 'forge', 'no-binary', 'basic']).default('builder'),
-  MODULE_TYPE: z.enum(['cjs', 'esm']).default('esm'),
+  MODULE_TYPE: z.enum(['cjs', 'esm']).optional().default('esm'),
   TEST_TYPE: z.enum(['standard', 'window', 'multiremote', 'standalone']).default('standard'),
   BINARY: z.enum(['true', 'false']).default('true'),
 
@@ -68,7 +68,7 @@ export class EnvironmentContext {
   }
 
   get moduleType(): 'cjs' | 'esm' {
-    return this.env.MODULE_TYPE;
+    return this.env.MODULE_TYPE ?? 'esm';
   }
 
   get testType(): 'standard' | 'window' | 'multiremote' | 'standalone' {
@@ -107,7 +107,7 @@ export class EnvironmentContext {
       return this.env.EXAMPLE_DIR;
     }
 
-    return getE2EAppDirName(this.framework, this.app, this.moduleType, this.isNoBinary);
+    return getE2EAppDirName(this.framework, this.app, this.isNoBinary);
   }
 
   /**
@@ -167,7 +167,6 @@ export class EnvironmentContext {
     return {
       FRAMEWORK: merged.FRAMEWORK,
       APP: merged.APP,
-      MODULE_TYPE: merged.MODULE_TYPE,
       TEST_TYPE: merged.TEST_TYPE,
       BINARY: merged.BINARY,
       APP_DIR: merged.APP_DIR || '',
@@ -183,7 +182,7 @@ export class EnvironmentContext {
    * Get human-readable description of this environment
    */
   toString(): string {
-    const parts = [this.framework, this.app, this.moduleType, this.testType, this.isBinary ? 'binary' : 'no-binary'];
+    const parts = [this.framework, this.app, this.testType, this.isBinary ? 'binary' : 'no-binary'];
 
     if (this.isMacUniversal) parts.push('mac-universal');
     if (this.isSplashEnabled) parts.push('splash');

e2e/lib/utils.ts

@@ -233,19 +233,17 @@ export function safeJsonParse<T>(json: string, fallback: T): T {
 }
 
 /**
- * Compute the E2E app directory name based on framework, app type, module type, and binary mode.
+ * Compute the E2E app directory name based on framework, app type, and binary mode.
  * This is used consistently across envSchema, build scripts, and test runners.
  *
  * @param framework - 'electron' or 'tauri'
  * @param app - App type: 'builder', 'forge', 'no-binary', or 'basic' (for Tauri)
- * @param moduleType - 'cjs' or 'esm' (only used for Electron)
  * @param isNoBinary - Whether this is a no-binary mode (only used for Electron)
  * @returns The computed directory name
  */
 export function getE2EAppDirName(
   framework: 'electron' | 'tauri',
   app: 'builder' | 'forge' | 'no-binary' | 'basic',
-  moduleType: 'cjs' | 'esm',
   isNoBinary: boolean,
 ): string {
   if (framework === 'tauri') {
@@ -254,8 +252,8 @@ export function getE2EAppDirName(
   }
 
   if (isNoBinary) {
-    return `electron-no-binary-${moduleType}`;
+    return 'electron-no-binary';
   }
 
-  return `electron-${app}-${moduleType}`;
+  return `electron-${app}`;
 }