@api-client/core 0.20.10 → 0.21.0

package/tests/unit/cookies/CookieParser.spec.ts

@@ -1,354 +0,0 @@
-/* eslint-disable max-len */
-import { test } from '@japa/runner'
-import { CookieParser } from '../../../src/cookies/CookieParser.js'
-
-test.group('#filterCookies()', () => {
-  const cookies = [
-    'a=b; domain=foo.com; path=/;',
-    'c=d; domain=foo.com; path=/test/path;',
-    'e=f; domain=bar.com; path=/;',
-    'g=h; domain=bar.com; path=/test/path;',
-    'i=j; domain=sub.bar.com; path=/;',
-    'k=l; domain=sub.bar.com; path=/test/path;',
-    'm=n;',
-  ]
-
-  test('removes cookies that does not match the domain', ({ assert }) => {
-    const str = cookies.slice(0, 4).join(' ')
-    const list = CookieParser.parse('http://foo.com/', str)
-    assert.lengthOf(list, 1)
-    assert.equal(list[0].name, 'a')
-  })
-
-  test('removes cookies when path does not match (sub path)', ({ assert }) => {
-    const str = cookies.slice(0, 2).join(' ')
-    const list = CookieParser.parse('http://foo.com/', str)
-    assert.lengthOf(list, 1)
-    assert.equal(list[0].name, 'a')
-  })
-
-  test('keeps cookies for the parent path', ({ assert }) => {
-    const str = cookies.slice(0, 2).join(' ')
-    const list = CookieParser.parse('http://foo.com/test/path/', str)
-    assert.lengthOf(list, 2)
-  })
-
-  test('removes cookies for different path', ({ assert }) => {
-    const str = cookies.slice(0, 2).join(' ')
-    const list = CookieParser.parse('http://foo.com/other/', str)
-    assert.lengthOf(list, 1)
-  })
-
-  test('includes the trailing slash', ({ assert }) => {
-    const str = cookies.slice(0, 2).join(' ')
-    const list = CookieParser.parse('http://foo.com/other', str)
-    assert.lengthOf(list, 1)
-  })
-
-  test('does not remove parent domain cookies', ({ assert }) => {
-    const str = cookies.slice(0, 2).join(' ')
-    // a=b; domain=foo.com; path=/; c=d; domain=foo.com; path=/test/path;
-    const list = CookieParser.parse('http://sub.foo.com/', str)
-    assert.lengthOf(list, 1)
-    assert.equal(list[0].name, 'a')
-  })
-
-  test('keeps sub domain cookies', ({ assert }) => {
-    const str = cookies.slice(4, 6).join(' ')
-    const list = CookieParser.parse('http://sub.bar.com/', str)
-    assert.lengthOf(list, 1)
-  })
-
-  test('add cookie path when missing', ({ assert }) => {
-    const list = CookieParser.parse('http://bar.com/', cookies[6])
-    assert.equal(list[0].path, '/')
-  })
-
-  test('sets hostOnly if domain missing', ({ assert }) => {
-    const list = CookieParser.parse('http://bar.com/', cookies[6])
-    assert.isTrue(list[0].hostOnly)
-  })
-})
-
-test.group('complex cookies', () => {
-  test('parses several simple cookies', ({ assert }) => {
-    const header = 'c1=v1,c2=v2,c3=v3'
-    const list = CookieParser.parse('http://api.com/', header)
-    assert.lengthOf(list, 3, 'has 3 cookies')
-
-    const [c1, c2, c3] = list
-
-    assert.equal(c1.name, 'c1', 'c1 name')
-    assert.equal(c1.value, 'v1', 'c1 value')
-    assert.isUndefined(c1.expirationDate, 'c1 expirationDate')
-    assert.isTrue(c1.session, 'c1 session')
-    assert.isTrue(c1.hostOnly, 'c1 hostOnly')
-    assert.isUndefined(c1.httpOnly, 'c1 httpOnly')
-    assert.equal(c1.path, '/', 'c1 path')
-    assert.equal(c1.domain, 'api.com', 'c1 domain')
-    assert.isUndefined(c1.maxAge, 'c1 maxAge')
-    assert.isUndefined(c1.secure, 'c1 secure')
-
-    assert.equal(c2.name, 'c2', 'c2 name')
-    assert.equal(c2.value, 'v2', 'c2 value')
-    assert.isUndefined(c2.expirationDate, 'c2 expirationDate')
-    assert.isTrue(c2.session, 'c2 session')
-    assert.isTrue(c2.hostOnly, 'c2 hostOnly')
-    assert.isUndefined(c2.httpOnly, 'c2 httpOnly')
-    assert.equal(c2.path, '/', 'c2 path')
-    assert.equal(c2.domain, 'api.com', 'c2 domain')
-    assert.isUndefined(c2.maxAge, 'c2 maxAge')
-    assert.isUndefined(c2.secure, 'c2 secure')
-
-    assert.equal(c3.name, 'c3', 'c3 name')
-    assert.equal(c3.value, 'v3', 'c3 value')
-    assert.isUndefined(c3.expirationDate, 'c3 expirationDate')
-    assert.isTrue(c3.session, 'c3 session')
-    assert.isTrue(c3.hostOnly, 'c3 hostOnly')
-    assert.isUndefined(c3.secure, 'c3 secure')
-    assert.isUndefined(c3.httpOnly, 'c3 httpOnly')
-    assert.equal(c3.path, '/', 'c3 path')
-    assert.equal(c3.domain, 'api.com', 'c3 domain')
-    assert.isUndefined(c3.maxAge, 'c3 maxAge')
-  })
-
-  test('parses several cookies with attributes', ({ assert }) => {
-    const header = 'c1=v1; Path=/; HttpOnly,c2=v2; Path=/,c3=v3; Path=/abc; Secure; HostOnly; SameSite=Strict'
-    const list = CookieParser.parse('http://api.com/abc/', header)
-    assert.lengthOf(list, 3, 'has 3 cookies')
-
-    const [c1, c2, c3] = list
-
-    assert.equal(c1.name, 'c1', 'c1 name')
-    assert.equal(c1.value, 'v1', 'c1 value')
-    assert.isUndefined(c1.expirationDate, 'c1 expirationDate')
-    assert.isTrue(c1.session, 'c1 session')
-    assert.isTrue(c1.hostOnly, 'c1 hostOnly')
-    assert.isTrue(c1.httpOnly, 'c1 httpOnly')
-    assert.equal(c1.path, '/', 'c1 path')
-    assert.equal(c1.domain, 'api.com', 'c1 domain')
-    assert.isUndefined(c1.maxAge, 'c1 maxAge')
-    assert.isUndefined(c1.secure, 'c1 secure')
-
-    assert.equal(c2.name, 'c2', 'c2 name')
-    assert.equal(c2.value, 'v2', 'c2 value')
-    assert.isUndefined(c2.expirationDate, 'c2 expirationDate')
-    assert.isTrue(c2.session, 'c2 session')
-    assert.isTrue(c2.hostOnly, 'c2 hostOnly')
-    assert.isUndefined(c2.httpOnly, 'c2 httpOnly')
-    assert.equal(c2.path, '/', 'c2 path')
-    assert.equal(c2.domain, 'api.com', 'c2 domain')
-    assert.isUndefined(c2.maxAge, 'c2 maxAge')
-    assert.isUndefined(c2.secure, 'c2 secure')
-
-    assert.equal(c3.name, 'c3', 'c3 name')
-    assert.equal(c3.value, 'v3', 'c3 value')
-    assert.isUndefined(c3.expirationDate, 'c3 expirationDate')
-    assert.isTrue(c3.session, 'c3 session')
-    assert.isTrue(c3.hostOnly, 'c3 hostOnly')
-    assert.isTrue(c3.secure, 'c3 secure')
-    assert.isUndefined(c3.httpOnly, 'c3 httpOnly')
-    assert.equal(c3.path, '/abc', 'c3 path')
-    assert.equal(c3.domain, 'api.com', 'c3 domain')
-    assert.isUndefined(c3.maxAge, 'c3 maxAge')
-  })
-
-  test('parses several cookies with attributes and expires', ({ assert }) => {
-    const header =
-      'c1=v1; Path=/; Expires=Wed, 09 Feb 2022 01:30:04 GMT; HttpOnly,c2=v2; Path=/,c3=v3; Path=/; Secure; SameSite=Strict'
-    const list = CookieParser.parse('http://api.com/', header)
-    assert.lengthOf(list, 3, 'has 3 cookies')
-
-    const [c1, c2, c3] = list
-
-    assert.equal(c1.name, 'c1', 'c1 name')
-    assert.equal(c1.value, 'v1', 'c1 value')
-    assert.equal(c1.expirationDate, 1644370204000, 'c1 expirationDate')
-    assert.isTrue(c2.session, 'c2 session')
-    assert.isTrue(c1.hostOnly, 'c1 hostOnly')
-    assert.isTrue(c1.httpOnly, 'c1 httpOnly')
-    assert.equal(c1.path, '/', 'c1 path')
-    assert.equal(c1.domain, 'api.com', 'c1 domain')
-    assert.isUndefined(c1.maxAge, 'c1 maxAge')
-    assert.isUndefined(c1.secure, 'c1 secure')
-
-    assert.equal(c2.name, 'c2', 'c2 name')
-    assert.equal(c2.value, 'v2', 'c2 value')
-    assert.isUndefined(c2.expirationDate, 'c2 expirationDate')
-    assert.isTrue(c2.session, 'c2 session')
-    assert.isTrue(c2.hostOnly, 'c2 hostOnly')
-    assert.isUndefined(c2.httpOnly, 'c2 httpOnly')
-    assert.equal(c2.path, '/', 'c2 path')
-    assert.equal(c2.domain, 'api.com', 'c2 domain')
-    assert.isUndefined(c2.maxAge, 'c2 maxAge')
-    assert.isUndefined(c2.secure, 'c2 secure')
-
-    assert.equal(c3.name, 'c3', 'c3 name')
-    assert.equal(c3.value, 'v3', 'c3 value')
-    assert.isUndefined(c3.expirationDate, 'c3 expirationDate')
-    assert.isTrue(c3.session, 'c3 session')
-    assert.isTrue(c3.hostOnly, 'c3 hostOnly')
-    assert.isTrue(c3.secure, 'c3 secure')
-    assert.isUndefined(c3.httpOnly, 'c3 httpOnly')
-    assert.equal(c3.path, '/', 'c3 path')
-    assert.equal(c3.domain, 'api.com', 'c3 domain')
-    assert.isUndefined(c3.maxAge, 'c3 maxAge')
-  })
-})
-
-test.group('#parse()', () => {
-  let httpStr = 'rememberme=1; domain=foo.com;'
-  httpStr += ' path=/; ssid=Hy1t5e#oj21.876aak;'
-
-  test('parses empty string', ({ assert }) => {
-    const cookieStr = ''
-    const list = CookieParser.parse('http://foo.com/', cookieStr)
-    assert.typeOf(list, 'array')
-    assert.deepEqual(list, [])
-  })
-
-  test('parses basic Set-Cookie string', ({ assert }) => {
-    const list = CookieParser.parse('http://foo.com/', 'cookie=value')
-    assert.typeOf(list, 'array')
-    assert.lengthOf(list, 1)
-    assert.equal(list[0].name, 'cookie')
-    assert.equal(list[0].value, 'value')
-  })
-
-  test('parses a Set-Cookie string', ({ assert }) => {
-    const list = CookieParser.parse('http://foo.com/', httpStr)
-    assert.lengthOf(list, 2)
-  })
-
-  test('should set cookie names', ({ assert }) => {
-    const list = CookieParser.parse('http://foo.com/', httpStr)
-    assert.equal(list[0].name, 'rememberme')
-    assert.equal(list[1].name, 'ssid')
-  })
-
-  test('should set cookie values', ({ assert }) => {
-    const list = CookieParser.parse('http://foo.com/', httpStr)
-    assert.equal(list[0].value, '1')
-    assert.equal(list[1].value, 'Hy1t5e#oj21.876aak')
-  })
-
-  test('should set domains and paths', ({ assert }) => {
-    const list = CookieParser.parse('http://foo.com/', httpStr)
-    const [c1, c2] = list
-    assert.equal(c1.domain, '.foo.com', 'c1 domain')
-    assert.equal(c1.path, '/', 'c1 path')
-    assert.equal(c2.domain, 'foo.com', 'c2 domain')
-    assert.equal(c2.path, '/', 'c2 path')
-  })
-
-  test('should set expires from max-age', ({ assert }) => {
-    const str = 'rememberme=1; domain=foo.com; path=/; max-age=100'
-    const list = CookieParser.parse('http://foo.com/', str)
-    const future = Date.now() + 100000
-    const [cookie] = list
-    assert.approximately(cookie.expirationDate!, future, 100)
-    assert.isFalse(cookie.session, 'The session flag is not set to true')
-  })
-
-  test('sets the domain and port', ({ assert }) => {
-    const str = 'rememberme=1'
-    const list = CookieParser.parse('http://localhost:1234/', str)
-    const [cookie] = list
-    assert.equal(cookie.domain, 'localhost:1234')
-  })
-})
-
-test.group('#matchesDomain()', () => {
-  test('matches .example.com with example.com', ({ assert }) => {
-    const result = CookieParser.matchesDomain('.example.com', 'www.example.com')
-    assert.isTrue(result)
-  })
-
-  test('matches .example.com for www.example.com', ({ assert }) => {
-    const result = CookieParser.matchesDomain('.example.com', 'www.example.com')
-    assert.isTrue(result)
-  })
-
-  test('matches .example.com for www.example.com', ({ assert }) => {
-    const result = CookieParser.matchesDomain('.example.com', 'example.com')
-    assert.isTrue(result)
-  })
-
-  test('does not match .example.com for another.com', ({ assert }) => {
-    const result = CookieParser.matchesDomain('.example.com', 'another.com')
-    assert.isFalse(result)
-  })
-
-  test('returns true when domain are the same', ({ assert }) => {
-    assert.isTrue(CookieParser.matchesDomain('bar.com', 'bar.com'))
-  })
-
-  test('returns true when a dot in argument and the url is a subdomain', ({ assert }) => {
-    assert.isTrue(CookieParser.matchesDomain('.bar.com', 'test.bar.com'))
-  })
-})
-
-test.group('matchesPath()', () => {
-  const baseUrl = 'http://bar.com/'
-
-  test('returns true when no argument', ({ assert }) => {
-    const uri = new URL(baseUrl)
-    assert.isTrue(CookieParser.matchesPath('', uri))
-  })
-
-  test('returns true when paths are the same', ({ assert }) => {
-    const uri = new URL(baseUrl)
-    assert.isTrue(CookieParser.matchesPath('/', uri))
-  })
-
-  test('returns true when URL has single separator', ({ assert }) => {
-    const url = `${baseUrl}test`
-    const uri = new URL(url)
-    assert.isTrue(CookieParser.matchesPath('/', uri))
-  })
-
-  test('returns true when URL has deep path that is a match', ({ assert }) => {
-    const url = `${baseUrl}test/other`
-    const uri = new URL(url)
-    assert.isTrue(CookieParser.matchesPath('/', uri))
-  })
-
-  test('returns false when argument path is different', ({ assert }) => {
-    const url = `${baseUrl}test/other`
-    const uri = new URL(url)
-    assert.isFalse(CookieParser.matchesPath('/other', uri))
-  })
-
-  test('returns false when argument path is higher', ({ assert }) => {
-    const url = `${baseUrl}other`
-    const uri = new URL(url)
-    assert.isFalse(CookieParser.matchesPath('/other/xyz', uri))
-  })
-})
-
-test.group('getPath()', () => {
-  test('returns default value when no path after separator domain', ({ assert }) => {
-    const result = CookieParser.getPath(new URL('https://api.com'))
-    assert.equal(result, '/')
-  })
-
-  test('returns default value when no path after domain', ({ assert }) => {
-    const result = CookieParser.getPath(new URL('https://api.com/'))
-    assert.equal(result, '/')
-  })
-
-  test('returns path value', ({ assert }) => {
-    const result = CookieParser.getPath(new URL('https://api.com/api/test/ignore'))
-    assert.equal(result, '/api/test')
-  })
-
-  test('ignores the query string', ({ assert }) => {
-    const result = CookieParser.getPath(new URL('https://api.com/api/?a=b'))
-    assert.equal(result, '/api')
-  })
-
-  test('ignores the hash part of the url', ({ assert }) => {
-    const result = CookieParser.getPath(new URL('https://api.com/api/#access_token=...'))
-    assert.equal(result, '/api')
-  })
-})

