@api-client/core 0.20.10 → 0.21.1

package/tests/unit/data/XmlReader.spec.ts

@@ -1,84 +0,0 @@
-import { test } from '@japa/runner'
-import { XmlReader } from '../../../src/data/index.js'
-
-test.group('XmlReader', () => {
-  const cities = `
-  <xml>
-    <city>
-      <name>Seattle</name>
-      <state>WA</state>
-    </city>
-    <city>
-      <name>New York</name>
-      <state>NY</state>
-    </city>
-    <city>
-      <name>Bellevue</name>
-      <state>WA</state>
-    </city>
-    <city>
-      <name>Olympia</name>
-      <state>WA</state>
-    </city>
-  </xml>
-  `
-
-  test('returns a value for a simple path', async ({ assert }) => {
-    const payload = '<xml><a>b</a><c>d</c></xml>'
-    const reader = new XmlReader()
-    await reader.writePayload(payload)
-    const result = await reader.getValue('/xml/a/text()')
-    assert.equal(result, 'b')
-  })
-
-  test('returns a value for a deep path', async ({ assert }) => {
-    const payload = '<xml><a><b>c</b></a></xml>'
-    const reader = new XmlReader()
-    await reader.writePayload(payload)
-
-    const result = await reader.getValue('/xml/a/b')
-    assert.equal(result, 'c')
-  })
-
-  test('searches for the value (absolute path)', async ({ assert }) => {
-    const reader = new XmlReader()
-    await reader.writePayload(cities)
-
-    const result = await reader.getValue("/xml/city[state='WA'][2]/name")
-
-    assert.equal(result, 'Bellevue')
-  })
-
-  test('searches for the value (relative path)', async ({ assert }) => {
-    const reader = new XmlReader()
-    await reader.writePayload(cities)
-
-    const result = await reader.getValue("//xml/city[state='WA'][2]/name")
-
-    assert.equal(result, 'Bellevue')
-  })
-
-  test('returns undefined when invalid xml', async ({ assert }) => {
-    const payload = '<xml><a>b</a><c>d</c></xml>'
-    const reader = new XmlReader()
-    await reader.writePayload(payload)
-    const result = await reader.getValue('a')
-    assert.isUndefined(result)
-  })
-
-  test('selects an element under root element', async ({ assert }) => {
-    const reader = new XmlReader()
-    await reader.writePayload(cities)
-
-    const result = await reader.getValue('xml/city[1]/name')
-    assert.equal(result, 'Seattle')
-  })
-
-  test('selects direct descendant of an element under root element', async ({ assert }) => {
-    const reader = new XmlReader()
-    await reader.writePayload(cities)
-
-    const result = await reader.getValue('xml/city[1]//name')
-    assert.equal(result, 'Seattle')
-  })
-})

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

