@openobserve/browser-core 0.3.2 → 0.3.3

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

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

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

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

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