fix(sessions): refactor flows, fix grouping bugs and align validation fail text (#21379)

* chore(sessions): break out sessions manager code

* manager manages registered sessions

* some unit tests

* add more tests and some slight clean up

* .

* fix run mode issue.

* bind correctly for spies

* remove types. not sure on the return values.

* fix tests

* check in dump

* add some command tests

* more driver tests and fix session config error

* Fix parsing error argument

* test for failed validation error messges

* wait for diff pr

* update ui tests

* add more ui tests

* align with 10.0 test setup

* clean up

* will add later

* fix

* fix tests

* baseline for session flow tests

* test for logs...lots here....

* update log attrs to be able to collect session logs for tests

* refactor flows, fix grouping bugs and align validation fail text

* update UI test these changes fixed.

* fix test failures observed in run mode

* reduce flake in log updates

Author: emilyrohrbough

packages/driver/cypress/integration/commands/sessions/sessions.spec.js

@@ -162,8 +162,7 @@ describe('cy.session', { retries: 0 }, () => {
 
         expect(logs[6].get()).to.contain({
           name: 'Clear Page',
-          // FIX ME...
-          // group: sessionGroupId,
+          group: sessionGroupId,
         })
       })
 
@@ -247,8 +246,7 @@ describe('cy.session', { retries: 0 }, () => {
 
         expect(validateSessionGroup).to.contain({
           displayName: 'Validate Session: valid',
-          // FIXME....
-          // group: sessionGroupId,
+          group: sessionGroupId,
         })
 
         expect(logs[7].get()).to.deep.contain({
@@ -258,8 +256,7 @@ describe('cy.session', { retries: 0 }, () => {
 
         expect(logs[8].get()).to.contain({
           name: 'Clear Page',
-          // FIXME...
-          // group: sessionGroupId,
+          group: sessionGroupId,
         })
       })
     })
@@ -317,11 +314,8 @@ describe('cy.session', { retries: 0 }, () => {
           const validateSessionGroup = logs[6].get()
 
           expect(validateSessionGroup).to.contain({
-            displayName: 'Validate Session',
-            // FIXME....
-            // displayName: 'Validate Session: invalid',
-            // FIXME....
-            // group: sessionGroupId,
+            displayName: 'Validate Session: invalid',
+            group: sessionGroupId,
           })
 
           done()
@@ -669,8 +663,7 @@ describe('cy.session', { retries: 0 }, () => {
           const secondValidateSessionGroup = logs[11].get()
 
           expect(secondValidateSessionGroup).to.contain({
-            displayName: 'Validate Session',
-            // displayName: 'Validate Session: invalid',
+            displayName: 'Validate Session: invalid',
             group: sessionGroupId,
           })
 

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

@@ -130,7 +130,7 @@ export default function (Commands, Cypress, cy) {
         message: `${existingSession.id.length > 50 ? `${existingSession.id.substr(0, 47)}...` : existingSession.id}`,
       })
 
-      function runSetup (existingSession) {
+      function createSession (existingSession, recreateSession = false) {
         Cypress.log({
           name: 'session',
           displayName: 'Create New Session',
@@ -141,17 +141,20 @@ export default function (Commands, Cypress, cy) {
           groupStart: true,
         })
 
-        if (!hadValidationError) {
-          _log.set({
-            renderProps: () => {
-              return {
-                indicator: 'successful',
-                message: `(new) ${_log.get().message}`,
-              }
-            },
-          })
+        let renderProps = {
+          indicator: 'successful',
+          message: `(new) ${_log.get().message}`,
         }
 
+        if (recreateSession) {
+          renderProps = {
+            indicator: 'bad',
+            message: `(recreated) ${_log.get().message}`,
+          }
+        }
+
+        _log.set({ renderProps: () => renderProps })
+
         return cy.then(async () => {
           await navigateAboutBlank()
           await sessions.clearCurrentSessionData()
@@ -179,8 +182,44 @@ export default function (Commands, Cypress, cy) {
         })
       }
 
+      function restoreSession (existingSession) {
+        Cypress.log({
+          name: 'session',
+          displayName: 'Restore Saved Session',
+          event: true,
+          state: 'passed',
+          type: 'system',
+          message: ``,
+          groupStart: true,
+        })
+
+        return cy.then(async () => {
+          await navigateAboutBlank()
+
+          _log.set({
+            renderProps: () => {
+              return {
+                indicator: 'pending',
+                message: `(saved) ${_log.get().message}`,
+              }
+            },
+          })
+
+          dataLog.set({
+            consoleProps: () => getConsoleProps(existingSession),
+          })
+
+          await sessions.setSessionData(existingSession)
+          Cypress.log({ groupEnd: true, emitOnly: true })
+        })
+      }
+
       // uses Cypress hackery to resolve `false` if validate() resolves/returns false or throws/fails a cypress command.
       function validateSession (existingSession, _onFail) {
+        if (!existingSession.validate) {
+          return
+        }
+
         const validatingLog = Cypress.log({
           name: 'session',
           displayName: 'Validate Session',
@@ -193,19 +232,14 @@ export default function (Commands, Cypress, cy) {
         })
 
         const onSuccess = () => {
-          validatingLog.set({
-            name: 'session',
-            displayName: 'Validate Session: valid',
-            message: '',
-            type: 'system',
-            event: true,
-            state: 'warning',
-          })
+          validatingLog.set({ displayName: 'Validate Session: valid' })
 
           Cypress.log({ groupEnd: true, emitOnly: true })
         }
 
         const onFail = (err) => {
+          validatingLog.set({ displayName: 'Validate Session: invalid' })
+
           _onFail(err, validatingLog)
         }
 
@@ -297,65 +331,66 @@ export default function (Commands, Cypress, cy) {
         return _catchCommand
       }
 
-      let hadValidationError = false
-      let onValidationError: Function = (err, log) => {
-        log.set({
-          name: 'session',
-          displayName: 'Validate Session: invalid',
-          message: '',
-          type: 'system',
-          event: true,
-          state: 'warning',
-        })
-
-        const errorLog = Cypress.log({
+      const onRestoreSessionValidationError = (err, log) => {
+        // create error log to show validation error to the user in the reporter
+        Cypress.log({
           showError: true,
           type: 'system',
           event: true,
           name: 'session',
           displayName: '',
           message: '',
-        })
+        }).error(err)
 
-        errorLog.error(err)
-        errorLog.set({
-          state: 'warn',
+        log.endGroup()
 
-        })
+        const recreateSession = true
 
-        _log.set({
-          renderProps: () => {
-            return {
-              indicator: 'bad',
-              message: `(recreated) ${_log.get().message}`,
-            }
-          },
-        })
+        return createSessionWorkflow(existingSession, recreateSession)
+      }
 
-        Cypress.log({ groupEnd: true, emitOnly: true })
+      const throwValidationError = (err, log) => {
+        log.endGroup()
+        $errUtils.modifyErrMsg(err, `\n\nThis error occurred in a session validate hook after initializing the session. Because validation failed immediately after session setup we failed the test.`, _.add)
 
-        hadValidationError = true
+        cy.fail(err)
+      }
 
-        return runSetup(existingSession)
+      /**
+       * Creates session flow:
+       *   1. create session
+       *   2. validate session
+       */
+      const createSessionWorkflow = (existingSession, recreateSession = false) => {
+        return createSession(existingSession, recreateSession)
         .then(() => {
-          cy.then(() => {
-            return validateSession(existingSession, throwValidationError)
-          })
-          .then(() => {
-            cy.then(async () => {
-              await navigateAboutBlank()
-              Cypress.log({ groupEnd: true, name: 'session', message: '', emitOnly: true })
-            })
-          })
+          validateSession(existingSession, throwValidationError)
         })
       }
 
-      const throwValidationError = (err) => {
-        $errUtils.modifyErrMsg(err, `\n\nThis error occurred in a session validate hook after initializing the session. Because validation failed immediately after session setup we failed the test.`, _.add)
-
-        cy.fail(err)
+      /**
+       * Restore session flow:
+       *   1. restore session
+       *   2. validation session
+       *   3. if validation fails, catch error and recreate session
+       */
+      const restoreSessionWorkflow = (existingSession) => {
+        return restoreSession(existingSession)
+        .then(() => {
+          validateSession(existingSession, onRestoreSessionValidationError)
+        })
       }
 
+      /**
+       * Session command rules:
+       *   If session does not exists or was no previously saved to the server, create session
+       *      1. run create session flow
+       *      2. clear page
+       *
+       *   If session exists or has been saved to the server, restore session
+       *      1. run restore session flow
+       *      2. clear page
+       */
       return cy.then(async () => {
         if (!existingSession.hydrated) {
           const serverStoredSession = await sessions.getSession(existingSession.id).catch(_.noop)
@@ -365,50 +400,15 @@ export default function (Commands, Cypress, cy) {
             _.extend(existingSession, _.omit(serverStoredSession, 'setup'))
             existingSession.hydrated = true
           } else {
-            onValidationError = throwValidationError
-
-            return runSetup(existingSession)
+            return createSessionWorkflow(existingSession)
           }
         }
 
-        Cypress.log({
-          name: 'session',
-          displayName: 'Restore Saved Session',
-          event: true,
-          state: 'passed',
-          type: 'system',
-          message: ``,
-          groupStart: true,
-        })
-
-        await navigateAboutBlank()
-
-        _log.set({
-          renderProps: () => {
-            return {
-              indicator: 'pending',
-              message: `(saved) ${_log.get().message}`,
-            }
-          },
-        })
-
-        dataLog.set({
-          consoleProps: () => getConsoleProps(existingSession),
-        })
-
-        await sessions.setSessionData(existingSession)
+        return restoreSessionWorkflow(existingSession)
       })
       .then(async () => {
+        await navigateAboutBlank()
         Cypress.log({ groupEnd: true, emitOnly: true })
-        if (existingSession.validate) {
-          await validateSession(existingSession, onValidationError)
-        }
-      })
-      .then(async () => {
-        if (!hadValidationError) {
-          await navigateAboutBlank()
-          Cypress.log({ groupEnd: true, emitOnly: true })
-        }
       })
     },
   })