@openobserve/browser-core 0.3.2 → 0.3.3

package/src/browser/xhrObservable.spec.ts

@@ -1,405 +0,0 @@
-import type { Configuration } from '../domain/configuration'
-import { withXhr, mockXhr } from '../../test'
-import type { Subscription } from '../tools/observable'
-import type { XhrCompleteContext, XhrContext } from './xhrObservable'
-import { initXhrObservable } from './xhrObservable'
-
-describe('xhr observable', () => {
-  let requestsTrackingSubscription: Subscription
-  let contextEditionSubscription: Subscription | undefined
-  let requests: XhrCompleteContext[]
-  let originalMockXhrSend: XMLHttpRequest['send']
-  let configuration: Configuration
-
-  beforeEach(() => {
-    mockXhr()
-    configuration = {} as Configuration
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    originalMockXhrSend = XMLHttpRequest.prototype.send
-
-    requests = []
-    startTrackingRequests()
-  })
-
-  afterEach(() => {
-    requestsTrackingSubscription.unsubscribe()
-    contextEditionSubscription?.unsubscribe()
-  })
-
-  function startTrackingRequests() {
-    requestsTrackingSubscription = initXhrObservable(configuration).subscribe((context) => {
-      if (context.state === 'complete') {
-        requests.push(context)
-      }
-    })
-  }
-
-  it('should track successful request', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.complete(200, 'ok')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/ok')
-        expect(request.status).toBe(200)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should sanitize request method', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('get', '/ok')
-        xhr.send()
-        xhr.complete(200, 'ok')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track client error', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/expected-404')
-        xhr.send()
-        xhr.complete(404, 'NOT FOUND')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/expected-404')
-        expect(request.status).toBe(404)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track server error', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/throw')
-        xhr.send()
-        xhr.complete(500, 'expected server error')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/throw')
-        expect(request.status).toBe(500)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track network error', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', 'http://foo.bar/qux')
-        xhr.send()
-        xhr.complete(0, '')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toBe('http://foo.bar/qux')
-        expect(request.status).toBe(0)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track successful request aborted', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.onreadystatechange = () => {
-          if (xhr.readyState === XMLHttpRequest.DONE) {
-            xhr.abort()
-          }
-        }
-        spyOn(xhr, 'onreadystatechange').and.callThrough()
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.complete(200, 'ok')
-      },
-      onComplete(xhr) {
-        const request = requests[0]
-        expect(requests.length).toBe(1)
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/ok')
-        expect(request.status).toBe(200)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.isAborted).toBe(false)
-        expect(xhr.status).toBe(0)
-        expect(xhr.onreadystatechange).toHaveBeenCalledTimes(1)
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track aborted requests', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.abort()
-      },
-      onComplete(xhr) {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/ok')
-        expect(request.status).toBe(0)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(request.isAborted).toBe(true)
-        expect(xhr.status).toBe(0)
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track request with onreadystatechange overridden before open', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.onreadystatechange = jasmine.createSpy()
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.complete(200, 'ok')
-      },
-      onComplete(xhr) {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/ok')
-        expect(request.status).toBe(200)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(xhr.onreadystatechange).toHaveBeenCalled()
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should track request with onreadystatechange overridden after open', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.onreadystatechange = jasmine.createSpy()
-        xhr.complete(200, 'ok')
-      },
-      onComplete(xhr) {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/ok')
-        expect(request.status).toBe(200)
-        expect(request.isAborted).toBe(false)
-        expect(request.duration).toEqual(jasmine.any(Number))
-        expect(xhr.onreadystatechange).toHaveBeenCalled()
-        expect(request.handlingStack).toBeDefined()
-        done()
-      },
-    })
-  })
-
-  it('should allow to enhance the context', (done) => {
-    type CustomContext = XhrContext & { foo: string }
-    contextEditionSubscription = initXhrObservable(configuration).subscribe((rawContext) => {
-      const context = rawContext as CustomContext
-      if (context.state === 'start') {
-        context.foo = 'bar'
-      }
-    })
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/ok')
-        xhr.send()
-        xhr.complete(200)
-      },
-      onComplete() {
-        const request = requests[0]
-        expect((request as CustomContext).foo).toBe('bar')
-        done()
-      },
-    })
-  })
-
-  it('should not break xhr opened before the instrumentation', (done) => {
-    requestsTrackingSubscription.unsubscribe()
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', '/ok')
-        startTrackingRequests()
-        xhr.send()
-        xhr.complete(200)
-      },
-      onComplete() {
-        expect(requests.length).toBe(0)
-        done()
-      },
-    })
-  })
-
-  it('should track multiple requests with the same xhr instance', (done) => {
-    let listeners: { [k: string]: Array<(event: Event) => void> }
-    withXhr({
-      setup(xhr) {
-        const secondOnload = () => {
-          xhr.removeEventListener('load', secondOnload)
-        }
-        const onLoad = () => {
-          xhr.removeEventListener('load', onLoad)
-          xhr.addEventListener('load', secondOnload)
-          xhr.open('GET', '/ok?request=2')
-          xhr.send()
-          xhr.complete(400, 'ok')
-        }
-        xhr.onreadystatechange = jasmine.createSpy()
-        xhr.addEventListener('load', onLoad)
-        xhr.open('GET', '/ok?request=1')
-        xhr.send()
-        xhr.complete(200, 'ok')
-        listeners = xhr.listeners
-      },
-      onComplete(xhr) {
-        const firstRequest = requests[0]
-        expect(firstRequest.method).toBe('GET')
-        expect(firstRequest.url).toContain('/ok?request=1')
-        expect(firstRequest.status).toBe(200)
-        expect(firstRequest.isAborted).toBe(false)
-        expect(firstRequest.duration).toEqual(jasmine.any(Number))
-        expect(firstRequest.handlingStack).toBeDefined()
-
-        const secondRequest = requests[1]
-        expect(secondRequest.method).toBe('GET')
-        expect(secondRequest.url).toContain('/ok?request=2')
-        expect(secondRequest.status).toBe(400)
-        expect(secondRequest.isAborted).toBe(false)
-        expect(secondRequest.duration).toEqual(jasmine.any(Number))
-        expect(secondRequest.handlingStack).toBeDefined()
-
-        expect(xhr.onreadystatechange).toHaveBeenCalledTimes(2)
-        expect(listeners.load.length).toBe(0)
-        expect(listeners.loadend.length).toBe(0)
-        done()
-      },
-    })
-  })
-
-  it('should track request to undefined url', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', undefined)
-        xhr.send()
-        xhr.complete(404, 'NOT FOUND')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/undefined')
-        expect(request.status).toBe(404)
-        done()
-      },
-    })
-  })
-
-  it('should track request to null url', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', null)
-        xhr.send()
-        xhr.complete(404, 'NOT FOUND')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toContain('/null')
-        expect(request.status).toBe(404)
-        done()
-      },
-    })
-  })
-
-  it('should track request to URL object', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open('GET', new URL('http://example.com/path'))
-        xhr.send()
-        xhr.complete(200, 'ok')
-      },
-      onComplete() {
-        const request = requests[0]
-        expect(request.method).toBe('GET')
-        expect(request.url).toBe('http://example.com/path')
-        done()
-      },
-    })
-  })
-
-  describe('when unsubscribing', () => {
-    it('should stop tracking requests', (done) => {
-      requestsTrackingSubscription.unsubscribe()
-
-      withXhr({
-        setup(xhr) {
-          xhr.open('GET', '/ok')
-          xhr.send()
-          xhr.complete(200)
-        },
-        onComplete() {
-          expect(requests.length).toBe(0)
-          done()
-        },
-      })
-    })
-
-    it('should restore original XMLHttpRequest methods', () => {
-      requestsTrackingSubscription.unsubscribe()
-
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      expect(XMLHttpRequest.prototype.send).toBe(originalMockXhrSend)
-    })
-  })
-
-  it('should track request with undefined or null methods', (done) => {
-    withXhr({
-      setup(xhr) {
-        xhr.open(null, '/ok')
-        xhr.send()
-        xhr.onreadystatechange = jasmine.createSpy()
-        xhr.complete(200, 'ok')
-        xhr.open(undefined, '/ok')
-        xhr.send()
-        xhr.onreadystatechange = jasmine.createSpy()
-        xhr.complete(200, 'ok')
-      },
-      onComplete() {
-        expect(requests[0].method).toBe('NULL')
-        expect(requests[1].method).toBe('UNDEFINED')
-        done()
-      },
-    })
-  })
-})