package/tests/unit/cookies/InMemoryCookieJar.spec.ts

@@ -1,112 +0,0 @@
-import { test } from '@japa/runner'
-import { clearStore, InMemoryCookieJar } from '../../../src/cookies/InMemoryCookieJar.js'
-import { HttpCookie } from '../../../src/models/HttpCookie.js'
-
-test.group('setCookies() listCookies()', (group) => {
-  const url = 'https://api.com/path?query'
-
-  let store: InMemoryCookieJar
-  group.each.setup(() => {
-    store = new InMemoryCookieJar()
-    clearStore()
-  })
-
-  test('stores a cookie', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v' })
-    await store.setCookies(url, [c1])
-    const stored = await store.listCookies(url)
-    assert.lengthOf(stored, 1, 'has 1 cookie')
-    assert.equal(stored[0].name, 'c1')
-  })
-
-  test('stores multiple cookies', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v' })
-    const c2 = new HttpCookie({ name: 'c2', value: 'v' })
-    const c3 = new HttpCookie({ name: 'c3', value: 'v' })
-    await store.setCookies(url, [c1, c2, c3])
-    const stored = await store.listCookies(url)
-    assert.lengthOf(stored, 3, 'has 3 cookies')
-  })
-
-  test('overrides existing cookies', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v' })
-    await store.setCookies(url, [c1.toJSON()])
-    c1.value = 'other'
-    await store.setCookies(url, [c1.toJSON()])
-
-    const stored = await store.listCookies(url)
-    assert.lengthOf(stored, 1, 'has 1 cookie')
-    const [r1] = stored
-    assert.equal(r1.value, 'other')
-  })
-
-  test('ignores different domains', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v1' })
-    const c2 = new HttpCookie({ name: 'c2', value: 'v2' })
-    const url2 = 'https://other.com'
-    await store.setCookies(url, [c1.toJSON()])
-    await store.setCookies(url2, [c2])
-
-    const stored1 = await store.listCookies(url)
-    assert.lengthOf(stored1, 1, 'has 1 cookie for url 1')
-
-    const stored2 = await store.listCookies(url2)
-    assert.lengthOf(stored2, 1, 'has 1 cookie for url 2')
-  })
-
-  test('stores and list cookies from a domain with a port', async ({ assert }) => {
-    const url1 = 'http://localhost:8000/v1/get'
-    const c1 = new HttpCookie({ name: 'c1', value: 'v1' })
-    await store.setCookies(url1, [c1])
-    const stored = await store.listCookies(url1)
-    assert.lengthOf(stored, 1, 'has 1 cookie')
-  })
-})
-
-test.group('deleteCookies()', (group) => {
-  const url1 = 'https://api.com/path?query'
-  const url2 = 'https://other.com'
-
-  let store: InMemoryCookieJar
-  group.each.setup(() => {
-    store = new InMemoryCookieJar()
-    clearStore()
-  })
-
-  test('deletes all cookies', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v' })
-    const c2 = new HttpCookie({ name: 'c2', value: 'v' })
-    const c3 = new HttpCookie({ name: 'c3', value: 'v' })
-    await store.setCookies(url1, [c1, c2, c3])
-    await store.deleteCookies(url1)
-    const stored = await store.listCookies(url1)
-    assert.lengthOf(stored, 0, 'has no cookies')
-  })
-
-  test('deletes cookies by name', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v' })
-    const c2 = new HttpCookie({ name: 'c2', value: 'v' })
-    const c3 = new HttpCookie({ name: 'c3', value: 'v' })
-    await store.setCookies(url1, [c1, c2, c3])
-    await store.deleteCookies(url1, 'c1')
-    const stored = await store.listCookies(url1)
-    assert.lengthOf(stored, 2, 'has 2 cookies')
-    assert.equal(stored[0].name, 'c2', 'has cookie #2')
-    assert.equal(stored[1].name, 'c3', 'has cookie #3')
-  })
-
-  test('ignores different domains', async ({ assert }) => {
-    const c1 = new HttpCookie({ name: 'c1', value: 'v1' })
-    const c2 = new HttpCookie({ name: 'c1', value: 'v2' })
-    await store.setCookies(url1, [c1.toJSON()])
-    await store.setCookies(url2, [c2])
-
-    await store.deleteCookies(url1, 'c1')
-
-    const stored1 = await store.listCookies(url1)
-    assert.lengthOf(stored1, 0, 'has 0 cookie for url 1')
-
-    const stored2 = await store.listCookies(url2)
-    assert.lengthOf(stored2, 1, 'has 1 cookie for url 2')
-  })
-})

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

