@openobserve/browser-core 0.3.2 → 0.3.3

package/src/domain/error/trackRuntimeError.spec.ts

@@ -1,343 +0,0 @@
-import { disableJasmineUncaughtExceptionTracking, wait } from '../../../test'
-import type { UnhandledErrorCallback } from './trackRuntimeError'
-import { instrumentOnError, instrumentUnhandledRejection, trackRuntimeError } from './trackRuntimeError'
-import type { RawError } from './error.types'
-
-describe('trackRuntimeError', () => {
-  const ERROR_MESSAGE = 'foo'
-
-  const errorViaTrackRuntimeError = async (callback: () => void): Promise<RawError> => {
-    disableJasmineUncaughtExceptionTracking()
-
-    const errorObservable = trackRuntimeError()
-    const errorNotification = new Promise<RawError>((resolve) => {
-      errorObservable.subscribe((e: RawError) => resolve(e))
-    })
-
-    try {
-      await invokeAndWaitForErrorHandlers(callback)
-      return await errorNotification
-    } finally {
-      stop()
-    }
-  }
-
-  it('should collect unhandled error', async () => {
-    const error = await errorViaTrackRuntimeError(() => {
-      throw new Error(ERROR_MESSAGE)
-    })
-    expect(error.message).toEqual(ERROR_MESSAGE)
-  })
-
-  it('should collect unhandled rejection', async () => {
-    if (!('onunhandledrejection' in window)) {
-      pending('onunhandledrejection not supported')
-    }
-
-    const error = await errorViaTrackRuntimeError(() => {
-      // Reject with a string instead of an Error here because Jasmine forwards the
-      // unhandled rejection to the onerror handler with the wrong argument structure if
-      // you use an Error. (It uses the argument structure you'd use for
-      // addEventListener('error'). We could make our error processing code robust to
-      // that, but since it's a Jasmine-specific issue with a simple workaround, it makes
-      // sense to just work around it here.
-      // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-      void Promise.reject(ERROR_MESSAGE)
-    })
-    expect(error.message).toEqual(jasmine.stringContaining(ERROR_MESSAGE))
-  })
-})
-
-describe('instrumentOnError', () => {
-  const testLineNo = 1337
-  const testColNo = 42
-  const ERROR_MESSAGE = 'foo'
-
-  const spyViaInstrumentOnError = async (callback: () => void) => {
-    const onErrorSpy = spyOn(window as any, 'onerror')
-    const callbackSpy = jasmine.createSpy<UnhandledErrorCallback>()
-    const { stop } = instrumentOnError(callbackSpy)
-
-    try {
-      await invokeAndWaitForErrorHandlers(callback)
-      expect(onErrorSpy).toHaveBeenCalled()
-      return callbackSpy
-    } finally {
-      stop()
-    }
-  }
-
-  it('should call original error handler', async () => {
-    // withInstrumentOnError() asserts that the original error handler has been called for
-    // every test, so we don't need an explicit expectation here.
-    await spyViaInstrumentOnError(() => {
-      throw new Error(ERROR_MESSAGE)
-    })
-  })
-
-  it('should notify unhandled error instance', async () => {
-    const error = new Error(ERROR_MESSAGE)
-    const spy = await spyViaInstrumentOnError(() => {
-      throw error
-    })
-
-    const [originalError, stack] = spy.calls.mostRecent().args
-    expect(originalError).toBe(error)
-    expect(stack).toBeUndefined()
-  })
-
-  it('should notify unhandled string', async () => {
-    const error = 'foo' as any
-    const spy = await spyViaInstrumentOnError(() => {
-      throw error
-    })
-
-    const [originalError, stack] = spy.calls.mostRecent().args
-    expect(originalError).toBe(error)
-    expect(stack).toBeDefined()
-  })
-
-  it('should notify unhandled object', async () => {
-    const error = { a: 'foo' } as any
-    const spy = await spyViaInstrumentOnError(() => {
-      throw error
-    })
-
-    const [originalError, stack] = spy.calls.mostRecent().args
-    expect(originalError).toBe(error)
-    expect(stack).toBeDefined()
-  })
-
-  describe('uncaught exception handling', () => {
-    it('should not go into an infinite loop', async () => {
-      const spy = await spyViaInstrumentOnError(() => {
-        throw new Error('expected error')
-      })
-
-      expect(spy).toHaveBeenCalledTimes(1)
-      await wait(1000)
-      expect(spy).toHaveBeenCalledTimes(1)
-    })
-
-    it('should get extra arguments (isWindowError and exception)', async () => {
-      const exception = new Error('expected error')
-      const spy = await spyViaInstrumentOnError(() => {
-        throw exception
-      })
-
-      expect(spy).toHaveBeenCalledTimes(1)
-      await wait(1000)
-      expect(spy).toHaveBeenCalledTimes(1)
-      const [reportedError] = spy.calls.mostRecent().args
-      expect(reportedError).toEqual(exception)
-    })
-  })
-
-  describe('should handle direct onerror calls', () => {
-    it('with objects', async () => {
-      const error = { foo: 'bar' } as any
-      const spy = await spyViaInstrumentOnError(() => {
-        window.onerror!(error, 'http://example.com', testLineNo, testColNo)
-      })
-
-      const [originalError, stack] = spy.calls.mostRecent().args
-      expect(originalError).toBe(error)
-      expect(stack).toBeDefined()
-    })
-
-    describe('with undefined arguments', () => {
-      it('discards the stack', async () => {
-        // this is probably not good behavior;  just writing this test to verify
-        // that it doesn't change unintentionally
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!(undefined!, undefined, testLineNo)
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack).toBeUndefined()
-      })
-    })
-
-    describe('when no 5th argument (error object)', () => {
-      it('should separate name, message for default error types (e.g. ReferenceError)', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!('ReferenceError: foo is undefined', 'http://example.com', testLineNo)
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.name).toEqual('ReferenceError')
-        expect(stack!.message).toEqual('foo is undefined')
-      })
-
-      it('should separate name, message for default error types (e.g. Uncaught ReferenceError)', async () => {
-        // should work with/without 'Uncaught'
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!('Uncaught ReferenceError: foo is undefined', 'http://example.com', testLineNo)
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.name).toEqual('ReferenceError')
-        expect(stack!.message).toEqual('foo is undefined')
-      })
-
-      it('should separate name, message for default error types on Opera Mini', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!(
-            'Uncaught exception: ReferenceError: Undefined variable: foo',
-            'http://example.com',
-            testLineNo
-          )
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.name).toEqual('ReferenceError')
-        expect(stack!.message).toEqual('Undefined variable: foo')
-      })
-
-      it('should separate name, message for error with multiline message', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!(
-            "TypeError: foo is not a function. (In 'my.function(\n foo)",
-            'http://example.com',
-            testLineNo
-          )
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.message).toEqual("foo is not a function. (In 'my.function(\n foo)")
-        expect(stack!.name).toEqual('TypeError')
-      })
-
-      it('should ignore unknown error types', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!('CustomError: woo scary', 'http://example.com', testLineNo)
-        })
-
-        // TODO: should we attempt to parse this?
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.name).toEqual(undefined)
-        expect(stack!.message).toEqual('CustomError: woo scary')
-      })
-
-      it('should ignore arbitrary messages passed through onerror', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!('all work and no play makes homer: something something', 'http://example.com', testLineNo)
-        })
-
-        const [, stack] = spy.calls.mostRecent().args
-        expect(stack!.name).toEqual(undefined)
-        expect(stack!.message).toEqual('all work and no play makes homer: something something')
-      })
-
-      it('should handle object message passed through onerror', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!({ foo: 'bar' } as any, 'http://example.com', testLineNo, testColNo)
-        })
-
-        const [error, stack] = spy.calls.mostRecent().args
-        expect(stack!.message).toBeUndefined()
-        expect(error).toEqual({ foo: 'bar' }) // consider the message as initial error
-      })
-    })
-
-    describe('when 5th argument (errorObj) is not of type Error', () => {
-      it('should handle strings', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!(
-            'Any error message',
-            'https://example.com',
-            testLineNo,
-            testColNo,
-            'Actual Error Message' as any
-          )
-        })
-
-        const [error, stack] = spy.calls.mostRecent().args
-        expect(stack!.message).toBe('Any error message')
-        expect(stack!.stack).toEqual([{ url: 'https://example.com', column: testColNo, line: testLineNo }])
-        expect(error).toEqual('Actual Error Message')
-      })
-
-      it('should handle objects', async () => {
-        const spy = await spyViaInstrumentOnError(() => {
-          window.onerror!('Any error message', 'https://example.com', testLineNo, testColNo, {
-            message: 'SyntaxError',
-            data: 'foo',
-          } as any)
-        })
-
-        const [error, stack] = spy.calls.mostRecent().args
-        expect(stack!.message).toBe('Any error message')
-        expect(stack!.stack).toEqual([{ url: 'https://example.com', column: testColNo, line: testLineNo }])
-        expect(error).toEqual({ message: 'SyntaxError', data: 'foo' })
-      })
-    })
-  })
-})
-
-describe('instrumentUnhandledRejection', () => {
-  const ERROR_MESSAGE = 'foo'
-
-  const spyViaInstrumentOnUnhandledRejection = async (callback: () => void) => {
-    if (!('onunhandledrejection' in window)) {
-      pending('onunhandledrejection not supported')
-    }
-
-    const onUnhandledRejectionSpy = spyOn(window as any, 'onunhandledrejection')
-    const callbackSpy = jasmine.createSpy<UnhandledErrorCallback>()
-    const { stop } = instrumentUnhandledRejection(callbackSpy)
-
-    try {
-      await invokeAndWaitForErrorHandlers(callback)
-      expect(onUnhandledRejectionSpy).toHaveBeenCalled()
-      return callbackSpy
-    } finally {
-      stop()
-    }
-  }
-
-  it('should call original unhandled rejection handler', async () => {
-    // withInstrumentOnUnhandledRejection() asserts that the original unhandled
-    // rejection handler has been called for every test, so we don't need an
-    // explicit expectation here.
-    await spyViaInstrumentOnUnhandledRejection(() => {
-      window.onunhandledrejection!({
-        reason: new Error(ERROR_MESSAGE),
-      } as PromiseRejectionEvent)
-    })
-  })
-
-  it('should notify unhandled rejection', async () => {
-    const reason = new Error(ERROR_MESSAGE)
-    const spy = await spyViaInstrumentOnUnhandledRejection(() => {
-      window.onunhandledrejection!({ reason } as PromiseRejectionEvent)
-    })
-
-    const [originalError, stack] = spy.calls.mostRecent().args
-    expect(originalError).toBe(reason)
-    expect(stack).toBeUndefined()
-  })
-})
-
-/**
- * Invokes the given callback, which is expected to be a function that throws or generates
- * an unhandled promise rejection, and returns a promise that resolves after the callback
- * has finished running and any global error handlers that run as a result are complete.
- */
-function invokeAndWaitForErrorHandlers(callback: () => void): Promise<void> {
-  return new Promise<void>((resolve) => {
-    setTimeout(() => {
-      try {
-        // Invoke the callback.
-        callback()
-      } finally {
-        // The callback has generated an error here, but global error handlers
-        // have not yet run. The global unhandledrejection handler will run at
-        // the end of the next microtask checkpoint; the global error handler
-        // will run in a later macrotask. So, schedule a new task to resolve
-        // the promise after both of those things have happened.
-        setTimeout(resolve)
-      }
-    })
-  })
-}

