feat: [Multi-domain]: Yield subject from switchToDomain

packages/driver/cypress/integration/e2e/multi-domain/multi_domain_spec.ts

@@ -278,4 +278,93 @@ describe('multi-domain', { experimentalSessionSupport: true, experimentalMultiDo
 
  it('short circuits the secondary domain command queue when "done()" is called early')
  })
+
+ describe('yields', () => {
+ it('yields a value', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy
+ .get('[data-cy="dom-check"]')
+ .invoke('text')
+ }).should('equal', 'From a secondary domain')
+ })
+
+ it('yields the cy value even if a return is present', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy
+ .get('[data-cy="dom-check"]')
+ .invoke('text')
+
+ return 'text'
+ }).should('equal', 'From a secondary domain')
+ })
+
+ it('yields synchronously', () => {
+ cy.switchToDomain('foobar.com', () => {
+ return 'From a secondary domain'
+ }).should('equal', 'From a secondary domain')
+ })
+
+ it('yields undefined if subject cannot be serialized', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy
+ .get('[data-cy="dom-check"]')
+ }).should('equal', undefined)
+ })
+
+ it('yields undefined if an object contains undefined', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy.wrap({
+ key: undefined,
+ })
+ }).should('equal', undefined)
+ })
+
+ it('yields undefined if an object contains a function', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy.wrap({
+ key: () => {
+ return 'whoops'
+ },
+ })
+ }).should('equal', undefined)
+ })
+
+ it('yields undefined if an object contains a symbol', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy.wrap({
+ key: Symbol('whoops'),
+ })
+ }).should('equal', undefined)
+ })
+
+ it('yields an object containing valid types', () => {
+ cy.switchToDomain('foobar.com', () => {
+ cy.wrap({
+ array: [
+ 1,
+ 2,
+ ],
+ bool: true,
+ null: null,
+ number: 12,
+ object: {
+ key: 'key',
+ },
+ string: 'string',
+ })
+ }).should('deep.equal', {
+ array: [
+ 1,
+ 2,
+ ],
+ bool: true,
+ null: null,
+ number: 12,
+ object: {
+ key: 'key',
+ },
+ string: 'string',
+ })
+ })
+ })
 })

packages/driver/src/cy/multi-domain/commands_manager.ts

@@ -1,6 +1,7 @@
 import type { PrimaryDomainCommunicator } from '../../multi-domain/communicator'
 import { createDeferred, Deferred } from '../../util/deferred'
 import { correctStackForCrossDomainError } from './util'
