test(effects): port effects-under-tsx/cjs coverage from #5634 (#5635)

#5635 fixes the dual-realm split at the source (shared recorder/container), which makes
within/tryTo/hopeThat/retryTo work from a CJS-loaded test without the effects.js
indirection PR #5634 added — i.e. #5635 supersedes #5634's mechanism. To avoid losing
#5634's regression coverage, fold its effects assertions into this PR's fixture: extend
the helper with the effects-exercising methods and add effects_test.ts, then assert the
markers from the same single fixture run. retryTo is kept last and the child exec has a
timeout guard so a future regression that re-hangs it fails cleanly instead of hanging.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: mirao

test/data/internal-api-tsx-cjs/effects_test.ts

@@ -0,0 +1,41 @@
+// Effects regression under tsx/cjs (originally https://github.com/codeceptjs/CodeceptJS/issues/5632,
+// first addressed in PR #5634). within/tryTo/hopeThat/retryTo are part of the internal API and
+// delegate to the recorder/container singletons. Imported through a CommonJS loader (tsx/cjs) they
+// used to load a second, disconnected copy: tryTo/hopeThat returned without running their callback,
+// within skipped its inner steps, and retryTo hung forever.
+//
+// With the singletons shared at the source (lib/realm.js, #5635) the CJS copy of effects.js resolves
+// the live recorder/container, so all four run. Kept as dedicated coverage so a future regression that
+// re-splits the recorder/container fails here too.
+import { within, tryTo, hopeThat, retryTo } from "../../../lib/effects.js";
+
+Feature("effects under tsx/cjs");
+
+Scenario("tryTo executes the failing step and returns false", async ({ I }) => {
+  const ok = await tryTo(() => {
+    I.seeMissing();
+  });
+  console.log(`EFFECTS_TRYTO result=${ok}`);
+});
+
+Scenario("within applies the context to inner steps", ({ I }) => {
+  within("body", () => {
+    I.clickInside();
+  });
+});
+
+Scenario("hopeThat executes the soft assertion and returns true", async ({ I }) => {
+  const ok = await hopeThat(() => {
+    I.pass();
+  });
+  console.log(`EFFECTS_HOPETHAT result=${ok}`);
+});
+
+// Kept last on purpose: when the recorder is disconnected, retryTo never resolves and hangs,
+// so the earlier markers are already flushed before the runner-test timeout fires.
+Scenario("retryTo runs the callback until it succeeds", async ({ I }) => {
+  await retryTo(() => {
+    I.flaky();
+  }, 3);
+  console.log("EFFECTS_RETRY done");
+});

test/data/internal-api-tsx-cjs/internal_api_helper.js

@@ -5,10 +5,43 @@ const Helper = HelperModule.default || HelperModule
 const Config = ConfigModule.default || ConfigModule
 
 class ConfigHelper extends Helper {
+  constructor(config) {
+    super(config)
+    this._withinActive = false
+    this._tries = 0
+  }
+
   reportConfig() {
     // Helper is loaded via import() (the ESM realm), so it has always shared the live config.
     console.log(`API_HELPER marker=${Config.get().helpers.ConfigHelper.marker}`)
   }
+
+  // --- used by the effects scenarios ---
+  _withinBegin() {
+    this._withinActive = true
+  }
+
+  _withinEnd() {
+    this._withinActive = false
+  }
+
+  seeMissing() {
+    throw new Error('element not found')
+  }
+
+  clickInside() {
+    console.log(`EFFECTS_CLICK withinActive=${this._withinActive}`)
+  }
+
+  pass() {
+    console.log('EFFECTS_PASS ran')
+  }
+
+  flaky() {
+    this._tries++
+    console.log(`EFFECTS_FLAKY try=${this._tries}`)
+    if (this._tries < 2) throw new Error('not ready yet')
+  }
 }
 
 export default ConfigHelper

test/runner/internal_api_tsx_test.js