package/src/domain/eventRateLimiter/createEventRateLimiter.spec.ts

@@ -1,119 +0,0 @@
-import type { Clock } from '../../../test'
-import { mockClock } from '../../../test'
-import { relativeToClocks, ONE_MINUTE } from '../../tools/utils/timeUtils'
-import { noop } from '../../tools/utils/functionUtils'
-import type { RawError } from '../error/error.types'
-import { createEventRateLimiter } from './createEventRateLimiter'
-import type { EventRateLimiter } from './createEventRateLimiter'
-
-describe('createEventRateLimiter', () => {
-  let eventLimiter: EventRateLimiter | undefined
-  let clock: Clock
-  const limit = 1
-  beforeEach(() => {
-    clock = mockClock()
-  })
-
-  it('returns false if the limit is not reached', () => {
-    eventLimiter = createEventRateLimiter('error', noop, limit)
-
-    expect(eventLimiter.isLimitReached()).toBe(false)
-  })
-
-  it('returns true if the limit is reached', () => {
-    eventLimiter = createEventRateLimiter('error', noop, limit)
-
-    eventLimiter.isLimitReached()
-    expect(eventLimiter.isLimitReached()).toBe(true)
-  })
-
-  it('returns false again when one minute is passed after the first counted error', () => {
-    eventLimiter = createEventRateLimiter('error', noop, limit)
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    clock.tick(ONE_MINUTE)
-    expect(eventLimiter.isLimitReached()).toBe(false)
-  })
-
-  it('calls the "onLimitReached" callback with the raw "limit reached" error when the limit is reached', () => {
-    const onLimitReachedSpy = jasmine.createSpy<(rawError: RawError) => void>()
-    eventLimiter = createEventRateLimiter('error', onLimitReachedSpy, limit)
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    expect(onLimitReachedSpy).toHaveBeenCalledOnceWith({
-      message: 'Reached max number of errors by minute: 1',
-      source: 'agent',
-      startClocks: relativeToClocks(clock.relative(0)),
-    })
-  })
-
-  it('returns false when called from the "onLimitReached" callback to bypass the limit for the "limit reached" error', () => {
-    eventLimiter = createEventRateLimiter(
-      'error',
-      () => {
-        expect(eventLimiter!.isLimitReached()).toBe(false)
-      },
-      limit
-    )
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-  })
-
-  it('does not call the "onLimitReached" callback more than once when the limit is reached', () => {
-    const onLimitReachedSpy = jasmine.createSpy<(rawError: RawError) => void>()
-    eventLimiter = createEventRateLimiter('error', onLimitReachedSpy, limit)
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    expect(onLimitReachedSpy).toHaveBeenCalledTimes(1)
-  })
-
-  it('returns true after reaching the limit even if the "onLimitReached" callback throws', () => {
-    eventLimiter = createEventRateLimiter(
-      'error',
-      () => {
-        throw new Error('oops')
-      },
-      limit
-    )
-
-    eventLimiter.isLimitReached()
-    expect(() => eventLimiter!.isLimitReached()).toThrow()
-    expect(eventLimiter.isLimitReached()).toBe(true)
-    expect(eventLimiter.isLimitReached()).toBe(true)
-  })
-
-  it('returns true when the limit is reached and the "onLimitReached" callback does not call "isLimitReached" (ex: excluded by beforeSend)', () => {
-    eventLimiter = createEventRateLimiter(
-      'error',
-      () => {
-        // do not call isLimitReached
-      },
-      limit
-    )
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-    expect(eventLimiter.isLimitReached()).toBe(true)
-  })
-
-  it('returns false only once when called from the "onLimitReached" callback (edge case)', () => {
-    eventLimiter = createEventRateLimiter(
-      'error',
-      () => {
-        expect(eventLimiter!.isLimitReached()).toBe(false)
-        expect(eventLimiter!.isLimitReached()).toBe(true)
-      },
-      limit
-    )
-
-    eventLimiter.isLimitReached()
-    eventLimiter.isLimitReached()
-  })
-})

