@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/boot/displayAlreadyInitializedError.spec.ts

@@ -1,18 +0,0 @@
-import type { InitConfiguration } from '../domain/configuration'
-import { display } from '../tools/display'
-import { displayAlreadyInitializedError } from './displayAlreadyInitializedError'
-
-describe('displayAlreadyInitializedError', () => {
-  it('should display an error', () => {
-    const displayErrorSpy = spyOn(display, 'error')
-    displayAlreadyInitializedError('OO_RUM', {} as InitConfiguration)
-    expect(displayErrorSpy).toHaveBeenCalledTimes(1)
-    expect(displayErrorSpy).toHaveBeenCalledWith('OO_RUM is already initialized.')
-  })
-
-  it('should not display an error if the "silentMultipleInit" option is used', () => {
-    const displayErrorSpy = spyOn(display, 'error')
-    displayAlreadyInitializedError('OO_RUM', { silentMultipleInit: true } as InitConfiguration)
-    expect(displayErrorSpy).not.toHaveBeenCalled()
-  })
-})

package/src/boot/init.spec.ts

@@ -1,50 +0,0 @@
-import { display } from '../tools/display'
-import { defineGlobal } from './init'
-
-describe('defineGlobal', () => {
-  it('adds new property to the global object', () => {
-    const myGlobal = {} as any
-    const value = 'my value'
-    defineGlobal(myGlobal, 'foo', value)
-    expect(myGlobal.foo).toBe(value)
-  })
-
-  it('overrides property if exists on the global object', () => {
-    const myGlobal = { foo: 'old value' }
-    const value = 'my value'
-    defineGlobal(myGlobal, 'foo', value)
-    expect(myGlobal.foo).toBe(value)
-  })
-
-  it('run the queued callbacks on the old value', () => {
-    const fn1 = jasmine.createSpy()
-    const fn2 = jasmine.createSpy()
-    const myGlobal: any = {
-      foo: {
-        q: [fn1, fn2],
-      },
-    }
-    const value = 'my value'
-    defineGlobal(myGlobal, 'foo', value)
-    expect(myGlobal.foo).toBe(value)
-    expect(fn1).toHaveBeenCalled()
-    expect(fn2).toHaveBeenCalled()
-  })
-
-  it('catches the errors thrown by the queued callbacks', () => {
-    const myError = 'Ooops!'
-    const onReady = () => {
-      // eslint-disable-next-line @typescript-eslint/only-throw-error
-      throw myError
-    }
-    const myGlobal: any = {
-      foo: {
-        q: [onReady],
-      },
-    }
-    const displaySpy = spyOn(display, 'error')
-
-    defineGlobal(myGlobal, 'foo', {})
-    expect(displaySpy).toHaveBeenCalledWith('onReady callback threw an error:', myError)
-  })
-})

package/src/browser/addEventListener.spec.ts

