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

package/src/tools/monitor.spec.ts

@@ -0,0 +1,172 @@
+import { display } from './display'
+import { callMonitored, monitor, monitored, startMonitorErrorCollection, resetMonitor, setDebugMode } from './monitor'
+
+describe('monitor', () => {
+  let onMonitorErrorCollectedSpy: jasmine.Spy<(error: unknown) => void>
+
+  beforeEach(() => {
+    onMonitorErrorCollectedSpy = jasmine.createSpy()
+  })
+  afterEach(() => {
+    resetMonitor()
+  })
+
+  describe('decorator', () => {
+    class Candidate {
+      @monitored
+      monitoredThrowing() {
+        throw new Error('monitored')
+      }
+
+      @monitored
+      monitoredStringErrorThrowing() {
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
+        throw 'string error'
+      }
+
+      @monitored
+      monitoredObjectErrorThrowing() {
+        // eslint-disable-next-line @typescript-eslint/only-throw-error
+        throw { foo: 'bar' }
+      }
+
+      @monitored
+      monitoredNotThrowing() {
+        return 1
+      }
+
+      notMonitoredThrowing() {
+        throw new Error('not monitored')
+      }
+    }
+
+    let candidate: Candidate
+    beforeEach(() => {
+      candidate = new Candidate()
+    })
+
+    describe('before initialization', () => {
+      it('should not monitor', () => {
+        expect(() => candidate.notMonitoredThrowing()).toThrowError('not monitored')
+        expect(() => candidate.monitoredThrowing()).toThrowError('monitored')
+        expect(candidate.monitoredNotThrowing()).toEqual(1)
+      })
+    })
+
+    describe('after initialization', () => {
+      beforeEach(() => {
+        startMonitorErrorCollection(onMonitorErrorCollectedSpy)
+      })
+
+      it('should preserve original behavior', () => {
+        expect(candidate.monitoredNotThrowing()).toEqual(1)
+      })
+
+      it('should catch error', () => {
+        expect(() => candidate.notMonitoredThrowing()).toThrowError()
+        expect(() => candidate.monitoredThrowing()).not.toThrowError()
+      })
+
+      it('should report error', () => {
+        candidate.monitoredThrowing()
+
+        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('monitored'))
+      })
+
+      it('should report string error', () => {
+        candidate.monitoredStringErrorThrowing()
+
+        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith('string error')
+      })
+
+      it('should report object error', () => {
+        candidate.monitoredObjectErrorThrowing()
+
+        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith({ foo: 'bar' })
+      })
+    })
+  })
+
+  describe('function', () => {
+    const notThrowing = () => 1
+    const throwing = () => {
+      throw new Error('error')
+    }
+
+    beforeEach(() => {
+      startMonitorErrorCollection(onMonitorErrorCollectedSpy)
+    })
+
+    describe('direct call', () => {
+      it('should preserve original behavior', () => {
+        expect(callMonitored(notThrowing)).toEqual(1)
+      })
+
+      it('should catch error', () => {
+        expect(() => callMonitored(throwing)).not.toThrowError()
+      })
+
+      it('should report error', () => {
+        callMonitored(throwing)
+
+        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('error'))
+      })
+    })
+
+    describe('wrapper', () => {
+      it('should preserve original behavior', () => {
+        const decorated = monitor(notThrowing)
+        expect(decorated()).toEqual(1)
+      })
+
+      it('should catch error', () => {
+        const decorated = monitor(throwing)
+        expect(() => decorated()).not.toThrowError()
+      })
+
+      it('should report error', () => {
+        monitor(throwing)()
+
+        expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('error'))
+      })
+    })
+  })
+
+  describe('setDebugMode', () => {
+    let displaySpy: jasmine.Spy
+
+    beforeEach(() => {
+      displaySpy = spyOn(display, 'error')
+    })
+
+    it('when not called, should not display error', () => {
+      callMonitored(() => {
+        throw new Error('message')
+      })
+
+      expect(displaySpy).not.toHaveBeenCalled()
+    })
+
+    it('when called, should display error', () => {
+      setDebugMode(true)
+
+      callMonitored(() => {
+        throw new Error('message')
+      })
+
+      expect(displaySpy).toHaveBeenCalledOnceWith('[MONITOR]', new Error('message'))
+    })
+
+    it('displays errors thrown by the onMonitorErrorCollected callback', () => {
+      setDebugMode(true)
+      onMonitorErrorCollectedSpy.and.throwError(new Error('unexpected'))
+      startMonitorErrorCollection(onMonitorErrorCollectedSpy)
+
+      callMonitored(() => {
+        throw new Error('message')
+      })
+      expect(displaySpy).toHaveBeenCalledWith('[MONITOR]', new Error('message'))
+      expect(displaySpy).toHaveBeenCalledWith('[MONITOR]', new Error('unexpected'))
+    })
+  })
+})

