@openobserve/browser-core 0.3.3 → 0.3.4

package/src/browser/fetchObservable.spec.ts

@@ -0,0 +1,334 @@
+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

@@ -0,0 +1,56 @@
+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'))
+  }
+})