@openobserve/browser-core 0.2.12-beta.27 → 0.2.12-beta.28

package/src/tools/matchOption.spec.ts

@@ -0,0 +1,41 @@
+import { display } from './display'
+import { matchList } from './matchOption'
+
+describe('matchList', () => {
+  it('should match exact value', () => {
+    const list = ['foo', 'bar']
+    expect(matchList(list, 'foo')).toBe(true)
+    expect(matchList(list, 'bar')).toBe(true)
+    expect(matchList(list, 'qux')).toBe(false)
+  })
+
+  it('should match regexp', () => {
+    const list = [/^foo/, /foo$/]
+    expect(matchList(list, 'foobar')).toBe(true)
+    expect(matchList(list, 'barfoo')).toBe(true)
+    expect(matchList(list, 'barqux')).toBe(false)
+  })
+
+  it('should match function', () => {
+    const list = [(value: string) => value === 'foo', (value: string) => value === 'bar']
+    expect(matchList(list, 'foo')).toBe(true)
+    expect(matchList(list, 'bar')).toBe(true)
+    expect(matchList(list, 'qux')).toBe(false)
+  })
+
+  it('should compare strings using startsWith when enabling the option', () => {
+    const list = ['http://my.domain.com']
+    expect(matchList(list, 'http://my.domain.com/action', true)).toBe(true)
+  })
+
+  it('should catch error from provided function', () => {
+    spyOn(display, 'error')
+    const list = [
+      (_: string) => {
+        throw new Error('oops')
+      },
+    ]
+    expect(matchList(list, 'foo')).toBe(false)
+    expect(display.error).toHaveBeenCalled()
+  })
+})

package/src/tools/mergeInto.spec.ts