package/src/tools/observable.spec.ts

@@ -0,0 +1,259 @@
+import { waitNextMicrotask } from '../../test'
+import { BufferedObservable, mergeObservables, Observable } from './observable'
+
+describe('observable', () => {
+  let observable: Observable<void>
+  let subscriber: jasmine.Spy<jasmine.Func>
+
+  beforeEach(() => {
+    observable = new Observable()
+    subscriber = jasmine.createSpy('sub')
+  })
+
+  it('should allow to subscribe and be notified', () => {
+    observable.subscribe(subscriber)
+    expect(subscriber).not.toHaveBeenCalled()
+
+    observable.notify()
+    expect(subscriber).toHaveBeenCalledTimes(1)
+
+    observable.notify()
+    expect(subscriber).toHaveBeenCalledTimes(2)
+  })
+
+  it('should notify multiple clients', () => {
+    const otherSubscriber = jasmine.createSpy('sub2')
+    observable.subscribe(subscriber)
+    observable.subscribe(otherSubscriber)
+
+    observable.notify()
+
+    expect(subscriber).toHaveBeenCalled()
+    expect(otherSubscriber).toHaveBeenCalled()
+  })
+
+  it('should allow to unsubscribe', () => {
+    const subscription = observable.subscribe(subscriber)
+
+    subscription.unsubscribe()
+    observable.notify()
+
+    expect(subscriber).not.toHaveBeenCalled()
+  })
+
+  it('should execute onFirstSubscribe callback', () => {
+    const onFirstSubscribe = jasmine.createSpy('callback')
+    const otherSubscriber = jasmine.createSpy('sub2')
+    observable = new Observable(onFirstSubscribe)
+    expect(onFirstSubscribe).not.toHaveBeenCalled()
+
+    observable.subscribe(subscriber)
+    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
+
+    observable.subscribe(otherSubscriber)
+    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
+  })
+
+  it('should notify the first subscriber if the onFirstSubscribe callback notifies synchronously ', () => {
+    const onFirstSubscribe = jasmine.createSpy('callback').and.callFake((observable: Observable<void>) => {
+      observable.notify()
+    })
+    observable = new Observable(onFirstSubscribe)
+    observable.subscribe(subscriber)
+
+    expect(onFirstSubscribe).toHaveBeenCalledTimes(1)
+    expect(subscriber).toHaveBeenCalledTimes(1)
+  })
+
+  it('should pass the observable instance to the onFirstSubscribe callback', () => {
+    const onFirstSubscribe = jasmine.createSpy('callback')
+    observable = new Observable(onFirstSubscribe)
+    observable.subscribe(subscriber)
+
+    expect(onFirstSubscribe).toHaveBeenCalledWith(observable)
+  })
+
+  it('should execute onLastUnsubscribe callback', () => {
+    const onLastUnsubscribe = jasmine.createSpy('callback')
+    const otherSubscriber = jasmine.createSpy('sub2')
+    observable = new Observable(() => onLastUnsubscribe)
+    const subscription = observable.subscribe(subscriber)
+    const otherSubscription = observable.subscribe(otherSubscriber)
+    expect(onLastUnsubscribe).not.toHaveBeenCalled()
+
+    subscription.unsubscribe()
+    expect(onLastUnsubscribe).not.toHaveBeenCalled()
+
+    otherSubscription.unsubscribe()
+    expect(onLastUnsubscribe).toHaveBeenCalled()
+  })
+})
+
+describe('mergeObservables', () => {
+  let observableOne: Observable<void>
+  let observableTwo: Observable<void>
+  let mergedObservable: Observable<void>
+  let subscriber: jasmine.Spy<jasmine.Func>
+
+  beforeEach(() => {
+    observableOne = new Observable<void>()
+    observableTwo = new Observable<void>()
+    mergedObservable = mergeObservables(observableOne, observableTwo)
+    subscriber = jasmine.createSpy('subscriber')
+  })
+
+  it('should notify when one of the merged observable notifies', () => {
+    mergedObservable.subscribe(subscriber)
+    observableOne.notify()
+    observableTwo.notify()
+
+    expect(subscriber).toHaveBeenCalledTimes(2)
+  })
+
+  it('should allow to unsubscribe to all merged observables', () => {
+    const subscription = mergedObservable.subscribe(subscriber)
+
+    subscription.unsubscribe()
+    observableOne.notify()
+    observableTwo.notify()
+
+    expect(subscriber).not.toHaveBeenCalled()
+  })
+})
+
+describe('BufferedObservable', () => {
+  it('invokes the observer with buffered data', async () => {
+    const observable = new BufferedObservable<string>(100)
+    observable.notify('first')
+    observable.notify('second')
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+
+    await waitNextMicrotask()
+
+    expect(observer).toHaveBeenCalledTimes(2)
+  })
+
+  it('invokes the observer asynchronously', async () => {
+    const observable = new BufferedObservable<string>(100)
+    observable.notify('first')
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+
+    expect(observer).not.toHaveBeenCalled()
+
+    await waitNextMicrotask()
+
+    expect(observer).toHaveBeenCalledWith('first')
+  })
+
+  it('invokes the observer when new data is notified after subscription', async () => {
+    const observable = new BufferedObservable<string>(100)
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+
+    observable.notify('first')
+
+    await waitNextMicrotask()
+
+    observable.notify('second')
+
+    expect(observer).toHaveBeenCalledTimes(2)
+    expect(observer).toHaveBeenCalledWith('first')
+    expect(observer).toHaveBeenCalledWith('second')
+  })
+
+  it('drops data when the buffer is full', async () => {
+    const observable = new BufferedObservable<string>(2)
+    observable.notify('first') // This should be dropped
+    observable.notify('second')
+    observable.notify('third')
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+
+    await waitNextMicrotask()
+
+    expect(observer).toHaveBeenCalledTimes(2)
+    expect(observer).toHaveBeenCalledWith('second')
+    expect(observer).toHaveBeenCalledWith('third')
+  })
+
+  it('allows to unsubscribe from the observer, the middle of buffered data', async () => {
+    const observable = new BufferedObservable<string>(100)
+    observable.notify('first')
+    observable.notify('second')
+
+    const observer = jasmine.createSpy('observer').and.callFake(() => {
+      subscription.unsubscribe()
+    })
+    const subscription = observable.subscribe(observer)
+
+    await waitNextMicrotask()
+
+    expect(observer).toHaveBeenCalledTimes(1)
+  })
+
+  it('allows to unsubscribe before the buffered data', async () => {
+    const observable = new BufferedObservable<string>(100)
+    observable.notify('first')
+
+    const observer = jasmine.createSpy('observer')
+    const subscription = observable.subscribe(observer)
+
+    subscription.unsubscribe()
+
+    await waitNextMicrotask()
+
+    expect(observer).not.toHaveBeenCalled()
+  })
+
+  it('allows to unsubscribe after the buffered data', async () => {
+    const observable = new BufferedObservable<string>(100)
+
+    const observer = jasmine.createSpy('observer')
+    const subscription = observable.subscribe(observer)
+
+    await waitNextMicrotask()
+
+    subscription.unsubscribe()
+
+    observable.notify('first')
+
+    expect(observer).not.toHaveBeenCalled()
+  })
+
+  it('calling unbuffer() removes buffered data', async () => {
+    const observable = new BufferedObservable<string>(2)
+    observable.notify('first')
+    observable.notify('second')
+
+    observable.unbuffer()
+    await waitNextMicrotask()
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+    await waitNextMicrotask()
+
+    expect(observer).not.toHaveBeenCalled()
+  })
+
+  it('when calling unbuffer() right after subscription, buffered data should still be notified', async () => {
+    const observable = new BufferedObservable<string>(2)
+    observable.notify('first')
+    observable.notify('second')
+
+    const observer = jasmine.createSpy('observer')
+    observable.subscribe(observer)
+
+    observable.unbuffer()
+    await waitNextMicrotask()
+
+    expect(observer).toHaveBeenCalledTimes(2)
+    expect(observer).toHaveBeenCalledWith('first')
+    expect(observer).toHaveBeenCalledWith('second')
+  })
+})

