fix: do not watch specs on run mode (#22060)

Author: estrada9166

packages/data-context/src/sources/ProjectDataSource.ts

@@ -297,6 +297,12 @@ export class ProjectDataSource {
   }: FindSpecs<string[]>) {
     this.stopSpecWatcher()
 
+    // Early return the spec watcher if we're in run mode, we do not want to
+    // init a lot of files watchers that are unneeded
+    if (this.ctx.isRunMode) {
+      return
+    }
+
     const currentProject = this.ctx.currentProject
 
     if (!currentProject) {

packages/data-context/test/unit/sources/ProjectDataSource.spec.ts

@@ -447,127 +447,173 @@ describe('startSpecWatcher', () => {
 
   let ctx: DataContext
 
-  beforeEach(async () => {
-    ctx = createTestDataContext('run')
-
-    ctx.coreData.currentProject = projectRoot
-  })
-
   afterEach(async () => {
     sinon.restore()
   })
 
-  it('throws if no current project defined', () => {
-    ctx.coreData.currentProject = null
+  describe('run mode', () => {
+    beforeEach(async () => {
+      ctx = createTestDataContext('run')
+
+      ctx.coreData.currentProject = projectRoot
+    })
+
+    it('early return specWatcher', () => {
+      const onStub = sinon.stub()
+
+      sinon.stub(chokidar, 'watch').callsFake(() => {
+        const mockWatcher = {
+          on: onStub,
+          close: () => ({ catch: () => {} }),
+        } as unknown
+
+        return mockWatcher as chokidar.FSWatcher
+      })
+
+      let handleFsChange
+
+      sinon.stub(_, 'debounce').callsFake((funcToDebounce) => {
+        handleFsChange = (() => funcToDebounce())
+
+        return handleFsChange as _.DebouncedFunc<any>
+      })
 
-    expect(() => {
-      return ctx.project.startSpecWatcher({
+      ctx.project.startSpecWatcher({
         projectRoot,
         testingType: 'e2e',
         specPattern: ['**/*.{cy,spec}.{ts,js}'],
         configSpecPattern: ['**/*.{cy,spec}.{ts,js}'],
         excludeSpecPattern: ['**/ignore.spec.ts'],
-        additionalIgnorePattern: [],
+        additionalIgnorePattern: ['additional.ignore.cy.js'],
       })
-    }).to.throw()
-  })
 
-  it('creates file watcher based on given config properties', () => {
-    const onStub = sinon.stub()
+      expect(_.debounce).to.have.not.been.called
 
-    sinon.stub(chokidar, 'watch').callsFake(() => {
-      const mockWatcher = {
-        on: onStub,
-        close: () => ({ catch: () => {} }),
-      } as unknown
+      expect(chokidar.watch).to.have.not.been.called
 
-      return mockWatcher as chokidar.FSWatcher
+      expect(onStub).to.have.not.been.called
     })
+  })
 
-    let handleFsChange
-
-    sinon.stub(_, 'debounce').callsFake((funcToDebounce) => {
-      handleFsChange = (() => funcToDebounce())
+  describe('open mode', () => {
+    beforeEach(async () => {
+      ctx = createTestDataContext('open')
 
-      return handleFsChange as _.DebouncedFunc<any>
+      ctx.coreData.currentProject = projectRoot
     })
 
-    ctx.project.startSpecWatcher({
-      projectRoot,
-      testingType: 'e2e',
-      specPattern: ['**/*.{cy,spec}.{ts,js}'],
-      configSpecPattern: ['**/*.{cy,spec}.{ts,js}'],
-      excludeSpecPattern: ['**/ignore.spec.ts'],
-      additionalIgnorePattern: ['additional.ignore.cy.js'],
+    it('throws if no current project defined', () => {
+      ctx.coreData.currentProject = null
+
+      expect(() => {
+        return ctx.project.startSpecWatcher({
+          projectRoot,
+          testingType: 'e2e',
+          specPattern: ['**/*.{cy,spec}.{ts,js}'],
+          configSpecPattern: ['**/*.{cy,spec}.{ts,js}'],
+          excludeSpecPattern: ['**/ignore.spec.ts'],
+          additionalIgnorePattern: [],
+        })
+      }).to.throw()
     })
 
-    expect(_.debounce).to.have.been.calledWith(sinon.match.func, 250)
+    it('creates file watcher based on given config properties', () => {
+      const onStub = sinon.stub()
 
-    expect(chokidar.watch).to.have.been.calledWith('.', {
-      ignoreInitial: true,
-      cwd: projectRoot,
-      ignored: ['**/node_modules/**', '**/ignore.spec.ts', 'additional.ignore.cy.js'],
-      ignorePermissionErrors: true,
-    })
+      sinon.stub(chokidar, 'watch').callsFake(() => {
+        const mockWatcher = {
+          on: onStub,
+          close: () => ({ catch: () => {} }),
+        } as unknown
 
-    expect(onStub).to.have.been.calledWith('all', handleFsChange)
-  })
+        return mockWatcher as chokidar.FSWatcher
+      })
 
-  it('implements change handler with duplicate result handling', async () => {
-    const mockFoundSpecs = [
-      { name: 'test-1.cy.js' },
-      { name: 'test-2.cy.js' },
-      { name: 'test-3.cy.js' },
-    ] as FoundSpec[]
+      let handleFsChange
 
-    sinon.stub(ctx.project, 'findSpecs').resolves(mockFoundSpecs)
-    sinon.stub(ctx.actions.project, 'setSpecs')
+      sinon.stub(_, 'debounce').callsFake((funcToDebounce) => {
+        handleFsChange = (() => funcToDebounce())
 
-    sinon.stub(chokidar, 'watch').callsFake(() => {
-      const mockWatcher = {
-        on: () => {},
-        close: () => ({ catch: () => {} }),
-      } as unknown
+        return handleFsChange as _.DebouncedFunc<any>
+      })
 
-      return mockWatcher as chokidar.FSWatcher
-    })
+      ctx.project.startSpecWatcher({
+        projectRoot,
+        testingType: 'e2e',
+        specPattern: ['**/*.{cy,spec}.{ts,js}'],
+        configSpecPattern: ['**/*.{cy,spec}.{ts,js}'],
+        excludeSpecPattern: ['**/ignore.spec.ts'],
+        additionalIgnorePattern: ['additional.ignore.cy.js'],
+      })
 
-    let handleFsChange
+      expect(_.debounce).to.have.been.calledWith(sinon.match.func, 250)
 
-    sinon.stub(_, 'debounce').callsFake((funcToDebounce) => {
-      handleFsChange = (() => funcToDebounce())
+      expect(chokidar.watch).to.have.been.calledWith('.', {
+        ignoreInitial: true,
+        cwd: projectRoot,
+        ignored: ['**/node_modules/**', '**/ignore.spec.ts', 'additional.ignore.cy.js'],
+        ignorePermissionErrors: true,
+      })
 
-      return handleFsChange as _.DebouncedFunc<any>
+      expect(onStub).to.have.been.calledWith('all', handleFsChange)
     })
 
-    const watchOptions: FindSpecs<string[]> = {
-      projectRoot,
-      testingType: 'e2e',
-      specPattern: ['**/*.{cy,spec}.{ts,js}'],
-      configSpecPattern: ['**/ignore.spec.ts'],
-      excludeSpecPattern: ['additional.ignore.cy.js'],
-      additionalIgnorePattern: [],
-    }
+    it('implements change handler with duplicate result handling', async () => {
+      const mockFoundSpecs = [
+        { name: 'test-1.cy.js' },
+        { name: 'test-2.cy.js' },
+        { name: 'test-3.cy.js' },
+      ] as FoundSpec[]
 
-    ctx.project.startSpecWatcher(watchOptions)
+      sinon.stub(ctx.project, 'findSpecs').resolves(mockFoundSpecs)
+      sinon.stub(ctx.actions.project, 'setSpecs')
 
-    // Set internal specs state to the stubbed found value to simulate irrelevant FS changes
-    ctx.project.setSpecs(mockFoundSpecs)
+      sinon.stub(chokidar, 'watch').callsFake(() => {
+        const mockWatcher = {
+          on: () => {},
+          close: () => ({ catch: () => {} }),
+        } as unknown
 
-    await handleFsChange()
+        return mockWatcher as chokidar.FSWatcher
+      })
 
-    expect(ctx.project.findSpecs).to.have.been.calledWith(watchOptions)
-    expect(ctx.actions.project.setSpecs).not.to.have.been.called
+      let handleFsChange
 
-    // Update internal specs state so that a change will be detected on next FS event
-    const updatedSpecs = [...mockFoundSpecs, { name: 'test-4.cy.js' }] as FoundSpec[]
+      sinon.stub(_, 'debounce').callsFake((funcToDebounce) => {
+        handleFsChange = (() => funcToDebounce())
 
-    ctx.project.setSpecs(updatedSpecs)
+        return handleFsChange as _.DebouncedFunc<any>
+      })
+
+      const watchOptions: FindSpecs<string[]> = {
+        projectRoot,
+        testingType: 'e2e',
+        specPattern: ['**/*.{cy,spec}.{ts,js}'],
+        configSpecPattern: ['**/ignore.spec.ts'],
+        excludeSpecPattern: ['additional.ignore.cy.js'],
+        additionalIgnorePattern: [],
+      }
+
+      ctx.project.startSpecWatcher(watchOptions)
 
-    await handleFsChange()
+      // Set internal specs state to the stubbed found value to simulate irrelevant FS changes
+      ctx.project.setSpecs(mockFoundSpecs)
 
-    expect(ctx.project.findSpecs).to.have.been.calledWith(watchOptions)
-    expect(ctx.actions.project.setSpecs).to.have.been.calledWith(mockFoundSpecs)
+      await handleFsChange()
+
+      expect(ctx.project.findSpecs).to.have.been.calledWith(watchOptions)
+      expect(ctx.actions.project.setSpecs).not.to.have.been.called
+
+      // Update internal specs state so that a change will be detected on next FS event
+      const updatedSpecs = [...mockFoundSpecs, { name: 'test-4.cy.js' }] as FoundSpec[]
+
+      ctx.project.setSpecs(updatedSpecs)
+
+      await handleFsChange()
+
+      expect(ctx.project.findSpecs).to.have.been.calledWith(watchOptions)
+      expect(ctx.actions.project.setSpecs).to.have.been.calledWith(mockFoundSpecs)
+    })
   })
 })