@@ -0,0 +1,198 @@
+import { deepClone, mergeInto, combine } from './mergeInto'
+
+describe('mergeInto', () => {
+  describe('source is not an object or array', () => {
+    it('should ignore undefined sources', () => {
+      const destination = {}
+      expect(mergeInto(destination, undefined)).toBe(destination)
+    })
+
+    it('should ignore undefined destination', () => {
+      expect(mergeInto(undefined, 1)).toBe(1)
+    })
+
+    it('should ignore destinations with a different type', () => {
+      expect(mergeInto({}, 1)).toBe(1)
+    })
+  })
+
+  describe('source is an array', () => {
+    it('should create a new array if destination is undefined', () => {
+      const source = [1]
+      const result = mergeInto(undefined, source)
+      expect(result).not.toBe(source)
+      expect(result).toEqual(source)
+    })
+
+    it('should return the copy of source if the destination is not an array', () => {
+      const source = [1]
+      expect(mergeInto({}, source)).toEqual(source)
+    })
+
+    it('should mutate and return destination if it is an array', () => {
+      const destination = ['destination']
+      const source = ['source']
+      const result = mergeInto(destination, source)
+      expect(result).toBe(destination)
+      expect(result).toEqual(source)
+    })
+  })
+
+  describe('source is an object', () => {
+    it('should create a new object if destination is undefined', () => {
+      const source = {}
+      const result = mergeInto(undefined, source)
+      expect(result).not.toBe(source)
+      expect(result).toEqual(source)
+    })
+
+    it('should return the copy of source if the destination is not an object', () => {
+      const source = { a: 1 }
+      expect(mergeInto([], source)).toEqual(source)
+    })
+
+    it('should mutate and return destination if it is an object', () => {
+      const destination = {}
+      const source = { a: 'b' }
+      const result = mergeInto(destination, source)
+      expect(result).toBe(destination as any)
+      expect(result).toEqual(source)
+    })
+  })
+})
+
+describe('combine', () => {
+  it('should deeply add and replace keys', () => {
+    const sourceA = { a: { b: 'toBeReplaced', c: 'source a' } }
+    const sourceB = { a: { b: 'replaced', d: 'source b' } }
+    expect(combine(sourceA, sourceB)).toEqual({ a: { b: 'replaced', c: 'source a', d: 'source b' } })
+  })
+
+  it('should not replace with undefined', () => {
+    expect(combine({ a: 1 }, { a: undefined as number | undefined })).toEqual({ a: 1 })
+  })
+
+  it('should replace a sub-value with null', () => {
+    expect(combine({ a: {} }, { a: null as any })).toEqual({ a: null })
+  })
+
+  it('should ignore null arguments', () => {
+    expect(combine({ a: 1 }, null)).toEqual({ a: 1 })
+  })
+
+  it('should merge arrays', () => {
+    const sourceA = [{ a: 'source a' }, 'extraString'] as any
+    const sourceB = [{ b: 'source b' }] as any
+    expect(combine(sourceA, sourceB)).toEqual([{ a: 'source a', b: 'source b' }, 'extraString'])
+  })
+
+  it('should merge multiple objects', () => {
+    expect(combine({ a: 1 }, { b: 2 }, { c: 3 })).toEqual({ a: 1, b: 2, c: 3 })
+  })
+
+  it('should not keep references on objects', () => {
+    const source = { a: { b: 1 } }
+    const result = combine({}, source)
+    expect(result.a).not.toBe(source.a)
+  })
+
+  it('should not keep references on arrays', () => {
+    const source = { a: [1] }
+    const result = combine({}, source)
+    expect(result.a).not.toBe(source.a)
+  })
+})
+
+describe('deepClone', () => {
+  it('should pass-through primitive values', () => {
+    expect(deepClone('test')).toBe('test')
+    expect(deepClone(true)).toBe(true)
+    expect(deepClone(false)).toBe(false)
+    expect(deepClone(null)).toBe(null)
+    expect(deepClone(undefined)).toBe(undefined)
+    expect(deepClone(1)).toBe(1)
+    expect(deepClone(NaN)).toBeNaN()
+    expect(deepClone(Infinity)).toBe(Infinity)
+    expect(deepClone(-Infinity)).toBe(-Infinity)
+  })
+
+  it('should pass-through functions', () => {
+    const fn = () => null
+    expect(deepClone(fn)).toBe(fn)
+  })
+
+  it('should pass-through classes', () => {
+    class Foo {}
+    // typeof class is 'function' so it will behave the same as for function case
+    expect(deepClone(Foo)).toBe(Foo)
+  })
+
+  it('should clone array recursively', () => {
+    const source = [1, undefined, null, [4, 5, 6]]
+    const clone = deepClone(source)
+
+    expect(clone).toEqual(source)
+    expect(clone).not.toBe(source)
+    source.push(7)
+    ;(source[3] as any[]).push(8)
+
+    expect(clone[4]).toBeUndefined()
+    expect((clone[3] as any[])[3]).toBeUndefined()
+  })
+
+  it('should clone object recursively', () => {
+    const source = { foo: 'bar', baz: { arr: [1, 2], fn: () => undefined } }
+    const clone = deepClone(source)
+
+    expect(clone).toEqual(source)
+    expect(clone).not.toBe(source)
+    source.baz.arr.push(1)
+    ;(source.baz as any).added = 'test'
+
+    expect(clone.baz.arr).toEqual([1, 2])
+    expect((clone.baz as any).added).toBeUndefined()
+  })
+
+  it('should clone regexp', () => {
+    const source = { reg: /test/gi }
+    const clone = deepClone(source)
+
+    expect(clone).toEqual(source)
+    expect(clone).not.toBe(source)
+    expect(clone.reg).not.toBe(source.reg)
+
+    expect(clone.reg.ignoreCase).toBe(true)
+    expect(clone.reg.global).toBe(true)
+    expect(clone.reg.multiline).toBe(false)
+  })
+
+  it('should clone date', () => {
+    const source = [1, new Date('2012-12-12')] as const
+    const clone = deepClone(source)
+
+    expect(clone).toEqual(source)
+    expect(clone).not.toBe(source)
+    expect(clone[1]).not.toBe(source[1])
+
+    const originalTime = source[1].getTime()
+    source[1].setTime(originalTime + 100)
+    expect(clone[1].getTime()).toEqual(originalTime)
+  })
+
+  it('should remove circular references', () => {
+    const a: Record<string, any> = { foo: 'bar', ref: null }
+    const b: Record<string, any> = { baz: 'bar', ref: null }
+    // create circular reference
+    a.ref = b
+    b.ref = a
+
+    const clonedA = deepClone(a)
+    const clonedB = deepClone(b)
+
+    expect(clonedA).not.toEqual(a)
+    expect(clonedA.ref.ref).toBeUndefined()
+
+    expect(clonedB).not.toEqual(b)
+    expect(clonedB.ref.ref).toBeUndefined()
+  })
+})

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