package/src/tools/queueMicrotask.spec.ts

@@ -0,0 +1,24 @@
+import { startMockTelemetry, waitNextMicrotask } from '../../test'
+import { queueMicrotask } from './queueMicrotask'
+
+describe('queueMicrotask', () => {
+  it('calls the callback in a microtask', async () => {
+    let called = false
+    queueMicrotask(() => {
+      called = true
+    })
+    expect(called).toBe(false)
+    await waitNextMicrotask()
+    expect(called).toBe(true)
+  })
+
+  it('monitors the callback', async () => {
+    const telemetry = startMockTelemetry()
+    queueMicrotask(() => {
+      throw new Error('test error')
+    })
+    await waitNextMicrotask()
+
+    expect(await telemetry.hasEvents()).toBe(true)
+  })
+})

package/src/tools/readBytesFromStream.spec.ts

@@ -0,0 +1,62 @@
+import { readBytesFromStream } from './readBytesFromStream'
+
+describe('readBytesFromStream', () => {
+  const str = 'Lorem ipsum dolor sit amet.'
+  let stream: ReadableStream
+
+  beforeEach(() => {
+    stream = new ReadableStream({
+      start: (controller) => {
+        controller.enqueue(new TextEncoder().encode(str))
+        controller.close()
+      },
+    })
+  })
+
+  it('should read full stream', async () => {
+    const bytes = await readBytesFromStream(stream, {
+      collectStreamBody: true,
+    })
+
+    expect(bytes?.length).toBe(27)
+  })
+
+  it('should read full stream without body', async () => {
+    const bytes = await readBytesFromStream(stream, {
+      collectStreamBody: false,
+    })
+    expect(bytes).toBeUndefined()
+  })
+
+  it('should handle rejection error on read', async () => {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        controller.error(new Error('foo'))
+      },
+    })
+
+    try {
+      await readBytesFromStream(stream, {
+        collectStreamBody: true,
+      })
+      fail('Should have thrown an error')
+    } catch (error) {
+      expect(error).toEqual(jasmine.any(Error))
+    }
+  })
+
+  it('should handle rejection error on cancel', async () => {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        controller.enqueue(new TextEncoder().encode('f'))
+        controller.close()
+      },
+      cancel: () => Promise.reject(new Error('foo')),
+    })
+
+    const bytes = await readBytesFromStream(stream, {
+      collectStreamBody: true,
+    })
+    expect(bytes).toBeDefined()
+  })
+})

