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

package/src/tools/stackTrace/handlingStack.spec.ts

@@ -0,0 +1,20 @@
+import { createHandlingStack } from './handlingStack'
+
+describe('createHandlingStack', () => {
+  let handlingStack: string
+  function internalCall() {
+    handlingStack = createHandlingStack('error')
+  }
+  function userCallTwo() {
+    internalCall()
+  }
+  function userCallOne() {
+    userCallTwo()
+  }
+
+  it('should create handling stack trace without internal calls', () => {
+    userCallOne()
+
+    expect(handlingStack).toMatch(/^HandlingStack: error\n\s+at userCallTwo @ (.*)\n\s+at userCallOne @ (.*)/)
+  })
+})

package/src/tools/taskQueue.spec.ts

@@ -0,0 +1,60 @@
+import { mockClock, mockRequestIdleCallback } from '../../test'
+import { createTaskQueue, MAX_EXECUTION_TIME_ON_TIMEOUT } from './taskQueue'
+
+describe('createTaskQueue', () => {
+  it('runs the task using an idle callback', () => {
+    const requestIdleCallbackMock = mockRequestIdleCallback()
+    const taskQueue = createTaskQueue()
+    const task = jasmine.createSpy('task')
+
+    taskQueue.push(task)
+    expect(task).not.toHaveBeenCalled()
+
+    requestIdleCallbackMock.idle()
+    expect(task).toHaveBeenCalled()
+  })
+
+  it('runs as many tasks as possible in a single idle callback', () => {
+    const clock = mockClock()
+    const requestIdleCallbackMock = mockRequestIdleCallback()
+
+    // Each task takes 10ms to run
+    const task1 = jasmine.createSpy().and.callFake(() => clock.tick(10))
+    const task2 = jasmine.createSpy().and.callFake(() => clock.tick(10))
+    const task3 = jasmine.createSpy().and.callFake(() => clock.tick(10))
+
+    const taskQueue = createTaskQueue()
+
+    taskQueue.push(task1)
+    taskQueue.push(task2)
+    taskQueue.push(task3)
+
+    requestIdleCallbackMock.idle(15)
+    expect(task1).toHaveBeenCalled()
+    expect(task2).toHaveBeenCalled()
+    expect(task3).not.toHaveBeenCalled()
+
+    requestIdleCallbackMock.idle(5)
+    expect(task3).toHaveBeenCalled()
+  })
+
+  it('runs some tasks in case of timeout', () => {
+    const clock = mockClock()
+    const requestIdleCallbackMock = mockRequestIdleCallback()
+
+    const task1 = jasmine.createSpy().and.callFake(() => clock.tick(MAX_EXECUTION_TIME_ON_TIMEOUT - 10))
+    const task2 = jasmine.createSpy().and.callFake(() => clock.tick(20))
+    const task3 = jasmine.createSpy().and.callFake(() => clock.tick(20))
+
+    const taskQueue = createTaskQueue()
+
+    taskQueue.push(task1)
+    taskQueue.push(task2)
+    taskQueue.push(task3)
+
+    requestIdleCallbackMock.timeout()
+    expect(task1).toHaveBeenCalled()
+    expect(task2).toHaveBeenCalled()
+    expect(task3).not.toHaveBeenCalled()
+  })
+})

package/src/tools/timer.spec.ts

