fixed runner tests

Author: DavertMik

lib/mocha/asyncWrapper.js

@@ -86,7 +86,7 @@ export function test(test) {
         const result = testFn.call(test, args)
 
         // Wait for all recorder steps to complete
-        if (isAsyncFunction(testFn) && result.then) {
+        if (result && result.then) {
           return result.then(() => recorder.promise())
         }
         return recorder.promise()
@@ -148,7 +148,8 @@ export function injected(fn, suite, hookName) {
       async (retry, number) => {
         try {
           recorder.startUnlessRunning()
-          await fn.call(this, { ...getInjectedArguments(fn), suite, test: currentTest })
+          const injectedArgs = await getInjectedArguments(fn)
+          await fn.call(this, { ...injectedArgs, suite, test: currentTest })
           await recorder.promise().catch(err => retry(err))
         } catch (err) {
           retry(err)

lib/session.js

@@ -51,7 +51,7 @@ function session(sessionName, config, fn) {
       delete savedSessions[sessionName]
     }
 
-    event.dispatcher.once(event.test.after, () => {
+    event.dispatcher.once(event.test.finished, () => {
       recorder.add('close session browsers', closeBrowsers)
     })
 
@@ -77,10 +77,12 @@ function session(sessionName, config, fn) {
     'register session wrapper',
     async () => {
       const session = savedSessions[sessionName]
+      if (!session) {
+        throw new Error(`Session "${sessionName}" not found. It may have been closed already.`)
+      }
       recorder.session.start(`session:${sessionName}`)
       event.dispatcher.on(event.step.after, addContextToStep)
       recorder.add('switch to browser', () => {
-        const session = savedSessions[sessionName]
         return session.loadVars(session.vars)
       })
 

test/acceptance/session_test.js

@@ -63,12 +63,12 @@ Scenario('Different cookies for different sessions @Playwright @Puppeteer', asyn
 
   cookies.default = (await I.grabCookie(cookieName))?.value
   I.say(`${cookieName}: ${cookies.default}`)
-  session('john', async () => {
+  await session('john', async () => {
     const cookie = await I.grabCookie(cookieName)
     cookies.john = cookie?.value
     I.say(`${cookieName}: ${cookies.john}`)
   })
-  session('mary', async () => {
+  await session('mary', async () => {
     const cookie = await I.grabCookie(cookieName)
     cookies.mary = cookie?.value
     I.say(`${cookieName}: ${cookies.mary}`)
@@ -87,7 +87,7 @@ Scenario('should save screenshot for sessions @Puppeteer @Playwright', async fun
   await I.saveScreenshot('original.png')
   await I.amOnPage('/')
   await I.saveScreenshot('main_session.png')
-  session('john', async () => {
+  await session('john', async () => {
     await I.amOnPage('/form/bug1467')
     event.dispatcher.emit(event.test.failed, this)
   })

test/unit/mocha/asyncWrapper_test.js

@@ -59,7 +59,7 @@ describe('AsyncWrapper', () => {
 
   it('should work with async func', async () => {
     let counter = 0
-    test.fn = () => {
+    test.fn = async () => {
       recorder.add('test', async () => {
         counter++
         counter++
@@ -69,7 +69,9 @@ describe('AsyncWrapper', () => {
     }
 
     await setup()
-    testWrapper(test).fn(() => null)
+    const wrappedTest = testWrapper(test)
+    // Wait for the wrapped function to complete
+    await new Promise(resolve => wrappedTest.fn(resolve))
     recorder.add('validation', () => expect(counter).to.eq(4))
     return recorder.promise()
   })
@@ -81,8 +83,8 @@ describe('AsyncWrapper', () => {
       event.dispatcher.on(event.test.started, (started = sinon.spy()))
       event.dispatcher.on(event.suite.before, (beforeSuite = sinon.spy()))
       event.dispatcher.on(event.suite.after, (afterSuite = sinon.spy()))
-      await suiteSetup()()
-      await setup()()
+      await new Promise(r => suiteSetup()(r))
+      await new Promise(r => setup()(r))
     })
 
     it('should fire events', async () => {
@@ -91,25 +93,27 @@ describe('AsyncWrapper', () => {
 
       // Execute the wrapped test function with a mock done callback
       return new Promise((resolve, reject) => {
-        wrappedTest.fn(async err => {
-          try {
-            await teardown()()
-            await suiteTeardown()()
+        wrappedTest.fn(err => {
+          ;(async () => {
+            try {
+              await new Promise(r => teardown()(r))
+              await new Promise(r => suiteTeardown()(r))
 
-            if (err) {
-              reject(err)
-              return
-            }
+              if (err) {
+                reject(err)
+                return
+              }
 
-            expect(started.called).is.ok
-            expect(beforeSuite.called).is.ok
-            expect(afterSuite.called).is.ok
-            expect(before.called).is.ok
-            expect(after.called).is.ok
-            resolve()
-          } catch (testErr) {
-            reject(testErr)
-          }
+              expect(started.called).is.ok
+              expect(beforeSuite.called).is.ok
+              expect(afterSuite.called).is.ok
+              expect(before.called).is.ok
+              expect(after.called).is.ok
+              resolve()
+            } catch (testErr) {
+              reject(testErr)
+            }
+          })()
         })
       })
     })