From cbd5e81a8f704993828cdef1d3cbec48ce71cd52 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 04:49:34 +0000
Subject: [PATCH 1/6] Initial plan


From f561d29490f0d8b6879ba82d1c8121a85c54bf0d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 05:04:34 +0000
Subject: [PATCH 2/6] Changes before error encountered

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>
---
 bin/codecept.js                    |   1 +
 docs/parallel.md                   | 209 ++++++++++++++++++-----------
 lib/codecept.js                    |  40 ++++++
 test/unit/shard_cli_test.js        | 116 ++++++++++++++++
 test/unit/shard_edge_cases_test.js |  91 +++++++++++++
 test/unit/shard_test.js            | 105 +++++++++++++++
 6 files changed, 487 insertions(+), 75 deletions(-)
 create mode 100644 test/unit/shard_cli_test.js
 create mode 100644 test/unit/shard_edge_cases_test.js
 create mode 100644 test/unit/shard_test.js

diff --git a/bin/codecept.js b/bin/codecept.js
index 8a5d65b20..b420cfc08 100755
--- a/bin/codecept.js
+++ b/bin/codecept.js
@@ -165,6 +165,7 @@ program
   .option('--no-timeouts', 'disable all timeouts')
   .option('-p, --plugins <k=v,k2=v2,...>', 'enable plugins, comma-separated')
   .option('--shuffle', 'Shuffle the order in which test files run')
+  .option('--shard <index/total>', 'run only a fraction of tests (e.g., --shard 1/4)')
 
   // mocha options
   .option('--colors', 'force enabling of colors')
diff --git a/docs/parallel.md b/docs/parallel.md
index bea099046..5e7cdbe4f 100644
--- a/docs/parallel.md
+++ b/docs/parallel.md
@@ -5,13 +5,71 @@ title: Parallel Execution
 
 # Parallel Execution
 
-CodeceptJS has two engines for running tests in parallel:
+CodeceptJS has multiple approaches for running tests in parallel:
 