@@ -1,141 +0,0 @@
-// import type { Configuration } from '@openobserve/browser-core'
-// import { stubZoneJs } from '../../test'
-import type { Configuration } from '../domain/configuration'
-import { createNewEvent, mockZoneJs, registerCleanupTask } from '../../test'
-import type { MockZoneJs } from '../../test'
-import { noop } from '../tools/utils/functionUtils'
-import { addEventListener, DOM_EVENT } from './addEventListener'
-
-describe('addEventListener', () => {
-  let configuration: Configuration
-
-  describe('Zone.js support', () => {
-    let zoneJs: MockZoneJs
-
-    beforeEach(() => {
-      configuration = { allowUntrustedEvents: false } as Configuration
-      zoneJs = mockZoneJs()
-    })
-
-    it('uses the original addEventListener method instead of the method patched by Zone.js', () => {
-      const zoneJsPatchedAddEventListener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      zoneJs.replaceProperty(eventTarget, 'addEventListener', zoneJsPatchedAddEventListener)
-
-      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, noop)
-      expect(zoneJsPatchedAddEventListener).not.toHaveBeenCalled()
-    })
-
-    it('uses the original removeEventListener method instead of the method patched by Zone.js', () => {
-      const zoneJsPatchedRemoveEventListener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      zoneJs.replaceProperty(eventTarget, 'removeEventListener', zoneJsPatchedRemoveEventListener)
-
-      const { stop } = addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, noop)
-      stop()
-      expect(zoneJsPatchedRemoveEventListener).not.toHaveBeenCalled()
-    })
-  })
-
-  it('Use the EventTarget.prototype.addEventListener when the eventTarget is an instance of EventTarget', () => {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const originalAddEventListener = EventTarget.prototype.addEventListener
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const originalRemoveEventListener = EventTarget.prototype.removeEventListener
-
-    EventTarget.prototype.addEventListener = jasmine.createSpy()
-    EventTarget.prototype.removeEventListener = jasmine.createSpy()
-
-    registerCleanupTask(() => {
-      EventTarget.prototype.addEventListener = originalAddEventListener
-      EventTarget.prototype.removeEventListener = originalRemoveEventListener
-    })
-
-    const htmlDivElement = document.createElement('div')
-    htmlDivElement.addEventListener = jasmine.createSpy()
-    htmlDivElement.removeEventListener = jasmine.createSpy()
-
-    const { stop } = addEventListener({ allowUntrustedEvents: false }, htmlDivElement, DOM_EVENT.CLICK, noop)
-
-    const event = createNewEvent(DOM_EVENT.CLICK)
-    htmlDivElement.dispatchEvent(event)
-    stop()
-
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(htmlDivElement.addEventListener).not.toHaveBeenCalled()
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(htmlDivElement.removeEventListener).not.toHaveBeenCalled()
-
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(EventTarget.prototype.addEventListener).toHaveBeenCalled()
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(EventTarget.prototype.removeEventListener).toHaveBeenCalled()
-  })
-
-  it('Use the addEventListener method when the eventTarget is not an instance of EventTarget', () => {
-    const listener = jasmine.createSpy()
-
-    const customEventTarget = {
-      addEventListener: jasmine.createSpy(),
-      removeEventListener: jasmine.createSpy(),
-    } as unknown as HTMLElement
-
-    const { stop } = addEventListener({ allowUntrustedEvents: false }, customEventTarget, 'change', listener)
-    stop()
-
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(customEventTarget.addEventListener).toHaveBeenCalled()
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(customEventTarget.removeEventListener).toHaveBeenCalled()
-  })
-
-  describe('Untrusted event', () => {
-    beforeEach(() => {
-      configuration = { allowUntrustedEvents: false } as Configuration
-    })
-
-    it('should be ignored if __ooIsTrusted is absent', () => {
-      const listener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
-
-      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: undefined })
-      eventTarget.dispatchEvent(event)
-      expect(listener).not.toHaveBeenCalled()
-    })
-
-    it('should be ignored if __ooIsTrusted is false', () => {
-      const listener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
-
-      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: false })
-      eventTarget.dispatchEvent(event)
-      expect(listener).not.toHaveBeenCalled()
-    })
-
-    it('should not be ignored if __ooIsTrusted is true', () => {
-      const listener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
-
-      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: true })
-      eventTarget.dispatchEvent(event)
-
-      expect(listener).toHaveBeenCalled()
-    })
-
-    it('should not be ignored if allowUntrustedEvents is true', () => {
-      const listener = jasmine.createSpy()
-      const eventTarget = document.createElement('div')
-      configuration = { allowUntrustedEvents: true } as Configuration
-
-      addEventListener(configuration, eventTarget, DOM_EVENT.CLICK, listener)
-
-      const event = createNewEvent(DOM_EVENT.CLICK, { __ooIsTrusted: undefined })
-      eventTarget.dispatchEvent(event)
-
-      expect(listener).toHaveBeenCalled()
-    })
-  })
-})

package/src/browser/cookie.spec.ts