@@ -0,0 +1,76 @@
+import { mockClock, mockZoneJs, registerCleanupTask } from '../../test'
+import type { Clock, MockZoneJs } from '../../test'
+import { resetMonitor, startMonitorErrorCollection } from './monitor'
+import { setTimeout, clearTimeout, setInterval, clearInterval } from './timer'
+import { noop } from './utils/functionUtils'
+;[
+  {
+    name: 'setTimeout' as const,
+    setTimer: setTimeout,
+    clearTimer: clearTimeout,
+  },
+  {
+    name: 'setInterval' as const,
+    setTimer: setInterval,
+    clearTimer: clearInterval,
+  },
+].forEach(({ name, setTimer, clearTimer }) => {
+  describe(name, () => {
+    let clock: Clock
+    let zoneJs: MockZoneJs
+
+    beforeEach(() => {
+      clock = mockClock()
+      registerCleanupTask(() => {
+        resetMonitor()
+      })
+      zoneJs = mockZoneJs()
+    })
+
+    it('executes the callback asynchronously', () => {
+      const spy = jasmine.createSpy()
+      setTimer(spy)
+      expect(spy).not.toHaveBeenCalled()
+      clock.tick(0)
+      expect(spy).toHaveBeenCalledOnceWith()
+    })
+
+    it('schedules an asynchronous task', () => {
+      const spy = jasmine.createSpy()
+      setTimer(spy)
+      expect(spy).not.toHaveBeenCalled()
+      clock.tick(0)
+      expect(spy).toHaveBeenCalledOnceWith()
+    })
+
+    it('does not use the Zone.js function', () => {
+      const zoneJsSetTimerSpy = jasmine.createSpy()
+      zoneJs.replaceProperty(window, name, zoneJsSetTimerSpy)
+
+      setTimer(noop)
+      clock.tick(0)
+
+      expect(zoneJsSetTimerSpy).not.toHaveBeenCalled()
+    })
+
+    it('monitors the callback', () => {
+      const onMonitorErrorCollectedSpy = jasmine.createSpy()
+      startMonitorErrorCollection(onMonitorErrorCollectedSpy)
+
+      setTimer(() => {
+        throw new Error('foo')
+      })
+      clock.tick(0)
+
+      expect(onMonitorErrorCollectedSpy).toHaveBeenCalledOnceWith(new Error('foo'))
+    })
+
+    it('can be canceled', () => {
+      const spy = jasmine.createSpy()
+      const timerId = setTimer(spy)
+      clearTimer(timerId)
+      clock.tick(0)
+      expect(spy).not.toHaveBeenCalled()
+    })
+  })
+})

package/src/tools/utils/browserDetection.spec.ts

@@ -0,0 +1,120 @@
+import { combine } from '../mergeInto'
+import { Browser, detectBrowser } from './browserDetection'
+
+describe('browserDetection', () => {
+  it('detects Safari', () => {
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15',
+            vendor: 'Apple Computer, Inc.',
+          },
+        })
+      )
+    ).toBe(Browser.SAFARI)
+
+    // Emulates Safari detection if 'navigator.vendor' is removed one day
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Safari/605.1.15',
+          },
+        })
+      )
+    ).toBe(Browser.SAFARI)
+
+    // Webview on iOS
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (iPhone; CPU iPhone OS 16_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/20B110 [FBAN/FBIOS;FBDV/iPhone14,5;FBMD/iPhone;FBSN/iOS;FBSV/16.1.2;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5]',
+            vendor: 'Apple Computer, Inc.',
+          },
+        })
+      )
+    ).toBe(Browser.SAFARI)
+  })
+
+  it('detects Chromium', () => {
+    // Google Chrome 118
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36',
+            vendor: 'Google Inc.',
+          },
+          chrome: {},
+        })
+      )
+    ).toBe(Browser.CHROMIUM)
+
+    // Headless chrome
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/92.0.4512.0 Safari/537.36',
+            vendor: 'Google Inc.',
+          },
+        })
+      )
+    ).toBe(Browser.CHROMIUM)
+
+    // Microsoft Edge 89
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent:
+              'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36 Edg/89.0.774.54',
+            vendor: 'Google Inc.',
+          },
+          chrome: {},
+        })
+      )
+    ).toBe(Browser.CHROMIUM)
+  })
+
+  it('other browsers', () => {
+    // Firefox 10
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: { userAgent: 'Mozilla/5.0 (X11; Linux i686; rv:10.0) Gecko/20100101 Firefox/10.0' },
+        })
+      )
+    ).toBe(Browser.OTHER)
+
+    // Firefox 120
+    expect(
+      detectBrowser(
+        fakeWindowWithDefaults({
+          navigator: {
+            userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:120.0) Gecko/20100101 Firefox/120.0',
+          },
+        })
+      )
+    ).toBe(Browser.OTHER)
+  })
+
+  function fakeWindowWithDefaults(partial: any): Window {
+    return combine(
+      {
+        navigator: {
+          userAgent: '',
+        },
+        document: {},
+      },
+      partial
+    ) as Window
+  }
+})

package/src/tools/utils/byteUtils.spec.ts

