Merge branch 'cypress-io:develop' into feat/sticky-header-gradient-experimental-studio

Author: omareltomy

.circleci/src/workflows/@workflows.yml

@@ -1784,7 +1784,7 @@ jobs:
                   source ./scripts/ensure-node.sh
                   yarn lerna run types
             - sanitize-verify-and-store-mocha-results:
-                expectedResultCount: 17
+                expectedResultCount: 15
 
   verify-release-readiness:
     <<: *defaults

.circleci/workflows.yml

@@ -3486,7 +3486,7 @@ jobs:
                   yarn lerna run types
                 name: Test types
             - sanitize-verify-and-store-mocha-results:
-                expectedResultCount: 16
+                expectedResultCount: 15
     working_directory: ~/cypress
   v8-integration-tests:
     environment:

guides/esm-migration.md

@@ -106,7 +106,7 @@
 - [ ] packages/server
 - [ ] packages/socket
 - [x] packages/stderr-filtering ✅ **COMPLETED**
-- [ ] packages/telemetry
+- [x] packages/telemetry ✅ **COMPLETED**
 - [ ] packages/ts - ultimate goal is removal and likely not worth the effort to convert
 - [x] packages/types ✅ **COMPLETED**
 - [ ] packages/v8-snapshot-require

packages/telemetry/package.json

@@ -10,7 +10,8 @@
     "check-ts": "tsc --noEmit && yarn -s tslint",
     "clean": "rimraf dist",
     "test": "yarn test-unit",
-    "test-unit": "mocha --config ./test/.mocharc.js",
+    "test-debug": "vitest --inspect-brk --no-file-parallelism --test-timeout=0",
+    "test-unit": "vitest run",
     "tslint": "tslint --config ../ts/tslint.json --project .",
     "watch": "tsc --watch"
   },