@@ -1,53 +0,0 @@
-import { mockCookies } from '../../test'
-import { getCurrentSite, resetGetCurrentSite } from './cookie'
-
-describe('cookie', () => {
-  describe('getCurrentSite', () => {
-    beforeEach(() => {
-      resetGetCurrentSite()
-    })
-
-    it('returns the eTLD+1 for example.com', () => {
-      mockCookies()
-      expect(getCurrentSite('example.com')).toBe('example.com')
-    })
-
-    it('returns the eTLD+1 for example.co.uk', () => {
-      mockCookies({
-        filter: (cookie) => cookie.domain !== '.co.uk',
-      })
-      expect(getCurrentSite('example.co.uk')).toBe('example.co.uk')
-    })
-
-    it('returns the eTLD+1 for foo.bar.baz.example.com', () => {
-      mockCookies()
-      expect(getCurrentSite('foo.bar.baz.example.com')).toBe('example.com')
-    })
-
-    it('does not left any cookies', () => {
-      const { getCookies } = mockCookies()
-      expect(getCurrentSite('example.com')).toBe('example.com')
-      expect(getCookies()).toEqual([])
-    })
-
-    it('falls back to the referrer when the hostname is empty', () => {
-      mockCookies()
-      expect(getCurrentSite('', 'https://example.com')).toBe('example.com')
-    })
-
-    it('returns undefined when the referrer is empty', () => {
-      mockCookies()
-      expect(getCurrentSite('', '')).toBeUndefined()
-    })
-
-    it('caches the result', () => {
-      const { setter } = mockCookies()
-
-      expect(getCurrentSite('example.com')).toBe('example.com')
-      expect(setter).toHaveBeenCalledTimes(2)
-
-      expect(getCurrentSite('example.com')).toBe('example.com')
-      expect(setter).toHaveBeenCalledTimes(2)
-    })
-  })
-})

package/src/browser/fetchObservable.spec.ts