@@ -0,0 +1,29 @@
+import { computeBytesCount, concatBuffers } from './byteUtils'
+
+describe('byteUtils', () => {
+  describe('computeBytesCount', () => {
+    it('should count the bytes of a message composed of 1 byte characters', () => {
+      expect(computeBytesCount('1234')).toEqual(4)
+    })
+
+    it('should count the bytes of a message composed of multiple bytes characters', () => {
+      expect(computeBytesCount('🪐')).toEqual(4)
+    })
+  })
+
+  describe('concatBuffers', () => {
+    it('concatenates buffers correctly', () => {
+      expect(concatBuffers([new Uint8Array([1, 2]), new Uint8Array([3, 4, 5]), new Uint8Array([6])])).toEqual(
+        new Uint8Array([1, 2, 3, 4, 5, 6])
+      )
+    })
+
+    it('concatenates an empty buffer and a non-empty buffer', () => {
+      expect(concatBuffers([new Uint8Array([]), new Uint8Array([1, 2, 3])])).toEqual(new Uint8Array([1, 2, 3]))
+    })
+
+    it('returns an empty buffer when an empty array is passed', () => {
+      expect(concatBuffers([])).toEqual(new Uint8Array([]))
+    })
+  })
+})

package/src/tools/utils/functionUtils.spec.ts