@@ -12,30 +12,55 @@ const codecept_dir = path.join(__dirname, '/../data/internal-api-tsx-cjs')
 const codecept_run = `${runner} run --config ${codecept_dir}/codecept.conf.ts`
 
 // Regression test for https://github.com/codeceptjs/CodeceptJS/issues/5635
-// The internal API (config/container/recorder/event/store) must resolve to the live
-// singletons when imported from a test through a CommonJS loader (tsx/cjs), not a second,
-// disconnected copy. Drives a real tsx/cjs project and asserts each one is the live instance.
+// The internal API (config/container/recorder/event/store, and the effects that delegate to them)
+// must resolve to the live singletons when imported from a test through a CommonJS loader (tsx/cjs),
+// not a second, disconnected copy. Drives a real tsx/cjs project once and asserts on its output.
 describe('CodeceptJS internal API under tsx/cjs', function () {
   this.timeout(40000)
 
-  it('resolves config/container/recorder/event/store to the live singletons from a test', done => {
-    exec(`${codecept_run}`, { timeout: 30000 }, (err, stdout) => {
-      stdout.should.include('1 passed')
-      // config (#5635): the real config the runner loaded, not an empty {}
-      stdout.should.include('API_CONFIG name=internal-api-tsx-cjs-test')
-      stdout.should.include('API_CONFIG marker=config-marker-123')
-      // container: the live helpers map populated by the runner
-      stdout.should.include('API_CONTAINER helper=object')
-      // store: initialized by the runner
-      stdout.should.include('API_STORE hasDir=true')
-      // recorder: started by the runner for this test
-      stdout.should.include('API_RECORDER running=true')
-      // event: the live dispatcher the framework subscribes to
-      stdout.should.include('API_EVENT live=true')
-      // helper (ESM realm) reads the same live config
-      stdout.should.include('API_HELPER marker=config-marker-123')
-      chai.expect(err).to.be.null
+  let stdout = ''
+  let runErr = null
+
+  // Run the fixture once; the `timeout` kills the child if a regression makes retryTo() hang forever
+  // (its manual promise never resolves on a disconnected recorder), so a broken fix fails on the
+  // missing markers instead of hanging the whole suite.
+  before(done => {
+    exec(`${codecept_run}`, { timeout: 30000 }, (err, out) => {
+      runErr = err
+      stdout = out
       done()
     })
   })
+
+  it('resolves config/container/recorder/event/store to the live singletons from a test', () => {
+    stdout.should.include('5 passed')
+    // config (#5635): the real config the runner loaded, not an empty {}
+    stdout.should.include('API_CONFIG name=internal-api-tsx-cjs-test')
+    stdout.should.include('API_CONFIG marker=config-marker-123')
+    // container: the live helpers map populated by the runner
+    stdout.should.include('API_CONTAINER helper=object')
+    // store: initialized by the runner
+    stdout.should.include('API_STORE hasDir=true')
+    // recorder: started by the runner for this test
+    stdout.should.include('API_RECORDER running=true')
+    // event: the live dispatcher the framework subscribes to
+    stdout.should.include('API_EVENT live=true')
+    // helper (ESM realm) reads the same live config
+    stdout.should.include('API_HELPER marker=config-marker-123')
+    chai.expect(runErr).to.be.null
+  })
+
+  it('runs within/tryTo/hopeThat/retryTo imported through the CJS loader', () => {
+    // tryTo ran its callback and resolved to false (a failed try), instead of returning
+    // undefined from a disconnected, never-started recorder
+    stdout.should.include('EFFECTS_TRYTO result=false')
+    // within() applied its context so the inner step saw _withinBegin
+    stdout.should.include('EFFECTS_CLICK withinActive=true')
+    // hopeThat() ran its callback and resolved to true
+    stdout.should.include('EFFECTS_PASS ran')
+    stdout.should.include('EFFECTS_HOPETHAT result=true')
+    // retryTo() retried the flaky callback until it passed (and did not hang)
+    stdout.should.include('EFFECTS_FLAKY try=2')
+    stdout.should.include('EFFECTS_RETRY done')
+  })
 })