@api-client/core 0.14.10 → 0.15.1

package/tests/unit/events/cookie.spec.ts

@@ -0,0 +1,274 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { IHttpCookie } from '../../../src/models/HttpCookie.js'
+import { ContextUpdateEvent, ContextUpdateEventDetail, ContextChangeRecord } from '../../../src/events/BaseEvents.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Cookie > EventTypes.Cookie', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Cookie, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([
+      ['listAll', 'sessioncookielistall'],
+      ['listDomain', 'sessioncookielistdomain'],
+      ['listUrl', 'sessioncookielisturl'],
+      ['delete', 'sessioncookiedelete'],
+      ['deleteUrl', 'sessioncookiedeleteurl'],
+      ['update', 'sessioncookieupdate'],
+      ['updateBulk', 'sessioncookieupdatebulk'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Cookie[prop], value)
+    })
+
+  test('has State namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Cookie.State, 'object')
+  })
+
+  test('has frozen State namespace', ({ assert }) => {
+    assert.throws(() => {
+      // @ts-expect-error Used in testing
+      EventTypes.Cookie.State = { read: '' }
+    })
+  })
+
+  test('has "{prop}" property for State')
+    .with([
+      ['update', 'sessioncookiestateupdate'],
+      ['delete', 'sessioncookiestatedelete'],
+    ])
+    .run(({ assert }, [prop, value]) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Cookie.State[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Cookie', EventTypes.Cookie)
+  })
+
+  test('has unique events for State namespace', () => {
+    ensureUnique('EventTypes.Cookie.State', EventTypes.Cookie.State)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > listAll()', () => {
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.listAll, spy)
+    // In Node.js, document.body is not available.
+    // Assuming Events.Cookie.listAll dispatches globally or handles a null/undefined target.
+    Events.Cookie.listAll()
+    globalThis.removeEventListener(EventTypes.Cookie.listAll, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > listDomain()', () => {
+  const domain = 'dot.com'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.listDomain, spy)
+    Events.Cookie.listDomain(domain)
+    globalThis.removeEventListener(EventTypes.Cookie.listDomain, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the domain property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.listDomain, spy)
+    Events.Cookie.listDomain(domain)
+    globalThis.removeEventListener(EventTypes.Cookie.listDomain, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.domain, domain)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > listUrl()', () => {
+  const url = 'https://dot.com/path'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.listUrl, spy)
+    Events.Cookie.listUrl(url)
+    globalThis.removeEventListener(EventTypes.Cookie.listUrl, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the url property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.listUrl, spy)
+    Events.Cookie.listUrl(url)
+    globalThis.removeEventListener(EventTypes.Cookie.listUrl, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.url, url)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > delete()', () => {
+  const cookie: IHttpCookie = {
+    name: 'a',
+    value: 'b',
+    sameSite: 'no_restriction',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.delete, spy)
+    Events.Cookie.delete([cookie])
+    globalThis.removeEventListener(EventTypes.Cookie.delete, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the cookies property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.delete, spy)
+    Events.Cookie.delete([cookie])
+    globalThis.removeEventListener(EventTypes.Cookie.delete, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.cookies, [cookie])
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > deleteUrl()', () => {
+  const url = 'https://dot.com/path'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.deleteUrl, spy)
+    Events.Cookie.deleteUrl(url)
+    globalThis.removeEventListener(EventTypes.Cookie.deleteUrl, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the url property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.deleteUrl, spy)
+    Events.Cookie.deleteUrl(url)
+    globalThis.removeEventListener(EventTypes.Cookie.deleteUrl, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.url, url)
+  })
+
+  test('has the optional name property', async ({ assert }) => {
+    const name = 'test name'
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.deleteUrl, spy)
+    Events.Cookie.deleteUrl(url, name)
+    globalThis.removeEventListener(EventTypes.Cookie.deleteUrl, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.name, name)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > update()', () => {
+  const cookie: IHttpCookie = {
+    name: 'a',
+    value: 'b',
+    sameSite: 'no_restriction',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.update, spy)
+    Events.Cookie.update(cookie)
+    globalThis.removeEventListener(EventTypes.Cookie.update, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the detail property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.update, spy)
+    Events.Cookie.update(cookie)
+    globalThis.removeEventListener(EventTypes.Cookie.update, spy)
+    const e = spy.args[0][0] as ContextUpdateEvent<IHttpCookie>
+    const detail = e.detail as ContextUpdateEventDetail<IHttpCookie>
+    assert.deepEqual(detail.item, cookie)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > updateBulk()', () => {
+  const cookie: IHttpCookie = {
+    name: 'a',
+    value: 'b',
+    sameSite: 'no_restriction',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.updateBulk, spy)
+    Events.Cookie.updateBulk([cookie])
+    globalThis.removeEventListener(EventTypes.Cookie.updateBulk, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the cookies property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.updateBulk, spy)
+    Events.Cookie.updateBulk([cookie])
+    globalThis.removeEventListener(EventTypes.Cookie.updateBulk, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.cookies, [cookie])
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > State.delete()', () => {
+  const cookie: IHttpCookie = {
+    name: 'a',
+    value: 'b',
+    sameSite: 'no_restriction',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.State.delete, spy)
+    Events.Cookie.State.delete(cookie)
+    globalThis.removeEventListener(EventTypes.Cookie.State.delete, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the cookie property', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.State.delete, spy)
+    Events.Cookie.State.delete(cookie)
+    globalThis.removeEventListener(EventTypes.Cookie.State.delete, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.cookie, cookie)
+  })
+})
+
+test.group('Events > Cookie > Events.Cookie > State.update()', () => {
+  const cookie: IHttpCookie = {
+    name: 'a',
+    value: 'b',
+    sameSite: 'no_restriction',
+  }
+
+  const record: ContextChangeRecord<IHttpCookie> = {
+    item: cookie,
+    key: 'null',
+  }
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.State.update, spy)
+    Events.Cookie.State.update(record)
+    globalThis.removeEventListener(EventTypes.Cookie.State.update, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the change record', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Cookie.State.update, spy)
+    Events.Cookie.State.update(record)
+    globalThis.removeEventListener(EventTypes.Cookie.State.update, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail, record)
+  })
+})

