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

package/src/tools/abstractLifeCycle.spec.ts

@@ -0,0 +1,46 @@
+import { AbstractLifeCycle } from './abstractLifeCycle'
+
+describe('AbstractLifeCycle', () => {
+  const LifeCycle = AbstractLifeCycle<{
+    foo: 'bar'
+    no_data: void
+  }>
+
+  it('does nothing when notifying without subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    expect(() => lifeCycle.notify('foo', 'bar')).not.toThrow()
+  })
+
+  it('notifies subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriber1Spy = jasmine.createSpy()
+    const subscriber2Spy = jasmine.createSpy()
+    lifeCycle.subscribe('foo', subscriber1Spy)
+    lifeCycle.subscribe('foo', subscriber2Spy)
+
+    lifeCycle.notify('foo', 'bar')
+
+    expect(subscriber1Spy).toHaveBeenCalledOnceWith('bar')
+    expect(subscriber2Spy).toHaveBeenCalledOnceWith('bar')
+  })
+
+  it('notifies subscribers for events without data', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriberSpy = jasmine.createSpy()
+    lifeCycle.subscribe('no_data', subscriberSpy)
+
+    lifeCycle.notify('no_data')
+
+    expect(subscriberSpy).toHaveBeenCalledOnceWith(undefined)
+  })
+
+  it('does not notify unsubscribed subscribers', () => {
+    const lifeCycle = new LifeCycle()
+    const subscriberSpy = jasmine.createSpy()
+    lifeCycle.subscribe('foo', subscriberSpy).unsubscribe()
+
+    lifeCycle.notify('foo', 'bar')
+
+    expect(subscriberSpy).not.toHaveBeenCalled()
+  })
+})

package/src/tools/boundedBuffer.spec.ts

@@ -0,0 +1,40 @@
+import { createBoundedBuffer } from './boundedBuffer'
+
+describe('BoundedBuffer', () => {
+  it('collect and drain the callbacks', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+
+    buffered.add(spy)
+    expect(spy.calls.count()).toBe(0)
+
+    buffered.drain()
+    expect(spy.calls.count()).toBe(1)
+
+    buffered.drain()
+    expect(spy.calls.count()).toBe(1)
+  })
+
+  it('store at most 500 callbacks', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+    const limit = 500
+
+    for (let i = 0; i < limit + 1; i += 1) {
+      buffered.add(spy)
+    }
+
+    buffered.drain()
+    expect(spy.calls.count()).toEqual(limit)
+  })
+
+  it('removes a callback', () => {
+    const spy = jasmine.createSpy<() => void>()
+    const buffered = createBoundedBuffer()
+
+    buffered.add(spy)
+    buffered.remove(spy)
+    buffered.drain()
+    expect(spy).not.toHaveBeenCalled()
+  })
+})

package/src/tools/catchUserErrors.spec.ts

@@ -0,0 +1,20 @@
+import { catchUserErrors } from './catchUserErrors'
+import { display } from './display'
+
+describe('catchUserErrors', () => {
+  it('returns the same result as the original function', () => {
+    const wrappedFn = catchUserErrors((a: number, b: number) => a + b, 'Error during callback')
+    expect(wrappedFn(10, 2)).toBe(12)
+  })
+
+  it('logs errors using console.error and returns undefined', () => {
+    const displaySpy = spyOn(display, 'error')
+    const myError = 'Ooops!'
+    const wrappedFn = catchUserErrors(() => {
+      // eslint-disable-next-line @typescript-eslint/only-throw-error
+      throw myError
+    }, 'Error during callback')
+    expect(wrappedFn()).toBe(undefined)
+    expect(displaySpy).toHaveBeenCalledWith('Error during callback', myError)
+  })
+})

package/src/tools/encoder.spec.ts