@@ -0,0 +1,229 @@
+import type { Clock } from '../../../test'
+import { mockClock } from '../../../test'
+import { throttle } from './functionUtils'
+
+describe('functionUtils', () => {
+  describe('throttle', () => {
+    let spy: jasmine.Spy
+    let throttled: () => void
+    let cancel: () => void
+    let clock: Clock
+
+    beforeEach(() => {
+      clock = mockClock()
+      spy = jasmine.createSpy()
+    })
+
+    describe('when {leading: false, trailing:false}', () => {
+      beforeEach(() => {
+        throttled = throttle(spy, 2, { leading: false, trailing: false }).throttled
+      })
+
+      it('should not call throttled function', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(0)
+      })
+
+      it('should not called throttled function after the wait period', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(0)
+      })
+
+      it('should not called throttled function performed after the wait period', () => {
+        throttled()
+        clock.tick(2)
+        throttled()
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(0)
+      })
+    })
+
+    describe('when {leading: false, trailing:true}', () => {
+      beforeEach(() => {
+        throttled = throttle(spy, 2, { leading: false }).throttled
+      })
+
+      it('should call throttled function after the wait period', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+
+      it('should dismiss calls made during the wait period', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(0)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+
+      it('should perform calls made after the wait period', () => {
+        throttled()
+        clock.tick(2)
+        throttled()
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe('when {leading: true, trailing:false}', () => {
+      beforeEach(() => {
+        throttled = throttle(spy, 2, { trailing: false }).throttled
+      })
+
+      it('should call throttled function immediately', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+
+      it('should dismiss calls made during the wait period', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(2)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(2)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+
+      it('should perform calls made after the wait period', () => {
+        throttled()
+        clock.tick(2)
+        throttled()
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe('when {leading: true, trailing:true}', () => {
+      beforeEach(() => {
+        throttled = throttle(spy, 2).throttled
+      })
+
+      it('should call throttled function immediately', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+
+      it('should postpone calls made during the wait period to after the period', () => {
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(2)
+
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(3)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(3)
+
+        clock.tick(1)
+        expect(spy).toHaveBeenCalledTimes(3)
+      })
+
+      it('should perform calls made after the wait period', () => {
+        throttled()
+        clock.tick(2)
+        throttled()
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe('cancel', () => {
+      beforeEach(() => {
+        const result = throttle(spy, 2)
+        cancel = result.cancel
+        throttled = result.throttled
+      })
+
+      it('should abort pending execution', () => {
+        throttled()
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+
+        cancel()
+
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+
+      it('should allow future calls', () => {
+        cancel()
+        throttled()
+        expect(spy).toHaveBeenCalledTimes(1)
+        clock.tick(2)
+        expect(spy).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    it('passes last parameters as arguments', () => {
+      const throttled = throttle(spy, 2).throttled
+      throttled(1)
+      throttled(2)
+      throttled(3)
+      clock.tick(2)
+      expect(spy.calls.allArgs()).toEqual([[1], [3]])
+    })
+  })
+})

package/src/tools/utils/numberUtils.spec.ts

@@ -0,0 +1,27 @@
+import { performDraw, round } from './numberUtils'
+
+describe('numberUtils', () => {
+  it('should perform a draw', () => {
+    let random = 0
+    spyOn(Math, 'random').and.callFake(() => random)
+
+    expect(performDraw(0)).toBe(false)
+    expect(performDraw(100)).toEqual(true)
+
+    random = 1
+    expect(performDraw(100)).toEqual(true)
+
+    random = 0.0001
+    expect(performDraw(0.01)).toEqual(true)
+
+    random = 0.1
+    expect(performDraw(0.01)).toEqual(false)
+  })
+
+  it('should round', () => {
+    expect(round(10.12591, 0)).toEqual(10)
+    expect(round(10.12591, 1)).toEqual(10.1)
+    expect(round(10.12591, 2)).toEqual(10.13)
+    expect(round(10.12591, 3)).toEqual(10.126)
+  })
+})

package/src/tools/utils/stringUtils.spec.ts

@@ -0,0 +1,74 @@
+import {
+  safeTruncate,
+  findCommaSeparatedValue,
+  findCommaSeparatedValues,
+  findAllCommaSeparatedValues,
+} from './stringUtils'
+
+describe('stringUtils', () => {
+  describe('safeTruncate', () => {
+    it('should truncate a string', () => {
+      const truncated = safeTruncate('1234😎7890', 6)
+      expect(truncated.length).toBe(6)
+      expect(truncated).toBe('1234😎')
+    })
+
+    it('should not break a surrogate characters pair', () => {
+      const truncated = safeTruncate('12345😎890', 6)
+      expect(truncated.length).toBe(7)
+      expect(truncated).toBe('12345😎')
+    })
+
+    it('should add the suffix when the string is truncated', () => {
+      const truncated = safeTruncate('12345😎890', 6, '...')
+      expect(truncated).toBe('12345😎...')
+    })
+
+    it('should not add the suffix when the string is not truncated', () => {
+      const truncated = safeTruncate('1234😎', 5, '...')
+      expect(truncated).toBe('1234😎')
+    })
+  })
+
+  describe('findCommaSeparatedValue', () => {
+    it('returns the value from a comma separated hash', () => {
+      expect(findCommaSeparatedValue('foo=a;bar=b', 'foo')).toBe('a')
+      expect(findCommaSeparatedValue('foo=a;bar=b', 'bar')).toBe('b')
+    })
+
+    it('is white-spaces tolerant', () => {
+      expect(findCommaSeparatedValue('   foo  =   a;  bar  =   b', 'foo')).toBe('a')
+      expect(findCommaSeparatedValue('   foo  =   a;  bar  =   b', 'bar')).toBe('b')
+    })
+
+    it('supports values containing an = character', () => {
+      expect(findCommaSeparatedValue('foo=a=b', 'foo')).toBe('a=b')
+    })
+
+    it('supports keys containing `-`', () => {
+      expect(findCommaSeparatedValue('foo-bar=baz', 'foo-bar')).toBe('baz')
+    })
+
+    it('returns undefined if the value is not found', () => {
+      expect(findCommaSeparatedValue('foo=a;bar=b', 'baz')).toBe(undefined)
+    })
+  })
+
+  describe('findCommaSeparatedValues', () => {
+    it('returns the values from a comma separated hash', () => {
+      const expectedValues = new Map<string, string>()
+      expectedValues.set('foo', 'a')
+      expectedValues.set('bar', 'b')
+      expect(findCommaSeparatedValues('foo=a;bar=b')).toEqual(expectedValues)
+    })
+  })
+
+  describe('findAllCommaSeparatedValues', () => {
+    it('returns all the values from a comma separated hash', () => {
+      const expectedValues = new Map<string, string[]>()
+      expectedValues.set('foo', ['a', 'c'])
+      expectedValues.set('bar', ['b'])
+      expect(findAllCommaSeparatedValues('foo=a;bar=b;foo=c')).toEqual(expectedValues)
+    })
+  })
+})

package/src/tools/utils/typeUtils.spec.ts

@@ -0,0 +1,25 @@
+import { getType } from './typeUtils'
+
+describe('typeUtils', () => {
+  describe('getType', () => {
+    it('should return "null" for null value', () => {
+      expect(getType(null)).toEqual('null')
+      expect(getType(undefined)).not.toEqual('null')
+    })
+
+    it('should return "array" for array value', () => {
+      expect(getType([])).toEqual('array')
+      expect(getType([1, 2, 3])).toEqual('array')
+      expect(getType([1, 2, [3, 4, 5]])).toEqual('array')
+    })
+
+    it('should return result of typeof operator for other types', () => {
+      expect(getType({})).toEqual('object')
+      expect(getType(() => null)).toEqual('function')
+      expect(getType('test')).toEqual('string')
+      expect(getType(1)).toEqual('number')
+      expect(getType(false)).toEqual('boolean')
+      expect(getType(new Date())).toEqual('object')
+    })
+  })
+})