@@ -1,150 +0,0 @@
-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 > Authorization > EventTypes.Authorization', () => {
-  test('has the namespace', ({ assert }) => {
-    assert.typeOf(EventTypes.Authorization, 'object')
-  })
-
-  test('has OAuth2 namespace', ({ assert }) => {
-    assert.typeOf(EventTypes.Authorization.OAuth2, 'object')
-  })
-
-  test('has frozen OAuth2 namespace', ({ assert }) => {
-    assert.throws(() => {
-      // @ts-expect-error Used in testing
-      EventTypes.Authorization.OAuth2 = { read: '' }
-    })
-  })
-
-  test('has "{prop}" property for OAuth2')
-    .with([
-      { prop: 'authorize', value: 'oauth2authorize' },
-      { prop: 'removeToken', value: 'oauth2removetoken' },
-    ])
-    .run(({ assert }, { prop, value }) => {
-      // @ts-expect-error Used in testing
-      assert.equal(EventTypes.Authorization.OAuth2[prop], value)
-    })
-
-  test('has unique events for OAuth2 namespace', () => {
-    ensureUnique('EventTypes.Authorization.OAuth2', EventTypes.Authorization.OAuth2)
-  })
-
-  test('has frozen Oidc namespace', ({ assert }) => {
-    assert.throws(() => {
-      // @ts-expect-error Used in testing
-      EventTypes.Authorization.Oidc = { read: '' }
-    })
-  })
-
-  test('has "{prop}" property for Oidc')
-    .with([
-      { prop: 'authorize', value: 'oidcauthorize' },
-      { prop: 'removeTokens', value: 'oidcremovetokens' },
-    ])
-    .run(({ assert }, { prop, value }) => {
-      // @ts-expect-error Used in testing
-      assert.equal(EventTypes.Authorization.Oidc[prop], value)
-    })
-
-  test('has unique events for Oidc namespace', () => {
-    ensureUnique('EventTypes.Authorization.Oidc', EventTypes.Authorization.Oidc)
-  })
-})
-
-test.group('Events > Authorization > Events.Authorization > OAuth2 > authorize()', () => {
-  const config = { responseType: 'implicit' }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.OAuth2.authorize, spy)
-    Events.Authorization.OAuth2.authorize(config)
-    globalThis.removeEventListener(EventTypes.Authorization.OAuth2.authorize, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the configuration on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.OAuth2.authorize, spy)
-    Events.Authorization.OAuth2.authorize(config)
-    globalThis.removeEventListener(EventTypes.Authorization.OAuth2.authorize, spy)
-    const e = spy.args[0][0]
-    const cnf = e.detail
-    delete cnf.result
-    assert.deepEqual(cnf, config)
-  })
-})
-
-test.group('Events > Authorization > Events.Authorization > OAuth2 > removeToken()', () => {
-  const config = { clientId: 'id', authorizationUri: 'test' }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.OAuth2.removeToken, spy)
-    Events.Authorization.OAuth2.removeToken(config)
-    globalThis.removeEventListener(EventTypes.Authorization.OAuth2.removeToken, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the configuration on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.OAuth2.removeToken, spy)
-    Events.Authorization.OAuth2.removeToken(config)
-    globalThis.removeEventListener(EventTypes.Authorization.OAuth2.removeToken, spy)
-    const e = spy.args[0][0]
-    const cnf = e.detail
-    delete cnf.result
-    assert.deepEqual(cnf, config)
-  })
-})
-
-test.group('Events > Authorization > Events.Authorization > Oidc > authorize()', () => {
-  const config = { responseType: 'implicit' }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.Oidc.authorize, spy)
-    Events.Authorization.Oidc.authorize(config)
-    globalThis.removeEventListener(EventTypes.Authorization.Oidc.authorize, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the configuration on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.Oidc.authorize, spy)
-    Events.Authorization.Oidc.authorize(config)
-    globalThis.removeEventListener(EventTypes.Authorization.Oidc.authorize, spy)
-    const e = spy.args[0][0]
-    const cnf = e.detail
-    delete cnf.result
-    assert.deepEqual(cnf, config)
-  })
-})
-
-test.group('Events > Authorization > Events.Authorization > Oidc > removeToken()', () => {
-  const config = { clientId: 'id', authorizationUri: 'test' }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.Oidc.removeTokens, spy)
-    Events.Authorization.Oidc.removeTokens(config)
-    globalThis.removeEventListener(EventTypes.Authorization.Oidc.removeTokens, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the configuration on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Authorization.Oidc.removeTokens, spy)
-    Events.Authorization.Oidc.removeTokens(config) // Calling removeToken
-    globalThis.removeEventListener(EventTypes.Authorization.Oidc.removeTokens, spy)
-    const e = spy.args[0][0]
-    const cnf = e.detail
-    delete cnf.result
-    assert.deepEqual(cnf, config)
-  })
-})

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

@@ -1,274 +0,0 @@
-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/transport.spec.ts