package/tests/unit/events/encryption.spec.ts

@@ -0,0 +1,108 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Encryption > EventTypes.Encryption', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Encryption, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([
+      { prop: 'encrypt', value: 'encryptionencrypt' },
+      { prop: 'decrypt', value: 'encryptiondecrypt' },
+    ])
+    .run(({ assert }, { prop, value }) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Encryption[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Encryption', EventTypes.Encryption)
+  })
+})
+
+test.group('Events > Encryption > Events.Encryption > encrypt()', () => {
+  const data = 'export data'
+  const passphrase = 'passphrase data'
+  const method = 'aes'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.encrypt, spy)
+    await Events.Encryption.encrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.encrypt, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the data on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.encrypt, spy)
+    await Events.Encryption.encrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.encrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.data, data)
+  })
+
+  test('has the passphrase on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.encrypt, spy)
+    await Events.Encryption.encrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.encrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.passphrase, passphrase)
+  })
+
+  test('has the method on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.encrypt, spy)
+    await Events.Encryption.encrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.encrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.method, method)
+  })
+})
+
+test.group('Events > Encryption > Events.Encryption > decrypt()', () => {
+  const data = 'export data'
+  const passphrase = 'passphrase data'
+  const method = 'aes'
+
+  test('dispatches the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.decrypt, spy)
+    await Events.Encryption.decrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.decrypt, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the data on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.decrypt, spy)
+    await Events.Encryption.decrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.decrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.data, data)
+  })
+
+  test('has the passphrase on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.decrypt, spy)
+    await Events.Encryption.decrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.decrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.passphrase, passphrase)
+  })
+
+  test('has the method on the event', async ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Encryption.decrypt, spy)
+    await Events.Encryption.decrypt(data, passphrase, method)
+    globalThis.removeEventListener(EventTypes.Encryption.decrypt, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.method, method)
+  })
+})

package/tests/unit/events/events_polyfills.ts

@@ -0,0 +1,77 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Originally these tests were written for a browser environment.
+// They are now adapted to run in a Node.js environment with polyfills for browser APIs.
+
+// @ts-expect-error This is for testing.
+globalThis.window = globalThis
+
+// Polyfill for DOM EventTarget APIs in Node.js environment for testing
+if (typeof globalThis.Event === 'undefined') {
+  class EventPolyfill {
+    type: string
+    bubbles: boolean
+    cancelable: boolean
+    composed: boolean
+    defaultPrevented = false
+    readonly timeStamp: number = Date.now()
+    // Stub other properties/methods as needed by the code under test
+    target: any | null = null // Using 'any' for simplicity in polyfill
+    currentTarget: any | null = null
+
+    constructor(type: string, eventInitDict?: EventInit) {
+      this.type = type
+      this.bubbles = eventInitDict?.bubbles ?? false
+      this.cancelable = eventInitDict?.cancelable ?? false
+      this.composed = eventInitDict?.composed ?? false
+    }
+
+    preventDefault(): void {
+      if (this.cancelable) {
+        this.defaultPrevented = true
+      }
+    }
+
+    stopPropagation(): void {
+      /* Stub */
+    }
+    stopImmediatePropagation(): void {
+      /* Stub */
+    }
+  }
+  ;(globalThis as any).Event = EventPolyfill
+}
+
+if (typeof globalThis.CustomEvent === 'undefined') {
+  class CustomEventPolyfill<T = any> extends (globalThis as any).Event {
+    detail: T
+
+    constructor(type: string, eventInitDict?: CustomEventInit<T>) {
+      super(type, eventInitDict)
+      this.detail = eventInitDict?.detail ?? (null as T)
+    }
+  }
+  ;(globalThis as any).CustomEvent = CustomEventPolyfill
+}
+
+if (typeof globalThis.addEventListener !== 'function') {
+  const eventListeners = new Map<string, Set<EventListenerOrEventListenerObject>>()
+
+  globalThis.addEventListener = (type: string, listener: EventListenerOrEventListenerObject): void => {
+    if (!eventListeners.has(type)) {
+      eventListeners.set(type, new Set())
+    }
+    eventListeners.get(type)!.add(listener)
+  }
+
+  globalThis.removeEventListener = (type: string, listener: EventListenerOrEventListenerObject): void => {
+    eventListeners.get(type)?.delete(listener)
+  }
+
+  globalThis.dispatchEvent = (event: Event): boolean => {
+    eventListeners.get(event.type)?.forEach((handler) => {
+      if (typeof handler === 'function') handler.call(globalThis, event)
+      else handler.handleEvent.call(globalThis, event)
+    })
+    return !event.defaultPrevented
+  }
+}