@@ -1,334 +0,0 @@
-import type { MockFetch, MockFetchManager } from '../../test'
-import { registerCleanupTask, mockFetch } from '../../test'
-import type { Subscription } from '../tools/observable'
-import type { FetchResolveContext, FetchContext } from './fetchObservable'
-import { initFetchObservable, resetFetchObservable, ResponseBodyAction } from './fetchObservable'
-
-describe('fetch proxy', () => {
-  const FAKE_URL = 'http://fake-url/'
-  const FAKE_RELATIVE_URL = '/fake-path'
-  const NORMALIZED_FAKE_RELATIVE_URL = `${location.origin}/fake-path`
-  let mockFetchManager: MockFetchManager
-  let requestsTrackingSubscription: Subscription
-  let contextEditionSubscription: Subscription | undefined
-  let requests: FetchResolveContext[]
-  let originalMockFetch: typeof window.fetch
-  let fetch: MockFetch
-
-  beforeEach(() => {
-    mockFetchManager = mockFetch()
-    originalMockFetch = window.fetch
-
-    requests = []
-    requestsTrackingSubscription = initFetchObservable().subscribe((context) => {
-      if (context.state === 'resolve') {
-        requests.push(context)
-      }
-    })
-    fetch = window.fetch as MockFetch
-
-    registerCleanupTask(() => {
-      requestsTrackingSubscription.unsubscribe()
-      contextEditionSubscription?.unsubscribe()
-      resetFetchObservable()
-    })
-  })
-
-  it('should track server error', (done) => {
-    fetch(FAKE_URL).resolveWith({ status: 500, responseText: 'fetch error' })
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(500)
-      expect(request.isAborted).toBe(false)
-      expect(request.handlingStack).toBeDefined()
-      done()
-    })
-  })
-
-  it('should track refused fetch', (done) => {
-    fetch(FAKE_URL).rejectWith(new Error('fetch error'))
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(0)
-      expect(request.isAborted).toBe(false)
-      expect(request.error).toEqual(new Error('fetch error'))
-      expect(request.handlingStack).toBeDefined()
-      done()
-    })
-  })
-
-  it('should track aborted fetch', (done) => {
-    fetch(FAKE_URL).abort()
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(0)
-      expect(request.isAborted).toBe(true)
-      expect(request.error).toEqual(new DOMException('The user aborted a request', 'AbortError'))
-      expect(request.handlingStack).toBeDefined()
-      done()
-    })
-  })
-
-  it('should track fetch aborted by AbortController', (done) => {
-    if (!window.AbortController) {
-      pending('AbortController is not supported')
-    }
-
-    const controller = new AbortController()
-    void fetch(FAKE_URL, { signal: controller.signal })
-    controller.abort('AbortError')
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(0)
-      expect(request.isAborted).toBe(true)
-      expect(request.error).toEqual(controller.signal.reason)
-      expect(request.handlingStack).toBeDefined()
-      done()
-    })
-  })
-
-  it('should track opaque fetch', (done) => {
-    // https://fetch.spec.whatwg.org/#concept-filtered-response-opaque
-    fetch(FAKE_URL).resolveWith({ status: 0, type: 'opaque' })
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(0)
-      expect(request.isAborted).toBe(false)
-      done()
-    })
-  })
-
-  it('should track client error', (done) => {
-    fetch(FAKE_URL).resolveWith({ status: 400, responseText: 'Not found' })
-
-    mockFetchManager.whenAllComplete(() => {
-      const request = requests[0]
-      expect(request.method).toEqual('GET')
-      expect(request.url).toEqual(FAKE_URL)
-      expect(request.status).toEqual(400)
-      expect(request.isAborted).toBe(false)
-      done()
-    })
-  })
-
-  it('should get method from input', (done) => {
-    fetch(FAKE_URL).resolveWith({ status: 500 })
-    fetch(new Request(FAKE_URL)).resolveWith({ status: 500 })
-    fetch(new Request(FAKE_URL, { method: 'PUT' })).resolveWith({ status: 500 })
-    fetch(new Request(FAKE_URL, { method: 'PUT' }), { method: 'POST' }).resolveWith({ status: 500 })
-    fetch(new Request(FAKE_URL), { method: 'POST' }).resolveWith({ status: 500 })
-    fetch(FAKE_URL, { method: 'POST' }).resolveWith({ status: 500 })
-    fetch(FAKE_URL, { method: 'post' }).resolveWith({ status: 500 })
-    fetch(null as any).resolveWith({ status: 500 })
-    fetch({ method: 'POST' } as any).resolveWith({ status: 500 })
-    fetch(FAKE_URL, { method: null as any }).resolveWith({ status: 500 })
-    fetch(FAKE_URL, { method: undefined }).resolveWith({ status: 500 })
-
-    mockFetchManager.whenAllComplete(() => {
-      expect(requests[0].method).toEqual('GET')
-      expect(requests[1].method).toEqual('GET')
-      expect(requests[2].method).toEqual('PUT')
-      expect(requests[3].method).toEqual('POST')
-      expect(requests[4].method).toEqual('POST')
-      expect(requests[5].method).toEqual('POST')
-      expect(requests[6].method).toEqual('POST')
-      expect(requests[7].method).toEqual('GET')
-      expect(requests[8].method).toEqual('GET')
-      expect(requests[9].method).toEqual('NULL')
-      expect(requests[10].method).toEqual('GET')
-
-      done()
-    })
-  })
-
-  it('should get the normalized url from input', (done) => {
-    fetch(FAKE_URL).rejectWith(new Error('fetch error'))
-    fetch(new Request(FAKE_URL)).rejectWith(new Error('fetch error'))
-    fetch(null as any).rejectWith(new Error('fetch error'))
-    fetch({
-      toString() {
-        return FAKE_RELATIVE_URL
-      },
-    } as any).rejectWith(new Error('fetch error'))
-    fetch(FAKE_RELATIVE_URL).rejectWith(new Error('fetch error'))
-    fetch(new Request(FAKE_RELATIVE_URL)).rejectWith(new Error('fetch error'))
-
-    mockFetchManager.whenAllComplete(() => {
-      expect(requests[0].url).toEqual(FAKE_URL)
-      expect(requests[1].url).toEqual(FAKE_URL)
-      expect(requests[2].url).toMatch(/\/null$/)
-      expect(requests[3].url).toEqual(NORMALIZED_FAKE_RELATIVE_URL)
-      expect(requests[4].url).toEqual(NORMALIZED_FAKE_RELATIVE_URL)
-      expect(requests[5].url).toEqual(NORMALIZED_FAKE_RELATIVE_URL)
-      done()
-    })
-  })
-
-  it('should keep promise resolved behavior for Response', (done) => {
-    const mockFetchPromise = fetch(FAKE_URL)
-    const spy = jasmine.createSpy()
-    mockFetchPromise.then(spy).catch(() => {
-      fail('Should not have thrown an error!')
-    })
-    mockFetchPromise.resolveWith({ status: 500 })
-
-    setTimeout(() => {
-      expect(spy).toHaveBeenCalled()
-      done()
-    })
-  })
-
-  it('should keep promise resolved behavior for any other type', (done) => {
-    const mockFetchPromise = fetch(FAKE_URL)
-    const spy = jasmine.createSpy()
-    mockFetchPromise.then(spy).catch(() => {
-      fail('Should not have thrown an error!')
-    })
-    mockFetchPromise.resolveWith('response' as any)
-
-    setTimeout(() => {
-      expect(spy).toHaveBeenCalled()
-      done()
-    })
-  })
-
-  it('should keep promise rejected behavior for Error', (done) => {
-    const mockFetchPromise = fetch(FAKE_URL)
-    const spy = jasmine.createSpy()
-    mockFetchPromise.catch(spy)
-    mockFetchPromise.rejectWith(new Error('fetch error'))
-
-    setTimeout(() => {
-      expect(spy).toHaveBeenCalled()
-      done()
-    })
-  })
-
-  it('should keep promise rejected behavior for any other type', (done) => {
-    const mockFetchPromise = fetch(FAKE_URL)
-    const spy = jasmine.createSpy()
-    mockFetchPromise.catch(spy)
-    mockFetchPromise.rejectWith('fetch error' as any)
-
-    setTimeout(() => {
-      expect(spy).toHaveBeenCalled()
-      done()
-    })
-  })
-
-  it('should allow to enhance the context', (done) => {
-    type CustomContext = FetchContext & { foo: string }
-    contextEditionSubscription = initFetchObservable().subscribe((rawContext) => {
-      const context = rawContext as CustomContext
-      if (context.state === 'start') {
-        context.foo = 'bar'
-      }
-    })
-    fetch(FAKE_URL).resolveWith({ status: 500, responseText: 'fetch error' })
-
-    mockFetchManager.whenAllComplete(() => {
-      expect((requests[0] as CustomContext).foo).toBe('bar')
-      done()
-    })
-  })
-
-  describe('when unsubscribing', () => {
-    it('should stop tracking requests', (done) => {
-      requestsTrackingSubscription.unsubscribe()
-
-      fetch(FAKE_URL).resolveWith({ status: 200, responseText: 'ok' })
-
-      mockFetchManager.whenAllComplete(() => {
-        expect(requests).toEqual([])
-        done()
-      })
-    })
-
-    it('should restore original window.fetch', () => {
-      requestsTrackingSubscription.unsubscribe()
-
-      expect(window.fetch).toBe(originalMockFetch)
-    })
-  })
-})
-
-describe('fetch proxy with ResponseBodyAction', () => {
-  const FAKE_URL = 'http://fake-url/'
-  let mockFetchManager: MockFetchManager
-  let requestsTrackingSubscription: Subscription
-  let requests: FetchResolveContext[]
-  let fetch: MockFetch
-
-  function setupFetchTracking(responseBodyAction: () => ResponseBodyAction) {
-    mockFetchManager = mockFetch()
-    requests = []
-    requestsTrackingSubscription = initFetchObservable({ responseBodyAction }).subscribe((context) => {
-      if (context.state === 'resolve') {
-        requests.push(context)
-      }
-    })
-    fetch = window.fetch as MockFetch
-  }
-
-  afterEach(() => {
-    requestsTrackingSubscription?.unsubscribe()
-    resetFetchObservable()
-  })
-
-  it('should collect response body with COLLECT action', (done) => {
-    setupFetchTracking(() => ResponseBodyAction.COLLECT)
-
-    fetch(FAKE_URL).resolveWith({ status: 200, responseText: 'response body content' })
-
-    mockFetchManager.whenAllComplete(() => {
-      expect(requests[0].responseBody).toBe('response body content')
-      done()
-    })
-  })
-
-  it('should not collect response body with WAIT or IGNORE action', (done) => {
-    setupFetchTracking(() => ResponseBodyAction.WAIT)
-
-    fetch(FAKE_URL).resolveWith({ status: 200, responseText: 'response body content' })
-
-    mockFetchManager.whenAllComplete(() => {
-      expect(requests[0].responseBody).toBeUndefined()
-      done()
-    })
-  })
-
-  it('should use the highest priority action when multiple getters are registered', (done) => {
-    setupFetchTracking(() => ResponseBodyAction.WAIT)
-
-    initFetchObservable({
-      responseBodyAction: () => ResponseBodyAction.COLLECT,
-    })
-
-    registerCleanupTask(() => {
-      requestsTrackingSubscription.unsubscribe()
-    })
-
-    fetch = window.fetch as MockFetch
-    fetch(FAKE_URL).resolveWith({ status: 200, responseText: 'response body content' })
-
-    mockFetchManager.whenAllComplete(() => {
-      expect(requests[0].responseBody).toBe('response body content')
-      done()
-    })
-  })
-})