package/src/tools/requestIdleCallback.spec.ts

@@ -0,0 +1,65 @@
+import { mockClock, registerCleanupTask, type Clock } from '../../test'
+import { MAX_TASK_TIME, requestIdleCallbackShim, requestIdleCallback } from './requestIdleCallback'
+
+describe('requestIdleCallback', () => {
+  it('fallbacks to the shim when requestIdleCallback is not available', () => {
+    const clock = mockClock()
+    removeGlobalRequestIdleCallback()
+
+    const spy = jasmine.createSpy<(deadline: IdleDeadline) => void>()
+
+    requestIdleCallback(spy)
+    expect(spy).not.toHaveBeenCalled()
+
+    clock.tick(0)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('requestIdleCallbackShim', () => {
+  let clock: Clock
+
+  beforeEach(() => {
+    clock = mockClock()
+  })
+
+  it('calls the callback asynchronously', () => {
+    const spy = jasmine.createSpy<(deadline: IdleDeadline) => void>()
+    requestIdleCallbackShim(spy)
+    expect(spy).not.toHaveBeenCalled()
+    clock.tick(0)
+    expect(spy).toHaveBeenCalledOnceWith({ didTimeout: false, timeRemaining: jasmine.any(Function) })
+  })
+
+  it('notifies the remaining time', () => {
+    const spy = jasmine.createSpy<(deadline: IdleDeadline) => void>()
+    requestIdleCallbackShim(spy)
+
+    clock.tick(10)
+    const deadline = spy.calls.mostRecent().args[0]
+
+    expect(deadline.timeRemaining()).toBe(MAX_TASK_TIME - 10)
+
+    clock.tick(10)
+    expect(deadline.timeRemaining()).toBe(MAX_TASK_TIME - 20)
+
+    clock.tick(MAX_TASK_TIME + 100)
+    expect(deadline.timeRemaining()).toBe(0)
+  })
+
+  it('cancels the callback when calling the stop function', () => {
+    const spy = jasmine.createSpy<(deadline: IdleDeadline) => void>()
+    const stop = requestIdleCallbackShim(spy)
+    stop()
+    clock.tick(0)
+    expect(spy).not.toHaveBeenCalled()
+  })
+})
+
+function removeGlobalRequestIdleCallback() {
+  const original = window.requestIdleCallback
+  ;(window as any).requestIdleCallback = undefined
+  registerCleanupTask(() => {
+    window.requestIdleCallback = original
+  })
+}

package/src/tools/serialisation/jsonStringify.spec.ts

@@ -0,0 +1,76 @@
+import { jsonStringify } from './jsonStringify'
+
+describe('jsonStringify', () => {
+  afterEach(() => {
+    delete (Array.prototype as any).toJSON
+    delete (Object.prototype as any).toJSON
+  })
+
+  it('should jsonStringify a value with toJSON directly defined', () => {
+    const value = { 1: 'a' }
+    const expectedJson = JSON.stringify(value)
+
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    ;(value as any).toJSON = () => '42'
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    expect(JSON.stringify(value)).toEqual('"42"')
+  })
+
+  it('should jsonStringify a value with toJSON defined on its prototype', () => {
+    const value = createSampleClassInstance()
+    const expectedJson = JSON.stringify(value)
+
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    Object.getPrototypeOf(value).toJSON = () => '42'
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    expect(JSON.stringify(value)).toEqual('"42"')
+  })
+
+  it('should jsonStringify a value when toJSON is defined on Object prototype', () => {
+    const value = createSampleClassInstance()
+    const expectedJson = JSON.stringify(value)
+
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    ;(Object.prototype as any).toJSON = () => '42'
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    expect(JSON.stringify(value)).toEqual('"42"')
+  })
+
+  it('should jsonStringify a value when toJSON is defined on Array prototype', () => {
+    const value = createSampleClassInstance([1])
+    const expectedJson = JSON.stringify(value)
+
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    ;(Array.prototype as any).toJSON = () => '42'
+    expect(jsonStringify(value)).toEqual(expectedJson)
+    expect(JSON.stringify(value)).toEqual('{"value":"42"}')
+  })
+
+  it('should not restore the toJSON method on the wrong prototype', () => {
+    const value = [{ 1: 'a' }]
+    ;(Object.prototype as any).toJSON = () => '42'
+    jsonStringify(value)
+    expect(Object.prototype.hasOwnProperty.call(Array.prototype, 'toJSON')).toBe(false)
+  })
+
+  it('should jsonStringify edge cases', () => {
+    expect(jsonStringify(undefined)).toEqual(undefined)
+    expect(jsonStringify(null)).toEqual('null')
+    expect(jsonStringify(1)).toEqual('1')
+    expect(jsonStringify(true)).toEqual('true')
+  })
+
+  it('should not crash on serialization error', () => {
+    const circularReference: any = { otherData: 123 }
+    circularReference.myself = circularReference
+
+    expect(jsonStringify(circularReference)).toEqual('<error: unable to serialize object>')
+  })
+
+  function createSampleClassInstance(value: any = 'value') {
+    class Foo {
+      value = value
+    }
+    return new Foo()
+  }
+})