@openobserve/browser-core 0.2.12-beta.9 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openobserve/browser-core",
-  "version": "0.2.12-beta.9",
+  "version": "0.3.1",
   "license": "Apache-2.0",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -24,4 +24,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/boot/displayAlreadyInitializedError.spec.ts

@@ -0,0 +1,18 @@
+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/displayAlreadyInitializedError.ts

@@ -1,7 +1,7 @@
 import type { InitConfiguration } from '../domain/configuration'
 import { display } from '../tools/display'
 
-export function displayAlreadyInitializedError(sdkName: 'DD_RUM' | 'DD_LOGS', initConfiguration: InitConfiguration) {
+export function displayAlreadyInitializedError(sdkName: 'OO_RUM' | 'OO_LOGS', initConfiguration: InitConfiguration) {
   if (!initConfiguration.silentMultipleInit) {
     display.error(`${sdkName} is already initialized.`)
   }

package/src/boot/init.spec.ts

@@ -0,0 +1,50 @@
+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/boot/init.ts

@@ -12,7 +12,7 @@ export interface PublicApi {
   version: string
 
   /**
-   * For CDN async setup: Early RUM API calls must be wrapped in the `window.DD_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
+   * For CDN async setup: Early RUM API calls must be wrapped in the `window.OO_RUM.onReady()` callback. This ensures the code only gets executed once the SDK is properly loaded.
    *
    * See [CDN async setup](https://docs.datadoghq.com/real_user_monitoring/browser/#cdn-async) for further information.
    */

package/src/browser/addEventListener.spec.ts

@@ -0,0 +1,141 @@
+// 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/addEventListener.ts

@@ -2,7 +2,7 @@ import { monitor } from '../tools/monitor'
 import { getZoneJsOriginalValue } from '../tools/getZoneJsOriginalValue'
 import type { CookieStore, CookieStoreEventMap, VisualViewport, VisualViewportEventMap } from './browser.types'
 
-export type TrustableEvent<E extends Event = Event> = E & { __ddIsTrusted?: boolean }
+export type TrustableEvent<E extends Event = Event> = E & { __ooIsTrusted?: boolean }
 
 export const enum DOM_EVENT {
   BEFORE_UNLOAD = 'beforeunload',
@@ -116,7 +116,7 @@ export function addEventListeners<Target extends EventTarget, EventName extends
   { once, capture, passive }: AddEventListenerOptions = {}
 ) {
   const listenerWithMonitor = monitor((event: TrustableEvent) => {
-    if (!event.isTrusted && !event.__ddIsTrusted && !configuration.allowUntrustedEvents) {
+    if (!event.isTrusted && !event.__ooIsTrusted && !configuration.allowUntrustedEvents) {
       return
     }
     if (once) {

package/src/browser/cookie.spec.ts

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

@@ -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()
+    })
+  })
+})