@openobserve/browser-core 0.3.2 → 0.3.3

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'))
-  }
-})