+import { deserialize } from '../../multi-domain/serializer'
 
 export class CommandsManager {
  // these are proxy commands that represent real commands in a
@@ -57,15 +58,17 @@ export class CommandsManager {
  Cypress.action('cy:enqueue:command', attrs)
  }
 
- endCommand = ({ id, name, err, logId }) => {
+ endCommand = ({ id, subject, name, err, logId }) => {
  const command = this.commands[id]
 
  if (!command) return
 
  delete this.commands[id]
 
  if (!err) {
- return command.deferred.resolve()
+ const deserializedSubject = deserialize(subject)
+
+ return command.deferred.resolve(deserializedSubject)
  }
 
  // If the command has failed, cast the error back to a proper Error object

packages/driver/src/cy/multi-domain/index.ts

@@ -3,6 +3,7 @@ import $errUtils from '../../cypress/error_utils'
 import { CommandsManager } from './commands_manager'
 import { LogsManager } from './logs_manager'
 import { Validator } from './validator'
+import { deserialize } from '../../multi-domain/serializer'
 
 export function addCommands (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy, state: Cypress.State, config: Cypress.InternalConfig) {
  let timeoutId
@@ -118,7 +119,7 @@ export function addCommands (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy,
  logsManager.listen()
 
  return new Bluebird((resolve, reject) => {
- communicator.once('ran:domain:fn', (err) => {
+ communicator.once('ran:domain:fn', ({ subject, err }) => {
  sendReadyForDomain()
  if (err) {
  if (done) {
@@ -141,9 +142,13 @@ export function addCommands (Commands, Cypress: Cypress.Cypress, cy: Cypress.cy,
  // is common if there are only assertions enqueued in the SD.
  if (!commandsManager.hasCommands && !done) {
  cleanup()
- }
+ // This handles when a subject is returned synchronously
+ const deserializedSubject = deserialize(subject)
 
- resolve()
+ resolve(deserializedSubject)
+ } else {
+ resolve()
+ }
  })
 
  // If done is NOT passed into switchToDomain, wait for the command queue

packages/driver/src/cypress/log.ts

@@ -50,7 +50,7 @@ const toSerializedJSON = function (attrs) {
  return value()
  }
 
- if (_.isFunction(value)) {
+ if (_.isFunction(value) || _.isSymbol(value)) {
  return value.toString()
  }
 

packages/driver/src/multi-domain/commands.ts

@@ -1,5 +1,6 @@
 import type { $Cy } from '../cypress/cy'
 import type { SpecBridgeDomainCommunicator } from './communicator'
+import { serialize } from './serializer'
 
 export const handleCommands = (Cypress: Cypress.Cypress, cy: $Cy, specBridgeCommunicator: SpecBridgeDomainCommunicator) => {
  const onCommandEnqueued = (commandAttrs: Cypress.EnqueuedCommand) => {
@@ -14,7 +15,11 @@ export const handleCommands = (Cypress: Cypress.Cypress, cy: $Cy, specBridgeComm
  const id = command.get('id')
  const name = command.get('name')
 
- specBridgeCommunicator.toPrimary('command:end', { id, name })
+ let serializedSubject = serialize(cy.state('subject'))
+
+ // we need to serialize and send back the subject on each command because the next chained
+ // command outside of the multi-domain context will not wait for the queue finished event.
+ specBridgeCommunicator.toPrimary('command:end', { id, name, subject: serializedSubject })
  }
 
  const onRunCommand = () => {

packages/driver/src/multi-domain/domain_fn.ts

@@ -1,5 +1,6 @@
 import type { $Cy } from '../cypress/cy'
 import type { SpecBridgeDomainCommunicator } from './communicator'
+import { serialize } from './serializer'
 
 export const handleDomainFn = (cy: $Cy, specBridgeCommunicator: SpecBridgeDomainCommunicator) => {
  const doneEarly = () => {
@@ -86,11 +87,11 @@ export const handleDomainFn = (cy: $Cy, specBridgeCommunicator: SpecBridgeDomain
  // await the eval func, whether it is a promise or not
  // we should not need to transpile this as our target browsers support async/await
  // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function for more details
- await window.eval(fnWrapper)(data)
+ const subject = await window.eval(fnWrapper)(data)
 
- specBridgeCommunicator.toPrimary('ran:domain:fn')
+ specBridgeCommunicator.toPrimary('ran:domain:fn', { subject: serialize(subject) })
  } catch (err) {
- specBridgeCommunicator.toPrimary('ran:domain:fn', err)
+ specBridgeCommunicator.toPrimary('ran:domain:fn', { err })
  } finally {
  cy.state('done', undefined)
  }

packages/driver/src/multi-domain/serializer.ts

@@ -0,0 +1,44 @@
+import { isFunction, isSymbol } from 'lodash'
+import debugFn from 'debug'
+
+const debug = debugFn('cypress:driver:cypress')
+
+/**
+ * serialize. Used for serializing subject to be returned from subdomains to the primary domain.
+ * @param value any object to be serialized.
+ * @returns the serialized object as a string or undefined, if the object cannot be serialized.
+ */
+const serialize = (value: any): string | undefined => {
+ let serializedSubject: string = undefined!
+
+ try {
+ serializedSubject = JSON.stringify(value, (key, value) => {
+ // If we encounter any unserializable values we want to abort the whole process.
+ if (isFunction(value) || isSymbol(value) || value === undefined) {
+ throw 'abort serialization'
+ }
+
+ return value
+ })
+ } catch (error) {
+ // we only want to silence serialization errors.
+ if (error === 'abort serialization') {
+ debug(`Serialization aborted for subject: ${value}`)
+ } else {
+ throw error
+ }
+ }
+
+ return serializedSubject
+}
+
+/**
+ * deserialize. Companion to the above serialize function.
+ * @param value a string
+ * @returns the deserialized object
+ */
+const deserialize = (value: string|undefined): string|object|boolean|number|null|any[] => {
+ return value ? JSON.parse(value) : value
+}
+
+export { serialize, deserialize }