@@ -27,7 +28,7 @@
   },
   "devDependencies": {
     "@packages/ts": "0.0.0-development",
-    "mocha": "7.0.1"
+    "vitest": "^3.2.4"
   },
   "files": [
     "dist",

packages/telemetry/test/.mocharc.js

@@ -1,83 +1,83 @@
 // @ts-expect-error
 global.window = {}
 
-import { expect } from 'chai'
-
+import { describe, it, expect, beforeAll } from 'vitest'
 import { telemetry } from '../src/browser'
-
 import { Telemetry as TelemetryClass } from '../src/index'
 
 describe('telemetry is disabled', () => {
   describe('init', () => {
     it('does not throw', () => {
-      expect(telemetry.init({
-        namespace: 'namespace',
-        config: { version: 'version' },
-      })).to.not.throw
+      expect(() => {
+        telemetry.init({
+          namespace: 'namespace',
+          config: { version: 'version' },
+        })
+      }).not.toThrow()
 
-      expect(window.cypressTelemetrySingleton).to.be.undefined
+      expect(window.cypressTelemetrySingleton).toBeUndefined()
     })
   })
 
   describe('attach', () => {
     it('returns void', () => {
-      expect(telemetry.attach()).to.not.throw
+      expect(() => telemetry.attach()).not.toThrow()
     })
   })
 
   describe('startSpan', () => {
     it('returns undefined', () => {
-      expect(telemetry.startSpan({ name: 'nope' })).to.be.undefined
+      expect(telemetry.startSpan({ name: 'nope' })).toBeUndefined()
     })
   })
 
   describe('getSpan', () => {
     it('returns undefined', () => {
-      expect(telemetry.getSpan('nope')).to.be.undefined
+      expect(telemetry.getSpan('nope')).toBeUndefined()
     })
   })
 
   describe('findActiveSpan', () => {
     it('returns undefined', () => {
-      expect(telemetry.findActiveSpan((span) => true)).to.be.undefined
+      expect(telemetry.findActiveSpan((span) => true)).toBeUndefined()
     })
   })
 
   describe('endActiveSpanAndChildren', () => {
     it('does not throw', () => {
       const spanny = telemetry.startSpan({ name: 'active', active: true })
 
-      expect(telemetry.endActiveSpanAndChildren(spanny)).to.not.throw
+      expect(() => telemetry.endActiveSpanAndChildren(spanny)).not.toThrow()
     })
   })
 
   describe('getActiveContextObject', () => {
     it('returns an empty object', () => {
-      expect(telemetry.getActiveContextObject().context).to.be.undefined
+      expect(telemetry.getActiveContextObject().context).toBeUndefined()
     })
   })
 
   describe('shutdown', () => {
     it('does not throw', () => {
-      expect(telemetry.shutdown()).to.not.throw
+      expect(() => telemetry.shutdown()).not.toThrow()
     })
   })
 
   describe('attachWebSocket', () => {
     it('does not throw', () => {
-      expect(telemetry.attachWebSocket('s')).to.not.throw
+      expect(() => telemetry.attachWebSocket('s')).not.toThrow()
     })
   })
 
   describe('setRootContext', () => {
     it('does not throw', () => {
-      expect(telemetry.setRootContext()).to.not.throw
+      expect(() => telemetry.setRootContext()).not.toThrow()
     })
   })
 })
 
 describe('telemetry is enabled', () => {
-  before('init', () => {
+  beforeAll(() => {
     // @ts-expect-error
     global.window.__CYPRESS_TELEMETRY__ = {
       context: {
@@ -91,41 +91,43 @@ describe('telemetry is enabled', () => {
       isVerbose: false,
     }
 
-    expect(telemetry.init({
-      namespace: 'namespace',
-      config: { version: 'version' },
-    })).to.not.throw
+    expect(() => {
+      telemetry.init({
+        namespace: 'namespace',
+        config: { version: 'version' },
+      })
+    }).not.toThrow()
 
-    expect(window.cypressTelemetrySingleton).to.be.instanceOf(TelemetryClass)
-    expect(window.cypressTelemetrySingleton.getResources()).to.contain({ herp: 'derp' })
+    expect(window.cypressTelemetrySingleton).toBeInstanceOf(TelemetryClass)
+    expect(window.cypressTelemetrySingleton.getResources()).toEqual(expect.objectContaining({ herp: 'derp' }))
   })
 
   describe('attachWebSocket', () => {
     it('returns true', () => {
       telemetry.attachWebSocket('ws')
 
-      expect(window.cypressTelemetrySingleton?.getExporter()?.ws).to.equal('ws')
+      expect(window.cypressTelemetrySingleton?.getExporter()?.ws).toEqual('ws')
     })
   })
 
   describe('startSpan', () => {
     it('returns undefined', () => {
-      expect(telemetry.startSpan({ name: 'nope' })).to.exist
+      expect(telemetry.startSpan({ name: 'nope' })).toBeDefined()
     })
   })
 
   describe('getSpan', () => {
     it('returns undefined', () => {
       telemetry.startSpan({ name: 'nope' })
-      expect(telemetry.getSpan('nope')).to.be.exist
+      expect(telemetry.getSpan('nope')).toBeDefined()
     })
   })
 
   describe('findActiveSpan', () => {
     it('returns undefined', () => {
       const spanny = telemetry.startSpan({ name: 'active', active: true })
 
-      expect(telemetry.findActiveSpan((span) => true)).to.be.exist
+      expect(telemetry.findActiveSpan((span) => true)).toBeDefined()
       spanny?.end()
     })
   })
@@ -134,24 +136,24 @@ describe('telemetry is enabled', () => {
     it('does not throw', () => {
       const spanny = telemetry.startSpan({ name: 'active', active: true })
 
-      expect(telemetry.endActiveSpanAndChildren(spanny)).to.not.throw
+      expect(() => telemetry.endActiveSpanAndChildren(spanny)).not.toThrow()
 
-      expect(telemetry.getActiveContextObject().context).to.be.undefined
+      expect(telemetry.getActiveContextObject().context).toBeUndefined()
     })
   })
 
   describe('getActiveContextObject', () => {
     it('returns an empty object', () => {
       const spanny = telemetry.startSpan({ name: 'active', active: true })
 
-      expect(telemetry.getActiveContextObject().context.traceparent).to.exist
+      expect(telemetry.getActiveContextObject().context.traceparent).toBeDefined()
       spanny?.end()
     })
   })
 
   describe('shutdown', () => {
     it('does not throw', () => {
-      expect(telemetry.shutdown()).to.not.throw
+      expect(() => telemetry.shutdown()).not.toThrow()
     })
   })
 
@@ -163,20 +165,24 @@ describe('telemetry is enabled', () => {
           config: { version: 'version' },
         })
       } catch (err) {
-        expect(err).to.equal('Telemetry instance has already be initialized')
+        expect(err).toEqual('Telemetry instance has already be initialized')
+
+        return
       }
+
+      throw 'should not be called'
     })
   })
 
   describe('setRootContext', () => {
     it('it sets the context', () => {
       // @ts-expect-error
-      expect(window.cypressTelemetrySingleton?.rootContext?.getValue(Symbol.for('OpenTelemetry Context Key SPAN'))._spanContext.spanId).to.equal('4ad8bd26672a01b0')
+      expect(window.cypressTelemetrySingleton?.rootContext?.getValue(Symbol.for('OpenTelemetry Context Key SPAN'))._spanContext.spanId).toEqual('4ad8bd26672a01b0')
 
       telemetry.setRootContext({ context: { traceparent: '00-a14c8519972996a2a0748f2c8db5a775-4ad8bd26672a01b1-01' } })
 
       // @ts-expect-error
-      expect(window.cypressTelemetrySingleton?.rootContext?.getValue(Symbol.for('OpenTelemetry Context Key SPAN'))._spanContext.spanId).to.equal('4ad8bd26672a01b1')
+      expect(window.cypressTelemetrySingleton?.rootContext?.getValue(Symbol.for('OpenTelemetry Context Key SPAN'))._spanContext.spanId).toEqual('4ad8bd26672a01b1')
     })
   })
 })