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

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

@@ -0,0 +1,55 @@
+import { buildUrl, getPathName, isValidUrl, normalizeUrl, getPristineWindow } from './urlPolyfill'
+
+describe('normalize url', () => {
+  it('should resolve absolute paths', () => {
+    expect(normalizeUrl('/my/path')).toEqual(`${location.origin}/my/path`)
+  })
+
+  it('should resolve relative paths', () => {
+    history.pushState({}, '', '/foo/')
+    expect(normalizeUrl('./my/path')).toEqual(`${location.origin}/foo/my/path`)
+  })
+
+  it('should add protocol to relative url', () => {
+    expect(normalizeUrl('//foo.com:9876/my/path')).toEqual('http://foo.com:9876/my/path')
+  })
+
+  it('should keep full url unchanged', () => {
+    expect(normalizeUrl('https://foo.com/my/path')).toEqual('https://foo.com/my/path')
+  })
+
+  it('should keep non http url unchanged', () => {
+    expect(normalizeUrl('ftp://foo.com/my/path')).toEqual('ftp://foo.com/my/path')
+  })
+
+  it('should keep file url unchanged', () => {
+    // On firefox, URL host is empty for file URI: 'https://bugzilla.mozilla.org/show_bug.cgi?id=1578787'
+    // In some cases, Mobile Safari also have this issue.
+    // As we should follow the browser behavior, having one or the other doesn't matter too much, so
+    // let's check for both.
+    expect(['file:///my/path', 'file://foo.com/my/path']).toContain(normalizeUrl('file://foo.com/my/path'))
+  })
+})
+
+describe('isValidUrl', () => {
+  it('should ensure url is valid', () => {
+    expect(isValidUrl('https://cloud.openobserve.ai/')).toBe(true)
+    expect(isValidUrl('https://api.openobserve.ai/')).toBe(true)
+    expect(isValidUrl('file://cloud.openobserve.ai')).toBe(true)
+    expect(isValidUrl('/plop')).toBe(false)
+    expect(isValidUrl('')).toBe(false)
+  })
+
+  it('should return the same result if the URL has been wrongfully overridden between calls', () => {
+    expect(isValidUrl('https://cloud.openobserve.ai/')).toBe(true)
+    spyOn(window, 'URL').and.throwError('wrong URL override')
+    expect(isValidUrl('https://cloud.openobserve.ai')).toBe(true)
+  })
+})
+
+describe('getPathName', () => {
+  it('should retrieve url path name', () => {
+    expect(getPathName('http://cloud.openobserve.ai')).toBe('/')
+    expect(getPathName('http://cloud.openobserve.ai/foo/bar?a=b#hello')).toBe('/foo/bar')
+  })
+})

package/src/tools/valueHistory.spec.ts