@@ -1,139 +0,0 @@
-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 { IHttpRequest, HttpRequest, Kind as HttpRequestKind } from '../../../src/models/HttpRequest.js'
-import { Kind as HttpProjectKind } from '../../../src/models/HttpProject.js'
-import { IHttpRequestDetail } from '../../../src/events/transport/TransportEvents.js'
-import { IRequestProxyInit } from '../../../src/proxy/RequestProxy.js'
-import { ContextEventDetailWithResult } from '../../../src/events/BaseEvents.js'
-import { IHttpProjectProxyInit, IHttpProjectStoreProxyInit } from '../../../src/proxy/HttpProjectProxy.js'
-import './events_polyfills.js'
-
-test.group('Events > Transport > EventTypes.Transport.Core', () => {
-  test('has "{prop}" property')
-    .with([
-      ['request', 'transportcorerequest'],
-      ['httpProject', 'transportcorehttpproject'],
-    ])
-    .run(({ assert }, [prop, value]) => {
-      // @ts-expect-error Used in testing
-      assert.equal(EventTypes.Transport.Core[prop], value)
-    })
-
-  test('has unique events for the namespace', () => {
-    ensureUnique('EventTypes.Transport.Core', EventTypes.Transport.Core)
-  })
-})
-
-test.group('Events > Transport > EventTypes.Transport.Http', () => {
-  test('has "{prop}" property')
-    .with([['send', 'httptransportsend']])
-    .run(({ assert }, [prop, value]) => {
-      // @ts-expect-error Used in testing
-      assert.equal(EventTypes.Transport.Http[prop], value)
-    })
-
-  test('has unique events for the namespace', () => {
-    ensureUnique('EventTypes.Transport.Http', EventTypes.Transport.Http)
-  })
-})
-
-test.group('Events > Transport > EventTypes.Transport.Ws', () => {
-  test('has "{prop}" property')
-    .with([
-      ['connect', 'wstransportconnect'],
-      ['disconnect', 'wstransportdisconnect'],
-      ['send', 'wstransportsend'],
-    ])
-    .run(({ assert }, [prop, value]) => {
-      // @ts-expect-error Used in testing
-      assert.equal(EventTypes.Transport.Ws[prop], value)
-    })
-
-  test('has unique events for the namespace', () => {
-    ensureUnique('EventTypes.Transport.Ws', EventTypes.Transport.Ws)
-  })
-})
-
-test.group('Events > Transport > Events.Transport.Core > request()', () => {
-  const init: IRequestProxyInit = {
-    kind: HttpRequestKind,
-    request: new HttpRequest().toJSON(),
-  }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
-    await Events.Transport.Core.request(init)
-    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the detail object', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Core.request, spy)
-    await Events.Transport.Core.request(init)
-    globalThis.removeEventListener(EventTypes.Transport.Core.request, spy)
-    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IRequestProxyInit>>
-    assert.deepEqual(e.detail, { ...init, result: undefined })
-  })
-})
-
-test.group('Events > Transport > Events.Transport.Core > httpProject()', () => {
-  const init: IHttpProjectStoreProxyInit = {
-    kind: HttpProjectKind,
-    pid: 'test-id',
-    options: { parallel: true },
-    organization: 'test-organization',
-  }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
-    await Events.Transport.Core.httpProject(init)
-    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the detail object', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Core.httpProject, spy)
-    await Events.Transport.Core.httpProject(init)
-    globalThis.removeEventListener(EventTypes.Transport.Core.httpProject, spy)
-    const e = spy.args[0][0] as CustomEvent<ContextEventDetailWithResult<IHttpProjectProxyInit>>
-    assert.deepEqual(e.detail, { ...init, result: undefined })
-  })
-})
-
-test.group('Events > Transport > Events.Transport.Http > send()', () => {
-  const request: IHttpRequest = new HttpRequest().toJSON()
-  const init: RequestInit = { method: 'POST' }
-
-  test('dispatches the event', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
-    await Events.Transport.Http.send(request)
-    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
-    assert.isTrue(spy.calledOnce)
-  })
-
-  test('has the request on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
-    await Events.Transport.Http.send(request)
-    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
-    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
-    assert.equal(e.detail.request, request)
-  })
-
-  test('has the optional init on the detail', async ({ assert }) => {
-    const spy = sinon.spy()
-    globalThis.addEventListener(EventTypes.Transport.Http.send, spy)
-    await Events.Transport.Http.send(request, init)
-    globalThis.removeEventListener(EventTypes.Transport.Http.send, spy)
-    const e = spy.args[0][0] as CustomEvent<IHttpRequestDetail>
-    assert.deepEqual(e.detail.init, init)
-  })
-})