-* `run-workers` - which spawns [NodeJS Worker](https://nodejs.org/api/worker_threads.html) in a thread. Tests are split by scenarios, scenarios are mixed between groups, each worker runs tests from its own group.
-* `run-multiple` - which spawns a subprocess with CodeceptJS. Tests are split by files and configured in `codecept.conf.js`.
+- **Test Sharding** - distributes tests across multiple machines for CI matrix execution
+- `run-workers` - which spawns [NodeJS Worker](https://nodejs.org/api/worker_threads.html) in a thread. Tests are split by scenarios, scenarios are mixed between groups, each worker runs tests from its own group.
+- `run-multiple` - which spawns a subprocess with CodeceptJS. Tests are split by files and configured in `codecept.conf.js`.
 
 Workers are faster and simpler to start, while `run-multiple` requires additional configuration and can be used to run tests in different browsers at once.
 
+## Test Sharding for CI Matrix
+
+Test sharding allows you to split your test suite across multiple machines or CI workers without manual configuration. This is particularly useful for CI/CD pipelines where you want to run tests in parallel across different machines.
+
+Use the `--shard` option with the `run` command to execute only a portion of your tests:
+
+```bash
+# Run the first quarter of tests
+npx codeceptjs run --shard 1/4
+
+# Run the second quarter of tests
+npx codeceptjs run --shard 2/4
+
+# Run the third quarter of tests
+npx codeceptjs run --shard 3/4
+
+# Run the fourth quarter of tests
+npx codeceptjs run --shard 4/4
+```
+
+### CI Matrix Example
+
+Here's how you can use test sharding with GitHub Actions matrix strategy:
+
+```yaml
+name: Tests
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        shard: [1/4, 2/4, 3/4, 4/4]
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+      - run: npm install
+      - run: npx codeceptjs run --shard ${{ matrix.shard }}
+```
+
+This approach ensures:
+
+- Each CI job runs only its assigned portion of tests
+- Tests are distributed evenly across shards
+- No manual configuration or maintenance of test lists
+- Automatic load balancing as you add or remove tests
+
+### Shard Distribution
+
+Tests are distributed evenly across shards using a round-robin approach:
+
+- If you have 100 tests and 4 shards, each shard runs approximately 25 tests
+- The first shard gets tests 1-25, second gets 26-50, third gets 51-75, fourth gets 76-100
+- If tests don't divide evenly, earlier shards may get one extra test
+
 ## Parallel Execution by Workers
 
 It is easy to run tests in parallel if you have a lots of tests and free CPU cores. Just execute your tests using `run-workers` command specifying the number of workers to spawn:
@@ -128,27 +186,27 @@ FAIL  | 7 passed, 1 failed, 1 skipped   // 2s
 CodeceptJS also exposes the env var `process.env.RUNS_WITH_WORKERS` when running tests with `run-workers` command so that you could handle the events better in your plugins/helpers
 
 ```js
-const { event } = require('codeceptjs');
+const { event } = require('codeceptjs')
 
-module.exports = function() {
-    // this event would trigger the  `_publishResultsToTestrail` when running `run-workers` command
+module.exports = function () {
+  // this event would trigger the  `_publishResultsToTestrail` when running `run-workers` command
   event.dispatcher.on(event.workers.result, async () => {
-    await _publishResultsToTestrail();
-  });
-  
+    await _publishResultsToTestrail()
+  })
+
   // this event would not trigger the  `_publishResultsToTestrail` multiple times when running `run-workers` command
   event.dispatcher.on(event.all.result, async () => {
-      // when running `run` command, this env var is undefined
-    if (!process.env.RUNS_WITH_WORKERS) await _publishResultsToTestrail();
-  });
+    // when running `run` command, this env var is undefined
+    if (!process.env.RUNS_WITH_WORKERS) await _publishResultsToTestrail()
+  })
 }
 ```
 
 ## Parallel Execution by Workers on Multiple Browsers
 
-To run tests in parallel across multiple browsers, modify your `codecept.conf.js` file to configure multiple browsers on which you want to run your tests and your tests will run across multiple browsers. 
+To run tests in parallel across multiple browsers, modify your `codecept.conf.js` file to configure multiple browsers on which you want to run your tests and your tests will run across multiple browsers.
 
-Start with modifying the `codecept.conf.js` file. Add multiple key inside the config which will be used to configure multiple profiles. 
+Start with modifying the `codecept.conf.js` file. Add multiple key inside the config which will be used to configure multiple profiles.
 
 ```
 exports.config = {
@@ -174,7 +232,7 @@ exports.config = {
           }
         }
       ]
-    }, 
+    },
     profile2: {
       browsers: [
         {
@@ -188,16 +246,21 @@ exports.config = {
   }
 };
 ```
-To trigger tests on all the profiles configured, you can use the following command: 
+
+To trigger tests on all the profiles configured, you can use the following command:
+
 ```
 npx codeceptjs run-workers 3 all -c codecept.conf.js
 ```
+
 This will run your tests across all browsers configured from profile1 & profile2 on 3 workers.
 
-To trigger tests on specific profile, you can use the following command: 
+To trigger tests on specific profile, you can use the following command:
+
 ```
 npx codeceptjs run-workers 2 profile1 -c codecept.conf.js
 ```
+
 This will run your tests across 2 browsers from profile1 on 2 workers.
 
 ## Custom Parallel Execution
@@ -221,7 +284,7 @@ Create a placeholder in file:
 
 ```js
 #!/usr/bin/env node
-const { Workers, event } = require('codeceptjs');
+const { Workers, event } = require('codeceptjs')
 // here will go magic
 ```
 
@@ -232,59 +295,59 @@ Now let's see how to update this file for different parallelization modes:
 ```js
 const workerConfig = {
   testConfig: './test/data/sandbox/codecept.customworker.js',
-};
+}
 
 // don't initialize workers in constructor
-const workers = new Workers(null, workerConfig);
+const workers = new Workers(null, workerConfig)
 // split tests by suites in 2 groups
-const testGroups = workers.createGroupsOfSuites(2);
+const testGroups = workers.createGroupsOfSuites(2)
 
-const browsers = ['firefox', 'chrome'];
+const browsers = ['firefox', 'chrome']
 
 const configs = browsers.map(browser => {
   return {
     helpers: {
-      WebDriver: { browser }
-    }
-  };
-});
+      WebDriver: { browser },
+    },
+  }
+})
 
 for (const config of configs) {
   for (group of testGroups) {
-    const worker = workers.spawn();
-    worker.addTests(group);
-    worker.addConfig(config);
+    const worker = workers.spawn()
+    worker.addTests(group)
+    worker.addConfig(config)
   }
 }
 
 // Listen events for failed test
-workers.on(event.test.failed, (failedTest) => {
-  console.log('Failed : ', failedTest.title);
-});
+workers.on(event.test.failed, failedTest => {
+  console.log('Failed : ', failedTest.title)
+})
 
 // Listen events for passed test
-workers.on(event.test.passed, (successTest) => {
-  console.log('Passed : ', successTest.title);
-});
+workers.on(event.test.passed, successTest => {
+  console.log('Passed : ', successTest.title)
+})
 
 // test run status will also be available in event
 workers.on(event.all.result, () => {
   // Use printResults() to display result with standard style
-  workers.printResults();
-});
+  workers.printResults()
+})
 
 // run workers as async function
-runWorkers();
+runWorkers()
 
 async function runWorkers() {
   try {
     // run bootstrapAll
-    await workers.bootstrapAll();
+    await workers.bootstrapAll()
     // run tests
-    await workers.run();
+    await workers.run()
   } finally {
     // run teardown All
-    await workers.teardownAll();
+    await workers.teardownAll()
   }
 }
 ```
@@ -313,7 +376,6 @@ workers.on(event.all.result, (status, completedTests, workerStats) => {
 If you want your tests to split according to your need this method is suited for you. For example: If you have 4 long running test files and 4 normal test files there chance all 4 tests end up in same worker thread. For these cases custom function will be helpful.
 
 ```js
-
 /*
  Define a function to split your tests.
 
@@ -322,28 +384,25 @@ If you want your tests to split according to your need this method is suited for
  where file1 and file2 will run in a worker thread and file3 will run in a worker thread
 */
 const splitTests = () => {
-  const files = [
-    ['./test/data/sandbox/guthub_test.js', './test/data/sandbox/devto_test.js'],
-    ['./test/data/sandbox/longrunnig_test.js']
-  ];
+  const files = [['./test/data/sandbox/guthub_test.js', './test/data/sandbox/devto_test.js'], ['./test/data/sandbox/longrunnig_test.js']]
 
-  return files;
+  return files
 }
 
 const workerConfig = {
   testConfig: './test/data/sandbox/codecept.customworker.js',
-  by: splitTests
-};
+  by: splitTests,
+}
 
 // don't initialize workers in constructor
-const customWorkers = new Workers(null,  workerConfig);
+const customWorkers = new Workers(null, workerConfig)
 
-customWorkers.run();
+customWorkers.run()
 
 // You can use event listeners similar to above example.
 customWorkers.on(event.all.result, () => {
-  workers.printResults();
-});
+  workers.printResults()
+})
 ```
 
 ### Emitting messages to the parent worker
@@ -353,13 +412,13 @@ Child workers can send non-test events to the main process. This is useful if yo
 ```js
 // inside main process
 // listen for any non test related events
-workers.on('message', (data) => {
+workers.on('message', data => {
   console.log(data)
-});
+})
 
 workers.on(event.all.result, (status, completedTests, workerStats) => {
   // logic
-});
+})
 ```
 
 ## Sharing Data Between Workers
@@ -372,12 +431,12 @@ You can share data directly using the `share()` function and access it using `in
 
 ```js
 // In one test or worker
-share({ userData: { name: 'user', password: '123456' } });
+share({ userData: { name: 'user', password: '123456' } })
 
 // In another test or worker
-const testData = inject();
-console.log(testData.userData.name); // 'user'
-console.log(testData.userData.password); // '123456'
+const testData = inject()
+console.log(testData.userData.name) // 'user'
+console.log(testData.userData.password) // '123456'
 ```
 
 ### Initializing Data in Bootstrap
@@ -389,20 +448,20 @@ For complex scenarios where you need to initialize shared data before tests run,
 exports.config = {
   bootstrap() {
     // Initialize shared data container
-    share({ userData: null, config: { retries: 3 } });
-  }
+    share({ userData: null, config: { retries: 3 } })
+  },
 }
 ```
 
 Then in your tests, you can check and update the shared data:
 
 ```js
-const testData = inject();
+const testData = inject()
 if (!testData.userData) {
   // Update shared data - both approaches work:
-  share({ userData: { name: 'user', password: '123456' } });
+  share({ userData: { name: 'user', password: '123456' } })
   // or mutate the injected object:
-  testData.userData = { name: 'user', password: '123456' };
+  testData.userData = { name: 'user', password: '123456' }
 }
 ```
 
@@ -412,24 +471,24 @@ Since CodeceptJS 3.7.0+, shared data uses Proxy objects for synchronization betw
 
 ```js
 // ✅ All of these work correctly:
-const data = inject();
-console.log(data.userData.name);           // Access nested properties
-console.log(Object.keys(data));            // Enumerate shared keys  
-data.newProperty = 'value';                // Add new properties
-Object.assign(data, { more: 'data' });     // Merge objects
+const data = inject()
+console.log(data.userData.name) // Access nested properties
+console.log(Object.keys(data)) // Enumerate shared keys
+data.newProperty = 'value' // Add new properties
+Object.assign(data, { more: 'data' }) // Merge objects
 ```
 
 **Important Note:** Avoid reassigning the entire injected object:
 
 ```js
 // ❌ AVOID: This breaks the proxy reference
-let testData = inject();
-testData = someOtherObject; // This will NOT work as expected!
+let testData = inject()
+testData = someOtherObject // This will NOT work as expected!
 
 // ✅ PREFERRED: Use share() to replace data or mutate properties
-share({ userData: someOtherObject }); // This works!
+share({ userData: someOtherObject }) // This works!
 // or
-Object.assign(inject(), someOtherObject); // This works!
+Object.assign(inject(), someOtherObject) // This works!
 ```
 
 ### Local Data (Worker-Specific)
@@ -437,5 +496,5 @@ Object.assign(inject(), someOtherObject); // This works!
 If you want to share data only within the same worker (not across all workers), use the `local` option:
 
 ```js
-share({ localData: 'worker-specific' }, { local: true });
+share({ localData: 'worker-specific' }, { local: true })
 ```
diff --git a/lib/codecept.js b/lib/codecept.js
index 06752f593..3d274c1c5 100644
--- a/lib/codecept.js
+++ b/lib/codecept.js
@@ -185,6 +185,46 @@ class Codecept {
     if (this.opts.shuffle) {
       this.testFiles = shuffle(this.testFiles)
     }
+
+    if (this.opts.shard) {
+      this.testFiles = this._applySharding(this.testFiles, this.opts.shard)
+    }
+  }
+
+  /**
+   * Apply sharding to test files based on shard configuration
+   *
+   * @param {Array<string>} testFiles - Array of test file paths
+   * @param {string} shardConfig - Shard configuration in format "index/total" (e.g., "1/4")
+   * @returns {Array<string>} - Filtered array of test files for this shard
+   */
+  _applySharding(testFiles, shardConfig) {
+    const shardMatch = shardConfig.match(/^(\d+)\/(\d+)$/)
+    if (!shardMatch) {
+      throw new Error('Invalid shard format. Expected format: "index/total" (e.g., "1/4")')
+    }
+
+    const shardIndex = parseInt(shardMatch[1], 10)
+    const shardTotal = parseInt(shardMatch[2], 10)
+
+    if (shardTotal < 1) {
+      throw new Error('Shard total must be at least 1')
+    }
+
+    if (shardIndex < 1 || shardIndex > shardTotal) {
+      throw new Error(`Shard index ${shardIndex} must be between 1 and ${shardTotal}`)
+    }
+
+    if (testFiles.length === 0) {
+      return testFiles
+    }
+
+    // Calculate which tests belong to this shard
+    const shardSize = Math.ceil(testFiles.length / shardTotal)
+    const startIndex = (shardIndex - 1) * shardSize
+    const endIndex = Math.min(startIndex + shardSize, testFiles.length)
+
+    return testFiles.slice(startIndex, endIndex)
   }
 
   /**
diff --git a/test/unit/shard_cli_test.js b/test/unit/shard_cli_test.js
new file mode 100644
index 000000000..b4940b301
--- /dev/null
+++ b/test/unit/shard_cli_test.js
@@ -0,0 +1,116 @@
+const expect = require('chai').expect
+const exec = require('child_process').exec
+const path = require('path')
+const fs = require('fs')
+
+const codecept_run = `node ${path.resolve(__dirname, '../../bin/codecept.js')}`
+
+describe('CLI Sharding Integration', () => {
+  let tempDir
+  let configFile
+
+  beforeEach(() => {
+    // Create temporary test setup
+    tempDir = `/tmp/shard_test_${Date.now()}`
+    configFile = path.join(tempDir, 'codecept.conf.js')
+
+    // Create temp directory and test files
+    fs.mkdirSync(tempDir, { recursive: true })
+
+    // Create 4 test files
+    for (let i = 1; i <= 4; i++) {
+      fs.writeFileSync(
+        path.join(tempDir, `shard_test${i}.js`),
+        `
+Feature('Shard Test ${i}')
+
+Scenario('test ${i}', ({ I }) => {
+  I.say('This is test ${i}')
+})
+      `,
+      )
+    }
+
+    // Create config file
+    fs.writeFileSync(
+      configFile,
+      `
+exports.config = {
+  tests: '${tempDir}/shard_test*.js',
+  output: '${tempDir}/output',
+  helpers: {
+    FileSystem: {}
+  },
+  include: {},
+  bootstrap: null,
+  mocha: {},
+  name: 'shard-test'
+}
+    `,
+    )
+  })
+
+  afterEach(() => {
+    // Cleanup temp files
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+  })
+
+  it('should run tests with shard option', function (done) {
+    this.timeout(10000)
+
+    exec(`${codecept_run} run --config ${configFile} --shard 1/4`, (err, stdout, stderr) => {
+      expect(stdout).to.contain('CodeceptJS')
+      expect(stdout).to.contain('OK')
+      expect(stdout).to.match(/1 passed/)
+      expect(err).to.be.null
+      done()
+    })
+  })
+
+  it('should handle invalid shard format', function (done) {
+    this.timeout(10000)
+
+    exec(`${codecept_run} run --config ${configFile} --shard invalid`, (err, stdout, stderr) => {
+      expect(stdout).to.contain('Invalid shard format')
+      expect(err.code).to.equal(1)
+      done()
+    })
+  })
+
+  it('should handle shard index out of range', function (done) {
+    this.timeout(10000)
+
+    exec(`${codecept_run} run --config ${configFile} --shard 0/4`, (err, stdout, stderr) => {
+      expect(stdout).to.contain('Shard index 0 must be between 1 and 4')
+      expect(err.code).to.equal(1)
+      done()
+    })
+  })
+
+  it('should distribute tests correctly across all shards', function (done) {
+    this.timeout(20000)
+
+    const shardResults = []
+    let completedShards = 0
+
+    for (let i = 1; i <= 4; i++) {
+      exec(`${codecept_run} run --config ${configFile} --shard ${i}/4`, (err, stdout, stderr) => {
+        expect(err).to.be.null
+        expect(stdout).to.contain('OK')
+        expect(stdout).to.match(/1 passed/)
+
+        shardResults.push(i)
+        completedShards++
+
+        if (completedShards === 4) {
+          expect(shardResults).to.have.lengthOf(4)
+          done()
+        }
+      })
+    }
+  })
+})
diff --git a/test/unit/shard_edge_cases_test.js b/test/unit/shard_edge_cases_test.js
new file mode 100644
index 000000000..ff0c249e3
--- /dev/null
+++ b/test/unit/shard_edge_cases_test.js
@@ -0,0 +1,91 @@
+const expect = require('chai').expect
+const Codecept = require('../../lib/codecept')
+
+describe('Test Sharding Edge Cases', () => {
+  let codecept
+  const config = {
+    tests: '',
+    gherkin: { features: null },
+    output: './output',
+    hooks: [],
+  }
+
+  beforeEach(() => {
+    codecept = new Codecept(config, {})
+  })
+
+  describe('Large test suite distribution', () => {
+    it('should distribute 100 tests across 4 shards correctly', () => {
+      // Create a large array of test files with proper zero-padding for consistent sorting
+      const testFiles = Array.from({ length: 100 }, (_, i) => `test${String(i + 1).padStart(3, '0')}.js`)
+
+      const shard1 = codecept._applySharding(testFiles, '1/4')
+      const shard2 = codecept._applySharding(testFiles, '2/4')
+      const shard3 = codecept._applySharding(testFiles, '3/4')
+      const shard4 = codecept._applySharding(testFiles, '4/4')
+
+      // Each shard should get 25 tests
+      expect(shard1.length).to.equal(25)
+      expect(shard2.length).to.equal(25)
+      expect(shard3.length).to.equal(25)
+      expect(shard4.length).to.equal(25)
+
+      // Verify no overlap and complete coverage
+      const allShardedTests = [...shard1, ...shard2, ...shard3, ...shard4]
+      expect(allShardedTests.sort()).to.deep.equal(testFiles.sort())
+
+      // Verify correct distribution
+      expect(shard1).to.deep.equal(testFiles.slice(0, 25))
+      expect(shard2).to.deep.equal(testFiles.slice(25, 50))
+      expect(shard3).to.deep.equal(testFiles.slice(50, 75))
+      expect(shard4).to.deep.equal(testFiles.slice(75, 100))
+    })
+
+    it('should distribute 101 tests across 4 shards with uneven distribution', () => {
+      const testFiles = Array.from({ length: 101 }, (_, i) => `test${String(i + 1).padStart(3, '0')}.js`)
+
+      const shard1 = codecept._applySharding(testFiles, '1/4')
+      const shard2 = codecept._applySharding(testFiles, '2/4')
+      const shard3 = codecept._applySharding(testFiles, '3/4')
+      const shard4 = codecept._applySharding(testFiles, '4/4')
+
+      // First 3 shards get 26 tests (ceiling), last gets 23
+      expect(shard1.length).to.equal(26)
+      expect(shard2.length).to.equal(26)
+      expect(shard3.length).to.equal(26)
+      expect(shard4.length).to.equal(23)
+
+      // Verify complete coverage
+      const allShardedTests = [...shard1, ...shard2, ...shard3, ...shard4]
+      expect(allShardedTests.length).to.equal(101)
+      expect(allShardedTests.sort()).to.deep.equal(testFiles.sort())
+    })
+  })
+
+  describe('Works with shuffle option', () => {
+    it('should apply sharding after shuffle when both options are used', () => {
+      // This test verifies that the order of operations is correct:
+      // 1. Load tests
+      // 2. Shuffle (if enabled)
+      // 3. Apply sharding (if enabled)
+
+      const testFiles = ['test1.js', 'test2.js', 'test3.js', 'test4.js']
+
+      // Mock loadTests behavior with both shuffle and shard
+      codecept.testFiles = [...testFiles]
+      codecept.opts.shuffle = true
+      codecept.opts.shard = '1/2'
+
+      // Apply shuffle first (mocking the shuffle function)
+      const shuffled = ['test3.js', 'test1.js', 'test4.js', 'test2.js']
+      codecept.testFiles = shuffled
+
+      // Then apply sharding
+      codecept.testFiles = codecept._applySharding(codecept.testFiles, '1/2')
+
+      // Should get the first 2 tests from the shuffled array
+      expect(codecept.testFiles.length).to.equal(2)
+      expect(codecept.testFiles).to.deep.equal(['test3.js', 'test1.js'])
+    })
+  })
+})
diff --git a/test/unit/shard_test.js b/test/unit/shard_test.js
new file mode 100644
index 000000000..9a4dd2e73
--- /dev/null
+++ b/test/unit/shard_test.js
@@ -0,0 +1,105 @@
+const expect = require('chai').expect
+const Codecept = require('../../lib/codecept')
+
+describe('Test Sharding', () => {
+  let codecept
+  const config = {
+    tests: './test/data/sandbox/*_test.js',
+    gherkin: { features: null },
+    output: './output',
+    hooks: [],
+  }
+
+  beforeEach(() => {
+    codecept = new Codecept(config, {})
+    codecept.init('/home/runner/work/CodeceptJS/CodeceptJS/test/data/sandbox')
+  })
+
+  describe('_applySharding', () => {
+    it('should validate shard format', () => {
+      const testFiles = ['test1.js', 'test2.js', 'test3.js', 'test4.js']
+
+      expect(() => codecept._applySharding(testFiles, 'invalid')).to.throw('Invalid shard format')
+      expect(() => codecept._applySharding(testFiles, '1/0')).to.throw('Shard total must be at least 1')
+      expect(() => codecept._applySharding(testFiles, '0/4')).to.throw('Shard index 0 must be between 1 and 4')
+      expect(() => codecept._applySharding(testFiles, '5/4')).to.throw('Shard index 5 must be between 1 and 4')
+    })
+
+    it('should split tests evenly across shards', () => {
+      const testFiles = ['test1.js', 'test2.js', 'test3.js', 'test4.js']
+
+      const shard1 = codecept._applySharding(testFiles, '1/4')
+      const shard2 = codecept._applySharding(testFiles, '2/4')
+      const shard3 = codecept._applySharding(testFiles, '3/4')
+      const shard4 = codecept._applySharding(testFiles, '4/4')
+
+      expect(shard1).to.deep.equal(['test1.js'])
+      expect(shard2).to.deep.equal(['test2.js'])
+      expect(shard3).to.deep.equal(['test3.js'])
+      expect(shard4).to.deep.equal(['test4.js'])
+    })
+
+    it('should handle uneven distribution', () => {
+      const testFiles = ['test1.js', 'test2.js', 'test3.js', 'test4.js', 'test5.js']
+
+      const shard1 = codecept._applySharding(testFiles, '1/3')
+      const shard2 = codecept._applySharding(testFiles, '2/3')
+      const shard3 = codecept._applySharding(testFiles, '3/3')
+
+      expect(shard1).to.deep.equal(['test1.js', 'test2.js'])
+      expect(shard2).to.deep.equal(['test3.js', 'test4.js'])
+      expect(shard3).to.deep.equal(['test5.js'])
+
+      // All tests should be covered exactly once
+      const allShardedTests = [...shard1, ...shard2, ...shard3]
+      expect(allShardedTests.sort()).to.deep.equal(testFiles.sort())
+    })
+
+    it('should handle empty test files array', () => {
+      const result = codecept._applySharding([], '1/4')
+      expect(result).to.deep.equal([])
+    })
+
+    it('should handle more shards than tests', () => {
+      const testFiles = ['test1.js', 'test2.js']
+
+      const shard1 = codecept._applySharding(testFiles, '1/4')
+      const shard2 = codecept._applySharding(testFiles, '2/4')
+      const shard3 = codecept._applySharding(testFiles, '3/4')
+      const shard4 = codecept._applySharding(testFiles, '4/4')
+
+      expect(shard1).to.deep.equal(['test1.js'])
+      expect(shard2).to.deep.equal(['test2.js'])
+      expect(shard3).to.deep.equal([])
+      expect(shard4).to.deep.equal([])
+    })
+  })
+
+  describe('Integration with loadTests', () => {
+    it('should apply sharding when shard option is provided', () => {
+      // First load all tests without sharding
+      const codeceptAll = new Codecept(config, {})
+      codeceptAll.init('/home/runner/work/CodeceptJS/CodeceptJS/test/data/sandbox')
+      codeceptAll.loadTests()
+
+      // If there are no tests, skip this test
+      if (codeceptAll.testFiles.length === 0) {
+        return
+      }
+
+      // Now test sharding
+      codecept.opts.shard = '1/2'
+      codecept.loadTests()
+
+      // We expect some tests to be loaded and sharded
+      expect(codecept.testFiles.length).to.be.greaterThan(0)
+
+      // Sharded should be less than or equal to total
+      expect(codecept.testFiles.length).to.be.lessThanOrEqual(codeceptAll.testFiles.length)
+
+      // For 2 shards, we expect roughly half the tests (or at most ceil(total/2))
+      const expectedMax = Math.ceil(codeceptAll.testFiles.length / 2)
+      expect(codecept.testFiles.length).to.be.lessThanOrEqual(expectedMax)
+    })
+  })
+})

From 81a7aa754c58d5940d85c1f13c945859bf4c73a7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 05:31:38 +0000
Subject: [PATCH 3/6] Add GitHub workflows demonstrating test sharding
 functionality

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>
---
 .github/SHARDING_WORKFLOWS.md          | 90 ++++++++++++++++++++++++++
 .github/workflows/acceptance-tests.yml | 44 ++++++++++++-
 .github/workflows/sharding-demo.yml    | 89 +++++++++++++++++++++++++
 .github/workflows/test.yml             |  2 +
 4 files changed, 223 insertions(+), 2 deletions(-)
 create mode 100644 .github/SHARDING_WORKFLOWS.md
 create mode 100644 .github/workflows/sharding-demo.yml

diff --git a/.github/SHARDING_WORKFLOWS.md b/.github/SHARDING_WORKFLOWS.md
new file mode 100644
index 000000000..675edab38
--- /dev/null
+++ b/.github/SHARDING_WORKFLOWS.md
@@ -0,0 +1,90 @@
+# Test Sharding Workflows
+
+This document explains the GitHub Actions workflows that demonstrate the new test sharding functionality in CodeceptJS.
+
+## Updated/Created Workflows
+
+### 1. `acceptance-tests.yml` (Updated)
+
+**Purpose**: Demonstrates sharding with acceptance tests across multiple browser configurations.
+
+**Key Features**:
+- Runs traditional docker-compose tests (for backward compatibility)
+- Adds new sharded acceptance tests using CodeceptJS directly
+- Tests across multiple browser configurations (Puppeteer, Playwright)
+- Uses 2x2 matrix: 2 configs × 2 shards = 4 parallel jobs
+
+**Example Output**:
+```
+- Sharded Tests: codecept.Puppeteer.js (Shard 1/2)
+- Sharded Tests: codecept.Puppeteer.js (Shard 2/2)
+- Sharded Tests: codecept.Playwright.js (Shard 1/2)  
+- Sharded Tests: codecept.Playwright.js (Shard 2/2)
+```
+
+### 2. `sharding-demo.yml` (New)
+
+**Purpose**: Comprehensive demonstration of sharding features with larger test suite.
+
+**Key Features**:
+- Uses sandbox tests (38 test files) for meaningful sharding demonstration
+- Shows basic sharding with 4-way split (`1/4`, `2/4`, `3/4`, `4/4`)
+- Demonstrates combination of `--shuffle` + `--shard` options
+- Comprehensive documentation and examples
+
+### 3. `test.yml` (Updated)
+
+**Purpose**: Clarifies which tests support sharding.
+
+**Changes**:
+- Added comment explaining that runner tests are mocha-based and don't support sharding
+- Points to sharding-demo.yml for examples of CodeceptJS-based sharding
+
+## Sharding Commands Used
+
+### Basic Sharding
+```bash
+npx codeceptjs run --config ./codecept.js --shard 1/4
+npx codeceptjs run --config ./codecept.js --shard 2/4
+# etc.
+```
+
+### Combined with Other Options
+```bash
+npx codeceptjs run --config ./codecept.js --shuffle --shard 1/2 --verbose
+```
+
+## Test Distribution
+
+The sharding algorithm distributes tests evenly:
+
+- **38 tests across 4 shards**: ~9-10 tests per shard
+- **6 acceptance tests across 2 shards**: 3 tests per shard  
+- **Uneven splits handled gracefully**: Earlier shards get extra tests when needed
+
+## Benefits Demonstrated
+
+1. **Parallel Execution**: Tests run simultaneously across multiple CI workers
+2. **No Manual Configuration**: Automatic test distribution without maintaining test lists
+3. **Load Balancing**: Even distribution ensures balanced execution times
+4. **Flexibility**: Works with any number of shards and test configurations
+5. **Integration**: Compatible with existing CodeceptJS features (`--shuffle`, `--verbose`, etc.)
+
+## CI Matrix Integration
+
+The workflows show practical CI matrix usage:
+
+```yaml
+strategy:
+  matrix:
+    config: ['codecept.Puppeteer.js', 'codecept.Playwright.js']
+    shard: ['1/2', '2/2']
+```
+
+This creates 4 parallel jobs:
+- Config A, Shard 1/2
+- Config A, Shard 2/2  
+- Config B, Shard 1/2
+- Config B, Shard 2/2
+
+Perfect for scaling test execution across multiple machines and configurations.
\ No newline at end of file
diff --git a/.github/workflows/acceptance-tests.yml b/.github/workflows/acceptance-tests.yml
index 9af54c7d9..eb60b2d4c 100644
--- a/.github/workflows/acceptance-tests.yml
+++ b/.github/workflows/acceptance-tests.yml
@@ -1,4 +1,4 @@
-name: Acceptance Tests using docker compose
+name: Acceptance Tests with Sharding
 
 on:
   push:
@@ -14,8 +14,10 @@ env:
   FORCE_COLOR: 1
 
 jobs:
-  build:
+  # Traditional docker-compose tests (kept for compatibility)
+  docker-tests:
     runs-on: ubuntu-latest
+    name: Docker-based Tests
 
     strategy:
       matrix:
@@ -46,3 +48,41 @@ jobs:
       - name: Run Faker BDD Tests
         run: docker-compose run --rm test-bdd.faker
         working-directory: test
+
+  # New sharded acceptance tests using CodeceptJS directly
+  sharded-acceptance-tests:
+    runs-on: ubuntu-latest
+    name: "Sharded Tests: ${{ matrix.config }} (Shard ${{ matrix.shard }})"
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20.x]
+        config: ['codecept.Puppeteer.js', 'codecept.Playwright.js']
+        shard: ['1/2', '2/2']
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v5
+        
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          
+      - name: Install dependencies
+        run: npm install --ignore-scripts
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
+          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
+
+      - name: Run Acceptance Tests with Sharding
+        run: npx codeceptjs run --config ./test/acceptance/${{ matrix.config }} --shard ${{ matrix.shard }} --verbose
+        env:
+          FORCE_COLOR: 1
+          
+      - name: Display Test Info
+        run: |
+          echo "Configuration: ${{ matrix.config }}"
+          echo "Shard: ${{ matrix.shard }}"
+          echo "This demonstrates test sharding across different browser configurations"
diff --git a/.github/workflows/sharding-demo.yml b/.github/workflows/sharding-demo.yml
new file mode 100644
index 000000000..345546c25
--- /dev/null
+++ b/.github/workflows/sharding-demo.yml
@@ -0,0 +1,89 @@
+name: Test Sharding Demonstration
+
+on:
+  push:
+    branches:
+      - '3.x'
+  pull_request:
+    branches:
+      - '**'
+
+env:
+  CI: true
+  FORCE_COLOR: 1
+
+jobs:
+  # Demonstrate sharding with a larger test suite (sandbox tests)
+  sharded-sandbox-tests:
+    runs-on: ubuntu-latest
+    name: "Sandbox Tests (Shard ${{ matrix.shard }})"
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20.x]
+        # Split 38 sandbox tests across 4 shards for demonstration
+        shard: ['1/4', '2/4', '3/4', '4/4']
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v5
+        
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          
+      - name: Install dependencies
+        run: npm install
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
+          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
+
+      - name: Run Sandbox Tests with Sharding
+        run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shard ${{ matrix.shard }} --verbose
+        working-directory: test/data/sandbox
+        env:
+          FORCE_COLOR: 1
+          
+      - name: Display Shard Info
+        run: |
+          echo "This shard (${{ matrix.shard }}) ran a subset of the total sandbox tests"
+          echo "All shards together cover the complete test suite without duplication"
+
+  # Show combination with shuffle option
+  sharded-shuffled-tests:
+    runs-on: ubuntu-latest  
+    name: "Shuffled + Sharded Tests (Shard ${{ matrix.shard }})"
+
+    strategy:
+      fail-fast: false
+      matrix:
+        node-version: [20.x]
+        shard: ['1/2', '2/2']
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v5
+        
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          
+      - name: Install dependencies
+        run: npm install
+        env:
+          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
+          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
+
+      - name: Run Tests with Shuffle + Sharding
+        run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shuffle --shard ${{ matrix.shard }} --verbose
+        working-directory: test/data/sandbox
+        env:
+          FORCE_COLOR: 1
+          
+      - name: Display Combined Options Info
+        run: |
+          echo "This demonstrates sharding combined with shuffle option"
+          echo "Tests are first shuffled, then sharded for this worker (${{ matrix.shard }})"
\ No newline at end of file
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 585b33b29..6700710cc 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -48,3 +48,5 @@ jobs:
           PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
           PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
       - run: npm run test:runner
+        # Note: Runner tests are mocha-based, so sharding doesn't apply here.
+        # Sharding is specifically for CodeceptJS tests (see sharding-demo.yml for examples)

From ff8d52e6d61c61432c915a0c40f65a74d3229423 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 06:18:07 +0000
Subject: [PATCH 4/6] Changes before error encountered

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>
---
 .github/SHARDING_WORKFLOWS.md          | 26 ++++++++++++--------
 .github/workflows/acceptance-tests.yml | 24 +++++++++++++++---
 .github/workflows/sharding-demo.yml    | 34 ++++++++++++--------------
 3 files changed, 51 insertions(+), 33 deletions(-)

diff --git a/.github/SHARDING_WORKFLOWS.md b/.github/SHARDING_WORKFLOWS.md
index 675edab38..c4fde964a 100644
--- a/.github/SHARDING_WORKFLOWS.md
+++ b/.github/SHARDING_WORKFLOWS.md
@@ -9,16 +9,18 @@ This document explains the GitHub Actions workflows that demonstrate the new tes
 **Purpose**: Demonstrates sharding with acceptance tests across multiple browser configurations.
 
 **Key Features**:
+
 - Runs traditional docker-compose tests (for backward compatibility)
 - Adds new sharded acceptance tests using CodeceptJS directly
 - Tests across multiple browser configurations (Puppeteer, Playwright)
 - Uses 2x2 matrix: 2 configs × 2 shards = 4 parallel jobs
 
 **Example Output**:
+
 ```
 - Sharded Tests: codecept.Puppeteer.js (Shard 1/2)
 - Sharded Tests: codecept.Puppeteer.js (Shard 2/2)
-- Sharded Tests: codecept.Playwright.js (Shard 1/2)  
+- Sharded Tests: codecept.Playwright.js (Shard 1/2)
 - Sharded Tests: codecept.Playwright.js (Shard 2/2)
 ```
 
@@ -27,29 +29,32 @@ This document explains the GitHub Actions workflows that demonstrate the new tes
 **Purpose**: Comprehensive demonstration of sharding features with larger test suite.
 
 **Key Features**:
-- Uses sandbox tests (38 test files) for meaningful sharding demonstration
-- Shows basic sharding with 4-way split (`1/4`, `2/4`, `3/4`, `4/4`)
+
+- Uses sandbox tests (2 main test files) for sharding demonstration
+- Shows basic sharding with 2-way split (`1/2`, `2/2`)
 - Demonstrates combination of `--shuffle` + `--shard` options
-- Comprehensive documentation and examples
+- Uses `DONT_FAIL_ON_EMPTY_RUN=true` to handle cases where some shards may be empty
 
 ### 3. `test.yml` (Updated)
 
 **Purpose**: Clarifies which tests support sharding.
 
 **Changes**:
+
 - Added comment explaining that runner tests are mocha-based and don't support sharding
 - Points to sharding-demo.yml for examples of CodeceptJS-based sharding
 
 ## Sharding Commands Used
 
 ### Basic Sharding
+
 ```bash
-npx codeceptjs run --config ./codecept.js --shard 1/4
-npx codeceptjs run --config ./codecept.js --shard 2/4
-# etc.
+npx codeceptjs run --config ./codecept.js --shard 1/2
+npx codeceptjs run --config ./codecept.js --shard 2/2
 ```
 
 ### Combined with Other Options
+
 ```bash
 npx codeceptjs run --config ./codecept.js --shuffle --shard 1/2 --verbose
 ```
@@ -59,7 +64,7 @@ npx codeceptjs run --config ./codecept.js --shuffle --shard 1/2 --verbose
 The sharding algorithm distributes tests evenly:
 
 - **38 tests across 4 shards**: ~9-10 tests per shard
-- **6 acceptance tests across 2 shards**: 3 tests per shard  
+- **6 acceptance tests across 2 shards**: 3 tests per shard
 - **Uneven splits handled gracefully**: Earlier shards get extra tests when needed
 
 ## Benefits Demonstrated
@@ -82,9 +87,10 @@ strategy:
 ```
 
 This creates 4 parallel jobs:
+
 - Config A, Shard 1/2
-- Config A, Shard 2/2  
+- Config A, Shard 2/2
 - Config B, Shard 1/2
 - Config B, Shard 2/2
 
-Perfect for scaling test execution across multiple machines and configurations.
\ No newline at end of file
+Perfect for scaling test execution across multiple machines and configurations.
diff --git a/.github/workflows/acceptance-tests.yml b/.github/workflows/acceptance-tests.yml
index eb60b2d4c..959206e36 100644
--- a/.github/workflows/acceptance-tests.yml
+++ b/.github/workflows/acceptance-tests.yml
@@ -52,7 +52,7 @@ jobs:
   # New sharded acceptance tests using CodeceptJS directly
   sharded-acceptance-tests:
     runs-on: ubuntu-latest
-    name: "Sharded Tests: ${{ matrix.config }} (Shard ${{ matrix.shard }})"
+    name: 'Sharded Tests: ${{ matrix.config }} (Shard ${{ matrix.shard }})'
 
     strategy:
       fail-fast: false
@@ -64,23 +64,39 @@ jobs:
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v5
-        
+
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
-          
+
+      - name: Setup PHP
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: 7.4
+
       - name: Install dependencies
         run: npm install --ignore-scripts
         env:
           PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
           PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
 
+      - name: Install Puppeteer Browser
+        if: contains(matrix.config, 'Puppeteer')
+        run: npx puppeteer browsers install chrome
+
+      - name: Install Playwright Browsers
+        if: contains(matrix.config, 'Playwright')
+        run: npx playwright install chromium && npx playwright install-deps
+
+      - name: Start PHP Server
+        run: php -S 127.0.0.1:8000 -t test/data/app &
+
       - name: Run Acceptance Tests with Sharding
         run: npx codeceptjs run --config ./test/acceptance/${{ matrix.config }} --shard ${{ matrix.shard }} --verbose
         env:
           FORCE_COLOR: 1
-          
+
       - name: Display Test Info
         run: |
           echo "Configuration: ${{ matrix.config }}"
diff --git a/.github/workflows/sharding-demo.yml b/.github/workflows/sharding-demo.yml
index 345546c25..b78aecced 100644
--- a/.github/workflows/sharding-demo.yml
+++ b/.github/workflows/sharding-demo.yml
@@ -16,45 +16,43 @@ jobs:
   # Demonstrate sharding with a larger test suite (sandbox tests)
   sharded-sandbox-tests:
     runs-on: ubuntu-latest
-    name: "Sandbox Tests (Shard ${{ matrix.shard }})"
+    name: 'Sandbox Tests (Shard ${{ matrix.shard }})'
 
     strategy:
       fail-fast: false
       matrix:
         node-version: [20.x]
-        # Split 38 sandbox tests across 4 shards for demonstration
-        shard: ['1/4', '2/4', '3/4', '4/4']
+        # Split 2 sandbox tests across 2 shards for demonstration
+        shard: ['1/2', '2/2']
 
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v5
-        
+
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
-          
+
       - name: Install dependencies
         run: npm install
-        env:
-          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
-          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
 
       - name: Run Sandbox Tests with Sharding
         run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shard ${{ matrix.shard }} --verbose
         working-directory: test/data/sandbox
         env:
           FORCE_COLOR: 1
-          
+          DONT_FAIL_ON_EMPTY_RUN: true
+
       - name: Display Shard Info
         run: |
-          echo "This shard (${{ matrix.shard }}) ran a subset of the total sandbox tests"
+          echo "This shard (${{ matrix.shard }}) ran a subset of the available test files"
           echo "All shards together cover the complete test suite without duplication"
 
   # Show combination with shuffle option
   sharded-shuffled-tests:
-    runs-on: ubuntu-latest  
-    name: "Shuffled + Sharded Tests (Shard ${{ matrix.shard }})"
+    runs-on: ubuntu-latest
+    name: 'Shuffled + Sharded Tests (Shard ${{ matrix.shard }})'
 
     strategy:
       fail-fast: false
@@ -65,25 +63,23 @@ jobs:
     steps:
       - name: Checkout Repository
         uses: actions/checkout@v5
-        
+
       - name: Use Node.js ${{ matrix.node-version }}
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
-          
+
       - name: Install dependencies
         run: npm install
-        env:
-          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
-          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
 
       - name: Run Tests with Shuffle + Sharding
         run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shuffle --shard ${{ matrix.shard }} --verbose
         working-directory: test/data/sandbox
         env:
           FORCE_COLOR: 1
-          
+          DONT_FAIL_ON_EMPTY_RUN: true
+
       - name: Display Combined Options Info
         run: |
           echo "This demonstrates sharding combined with shuffle option"
-          echo "Tests are first shuffled, then sharded for this worker (${{ matrix.shard }})"
\ No newline at end of file
+          echo "Tests are first shuffled, then sharded for this worker (${{ matrix.shard }})"

From 0971ac977fd3594668999439563ec967cc90fbdd Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 11:10:07 +0000
Subject: [PATCH 5/6] Changes before error encountered

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>
---
 .github/workflows/acceptance-tests.yml | 18 +++++++++++++-----
 .github/workflows/sharding-demo.yml    | 12 ++++++------
 2 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/acceptance-tests.yml b/.github/workflows/acceptance-tests.yml
index 959206e36..926dd646d 100644
--- a/.github/workflows/acceptance-tests.yml
+++ b/.github/workflows/acceptance-tests.yml
@@ -81,21 +81,29 @@ jobs:
           PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
           PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
 
-      - name: Install Puppeteer Browser
-        if: contains(matrix.config, 'Puppeteer')
-        run: npx puppeteer browsers install chrome
+      - name: Setup Chrome
+        uses: browser-actions/setup-chrome@v1
 
       - name: Install Playwright Browsers
         if: contains(matrix.config, 'Playwright')
-        run: npx playwright install chromium && npx playwright install-deps
+        run: npx playwright install chromium --with-deps
+
+      - name: Verify browser setup
+        run: |
+          which google-chrome || which chromium-browser || echo "Chrome not found in PATH"
 
       - name: Start PHP Server
-        run: php -S 127.0.0.1:8000 -t test/data/app &
+        run: |
+          php -S 127.0.0.1:8000 -t test/data/app &
+          sleep 2
+          # Wait for server to be ready
+          timeout 10 bash -c 'until curl -s http://127.0.0.1:8000 >/dev/null; do sleep 1; done' || echo "Server may not be fully ready"
 
       - name: Run Acceptance Tests with Sharding
         run: npx codeceptjs run --config ./test/acceptance/${{ matrix.config }} --shard ${{ matrix.shard }} --verbose
         env:
           FORCE_COLOR: 1
+          DONT_FAIL_ON_EMPTY_RUN: true
 
       - name: Display Test Info
         run: |
diff --git a/.github/workflows/sharding-demo.yml b/.github/workflows/sharding-demo.yml
index b78aecced..dfea57197 100644
--- a/.github/workflows/sharding-demo.yml
+++ b/.github/workflows/sharding-demo.yml
@@ -13,7 +13,7 @@ env:
   FORCE_COLOR: 1
 
 jobs:
-  # Demonstrate sharding with a larger test suite (sandbox tests)
+  # Demonstrate sharding with sandbox tests (FileSystem-based, no browser needed)
   sharded-sandbox-tests:
     runs-on: ubuntu-latest
     name: 'Sandbox Tests (Shard ${{ matrix.shard }})'
@@ -22,7 +22,7 @@ jobs:
       fail-fast: false
       matrix:
         node-version: [20.x]
-        # Split 2 sandbox tests across 2 shards for demonstration
+        # Split sandbox tests across 2 shards
         shard: ['1/2', '2/2']
 
     steps:
@@ -35,10 +35,10 @@ jobs:
           node-version: ${{ matrix.node-version }}
 
       - name: Install dependencies
-        run: npm install
+        run: npm install --ignore-scripts
 
       - name: Run Sandbox Tests with Sharding
-        run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shard ${{ matrix.shard }} --verbose
+        run: npx codeceptjs run --config ./codecept.js --shard ${{ matrix.shard }} --verbose
         working-directory: test/data/sandbox
         env:
           FORCE_COLOR: 1
@@ -70,10 +70,10 @@ jobs:
           node-version: ${{ matrix.node-version }}
 
       - name: Install dependencies
-        run: npm install
+        run: npm install --ignore-scripts
 
       - name: Run Tests with Shuffle + Sharding
-        run: npx codeceptjs run --config ./test/data/sandbox/codecept.js --shuffle --shard ${{ matrix.shard }} --verbose
+        run: npx codeceptjs run --config ./codecept.js --shuffle --shard ${{ matrix.shard }} --verbose
         working-directory: test/data/sandbox
         env:
           FORCE_COLOR: 1

From e5aaad0a52e5fb5019cb1450a40f231a95b1f47d Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 23 Aug 2025 13:58:28 +0000
Subject: [PATCH 6/6] Changes before error encountered

Co-authored-by: kobenguyent <7845001+kobenguyent@users.noreply.github.com>
---
 .github/workflows/acceptance-tests.yml | 68 +-------------------------
 .github/workflows/sharding-demo.yml    | 62 +++--------------------
 .github/workflows/test.yml             |  2 +-
 3 files changed, 11 insertions(+), 121 deletions(-)

diff --git a/.github/workflows/acceptance-tests.yml b/.github/workflows/acceptance-tests.yml
index 926dd646d..e92699122 100644
--- a/.github/workflows/acceptance-tests.yml
+++ b/.github/workflows/acceptance-tests.yml
@@ -1,4 +1,4 @@
-name: Acceptance Tests with Sharding
+name: Acceptance Tests
 
 on:
   push:
@@ -14,10 +14,8 @@ env:
   FORCE_COLOR: 1
 
 jobs:
-  # Traditional docker-compose tests (kept for compatibility)
-  docker-tests:
+  build:
     runs-on: ubuntu-latest
-    name: Docker-based Tests
 
     strategy:
       matrix:
@@ -48,65 +46,3 @@ jobs:
       - name: Run Faker BDD Tests
         run: docker-compose run --rm test-bdd.faker
         working-directory: test
-
-  # New sharded acceptance tests using CodeceptJS directly
-  sharded-acceptance-tests:
-    runs-on: ubuntu-latest
-    name: 'Sharded Tests: ${{ matrix.config }} (Shard ${{ matrix.shard }})'
-
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version: [20.x]
-        config: ['codecept.Puppeteer.js', 'codecept.Playwright.js']
-        shard: ['1/2', '2/2']
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v5
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Setup PHP
-        uses: shivammathur/setup-php@v2
-        with:
-          php-version: 7.4
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-        env:
-          PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: true
-          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
-
-      - name: Setup Chrome
-        uses: browser-actions/setup-chrome@v1
-
-      - name: Install Playwright Browsers
-        if: contains(matrix.config, 'Playwright')
-        run: npx playwright install chromium --with-deps
-
-      - name: Verify browser setup
-        run: |
-          which google-chrome || which chromium-browser || echo "Chrome not found in PATH"
-
-      - name: Start PHP Server
-        run: |
-          php -S 127.0.0.1:8000 -t test/data/app &
-          sleep 2
-          # Wait for server to be ready
-          timeout 10 bash -c 'until curl -s http://127.0.0.1:8000 >/dev/null; do sleep 1; done' || echo "Server may not be fully ready"
-
-      - name: Run Acceptance Tests with Sharding
-        run: npx codeceptjs run --config ./test/acceptance/${{ matrix.config }} --shard ${{ matrix.shard }} --verbose
-        env:
-          FORCE_COLOR: 1
-          DONT_FAIL_ON_EMPTY_RUN: true
-
-      - name: Display Test Info
-        run: |
-          echo "Configuration: ${{ matrix.config }}"
-          echo "Shard: ${{ matrix.shard }}"
-          echo "This demonstrates test sharding across different browser configurations"
diff --git a/.github/workflows/sharding-demo.yml b/.github/workflows/sharding-demo.yml
index dfea57197..c2408a8f8 100644
--- a/.github/workflows/sharding-demo.yml
+++ b/.github/workflows/sharding-demo.yml
@@ -1,4 +1,4 @@
-name: Test Sharding Demonstration
+name: Minimal Sharding Test
 
 on:
   push:
@@ -13,73 +13,27 @@ env:
   FORCE_COLOR: 1
 
 jobs:
-  # Demonstrate sharding with sandbox tests (FileSystem-based, no browser needed)
-  sharded-sandbox-tests:
+  test-sharding:
     runs-on: ubuntu-latest
-    name: 'Sandbox Tests (Shard ${{ matrix.shard }})'
+    name: 'Shard ${{ matrix.shard }}'
 
     strategy:
       fail-fast: false
       matrix:
-        node-version: [20.x]
-        # Split sandbox tests across 2 shards
         shard: ['1/2', '2/2']
 
     steps:
-      - name: Checkout Repository
+      - name: Checkout
         uses: actions/checkout@v5
 
-      - name: Use Node.js ${{ matrix.node-version }}
+      - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: ${{ matrix.node-version }}
+          node-version: 20
 
       - name: Install dependencies
         run: npm install --ignore-scripts
 
-      - name: Run Sandbox Tests with Sharding
-        run: npx codeceptjs run --config ./codecept.js --shard ${{ matrix.shard }} --verbose
+      - name: Run tests with sharding
+        run: npx codeceptjs run --config ./codecept.js --shard ${{ matrix.shard }}
         working-directory: test/data/sandbox
-        env:
-          FORCE_COLOR: 1
-          DONT_FAIL_ON_EMPTY_RUN: true
-
-      - name: Display Shard Info
-        run: |
-          echo "This shard (${{ matrix.shard }}) ran a subset of the available test files"
-          echo "All shards together cover the complete test suite without duplication"
-
-  # Show combination with shuffle option
-  sharded-shuffled-tests:
-    runs-on: ubuntu-latest
-    name: 'Shuffled + Sharded Tests (Shard ${{ matrix.shard }})'
-
-    strategy:
-      fail-fast: false
-      matrix:
-        node-version: [20.x]
-        shard: ['1/2', '2/2']
-
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v5
-
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-
-      - name: Run Tests with Shuffle + Sharding
-        run: npx codeceptjs run --config ./codecept.js --shuffle --shard ${{ matrix.shard }} --verbose
-        working-directory: test/data/sandbox
-        env:
-          FORCE_COLOR: 1
-          DONT_FAIL_ON_EMPTY_RUN: true
-
-      - name: Display Combined Options Info
-        run: |
-          echo "This demonstrates sharding combined with shuffle option"
-          echo "Tests are first shuffled, then sharded for this worker (${{ matrix.shard }})"
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 6700710cc..f979e09fe 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -49,4 +49,4 @@ jobs:
           PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true
       - run: npm run test:runner
         # Note: Runner tests are mocha-based, so sharding doesn't apply here.
-        # Sharding is specifically for CodeceptJS tests (see sharding-demo.yml for examples)
+        # For CodeceptJS sharding examples, see sharding-demo.yml workflow.