@@ -0,0 +1,180 @@
+import type { Clock } from '../../test'
+import { mockClock } from '../../test'
+import type { Duration, RelativeTime } from './utils/timeUtils'
+import { addDuration, ONE_MINUTE } from './utils/timeUtils'
+import { CLEAR_OLD_VALUES_INTERVAL, type ValueHistory, createValueHistory } from './valueHistory'
+
+const EXPIRE_DELAY = 10 * ONE_MINUTE
+const MAX_ENTRIES = 5
+
+describe('valueHistory', () => {
+  let valueHistory: ValueHistory<string>
+  let clock: Clock
+
+  beforeEach(() => {
+    clock = mockClock()
+    valueHistory = createValueHistory({ expireDelay: EXPIRE_DELAY, maxEntries: MAX_ENTRIES })
+  })
+
+  afterEach(() => {
+    valueHistory.stop()
+  })
+
+  describe('find', () => {
+    it('should return undefined when there is no active entry and no startTime', () => {
+      expect(valueHistory.find()).toBeUndefined()
+    })
+
+    it('should return the value of the first active entry when there is no startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime)
+
+      expect(valueHistory.find()).toEqual('foo')
+    })
+
+    it('should return undefined if the most recent entry is closed and no startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime).close(5 as RelativeTime)
+
+      expect(valueHistory.find()).toBeUndefined()
+    })
+
+    it('should return the value of entries matching startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime).close(5 as RelativeTime)
+      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
+      valueHistory.add('qux', 10 as RelativeTime)
+
+      expect(valueHistory.find(2 as RelativeTime)).toEqual('foo')
+      expect(valueHistory.find(7 as RelativeTime)).toEqual('bar')
+      expect(valueHistory.find(10 as RelativeTime)).toEqual('qux')
+    })
+
+    it('should return undefined when no entries matches startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
+      valueHistory.add('bar', 20 as RelativeTime)
+
+      expect(valueHistory.find(15 as RelativeTime)).toBeUndefined()
+    })
+
+    describe('with `option.returnInactive` true', () => {
+      it('should return the value of the closest entry regardless of the being closed', () => {
+        valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
+        valueHistory.add('bar', 20 as RelativeTime)
+        expect(valueHistory.find(15 as RelativeTime, { returnInactive: true })).toEqual('foo')
+      })
+    })
+  })
+
+  describe('findAll', () => {
+    it('should return an empty array when there is no active entry and no startTime', () => {
+      expect(valueHistory.findAll()).toEqual([])
+    })
+
+    it('should return all active entry value when there is no startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime)
+      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
+      valueHistory.add('qux', 10 as RelativeTime)
+
+      expect(valueHistory.findAll()).toEqual(['qux', 'foo'])
+    })
+
+    it('should return the entries of entries matching startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime).close(6 as RelativeTime)
+      valueHistory.add('bar', 5 as RelativeTime).close(8 as RelativeTime)
+      valueHistory.add('qux', 10 as RelativeTime)
+
+      expect(valueHistory.findAll(2 as RelativeTime)).toEqual(['foo'])
+      expect(valueHistory.findAll(5 as RelativeTime)).toEqual(['bar', 'foo'])
+      expect(valueHistory.findAll(7 as RelativeTime)).toEqual(['bar'])
+      expect(valueHistory.findAll(9 as RelativeTime)).toEqual([])
+      expect(valueHistory.findAll(10 as RelativeTime)).toEqual(['qux'])
+    })
+
+    it('should return an empty array when no entry is matching startTime', () => {
+      valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
+      valueHistory.add('bar', 20 as RelativeTime)
+
+      expect(valueHistory.findAll(15 as RelativeTime)).toEqual([])
+    })
+
+    it('should return all context overlapping with the duration', () => {
+      valueHistory.add('foo', 0 as RelativeTime)
+      valueHistory.add('bar', 5 as RelativeTime).close(10 as RelativeTime)
+      valueHistory.add('baz', 10 as RelativeTime).close(15 as RelativeTime)
+      valueHistory.add('qux', 15 as RelativeTime)
+
+      expect(valueHistory.findAll(0 as RelativeTime, 20 as Duration)).toEqual(['qux', 'baz', 'bar', 'foo'])
+      expect(valueHistory.findAll(6 as RelativeTime, 5 as Duration)).toEqual(['baz', 'bar', 'foo'])
+      expect(valueHistory.findAll(11 as RelativeTime, 5 as Duration)).toEqual(['qux', 'baz', 'foo'])
+    })
+  })
+
+  describe('removing entries', () => {
+    it('should not return removed entries', () => {
+      valueHistory.add('foo', 0 as RelativeTime).remove()
+      expect(valueHistory.find()).toBeUndefined()
+    })
+
+    it('removing an entry twice should not impact other entries', () => {
+      valueHistory.add('bar', 5 as RelativeTime)
+      const entry = valueHistory.add('foo', 0 as RelativeTime)
+      entry.remove()
+      entry.remove()
+      expect(valueHistory.find()).toEqual('bar')
+    })
+  })
+
+  it('should reset values', () => {
+    valueHistory.add('foo', 0 as RelativeTime).close(10 as RelativeTime)
+    valueHistory.add('bar', 10 as RelativeTime)
+
+    valueHistory.reset()
+
+    expect(valueHistory.find()).toBeUndefined()
+    expect(valueHistory.find(0 as RelativeTime)).toBeUndefined()
+  })
+
+  describe('clearing old values', () => {
+    it('should clear old values after expiration', () => {
+      const originalTime = performance.now() as RelativeTime
+      valueHistory.add('foo', originalTime).close(addDuration(originalTime, 10 as Duration))
+      clock.tick(10)
+
+      expect(valueHistory.find(originalTime)).toBeDefined()
+
+      clock.tick(EXPIRE_DELAY + CLEAR_OLD_VALUES_INTERVAL)
+
+      expect(valueHistory.find(originalTime)).toBeUndefined()
+    })
+
+    it('should clear multiple histories at the same time to avoid race condition', () => {
+      const delay = 5
+      const originalTime = performance.now() as RelativeTime
+
+      const valueHistory1 = createValueHistory({ expireDelay: EXPIRE_DELAY })
+      clock.tick(delay)
+      const valueHistory2 = createValueHistory({ expireDelay: EXPIRE_DELAY })
+
+      valueHistory1.add('foo', originalTime).close(addDuration(originalTime, 10 as Duration))
+      valueHistory2.add('bar', originalTime).close(addDuration(originalTime, 10 as Duration))
+
+      expect(valueHistory1.find(originalTime)).toBeDefined()
+      expect(valueHistory2.find(originalTime)).toBeDefined()
+
+      clock.tick(EXPIRE_DELAY + CLEAR_OLD_VALUES_INTERVAL - delay)
+
+      expect(valueHistory1.find(originalTime)).toBeUndefined()
+      expect(valueHistory2.find(originalTime)).toBeUndefined()
+
+      valueHistory1.stop()
+      valueHistory2.stop()
+    })
+  })
+
+  it('should limit the number of entries', () => {
+    for (let i = 0; i < MAX_ENTRIES + 1; i++) {
+      valueHistory.add(`${i}`, 0 as RelativeTime)
+    }
+    const values = valueHistory.findAll()
+    expect(values.length).toEqual(5)
+    expect(values).toEqual(['5', '4', '3', '2', '1'])
+  })
+})