package/src/domain/extension/extensionUtils.spec.ts

@@ -1,47 +0,0 @@
-import {
-  STACK_WITH_INIT_IN_EXTENSION,
-  STACK_WITH_INIT_IN_EXTENSION_FIREFOX,
-  STACK_WITH_INIT_IN_PAGE,
-} from '../../../test'
-import { containsExtensionUrl, EXTENSION_PREFIXES, isUnsupportedExtensionEnvironment } from './extensionUtils'
-
-describe('extensionUtils', () => {
-  describe('containsExtensionUrl', () => {
-    it('should return true if string contains an extension URL', () => {
-      EXTENSION_PREFIXES.forEach((prefix) => {
-        expect(containsExtensionUrl(`${prefix}some/path`)).toBe(true)
-      })
-    })
-
-    it('should return false if string does not contain extension URL', () => {
-      expect(containsExtensionUrl('https://example.com')).toBe(false)
-      expect(containsExtensionUrl('')).toBe(false)
-    })
-  })
-
-  describe('isUnsupportedExtensionEnvironment', () => {
-    it('should return true when window location is a regular URL and error stack init is in an extension', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com', STACK_WITH_INIT_IN_EXTENSION)).toBe(true)
-    })
-
-    it('should return false when both window location and error stack init are regular URLs', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com', STACK_WITH_INIT_IN_PAGE)).toBe(false)
-    })
-
-    it('should return false when error stack is empty', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com', '')).toBe(false)
-    })
-
-    it('should handle each extension prefix in firefox', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com', STACK_WITH_INIT_IN_EXTENSION_FIREFOX)).toBe(true)
-    })
-
-    it('should handle case when stack trace is undefined', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com')).toBe(false)
-    })
-
-    it('should handle extension stack trace', () => {
-      expect(isUnsupportedExtensionEnvironment('https://example.com', STACK_WITH_INIT_IN_EXTENSION)).toBe(true)
-    })
-  })
-})

