@openobserve/browser-core 0.3.4 → 0.4.0-beta.1

package/src/tools/instrumentMethod.spec.ts

@@ -1,381 +0,0 @@
-import { mockClock, mockZoneJs } from '../../test'
-import type { Clock, MockZoneJs } from '../../test'
-import type { InstrumentedMethodCall } from './instrumentMethod'
-import { instrumentMethod, instrumentSetter } from './instrumentMethod'
-import { noop } from './utils/functionUtils'
-
-describe('instrumentMethod', () => {
-  const THIRD_PARTY_RESULT = 42
-
-  it('replaces the original method', () => {
-    const original = () => 1
-    const object = { method: original }
-
-    instrumentMethod(object, 'method', noop)
-
-    expect(object.method).not.toBe(original)
-  })
-
-  it('calls the instrumentation before the original method', () => {
-    const originalSpy = jasmine.createSpy()
-    const instrumentationSpy = jasmine.createSpy()
-    const object = { method: originalSpy }
-
-    instrumentMethod(object, 'method', instrumentationSpy)
-
-    object.method()
-
-    expect(instrumentationSpy).toHaveBeenCalledBefore(originalSpy)
-  })
-
-  it('does not set a method originally undefined', () => {
-    const object: { method?: () => number } = {}
-
-    instrumentMethod(object, 'method', noop)
-
-    expect(object.method).toBeUndefined()
-  })
-
-  it('sets an event handler even if it was originally undefined', () => {
-    const object: { onevent?: () => void } = { onevent: undefined }
-
-    const instrumentationSpy = jasmine.createSpy()
-    instrumentMethod(object, 'onevent', instrumentationSpy)
-
-    expect(object.onevent).toBeDefined()
-
-    object.onevent!()
-    expect(instrumentationSpy).toHaveBeenCalled()
-  })
-
-  it('do not set an event handler even if the event is not supported (i.e. property does not exist on object)', () => {
-    const object: { onevent?: () => void } = {}
-
-    const instrumentationSpy = jasmine.createSpy()
-    instrumentMethod(object, 'onevent', instrumentationSpy)
-
-    expect('onevent' in object).toBeFalse()
-  })
-
-  it('calls the instrumentation with method target and parameters', () => {
-    const object = { method: (a: number, b: number) => a + b }
-    const instrumentationSpy = jasmine.createSpy<(call: InstrumentedMethodCall<typeof object, 'method'>) => void>()
-    instrumentMethod(object, 'method', instrumentationSpy)
-
-    object.method(2, 3)
-
-    expect(instrumentationSpy).toHaveBeenCalledOnceWith({
-      target: object,
-      parameters: jasmine.any(Object),
-      onPostCall: jasmine.any(Function),
-      handlingStack: undefined,
-    })
-    expect(instrumentationSpy.calls.mostRecent().args[0].parameters[0]).toBe(2)
-    expect(instrumentationSpy.calls.mostRecent().args[0].parameters[1]).toBe(3)
-  })
-
-  it('allows replacing a parameter', () => {
-    const object = { method: (a: number) => a }
-    instrumentMethod(object, 'method', ({ parameters }) => {
-      parameters[0] = 2
-    })
-
-    expect(object.method(1)).toBe(2)
-  })
-
-  it('allows adding a parameter', () => {
-    const object = { method: (a?: number) => a }
-    instrumentMethod(object, 'method', ({ parameters }) => {
-      parameters[0] = 2
-    })
-
-    expect(object.method()).toBe(2)
-  })
-
-  it('calls the "onPostCall" callback with the original method result', () => {
-    const object = { method: () => 1 }
-    const onPostCallSpy = jasmine.createSpy()
-    instrumentMethod(object, 'method', ({ onPostCall }) => onPostCall(onPostCallSpy))
-
-    object.method()
-
-    expect(onPostCallSpy).toHaveBeenCalledOnceWith(1)
-  })
-
-  it('allows other instrumentations from third parties', () => {
-    const object = { method: () => 1 }
-    const instrumentationSpy = jasmine.createSpy()
-    instrumentMethod(object, 'method', instrumentationSpy)
-
-    thirdPartyInstrumentation(object)
-
-    expect(object.method()).toBe(THIRD_PARTY_RESULT)
-    expect(instrumentationSpy).toHaveBeenCalled()
-  })
-
-  it('computes the handling stack', () => {
-    const object = { method: () => 1 }
-    const instrumentationSpy = jasmine.createSpy()
-    instrumentMethod(object, 'method', instrumentationSpy, { computeHandlingStack: true })
-
-    function foo() {
-      object.method()
-    }
-
-    foo()
-
-    expect(instrumentationSpy.calls.mostRecent().args[0].handlingStack).toEqual(
-      jasmine.stringMatching(/^HandlingStack: instrumented method\n {2}at foo @/)
-    )
-  })
-
-  describe('stop()', () => {
-    it('does not call the instrumentation anymore', () => {
-      const object = { method: () => 1 }
-      const instrumentationSpy = jasmine.createSpy()
-      const { stop } = instrumentMethod(object, 'method', () => instrumentationSpy)
-
-      stop()
-
-      object.method()
-      expect(instrumentationSpy).not.toHaveBeenCalled()
-    })
-
-    describe('when the method has been instrumented by a third party', () => {
-      it('should not break the third party instrumentation', () => {
-        const object = { method: () => 1 }
-        const { stop } = instrumentMethod(object, 'method', noop)
-
-        thirdPartyInstrumentation(object)
-        const instrumentedMethod = object.method
-
-        stop()
-
-        expect(object.method).toBe(instrumentedMethod)
-      })
-
-      it('does not call the instrumentation', () => {
-        const object = { method: () => 1 }
-        const instrumentationSpy = jasmine.createSpy()
-        const { stop } = instrumentMethod(object, 'method', instrumentationSpy)
-
-        thirdPartyInstrumentation(object)
-
-        stop()
-
-        expect(instrumentationSpy).not.toHaveBeenCalled()
-      })
-
-      it('should not throw errors if original method was undefined', () => {
-        const object: { onevent?: () => number } = {}
-        const instrumentationStub = () => 2
-        const { stop } = instrumentMethod(object, 'onevent', instrumentationStub)
-
-        thirdPartyInstrumentation(object)
-
-        stop()
-
-        expect(object.onevent).not.toThrow()
-      })
-    })
-  })
-
-  function thirdPartyInstrumentation(object: { method?: () => number; onevent?: () => void }) {
-    const originalMethod = object.method
-    if (typeof originalMethod === 'function') {
-      object.method = () => {
-        originalMethod()
-        return THIRD_PARTY_RESULT
-      }
-    }
-
-    const originalOnEvent = object.onevent
-    object.onevent = () => {
-      if (originalOnEvent) {
-        originalOnEvent()
-      }
-    }
-  }
-})
-
-describe('instrumentSetter', () => {
-  let clock: Clock
-  let zoneJs: MockZoneJs
-
-  beforeEach(() => {
-    clock = mockClock()
-    zoneJs = mockZoneJs()
-  })
-
-  it('replaces the original setter', () => {
-    const originalSetter = () => {
-      // do nothing particular, only used to test if this setter gets replaced
-    }
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: originalSetter, configurable: true })
-
-    instrumentSetter(object, 'foo', noop)
-
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(Object.getOwnPropertyDescriptor(object, 'foo')!.set).not.toBe(originalSetter)
-  })
-
-  it('skips instrumentation if there is no original setter', () => {
-    const object = { foo: 1 }
-
-    instrumentSetter(object, 'foo', noop)
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(Object.getOwnPropertyDescriptor(object, 'foo')!.set).toBeUndefined()
-  })
-
-  it('skips instrumentation if the descriptor is not configurable', () => {
-    const originalSetter = () => {
-      // do nothing particular, only used to test if this setter gets replaced
-    }
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: originalSetter, configurable: false })
-
-    instrumentSetter(object, 'foo', noop)
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    expect(Object.getOwnPropertyDescriptor(object, 'foo')!.set).toBe(originalSetter)
-  })
-
-  it('calls the original setter', () => {
-    const originalSetterSpy = jasmine.createSpy()
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: originalSetterSpy, configurable: true })
-
-    instrumentSetter(object, 'foo', noop)
-
-    object.foo = 1
-    expect(originalSetterSpy).toHaveBeenCalledOnceWith(1)
-  })
-
-  it('calls the instrumentation asynchronously', () => {
-    const instrumentationSetterSpy = jasmine.createSpy()
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-
-    instrumentSetter(object, 'foo', instrumentationSetterSpy)
-
-    object.foo = 1
-    expect(instrumentationSetterSpy).not.toHaveBeenCalled()
-    clock.tick(0)
-    expect(instrumentationSetterSpy).toHaveBeenCalledOnceWith(object, 1)
-  })
-
-  it('does not use the Zone.js setTimeout function', () => {
-    const zoneJsSetTimeoutSpy = jasmine.createSpy()
-    zoneJs.replaceProperty(window, 'setTimeout', zoneJsSetTimeoutSpy)
-
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-
-    instrumentSetter(object, 'foo', noop)
-    object.foo = 2
-
-    clock.tick(0)
-
-    expect(zoneJsSetTimeoutSpy).not.toHaveBeenCalled()
-  })
-
-  it('allows other instrumentations from third parties', () => {
-    const object = {} as { foo: number }
-    Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-    const instrumentationSetterSpy = jasmine.createSpy()
-    instrumentSetter(object, 'foo', instrumentationSetterSpy)
-
-    const thirdPartyInstrumentationSpy = thirdPartyInstrumentation(object)
-
-    object.foo = 2
-    expect(thirdPartyInstrumentationSpy).toHaveBeenCalledOnceWith(2)
-    clock.tick(0)
-    expect(instrumentationSetterSpy).toHaveBeenCalledOnceWith(object, 2)
-  })
-
-  describe('stop()', () => {
-    it('restores the original behavior', () => {
-      const object = {} as { foo: number }
-      const originalSetter = () => {
-        // do nothing particular, only used to test if this setter gets replaced
-      }
-      Object.defineProperty(object, 'foo', { set: originalSetter, configurable: true })
-      const { stop } = instrumentSetter(object, 'foo', noop)
-
-      stop()
-
-      // eslint-disable-next-line @typescript-eslint/unbound-method
-      expect(Object.getOwnPropertyDescriptor(object, 'foo')!.set).toBe(originalSetter)
-    })
-
-    it('does not call the instrumentation anymore', () => {
-      const object = {} as { foo: number }
-      Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-      const instrumentationSetterSpy = jasmine.createSpy()
-      const { stop } = instrumentSetter(object, 'foo', instrumentationSetterSpy)
-
-      stop()
-
-      object.foo = 2
-      clock.tick(0)
-
-      expect(instrumentationSetterSpy).not.toHaveBeenCalled()
-    })
-
-    it('does not call instrumentation pending in the event loop via setTimeout', () => {
-      const object = {} as { foo: number }
-      Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-      const instrumentationSetterSpy = jasmine.createSpy()
-      const { stop } = instrumentSetter(object, 'foo', instrumentationSetterSpy)
-
-      object.foo = 2
-      stop()
-      clock.tick(0)
-
-      expect(instrumentationSetterSpy).not.toHaveBeenCalled()
-    })
-
-    describe('when the method has been instrumented by a third party', () => {
-      it('should not break the third party instrumentation', () => {
-        const object = {} as { foo: number }
-        Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-        const { stop } = instrumentSetter(object, 'foo', noop)
-
-        const thirdPartyInstrumentationSpy = thirdPartyInstrumentation(object)
-
-        stop()
-
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        expect(Object.getOwnPropertyDescriptor(object, 'foo')!.set).toBe(thirdPartyInstrumentationSpy)
-      })
-
-      it('does not call the instrumentation', () => {
-        const object = {} as { foo: number }
-        Object.defineProperty(object, 'foo', { set: noop, configurable: true })
-        const instrumentationSetterSpy = jasmine.createSpy()
-        const { stop } = instrumentSetter(object, 'foo', instrumentationSetterSpy)
-
-        thirdPartyInstrumentation(object)
-
-        stop()
-
-        object.foo = 2
-        clock.tick(0)
-
-        expect(instrumentationSetterSpy).not.toHaveBeenCalled()
-      })
-    })
-  })
-
-  function thirdPartyInstrumentation(object: { foo: number }) {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const originalSetter = Object.getOwnPropertyDescriptor(object, 'foo')!.set
-    const thirdPartyInstrumentationSpy = jasmine.createSpy().and.callFake(function (this: any, value) {
-      if (originalSetter) {
-        originalSetter.call(this, value)
-      }
-    })
-    Object.defineProperty(object, 'foo', { set: thirdPartyInstrumentationSpy })
-    return thirdPartyInstrumentationSpy
-  }
-})

package/src/tools/matchOption.spec.ts

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

@@ -1,198 +0,0 @@
-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()
-  })
-})