@@ -1,36 +0,0 @@
-import { test } from '@japa/runner'
-import { JmespathReader } from '../../../src/data/index.js'
-
-test.group('JmespathReader', () => {
-  test('returns a value for a simple path', async ({ assert }) => {
-    const payload = JSON.stringify({ a: 'b', c: 'd' })
-    const reader = new JmespathReader()
-    await reader.writePayload(payload)
-
-    const result = await reader.getValue('a')
-    assert.equal(result, 'b')
-  })
-
-  test('returns a value for a deep path', async ({ assert }) => {
-    const payload = JSON.stringify({ a: { b: 'c' } })
-    const reader = new JmespathReader()
-    await reader.writePayload(payload)
-
-    const result = await reader.getValue('a.b')
-    assert.equal(result, 'c')
-  })
-
-  test('searches for the value', async ({ assert }) => {
-    const payload = JSON.stringify([
-      { name: 'Seattle', state: 'WA' },
-      { name: 'New York', state: 'NY' },
-      { name: 'Bellevue', state: 'WA' },
-      { name: 'Olympia', state: 'WA' },
-    ])
-    const reader = new JmespathReader()
-    await reader.writePayload(payload)
-
-    const result = await reader.getValue("[?state == 'WA'].name | [1]")
-    assert.equal(result, 'Bellevue')
-  })
-})

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