package/tests/unit/events/process.spec.ts

@@ -0,0 +1,120 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Process > EventTypes.Process', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Process, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([
+      { prop: 'loadingStart', value: 'processloadingstart' },
+      { prop: 'loadingStop', value: 'processloadingstop' },
+      { prop: 'loadingError', value: 'processloadingerror' },
+    ])
+    .run(({ assert }, { prop, value }) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Process[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Process', EventTypes.Process)
+  })
+})
+
+test.group('Events > Process > Events.Process > loadingStart()', () => {
+  const pid = 'process-id-1'
+  const message = 'test-message'
+
+  test('dispatches the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingStart, spy)
+    Events.Process.loadingStart(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingStart, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the pid on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingStart, spy)
+    Events.Process.loadingStart(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingStart, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.pid, pid)
+  })
+
+  test('has the message on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingStart, spy)
+    Events.Process.loadingStart(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingStart, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.message, message)
+  })
+})
+
+test.group('Events > Process > Events.Process > loadingStop()', () => {
+  const pid = 'process-id-1'
+
+  test('dispatches the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingStop, spy)
+    Events.Process.loadingStop(pid)
+    globalThis.removeEventListener(EventTypes.Process.loadingStop, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the pid on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingStop, spy)
+    Events.Process.loadingStop(pid)
+    globalThis.removeEventListener(EventTypes.Process.loadingStop, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.pid, pid)
+  })
+})
+
+test.group('Events > Process > Events.Process > loadingError()', () => {
+  const pid = 'process-id-1'
+  const message = 'test-message'
+  const error = new Error('test-message')
+
+  test('dispatches the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingError, spy)
+    Events.Process.loadingError(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingError, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the pid on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingError, spy)
+    Events.Process.loadingError(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingError, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.pid, pid)
+  })
+
+  test('has the message on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingError, spy)
+    Events.Process.loadingError(pid, message)
+    globalThis.removeEventListener(EventTypes.Process.loadingError, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.message, message)
+  })
+
+  test('has the optional error on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Process.loadingError, spy)
+    Events.Process.loadingError(pid, message, error)
+    globalThis.removeEventListener(EventTypes.Process.loadingError, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.error, error)
+  })
+})

package/tests/unit/events/reporting.spec.ts

@@ -0,0 +1,82 @@
+import { test } from '@japa/runner'
+import sinon from 'sinon'
+import { EventTypes } from '../../../src/events/EventTypes.js'
+import { Events } from '../../../src/events/Events.js'
+import { ensureUnique } from './EventsTestHelpers.js'
+import './events_polyfills.js'
+
+test.group('Events > Reporting > EventTypes.Reporting', () => {
+  test('has the namespace', ({ assert }) => {
+    assert.typeOf(EventTypes.Reporting, 'object')
+  })
+
+  test('has "{prop}" property')
+    .with([{ prop: 'error', value: 'reporterror' }])
+    .run(({ assert }, { prop, value }) => {
+      // @ts-expect-error Used in testing
+      assert.equal(EventTypes.Reporting[prop], value)
+    })
+
+  test('has unique events for the namespace', () => {
+    ensureUnique('EventTypes.Reporting', EventTypes.Reporting)
+  })
+})
+
+test.group('Events > Reporting > Events.Reporting > error()', () => {
+  const err = new Error('Test Error')
+  const desc = 'test error description'
+  const cmp = 'test-component'
+
+  test('dispatches the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc)
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    assert.isTrue(spy.calledOnce)
+  })
+
+  test('has the description on the event', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc)
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.description, desc)
+  })
+
+  test('has the error on the event when provided', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc, err)
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.deepEqual(e.detail.error, err)
+  })
+
+  test('error property is undefined when not provided', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc)
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.isUndefined(e.detail.error)
+  })
+
+  test('has the component on the event when provided', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc, err, cmp)
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.equal(e.detail.component, cmp)
+  })
+
+  test('component property is undefined when not provided', ({ assert }) => {
+    const spy = sinon.spy()
+    globalThis.addEventListener(EventTypes.Reporting.error, spy)
+    Events.Reporting.error(desc, err) // No component here
+    globalThis.removeEventListener(EventTypes.Reporting.error, spy)
+    const e = spy.args[0][0] as CustomEvent
+    assert.isUndefined(e.detail.component)
+  })
+})