Merge branch 'develop' into retry-flake

npm/xpath/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [@cypress/xpath-v2.0.3](https://github.com/cypress-io/cypress/compare/@cypress/xpath-v2.0.2...@cypress/xpath-v2.0.3) (2022-10-26)
+
+
+### Bug Fixes
+
+* **xpath:** update xpath main path ([#24259](https://github.com/cypress-io/cypress/issues/24259)) ([edf99c4](https://github.com/cypress-io/cypress/commit/edf99c41d6031c7a72ad2258f4fd29231823790c))
+
 # [@cypress/xpath-v2.0.2](https://github.com/cypress-io/cypress/compare/@cypress/xpath-v2.0.1...@cypress/xpath-v2.0.2) (2022-09-29)
 
 

npm/xpath/package.json

@@ -2,7 +2,7 @@
   "name": "@cypress/xpath",
   "version": "0.0.0-development",
   "description": "Adds XPath command to Cypress.io test runner",
-  "main": "scripts",
+  "main": "src",
   "scripts": {
     "cy:run": "node ../../scripts/cypress.js run --e2e",
     "cy:open": "node ../../scripts/cypress.js open --e2e --project ${PWD}"

packages/app/src/runner/event-manager.ts

@@ -11,6 +11,7 @@ import { automation, useRunnerUiStore } from '../store'
 import { useScreenshotStore } from '../store/screenshot-store'
 import { useStudioStore } from '../store/studio-store'
 import { getAutIframeModel } from '.'
+import { handlePausing } from './events/pausing'
 
 export type CypressInCypressMochaEvent = Array<Array<string | Record<string, any>>>
 
@@ -33,7 +34,6 @@ interface AddGlobalListenerOptions {
   randomString: string
 }
 
-const driverToReporterEvents = 'paused'.split(' ')
 const driverToLocalAndReporterEvents = 'run:start run:end'.split(' ')
 const driverToSocketEvents = 'backend:request automation:request mocha recorder:frame'.split(' ')
 const driverTestEvents = 'test:before:run:async test:after:run'.split(' ')
@@ -225,18 +225,6 @@ export class EventManager {
 
     this.reporterBus.on('runner:unpin:snapshot', this._unpinSnapshot.bind(this))
 
-    this.reporterBus.on('runner:resume', () => {
-      if (!Cypress) return
-
-      Cypress.emit('resume:all')
-    })
-
-    this.reporterBus.on('runner:next', () => {
-      if (!Cypress) return
-
-      Cypress.emit('resume:next')
-    })
-
     this.reporterBus.on('runner:stop', () => {
       if (!Cypress) return
 
@@ -538,12 +526,6 @@ export class EventManager {
 
     Cypress.on('after:screenshot', handleAfterScreenshot)
 
-    driverToReporterEvents.forEach((event) => {
-      Cypress.on(event, (...args) => {
-        this.reporterBus.emit(event, ...args)
-      })
-    })
-
     driverTestEvents.forEach((event) => {
       Cypress.on(event, (test, cb) => {
         this.reporterBus.emit(event, test, cb)
@@ -596,6 +578,8 @@ export class EventManager {
       }
     })
 
+    handlePausing(this.getCypress, this.reporterBus)
+
     Cypress.on('test:before:run', (...args) => {
       Cypress.primaryOriginCommunicator.toAllSpecBridges('test:before:run', ...args)
     })

packages/app/src/runner/events/pausing.ts

@@ -0,0 +1,50 @@
+export const handlePausing = (getCypress, reporterBus) => {
+  const Cypress = getCypress()
+  // tracks whether the cy.pause() was called from the primary driver
+  // (value === null) or from a cross-origin spec bridge (value is the origin
+  // matching that spec bridge)
+  let sendEventsToOrigin = null
+
+  reporterBus.on('runner:next', () => {
+    const Cypress = getCypress()
+
+    if (!Cypress) return
+
+    // if paused from within a cy.origin() callback, send the event to the
+    // corresponding spec bridge
+    if (sendEventsToOrigin) {
+      Cypress.primaryOriginCommunicator.toSpecBridge(sendEventsToOrigin, 'resume:next')
+    } else {
+      Cypress.emit('resume:next')
+    }
+  })
+
+  reporterBus.on('runner:resume', () => {
+    const Cypress = getCypress()
+
+    if (!Cypress) return
+
+    // if paused from within a cy.origin() callback, send the event to the
+    // corresponding spec bridge
+    if (sendEventsToOrigin) {
+      Cypress.primaryOriginCommunicator.toSpecBridge(sendEventsToOrigin, 'resume:all')
+    } else {
+      Cypress.emit('resume:all')
+    }
+
+    // pause sequence is over - reset this for subsequent pauses
+    sendEventsToOrigin = null
+  })
+
+  // from the primary driver
+  Cypress.on('paused', (nextCommandName) => {
+    reporterBus.emit('paused', nextCommandName)
+  })
+
+  // from a cross-origin spec bridge
+  Cypress.primaryOriginCommunicator.on('paused', ({ nextCommandName, origin }) => {
+    sendEventsToOrigin = origin
+
+    reporterBus.emit('paused', nextCommandName)
+  })
+}

packages/driver/cypress/e2e/commands/navigation.cy.js

@@ -765,7 +765,6 @@ describe('src/cy/commands/navigation', () => {
       })
 
       cy.visit('fixtures/redirection-loop-a.html')
-      cy.get('div').should('contain', 'this should fail?')
     })
 
     if (!Cypress.config('experimentalSessionAndOrigin')) {

packages/driver/cypress/e2e/commands/sessions/sessions.cy.js

@@ -1754,4 +1754,10 @@ describe('cy.session', { retries: 0 }, () => {
       })
     })
   })
+
+  it('should allow more than 20 sessions to be created per test', () => {
+    for (let index = 0; index < 21; index++) {
+      cy.session(`${index}`, () => {})
+    }
+  })
 })

packages/driver/cypress/e2e/e2e/origin/commands/misc.cy.ts

@@ -37,10 +37,22 @@ context('cy.origin misc', { browser: '!webkit' }, () => {
   })
 
   it('.pause()', () => {
+    // ensures the 'paused' event makes it to the event-manager in the primary.
+    // if we get cross-origin cy-in-cy test working, we could potentially make
+    // this even more end-to-end: test out the reporter UI and click the
+    // resume buttons instead of sending the resume:all event
+    Cypress.primaryOriginCommunicator.once('paused', ({ nextCommandName, origin }) => {
+      expect(nextCommandName).to.equal('wrap')
+      expect(origin).to.equal('http://www.foobar.com:3500')
+
+      Cypress.primaryOriginCommunicator.toSpecBridge(origin, 'resume:all')
+    })
+
     cy.origin('http://www.foobar.com:3500', () => {
       const afterPaused = new Promise<void>((resolve) => {
-        cy.once('paused', () => {
-          Cypress.emit('resume:all')
+        // event is sent from the event listener in the primary above,
+        // ensuring that the pause sequence has come full circle
+        cy.once('resume:all', () => {
           resolve()
         })
       })

packages/driver/src/cross-origin/events/misc.ts

@@ -35,4 +35,16 @@ export const handleMiscEvents = (Cypress: Cypress.Cypress, cy: $Cy) => {
     Cypress.action('app:window:load', undefined, url)
     Cypress.emit('internal:window:load', { type: 'same:origin', url })
   })
+
+  Cypress.on('paused', (nextCommandName: string) => {
+    Cypress.specBridgeCommunicator.toPrimary('paused', { nextCommandName, origin: window.origin })
+  })
+
+  Cypress.specBridgeCommunicator.on('resume:next', () => {
+    Cypress.emit('resume:next')
+  })
+
+  Cypress.specBridgeCommunicator.on('resume:all', () => {
+    Cypress.emit('resume:all')
+  })
 }

packages/driver/src/cy/commands/navigation.ts

@@ -315,6 +315,11 @@ const stabilityChanged = async (Cypress, state, config, stable) => {
   const onPageLoadErr = (err) => {
     state('onPageLoadErr', null)
 
+    // If the error thrown is a cypress error, return it instead of throwing a cross origin error.
+    if ($errUtils.isCypressErr(err)) {
+      return err
+    }
+
     const { origin } = $Location.create(window.location.href)
 
     try {
@@ -336,6 +341,11 @@ const stabilityChanged = async (Cypress, state, config, stable) => {
   state('onPageLoadErr', onPageLoadErr)
 
   const getRedirectionCount = (href) => {
+    // redirecting to about:blank should not count towards the redirection limit.
+    if (href === 'about:blank') {
+      return 0
+    }
+
     // object updated at test:before:run:async
     const count = state('redirectionCount')
 
@@ -363,6 +373,7 @@ const stabilityChanged = async (Cypress, state, config, stable) => {
 
         if (count === limit) {
           $errUtils.throwErrByPath('navigation.reached_redirection_limit', {
+            onFail: options._log,
             args: {
               href,
               limit,

packages/driver/src/cy/commands/origin/index.ts

@@ -64,6 +64,7 @@ export default (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy, state: State
         name: 'origin',
         type: 'parent',
         message: urlOrDomain,
+        timeout: 0,
         // @ts-ignore TODO: revisit once log-grouping has more implementations
       }, (_log) => {
         log = _log

packages/driver/src/cypress/cy.ts

@@ -592,7 +592,10 @@ export class $Cy extends EventEmitter2 implements ITimeouts, IStability, IAssert
           // this catches errors thrown by user-registered event handlers
           // for `window:load`. this is used in the `catch` below so they
           // aren't mistaken as cross-origin errors
-          err.isFromWindowLoadEvent = true
+          // If this is a cypress error, pass it on through.
+          if (!$errUtils.isCypressErr(err)) {
+            err.isFromWindowLoadEvent = true
+          }
 
           throw err
         } finally {

packages/driver/types/internal-types.d.ts

@@ -58,6 +58,7 @@ declare namespace Cypress {
     (action: 'clear:cookies', fn: () => void)
     (action: 'cross:origin:cookies', fn: (cookies: AutomationCookie[]) => void)
     (action: 'before:stability:release', fn: () => void)
+    (action: 'paused', fn: (nextCommandName: string) => void)
   }
 
   interface Backend {

packages/server/lib/modes/run.ts

@@ -164,8 +164,8 @@ const openProjectCreate = (projectRoot, socketId, args) => {
 
 async function checkAccess (folderPath) {
   return fs.access(folderPath, fs.constants.W_OK).catch((err) => {
-    if (['EACCES', 'EPERM'].includes(err.code)) {
-      // we cannot write due to folder permissions
+    if (['EACCES', 'EPERM', 'EROFS'].includes(err.code)) {
+      // we cannot write due to folder permissions, or read-only filesystem
       return errors.warning('FOLDER_NOT_WRITABLE', folderPath)
     }
 

packages/server/test/unit/project_spec.js

@@ -611,6 +611,21 @@ This option will not have an effect in Some-other-name. Tests that rely on web s
         expect(err.code).to.eq('EPERM')
       })
     })
+
+    it('bubbles up Settings.read EROFS error', function () {
+      const err = new Error()
+
+      err.code = 'EROFS'
+
+      sinon.stub(settings, 'read').rejects(err)
+
+      return this.project.getProjectId()
+      .then((id) => {
+        throw new Error('expected to fail, but did not')
+      }).catch((err) => {
+        expect(err.code).to.eq('EROFS')
+      })
+    })
   })
 })