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

package/src/tools/instrumentMethod.spec.ts

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

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