package/src/domain/report/reportObservable.spec.ts

@@ -1,71 +0,0 @@
-import type { MockCspEventListener, MockReportingObserver } from '../../../test'
-import { mockReportingObserver, mockCspEventListener, FAKE_CSP_VIOLATION_EVENT } from '../../../test'
-import type { Subscription } from '../../tools/observable'
-import type { Configuration } from '../configuration'
-import { ErrorHandling, ErrorSource } from '../error/error.types'
-import type { RawReportError } from './reportObservable'
-import { initReportObservable, RawReportType } from './reportObservable'
-
-describe('report observable', () => {
-  let reportingObserver: MockReportingObserver
-  let cspEventListener: MockCspEventListener
-  let consoleSubscription: Subscription
-  let notifyReport: jasmine.Spy<(reportError: RawReportError) => void>
-  let configuration: Configuration
-
-  beforeEach(() => {
-    if (!window.ReportingObserver) {
-      pending('ReportingObserver not supported')
-    }
-    configuration = {} as Configuration
-    reportingObserver = mockReportingObserver()
-    cspEventListener = mockCspEventListener()
-    notifyReport = jasmine.createSpy('notifyReport')
-  })
-
-  afterEach(() => {
-    consoleSubscription?.unsubscribe()
-  })
-  ;[RawReportType.deprecation, RawReportType.intervention].forEach((type) => {
-    it(`should notify ${type} reports`, () => {
-      consoleSubscription = initReportObservable(configuration, [type]).subscribe(notifyReport)
-      reportingObserver.raiseReport(type)
-
-      const [report] = notifyReport.calls.mostRecent().args
-
-      expect(report).toEqual(
-        jasmine.objectContaining({
-          message: `${type}: foo bar`,
-          type: 'NavigatorVibrate',
-        })
-      )
-    })
-  })
-
-  it(`should compute stack for ${RawReportType.intervention}`, () => {
-    consoleSubscription = initReportObservable(configuration, [RawReportType.intervention]).subscribe(notifyReport)
-    reportingObserver.raiseReport(RawReportType.intervention)
-
-    const [report] = notifyReport.calls.mostRecent().args
-
-    expect(report.stack).toEqual(`NavigatorVibrate: foo bar
-  at <anonymous> @ http://foo.bar/index.js:20:10`)
-  })
-
-  it(`should notify ${RawReportType.cspViolation}`, () => {
-    consoleSubscription = initReportObservable(configuration, [RawReportType.cspViolation]).subscribe(notifyReport)
-    cspEventListener.dispatchEvent()
-
-    expect(notifyReport).toHaveBeenCalledOnceWith({
-      startClocks: jasmine.any(Object),
-      source: ErrorSource.REPORT,
-      message: "csp_violation: 'blob' blocked by 'worker-src' directive",
-      type: 'worker-src',
-      originalError: FAKE_CSP_VIOLATION_EVENT,
-      stack: `worker-src: 'blob' blocked by 'worker-src' directive of the policy "worker-src 'none'"
-  at <anonymous> @ http://foo.bar/index.js:17:8`,
-      handling: ErrorHandling.UNHANDLED,
-      csp: { disposition: 'enforce' },
-    })
-  })
-})