@@ -1,178 +0,0 @@
-import { test } from '@japa/runner'
-import { Json2Xml } from '../../../src/data/Json2Xml.js'
-
-test.group('integration tests', (group) => {
-  let converter: Json2Xml
-  group.each.setup(() => {
-    converter = new Json2Xml()
-  })
-
-  test('converts a simple JSON object', async ({ assert }) => {
-    assert.equal(await converter.serializeJson({ a: {} }), '<root><a/></root>')
-    assert.equal(await converter.serializeJson({ a: null }), '<root><a/></root>')
-    assert.equal(await converter.serializeJson({ a: [] }), '<root><a/></root>')
-    assert.equal(await converter.serializeJson({ a: -1 }), '<root><a>-1</a></root>')
-    assert.equal(await converter.serializeJson({ a: false }), '<root><a>false</a></root>')
-    assert.equal(await converter.serializeJson({ a: 'a value' }), '<root><a>a value</a></root>')
-    assert.equal(await converter.serializeJson({ a: 'b' }), '<root><a>b</a></root>')
-  })
-
-  test('converts a simple JSON array', async ({ assert }) => {
-    assert.equal(await converter.serializeJson([{ a: {} }]), '<root><a/></root>')
-    assert.equal(await converter.serializeJson([{ a: null }]), '<root><a/></root>')
-    assert.equal(await converter.serializeJson([{ a: [] }]), '<root><a/></root>')
-    assert.equal(await converter.serializeJson([{ a: -1 }]), '<root><a>-1</a></root>')
-    assert.equal(await converter.serializeJson([{ a: false }]), '<root><a>false</a></root>')
-    assert.equal(await converter.serializeJson([{ a: 'a value' }]), '<root><a>a value</a></root>')
-    assert.equal(await converter.serializeJson([{ a: 'b' }]), '<root><a>b</a></root>')
-    assert.equal(
-      await converter.serializeJson([{ a: 'b' }, { c: false }, { d: 123 }, { e: -0.7 }]),
-      '<root><a>b</a><c>false</c><d>123</d><e>-0.7</e></root>'
-    )
-  })
-
-  test('converts deeply nested JSON object', async ({ assert }) => {
-    assert.equal(
-      await converter.serializeJson([{ a: [{ b: [{ c: 1 }, { c: 2 }, { c: 3 }] }] }]),
-      '<root><a><b><c>1</c><c>2</c><c>3</c></b></a></root>'
-    )
-    assert.equal(
-      await converter.serializeJson([{ a: [{ b: [{ c: 1 }, { c: [] }, { c: 3 }] }] }]),
-      '<root><a><b><c>1</c><c/><c>3</c></b></a></root>'
-    )
-  })
-
-  test('converts an object with an array', async ({ assert }) => {
-    const input = {
-      items: [
-        {
-          name: 'n1',
-          value: 'v1',
-        },
-        {
-          name: 'n2',
-        },
-      ],
-    }
-    await converter.convert(input)
-    const result = await converter.serialize()
-    assert.equal(result, '<root><items><name>n1</name><value>v1</value><name>n2</name></items></root>')
-  })
-
-  test('accepts a custom root element', async ({ assert }) => {
-    assert.equal(await converter.serializeJson({ a: {} }, 'items'), '<items><a/></items>')
-  })
-
-  test('wraps a value into a cdata', async ({ assert }) => {
-    assert.equal(
-      await converter.serializeJson({ a: '<span>test</span>' }),
-      '<root><a><![CDATA[<span>test</span>]]></a></root>'
-    )
-  })
-
-  test('uses the synthetic APIimplementation in node', ({ assert }) => {
-    assert.isTrue(converter.syntheticApi)
-  })
-
-  test('throws when parsing a scalar value', async ({ assert }) => {
-    let message: string | undefined
-    try {
-      await converter.serializeJson('test')
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'Invalid object. Unable to process non-object property.')
-  })
-})
-
-test.group('serialize()', (group) => {
-  let converter: Json2Xml
-  group.each.setup(() => {
-    converter = new Json2Xml()
-  })
-
-  test('throws when no document', async ({ assert }) => {
-    let message: string | undefined
-    try {
-      await converter.serialize()
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'No document created.')
-  })
-})
-
-test.group('processArray()', (group) => {
-  let converter: Json2Xml
-  group.each.setup(() => {
-    converter = new Json2Xml()
-  })
-
-  test('throws when no array argument', ({ assert }) => {
-    let message: string | undefined
-    try {
-      // @ts-expect-error Used in testing
-      converter.processArray({})
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'Expected array. object given.')
-  })
-})
-
-test.group('processObject()', (group) => {
-  let converter: Json2Xml
-  group.each.setup(() => {
-    converter = new Json2Xml()
-  })
-
-  test('throws when not initialized', ({ assert }) => {
-    let message: string | undefined
-    try {
-      converter.processObject({})
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'Library not initialized. Call the convert() function.')
-  })
-})
-
-test.group('processScalar()', (group) => {
-  let converter: Json2Xml
-  group.each.setup(() => {
-    converter = new Json2Xml()
-  })
-
-  test('throws when not initialized', ({ assert }) => {
-    let message: string | undefined
-    try {
-      converter.processScalar('test')
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'Library not initialized. Call the convert() function.')
-  })
-
-  test('throws when invalid type', async ({ assert }) => {
-    const doc = await converter.getDocument()
-    converter.doc = doc
-    const rootNode = doc.createElement('root')
-    doc.append(rootNode)
-    converter.currentNode = rootNode
-
-    let message: string | undefined
-    try {
-      // @ts-expect-error Used in testing
-      converter.processScalar({})
-    } catch (e) {
-      const err = e as Error
-      message = err.message
-    }
-    assert.equal(message, 'Invalid scalar type: object.')
-  }).skip()
-})