package/src/browser/pageMayExitObservable.spec.ts

@@ -1,56 +0,0 @@
-import type { Configuration } from '../domain/configuration'
-import { createNewEvent, restorePageVisibility, setPageVisibility, registerCleanupTask } from '../../test'
-import type { PageMayExitEvent } from './pageMayExitObservable'
-import { PageExitReason, createPageMayExitObservable } from './pageMayExitObservable'
-
-describe('createPageMayExitObservable', () => {
-  let onExitSpy: jasmine.Spy<(event: PageMayExitEvent) => void>
-  let configuration: Configuration
-
-  beforeEach(() => {
-    onExitSpy = jasmine.createSpy()
-    configuration = {} as Configuration
-    registerCleanupTask(createPageMayExitObservable(configuration).subscribe(onExitSpy).unsubscribe)
-  })
-
-  afterEach(() => {
-    restorePageVisibility()
-  })
-
-  it('notifies when the page fires beforeunload', () => {
-    window.dispatchEvent(createNewEvent('beforeunload'))
-
-    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.UNLOADING })
-  })
-
-  it('notifies when the page becomes hidden', () => {
-    emulatePageVisibilityChange('hidden')
-
-    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.HIDDEN })
-  })
-
-  it('notifies when the page becomes frozen', () => {
-    window.dispatchEvent(createNewEvent('freeze'))
-
-    expect(onExitSpy).toHaveBeenCalledOnceWith({ reason: PageExitReason.FROZEN })
-  })
-
-  it('notifies multiple times', () => {
-    window.dispatchEvent(createNewEvent('beforeunload'))
-    window.dispatchEvent(createNewEvent('beforeunload'))
-    emulatePageVisibilityChange('hidden')
-
-    expect(onExitSpy).toHaveBeenCalledTimes(3)
-  })
-
-  it('does not notify when the page becomes visible', () => {
-    emulatePageVisibilityChange('visible')
-
-    expect(onExitSpy).not.toHaveBeenCalled()
-  })
-
-  function emulatePageVisibilityChange(visibility: 'visible' | 'hidden') {
-    setPageVisibility(visibility)
-    document.dispatchEvent(createNewEvent('visibilitychange'))
-  }
-})