package/src/domain/session/oldCookiesMigration.spec.ts

@@ -1,76 +0,0 @@
-import { getCookie, resetInitCookies, setCookie } from '../../browser/cookie'
-import { getSessionState } from '../../../test'
-import type { Configuration } from '../configuration'
-import {
-  OLD_LOGS_COOKIE_NAME,
-  OLD_RUM_COOKIE_NAME,
-  OLD_SESSION_COOKIE_NAME,
-  tryOldCookiesMigration,
-} from './oldCookiesMigration'
-import { SESSION_EXPIRATION_DELAY } from './sessionConstants'
-import { initCookieStrategy } from './storeStrategies/sessionInCookie'
-import type { SessionStoreStrategy } from './storeStrategies/sessionStoreStrategy'
-import { SESSION_STORE_KEY } from './storeStrategies/sessionStoreStrategy'
-const DEFAULT_INIT_CONFIGURATION = { trackAnonymousUser: true } as Configuration
-
-describe('old cookies migration', () => {
-  let sessionStoreStrategy: SessionStoreStrategy
-
-  beforeEach(() => {
-    sessionStoreStrategy = initCookieStrategy(DEFAULT_INIT_CONFIGURATION, {})
-    resetInitCookies()
-  })
-
-  afterEach(() => {
-    resetInitCookies()
-  })
-
-  it('should not touch current cookie', () => {
-    setCookie(SESSION_STORE_KEY, 'id=abcde&rum=0&logs=1&expire=1234567890', SESSION_EXPIRATION_DELAY)
-
-    tryOldCookiesMigration(sessionStoreStrategy)
-
-    expect(getCookie(SESSION_STORE_KEY)).toBe('id=abcde&rum=0&logs=1&expire=1234567890')
-  })
-
-  it('should create new cookie from old cookie values', () => {
-    setCookie(OLD_SESSION_COOKIE_NAME, 'abcde', SESSION_EXPIRATION_DELAY)
-    setCookie(OLD_LOGS_COOKIE_NAME, '1', SESSION_EXPIRATION_DELAY)
-    setCookie(OLD_RUM_COOKIE_NAME, '0', SESSION_EXPIRATION_DELAY)
-
-    tryOldCookiesMigration(sessionStoreStrategy)
-
-    expect(getSessionState(SESSION_STORE_KEY).id).toBe('abcde')
-    expect(getSessionState(SESSION_STORE_KEY).rum).toBe('0')
-    expect(getSessionState(SESSION_STORE_KEY).logs).toBe('1')
-    expect(getSessionState(SESSION_STORE_KEY).expire).toMatch(/\d+/)
-  })
-
-  it('should create new cookie from a single old cookie', () => {
-    setCookie(OLD_RUM_COOKIE_NAME, '0', SESSION_EXPIRATION_DELAY)
-
-    tryOldCookiesMigration(sessionStoreStrategy)
-    expect(getSessionState(SESSION_STORE_KEY).id).not.toBeDefined()
-    expect(getSessionState(SESSION_STORE_KEY).rum).toBe('0')
-    expect(getSessionState(SESSION_STORE_KEY).expire).toMatch(/\d+/)
-  })
-
-  it('should not create a new cookie if no old cookie is present', () => {
-    tryOldCookiesMigration(sessionStoreStrategy)
-    expect(getCookie(SESSION_STORE_KEY)).toBeUndefined()
-  })
-
-  it('should behave correctly when performing the migration multiple times', () => {
-    setCookie(OLD_SESSION_COOKIE_NAME, 'abcde', SESSION_EXPIRATION_DELAY)
-    setCookie(OLD_LOGS_COOKIE_NAME, '1', SESSION_EXPIRATION_DELAY)
-    setCookie(OLD_RUM_COOKIE_NAME, '0', SESSION_EXPIRATION_DELAY)
-
-    tryOldCookiesMigration(sessionStoreStrategy)
-    tryOldCookiesMigration(sessionStoreStrategy)
-
-    expect(getSessionState(SESSION_STORE_KEY).id).toBe('abcde')
-    expect(getSessionState(SESSION_STORE_KEY).rum).toBe('0')
-    expect(getSessionState(SESSION_STORE_KEY).logs).toBe('1')
-    expect(getSessionState(SESSION_STORE_KEY).expire).toMatch(/\d+/)
-  })
-})