@@ -0,0 +1,112 @@
+import { createIdentityEncoder } from './encoder'
+import { noop } from './utils/functionUtils'
+
+describe('createIdentityEncoder', () => {
+  it('creates an encoder with initial values', () => {
+    const encoder = createIdentityEncoder()
+
+    expect(encoder.isEmpty).toBe(true)
+    expect(encoder.finishSync()).toEqual({
+      output: '',
+      outputBytesCount: 0,
+      rawBytesCount: 0,
+      pendingData: '',
+    })
+  })
+
+  describe('write()', () => {
+    it('writes data to the encoder', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Hello, world!'
+
+      encoder.write(data)
+
+      expect(encoder.isEmpty).toBe(false)
+    })
+
+    it('calls the callback when writing data with a callback', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Callback test'
+      const callbackSpy = jasmine.createSpy()
+
+      encoder.write(data, callbackSpy)
+
+      expect(callbackSpy).toHaveBeenCalledOnceWith(data.length)
+    })
+  })
+
+  describe('finish()', () => {
+    it('calls the callback with the result', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Final data'
+      encoder.write(data)
+      const callbackSpy = jasmine.createSpy()
+
+      encoder.finish(callbackSpy)
+
+      expect(callbackSpy).toHaveBeenCalledWith({
+        output: data,
+        outputBytesCount: data.length,
+        rawBytesCount: data.length,
+        pendingData: '',
+      })
+    })
+
+    it('after calling finish(), the encoder should be considered empty', () => {
+      const encoder = createIdentityEncoder()
+      encoder.write('Some data')
+
+      encoder.finish(noop)
+
+      expect(encoder.isEmpty).toBe(true)
+      expect(encoder.finishSync()).toEqual({
+        output: '',
+        outputBytesCount: 0,
+        rawBytesCount: 0,
+        pendingData: '',
+      })
+    })
+  })
+
+  describe('finishSync()', () => {
+    it('returns the encoder result', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Hello, world!'
+
+      encoder.write(data)
+
+      expect(encoder.finishSync()).toEqual({
+        output: data,
+        outputBytesCount: data.length,
+        rawBytesCount: data.length,
+        pendingData: '',
+      })
+    })
+
+    it('after calling finish(), the encoder should be considered empty', () => {
+      const encoder = createIdentityEncoder()
+      encoder.write('Some data')
+
+      encoder.finishSync()
+
+      expect(encoder.isEmpty).toBe(true)
+      expect(encoder.finishSync()).toEqual({
+        output: '',
+        outputBytesCount: 0,
+        rawBytesCount: 0,
+        pendingData: '',
+      })
+    })
+  })
+
+  describe('estimateEncodedBytesCount()', () => {
+    it('estimates encoded bytes count accurately', () => {
+      const encoder = createIdentityEncoder()
+      const data = 'Estimation test'
+
+      const estimatedBytes = encoder.estimateEncodedBytesCount(data)
+
+      expect(estimatedBytes).toBe(data.length)
+    })
+  })
+})

package/src/tools/experimentalFeatures.spec.ts

@@ -0,0 +1,60 @@
+import {
+  ExperimentalFeature,
+  addExperimentalFeatures,
+  initFeatureFlags,
+  isExperimentalFeatureEnabled,
+  resetExperimentalFeatures,
+} from './experimentalFeatures'
+
+const TEST_FEATURE_FLAG_ONE = 'foo' as ExperimentalFeature
+const TEST_FEATURE_FLAG_TWO = 'bar' as ExperimentalFeature
+
+describe('experimentalFeatures', () => {
+  afterEach(() => {
+    resetExperimentalFeatures()
+  })
+
+  it('initial state is empty', () => {
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
+  })
+
+  it('should define enabled experimental features', () => {
+    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeFalse()
+  })
+
+  it('should allow to be shared between products', () => {
+    addExperimentalFeatures([TEST_FEATURE_FLAG_ONE])
+    addExperimentalFeatures([TEST_FEATURE_FLAG_TWO])
+
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_TWO)).toBeTrue()
+  })
+})
+
+describe('initFeatureFlags', () => {
+  beforeEach(() => {
+    ;(ExperimentalFeature as any).FOO = TEST_FEATURE_FLAG_ONE
+  })
+
+  afterEach(() => {
+    delete (ExperimentalFeature as any).FOO
+    resetExperimentalFeatures()
+  })
+
+  it('ignores unknown experimental features', () => {
+    initFeatureFlags(['bar', undefined as any, null as any, 11 as any])
+
+    expect(isExperimentalFeatureEnabled('bar' as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(undefined as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(null as any)).toBeFalse()
+    expect(isExperimentalFeatureEnabled(11 as any)).toBeFalse()
+  })
+
+  it('updates experimental feature flags', () => {
+    initFeatureFlags(['foo'])
+    expect(isExperimentalFeatureEnabled(TEST_FEATURE_FLAG_ONE)).toBeTrue()
+  })
+})

package/src/tools/getZoneJsOriginalValue.spec.ts

@@ -0,0 +1,36 @@
+import { mockZoneJs } from '../../test'
+
+import type { BrowserWindowWithZoneJs } from './getZoneJsOriginalValue'
+import { getZoneJsOriginalValue } from './getZoneJsOriginalValue'
+import { noop } from './utils/functionUtils'
+
+describe('getZoneJsOriginalValue', () => {
+  function originalValue() {
+    // just a function that does nothing but different than 'noop' as we'll want to differentiate
+    // them.
+  }
+  const object = {
+    name: originalValue,
+  }
+
+  it('returns the original value directly if Zone is not not defined', () => {
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it("returns the original value if Zone is defined but didn't patch that method", () => {
+    mockZoneJs()
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it('returns the original value if Zone is defined but does not define the __symbol__ function', () => {
+    mockZoneJs()
+    delete (window as BrowserWindowWithZoneJs).Zone!.__symbol__
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+
+  it('returns the original value if Zone did patch the method', () => {
+    const zoneJs = mockZoneJs()
+    zoneJs.replaceProperty(object, 'name', noop)
+    expect(getZoneJsOriginalValue(object, 'name')).toBe(originalValue)
+  })
+})

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