package/src/domain/allowedTrackingOrigins.spec.ts

@@ -1,210 +0,0 @@
-import { STACK_WITH_INIT_IN_EXTENSION, STACK_WITH_INIT_IN_PAGE } from '../../test'
-import { display } from '../tools/display'
-import {
-  isAllowedTrackingOrigins,
-  ERROR_NOT_ALLOWED_TRACKING_ORIGIN,
-  ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN,
-} from './allowedTrackingOrigins'
-
-const DEFAULT_CONFIG = {
-  applicationId: 'xxx',
-  clientToken: 'xxx',
-  allowedTrackingOrigins: undefined as any,
-}
-
-describe('checkForAllowedTrackingOrigins', () => {
-  let displayErrorSpy: jasmine.Spy
-
-  beforeEach(() => {
-    displayErrorSpy = spyOn(display, 'error')
-  })
-
-  it('should not warn if not in extension environment', () => {
-    const result = isAllowedTrackingOrigins(DEFAULT_CONFIG, STACK_WITH_INIT_IN_PAGE, 'https://app.example.com')
-    expect(displayErrorSpy).not.toHaveBeenCalled()
-    expect(result).toBe(true)
-  })
-
-  describe('when configuration has allowedTrackingOrigins and origin is allowed', () => {
-    it('should not warn if origin matches exactly', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: ['https://app.example.com'],
-        },
-        STACK_WITH_INIT_IN_PAGE,
-        'https://app.example.com'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-
-    it('should not warn if origin matches regex pattern', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [/^https:\/\/.*\.example\.com$/],
-        },
-        STACK_WITH_INIT_IN_PAGE,
-        'https://app.example.com'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-
-    it('should not warn if origin matches predicate function', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [(origin: string) => origin.includes('example.com')],
-        },
-        STACK_WITH_INIT_IN_PAGE,
-        'https://app.example.com'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-
-    it('should handle multiple patterns', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [
-            'https://exact-match.com',
-            /^https:\/\/.*\.example\.com$/,
-            (origin: string) => origin.startsWith('https://app.'),
-          ],
-        },
-        STACK_WITH_INIT_IN_PAGE,
-        'https://app.example.com'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-  })
-
-  describe('when configuration has allowedTrackingOrigins but origin is not allowed in extension context', () => {
-    it('should error when origin does not match any allowed pattern', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: ['https://different.com'],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should error when origin does not match regex pattern', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [/^https:\/\/specific-[a-z]+\.com$/],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should error when origin does not match predicate function', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [(origin: string) => origin.includes('specific-id')],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should error when origin does not match any of multiple patterns', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [
-            'https://specific.com',
-            /^https:\/\/.*\.specific\.com$/,
-            (origin: string) => origin.includes('specific-id'),
-          ],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should error when origin is a partial match', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: ['https://example.com'],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com.extra.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should not error when in extension and origin matches', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [/^chrome-extension:\/\//],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'chrome-extension://abcdefghijklmno'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-  })
-
-  describe('when configuration does not have allowedTrackingOrigins', () => {
-    it('should log an error when in extension environment and allowedTrackingOrigins is undefined', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: undefined,
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should error when in extension environment and allowedTrackingOrigins is an empty array', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: [],
-        },
-        STACK_WITH_INIT_IN_EXTENSION,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).toHaveBeenCalledWith(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
-      expect(result).toBe(false)
-    })
-
-    it('should not warn when not in extension environment and allowedTrackingOrigins is undefined', () => {
-      const result = isAllowedTrackingOrigins(
-        {
-          ...DEFAULT_CONFIG,
-          allowedTrackingOrigins: undefined,
-        },
-        STACK_WITH_INIT_IN_PAGE,
-        'https://example.com'
-      )
-      expect(displayErrorSpy).not.toHaveBeenCalled()
-      expect(result).toBe(true)
-    })
-  })
-})

package/src/domain/bufferedData.spec.ts

@@ -1,34 +0,0 @@
-import { registerCleanupTask } from '../../test'
-import { Observable } from '../tools/observable'
-import { clocksNow } from '../tools/utils/timeUtils'
-import { BufferedDataType, startBufferingData } from './bufferedData'
-import { ErrorHandling, ErrorSource, type RawError } from './error/error.types'
-
-describe('startBufferingData', () => {
-  it('collects runtime errors', (done) => {
-    const runtimeErrorObservable = new Observable<RawError>()
-    const { observable, stop } = startBufferingData(() => runtimeErrorObservable)
-    registerCleanupTask(stop)
-
-    const rawError = {
-      startClocks: clocksNow(),
-      source: ErrorSource.SOURCE,
-      type: 'Error',
-      stack: 'Error: error!',
-      handling: ErrorHandling.UNHANDLED,
-      causes: undefined,
-      fingerprint: undefined,
-      message: 'error!',
-    }
-
-    runtimeErrorObservable.notify(rawError)
-
-    observable.subscribe((data) => {
-      expect(data).toEqual({
-        type: BufferedDataType.RUNTIME_ERROR,
-        error: rawError,
-      })
-      done()
-    })
-  })
-})