package/src/transport/batch.spec.ts

@@ -0,0 +1,261 @@
+import { Observable } from '..'
+import type { MockFlushController } from '../../test'
+import { createMockFlushController } from '../../test'
+import { display } from '../tools/display'
+import type { Encoder } from '../tools/encoder'
+import { createIdentityEncoder } from '../tools/encoder'
+import { createBatch, MESSAGE_BYTES_LIMIT, type Batch } from './batch'
+import type { HttpRequest, HttpRequestEvent } from './httpRequest'
+
+describe('batch', () => {
+  const BIG_MESSAGE_OVER_BYTES_LIMIT = { message: 'x'.repeat(MESSAGE_BYTES_LIMIT + 1) }
+  const SMALL_MESSAGE = { message: 'hello' }
+  const SMALL_MESSAGE_BYTES_COUNT = 19
+  const SEPARATOR_BYTES_COUNT = 1
+
+  let batch: Batch
+  let transport: {
+    observable: Observable<HttpRequestEvent>
+    send: jasmine.Spy<HttpRequest['send']>
+    sendOnExit: jasmine.Spy<HttpRequest['sendOnExit']>
+  }
+
+  let flushController: MockFlushController
+  let encoder: Encoder<string>
+
+  beforeEach(() => {
+    transport = {
+      observable: new Observable<HttpRequestEvent>(),
+      send: jasmine.createSpy(),
+      sendOnExit: jasmine.createSpy(),
+    } satisfies HttpRequest
+    flushController = createMockFlushController()
+    encoder = createIdentityEncoder()
+    batch = createBatch({ encoder, request: transport, flushController })
+  })
+
+  it('should send a message', () => {
+    batch.add(SMALL_MESSAGE)
+
+    flushController.notifyFlush()
+
+    expect(transport.send.calls.mostRecent().args[0]).toEqual({
+      data: '{"message":"hello"}',
+      bytesCount: SMALL_MESSAGE_BYTES_COUNT,
+      encoding: undefined,
+    })
+  })
+
+  describe('adding a message', () => {
+    it('should add message to the flush controller', () => {
+      batch.add(SMALL_MESSAGE)
+
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
+      expect(flushController.notifyAfterAddMessage).toHaveBeenCalledOnceWith(0)
+    })
+
+    it('should consider separators when adding message', () => {
+      batch.add(SMALL_MESSAGE)
+      batch.add(SMALL_MESSAGE)
+      batch.add(SMALL_MESSAGE)
+
+      expect(flushController.bytesCount).toEqual(
+        SMALL_MESSAGE_BYTES_COUNT +
+          SEPARATOR_BYTES_COUNT +
+          SMALL_MESSAGE_BYTES_COUNT +
+          SEPARATOR_BYTES_COUNT +
+          SMALL_MESSAGE_BYTES_COUNT
+      )
+    })
+
+    it('should remove the estimated message bytes count when replacing a message', () => {
+      batch.add(SMALL_MESSAGE)
+      batch.upsert(SMALL_MESSAGE, 'a')
+
+      flushController.notifyBeforeAddMessage.calls.reset()
+
+      batch.upsert(SMALL_MESSAGE, 'a')
+
+      expect(flushController.notifyAfterRemoveMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(SMALL_MESSAGE_BYTES_COUNT)
+      expect(flushController.bytesCount).toEqual(
+        // Note: contrary to added messages (see test above), we don't take separators into account
+        // when upserting messages, because it's irrelevant: upserted messages size are not yet
+        // encoded so the bytes count is only an estimation
+        SMALL_MESSAGE_BYTES_COUNT + SMALL_MESSAGE_BYTES_COUNT
+      )
+    })
+
+    it('should not send a message with a bytes size above the limit', () => {
+      const warnSpy = spyOn(display, 'warn')
+      batch.add(BIG_MESSAGE_OVER_BYTES_LIMIT)
+
+      expect(warnSpy).toHaveBeenCalled()
+      expect(flushController.notifyBeforeAddMessage).not.toHaveBeenCalled()
+    })
+
+    it('should adjust the message size after the message has been added', () => {
+      const message = { message: '😤' } // JS string length = 2, but 4 bytes once encoded to UTF-8
+      batch.add(message)
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledOnceWith(16)
+      expect(flushController.notifyAfterAddMessage).toHaveBeenCalledOnceWith(2) // 2 more bytes once encoded
+    })
+  })
+
+  it('should upsert a message for a given key', () => {
+    batch.upsert({ message: '1' }, 'a')
+    batch.upsert({ message: '2' }, 'a')
+    batch.upsert({ message: '3' }, 'b')
+    batch.upsert({ message: '4' }, 'c')
+    flushController.notifyFlush()
+
+    expect(transport.send.calls.mostRecent().args[0]).toEqual({
+      data: '{"message":"2"}\n{"message":"3"}\n{"message":"4"}',
+      bytesCount: jasmine.any(Number),
+      encoding: undefined,
+    })
+
+    batch.upsert({ message: '5' }, 'c')
+    batch.upsert({ message: '6' }, 'b')
+    batch.upsert({ message: '7' }, 'a')
+    flushController.notifyFlush()
+
+    expect(transport.send.calls.mostRecent().args[0]).toEqual({
+      data: '{"message":"5"}\n{"message":"6"}\n{"message":"7"}',
+      bytesCount: jasmine.any(Number),
+      encoding: undefined,
+    })
+
+    batch.upsert({ message: '8' }, 'a')
+    batch.upsert({ message: '9' }, 'b')
+    batch.upsert({ message: '10' }, 'a')
+    batch.upsert({ message: '11' }, 'b')
+    flushController.notifyFlush()
+
+    expect(transport.send.calls.mostRecent().args[0]).toEqual({
+      data: '{"message":"10"}\n{"message":"11"}',
+      bytesCount: jasmine.any(Number),
+      encoding: undefined,
+    })
+  })
+
+  describe('flush messages when the page is not exiting or with a synchronous encoder', () => {
+    it('should send addend and upserted messages in the same request', () => {
+      batch.add({ message: '1' })
+      batch.upsert({ message: '2' }, 'a')
+
+      flushController.notifyFlush()
+
+      expect(transport.send.calls.mostRecent().args[0]).toEqual({
+        data: '{"message":"1"}\n{"message":"2"}',
+        bytesCount: jasmine.any(Number),
+        encoding: undefined,
+      })
+    })
+
+    it('should encode upserted messages', () => {
+      const encoderWriteSpy = spyOn(encoder, 'write')
+
+      batch.upsert({ message: '2' }, 'a')
+
+      flushController.notifyFlush()
+
+      expect(encoderWriteSpy).toHaveBeenCalledOnceWith('{"message":"2"}')
+    })
+
+    it('should be able to use telemetry in the httpRequest.send', () => {
+      transport.send.and.callFake(() => {
+        addTelemetryDebugFake()
+      })
+      const addTelemetryDebugFake = () => batch.add({ message: 'telemetry message' })
+
+      batch.add({ message: 'normal message' })
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(1)
+
+      flushController.notifyFlush()
+      expect(transport.send).toHaveBeenCalledTimes(1)
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(2)
+
+      flushController.notifyFlush()
+      expect(transport.send).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  describe('flush messages when the page is exiting and with an asynchronous encoder', () => {
+    beforeEach(() => {
+      encoder.isAsync = true
+    })
+
+    //
+    ;[
+      {
+        title: 'when adding a message, it should be sent in one request',
+        add: { message: 1 },
+        expectedRequests: ['{"message":1}'],
+      },
+      {
+        title: 'when upserting a message, it should be sent in one request',
+        upsert: { message: 1 },
+        expectedRequests: ['{"message":1}'],
+      },
+      {
+        title: 'when adding a message and upserting another, they should be sent in two separate requests',
+        add: { message: 1 },
+        upsert: { message: 2 },
+        expectedRequests: ['{"message":1}', '{"message":2}'],
+      },
+      {
+        title:
+          'when adding a message and another message is still pending, they should be sent in two separate requests',
+        add: { message: 1 },
+        pending: { message: 2 },
+        expectedRequests: ['{"message":1}', '{"message":2}'],
+      },
+      {
+        title: 'when upserting a message and another message is still pending, they should be sent in one request',
+        upsert: { message: 1 },
+        pending: { message: 2 },
+        expectedRequests: ['{"message":2}\n{"message":1}'],
+      },
+    ].forEach(({ title, add, upsert, pending, expectedRequests }) => {
+      it(title, () => {
+        if (add) {
+          batch.add(add)
+        }
+        if (upsert) {
+          batch.upsert(upsert, 'a')
+        }
+        if (pending) {
+          // eslint-disable-next-line @typescript-eslint/unbound-method
+          const original = encoder.finishSync
+          spyOn(encoder, 'finishSync').and.callFake(() => ({
+            ...original(),
+            pendingData: JSON.stringify(pending),
+          }))
+        }
+
+        flushController.notifyFlush('before_unload')
+
+        expect(transport.sendOnExit.calls.allArgs().map(([payload]) => payload.data)).toEqual(expectedRequests)
+      })
+    })
+
+    it('should be able to use telemetry in the httpRequest.sendOnExit', () => {
+      transport.sendOnExit.and.callFake(() => {
+        addTelemetryDebugFake()
+      })
+      const addTelemetryDebugFake = () => batch.add({ message: 'telemetry message' })
+
+      batch.add({ message: 'normal message' })
+      batch.upsert({ message: '2' }, 'a')
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(2)
+
+      flushController.notifyFlush('before_unload')
+      expect(transport.sendOnExit).toHaveBeenCalledTimes(2)
+      expect(flushController.notifyBeforeAddMessage).toHaveBeenCalledTimes(4)
+
+      flushController.notifyFlush('before_unload')
+      expect(transport.sendOnExit).toHaveBeenCalledTimes(3)
+    })
+  })
+})

package/src/transport/eventBridge.spec.ts

@@ -0,0 +1,90 @@
+import { mockEventBridge } from '../../test'
+import { DefaultPrivacyLevel } from '../domain/configuration'
+import type { BrowserWindowWithEventBridge } from './eventBridge'
+import { getEventBridge, canUseEventBridge, BridgeCapability, bridgeSupports } from './eventBridge'
+
+describe('canUseEventBridge', () => {
+  const allowedWebViewHosts = ['foo.bar']
+
+  it('should detect when the bridge is present and the webView host is allowed', () => {
+    mockEventBridge({ allowedWebViewHosts })
+    expect(canUseEventBridge('foo.bar')).toBeTrue()
+    expect(canUseEventBridge('baz.foo.bar')).toBeTrue()
+    expect(canUseEventBridge('www.foo.bar')).toBeTrue()
+    expect(canUseEventBridge('www.qux.foo.bar')).toBeTrue()
+  })
+
+  it('should not detect when the bridge is present and the webView host is not allowed', () => {
+    mockEventBridge({ allowedWebViewHosts })
+    expect(canUseEventBridge('foo.com')).toBeFalse()
+    expect(canUseEventBridge('foo.bar.baz')).toBeFalse()
+    expect(canUseEventBridge('bazfoo.bar')).toBeFalse()
+  })
+
+  it('should not detect when the bridge on the parent domain if only the subdomain is allowed', () => {
+    mockEventBridge({ allowedWebViewHosts: ['baz.foo.bar'] })
+    expect(canUseEventBridge('foo.bar')).toBeFalse()
+  })
+
+  it('should not detect when the bridge is absent', () => {
+    expect(canUseEventBridge()).toBeFalse()
+  })
+})
+
+describe('event bridge send', () => {
+  let sendSpy: jasmine.Spy<(msg: string) => void>
+
+  beforeEach(() => {
+    const eventBridge = mockEventBridge()
+    sendSpy = spyOn(eventBridge, 'send')
+  })
+
+  it('should serialize sent events without view', () => {
+    const eventBridge = getEventBridge()!
+
+    eventBridge.send('view', { foo: 'bar' })
+
+    expect(sendSpy).toHaveBeenCalledOnceWith('{"eventType":"view","event":{"foo":"bar"}}')
+  })
+
+  it('should serialize sent events with view', () => {
+    const eventBridge = getEventBridge()!
+
+    eventBridge.send('view', { foo: 'bar' }, '123')
+
+    expect(sendSpy).toHaveBeenCalledOnceWith('{"eventType":"view","event":{"foo":"bar"},"view":{"id":"123"}}')
+  })
+})
+
+describe('event bridge getPrivacyLevel', () => {
+  const bridgePrivacyLevel = DefaultPrivacyLevel.MASK
+
+  beforeEach(() => {
+    mockEventBridge({ privacyLevel: bridgePrivacyLevel })
+  })
+
+  it('should return the privacy level', () => {
+    const eventBridge = getEventBridge()!
+
+    expect(eventBridge.getPrivacyLevel()).toEqual(bridgePrivacyLevel)
+  })
+
+  it('should return undefined if getPrivacyLevel not present in the bridge', () => {
+    delete (window as BrowserWindowWithEventBridge).DatadogEventBridge?.getPrivacyLevel
+    const eventBridge = getEventBridge()!
+
+    expect(eventBridge.getPrivacyLevel()).toBeUndefined()
+  })
+
+  describe('bridgeSupports', () => {
+    it('should returns true when the bridge supports a capability', () => {
+      mockEventBridge({ capabilities: [BridgeCapability.RECORDS] })
+      expect(bridgeSupports(BridgeCapability.RECORDS)).toBeTrue()
+    })
+
+    it('should returns false when the bridge does not support a capability', () => {
+      mockEventBridge({ capabilities: [] })
+      expect(bridgeSupports(BridgeCapability.RECORDS)).toBeFalse()
+    })
+  })
+})