@blueprint-ts/core 4.0.0-beta.8 → 4.0.0

package/tests/service/pagination/VueViewDrivers.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { VueBaseViewDriver } from '../../../src/pagination/frontendDrivers/VueBaseViewDriver'
+import { VuePaginationDriver } from '../../../src/pagination/frontendDrivers/VuePaginationDriver'
+import { VueBaseViewDriverFactory } from '../../../src/pagination/factories/VueBaseViewDriverFactory'
+
+
+
+describe('Vue view drivers', () => {
+  it('VueBaseViewDriver stores data and total', () => {
+    const driver = new VueBaseViewDriver<number>()
+
+    driver.setData([1, 2])
+    driver.setTotal(5)
+
+    expect(driver.getData()).toEqual([1, 2])
+    expect(driver.getTotal()).toBe(5)
+  })
+
+  it('VuePaginationDriver tracks pages', () => {
+    const driver = new VuePaginationDriver<number>(2, 5)
+
+    driver.setTotal(12)
+
+    expect(driver.getCurrentPage()).toBe(2)
+    expect(driver.getPageSize()).toBe(5)
+    expect(driver.getLastPage()).toBe(3)
+    expect(driver.getPages()).toEqual([1, 2, 3])
+
+    driver.setPage(1)
+    driver.setPageSize(4)
+    driver.setTotal(9)
+
+    expect(driver.getCurrentPage()).toBe(1)
+    expect(driver.getPageSize()).toBe(4)
+    expect(driver.getLastPage()).toBe(3)
+  })
+
+  it('VueBaseViewDriverFactory creates a driver', () => {
+    const factory = new VueBaseViewDriverFactory()
+
+    const driver = factory.make<number>()
+
+    expect(driver.getData()).toEqual([])
+    expect(driver.getTotal()).toBe(0)
+  })
+})

package/tests/service/pagination/dtos/StatePaginationDataDto.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest'
+import { StatePaginationDataDto } from '../../../../src/pagination/dtos/StatePaginationDataDto'
+
+describe('StatePaginationDataDto', () => {
+  it('returns state and next page status', () => {
+    const dto = new StatePaginationDataDto([1], 1, 'next')
+
+    expect(dto.getState()).toBe('next')
+    expect(dto.hasNextPage()).toBe(true)
+
+    const end = new StatePaginationDataDto([1], 1, null)
+    expect(end.hasNextPage()).toBe(false)
+  })
+})

package/tests/service/persistenceDrivers/PersistenceDrivers.test.ts

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { LocalStorageDriver } from '../../../src/persistenceDrivers/LocalStorageDriver'
+import { NonPersistentDriver } from '../../../src/persistenceDrivers/NonPersistentDriver'
+import { SessionStorageDriver } from '../../../src/persistenceDrivers/SessionStorageDriver'
+
+const clearStorage = () => {
+  localStorage.clear()
+  sessionStorage.clear()
+}
+
+describe('Persistence drivers', () => {
+  beforeEach(() => {
+    clearStorage()
+  })
+
+  it('NonPersistentDriver does not persist', () => {
+    const driver = new NonPersistentDriver()
+
+    expect(driver.get('any')).toBeNull()
+    expect(() => driver.set('key', { value: 1 })).not.toThrow()
+    expect(() => driver.remove('key')).not.toThrow()
+  })
+
+  it('LocalStorageDriver stores and retrieves values with suffix', () => {
+    const driver = new LocalStorageDriver('abc')
+
+    driver.set('user', { id: 1 })
+
+    expect(localStorage.getItem('state_user_abc')).toBe('{"id":1}')
+    expect(driver.get('user')).toEqual({ id: 1 })
+
+    driver.remove('user')
+    expect(localStorage.getItem('state_user_abc')).toBeNull()
+  })
+
+  it('LocalStorageDriver stores and retrieves values without suffix', () => {
+    const driver = new LocalStorageDriver()
+
+    driver.set('prefs', { dark: true })
+
+    expect(localStorage.getItem('state_prefs')).toBe('{"dark":true}')
+    expect(driver.get('prefs')).toEqual({ dark: true })
+  })
+
+  it('SessionStorageDriver stores and retrieves values with suffix', () => {
+    const driver = new SessionStorageDriver('v1')
+
+    driver.set('token', { value: 'abc' })
+
+    expect(sessionStorage.getItem('state_token_v1')).toBe('{"value":"abc"}')
+    expect(driver.get('token')).toEqual({ value: 'abc' })
+
+    driver.remove('token')
+    expect(sessionStorage.getItem('state_token_v1')).toBeNull()
+  })
+})

package/tests/service/requests/BaseRequest.test.ts

@@ -0,0 +1,199 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { BaseRequest } from '../../../src/requests/BaseRequest'
+import { BaseResponse } from '../../../src/requests/responses/BaseResponse'
+import { JsonBodyFactory } from '../../../src/requests/factories/JsonBodyFactory'
+import { RequestMethodEnum } from '../../../src/requests/RequestMethod.enum'
+import { RequestEvents } from '../../../src/requests/RequestEvents.enum'
+import { RequestConcurrencyMode } from '../../../src/requests/RequestConcurrencyMode.enum'
+import { StaleResponseException } from '../../../src/requests/exceptions/StaleResponseException'
+import { ResponseException } from '../../../src/requests/exceptions/ResponseException'
+import { ErrorHandler } from '../../../src/requests/ErrorHandler'
+import type { RequestDriverContract } from '../../../src/requests/contracts/RequestDriverContract'
+import type { RequestLoaderContract } from '../../../src/requests/contracts/RequestLoaderContract'
+import type { RequestLoaderFactoryContract } from '../../../src/requests/contracts/RequestLoaderFactoryContract'
+import type { ResponseHandlerContract } from '../../../src/requests/drivers/contracts/ResponseHandlerContract'
+
+class TestResponse extends BaseResponse<string> {
+  public getAcceptHeader(): string {
+    return 'text/plain'
+  }
+
+  protected resolveBody(): Promise<string> {
+    return Promise.resolve('ok')
+  }
+}
+
+class TestLoader implements RequestLoaderContract<boolean> {
+  private loading = false
+
+  isLoading(): boolean {
+    return this.loading
+  }
+
+  setLoading(value: boolean): void {
+    this.loading = value
+  }
+}
+
+class TestRequest extends BaseRequest<boolean, { message: string }, string, TestResponse, { name: string }, { filter?: { active?: boolean } }> {
+  public method(): RequestMethodEnum {
+    return RequestMethodEnum.POST
+  }
+
+  public url(): string {
+    return '/test'
+  }
+
+  public getResponse(): TestResponse {
+    return new TestResponse()
+  }
+
+  public requestHeaders() {
+    return { 'X-Req': 'value' }
+  }
+
+  public getRequestBodyFactory() {
+    return new JsonBodyFactory<{ name: string }>()
+  }
+}
+
+const createResponseHandler = (): ResponseHandlerContract => ({
+  getStatusCode: () => 200,
+  getHeaders: () => ({}),
+  getRawResponse: () => new Response('ok'),
+  json: async () => ({ ok: true }),
+  text: async () => 'ok',
+  blob: async () => new Blob(),
+})
+
+describe('BaseRequest', () => {
+  beforeEach(() => {
+    BaseRequest.setDefaultBaseUrl('https://example.com')
+    BaseRequest.setRequestLoaderFactory(undefined as unknown as RequestLoaderFactoryContract<boolean>)
+    BaseRequest.setRequestDriver(undefined as unknown as RequestDriverContract)
+  })
+
+  it('builds URLs with params and merges params deeply', () => {
+    const request = new TestRequest()
+
+    request.setParams({ filter: { active: true } })
+    request.withParams({ filter: { active: false } })
+
+    expect(request.getParams()).toEqual({ filter: { active: false } })
+
+    const url = request.buildUrl()
+    expect(url.toString()).toBe('https://example.com/test?filter%5Bactive%5D=false')
+  })
+
+  it('dispatches loading events and toggles loader', async () => {
+    const loaderFactory: RequestLoaderFactoryContract<boolean> = {
+      make: () => new TestLoader(),
+    }
+
+    BaseRequest.setRequestLoaderFactory(loaderFactory)
+
+    const driver: RequestDriverContract = {
+      send: vi.fn().mockResolvedValue(createResponseHandler()),
+    }
+    BaseRequest.setRequestDriver(driver)
+
+    const request = new TestRequest()
+    const loadingEvents: boolean[] = []
+
+    request.on(RequestEvents.LOADING, (value: boolean) => loadingEvents.push(value))
+    request.setBody({ name: 'Ada' })
+
+    const response = await request.send()
+
+    expect(response.getBody()).toBe('ok')
+    expect(loadingEvents).toEqual([true, false])
+    expect(request.isLoading()).toBe(false)
+
+    expect(driver.send).toHaveBeenCalledTimes(1)
+
+    const [url, method, headers, body] = (driver.send as ReturnType<typeof vi.fn>).mock.calls[0]
+    expect(url.toString()).toBe('https://example.com/test')
+    expect(method).toBe(RequestMethodEnum.POST)
+    expect(headers).toEqual({ Accept: 'text/plain', 'X-Req': 'value' })
+    expect(body?.getContent()).toBe('{"name":"Ada"}')
+  })
+
+  it('throws when loading state is requested without a loader', () => {
+    const request = new TestRequest()
+
+    expect(() => request.isLoading()).toThrow('Request loader is not set.')
+  })
+
+  it('marks stale responses when using LATEST concurrency mode', async () => {
+    const driver: RequestDriverContract = {
+      send: vi.fn(),
+    }
+    BaseRequest.setRequestDriver(driver)
+
+    const resolvers: Array<(value: ResponseHandlerContract) => void> = []
+
+    ;(driver.send as ReturnType<typeof vi.fn>).mockImplementation(() =>
+      new Promise<ResponseHandlerContract>((resolve) => {
+        resolvers.push(resolve)
+      })
+    )
+
+    const request = new TestRequest()
+    request.setConcurrency({ mode: RequestConcurrencyMode.LATEST, key: 'latest-test' })
+
+    const first = request.send()
+    const second = request.send()
+
+    resolvers[1](createResponseHandler())
+    await expect(second).resolves.toBeInstanceOf(TestResponse)
+
+    resolvers[0](createResponseHandler())
+    await expect(first).rejects.toBeInstanceOf(StaleResponseException)
+  })
+
+  it('aborts previous request when using REPLACE mode', async () => {
+    const driver: RequestDriverContract = {
+      send: vi.fn(),
+    }
+    BaseRequest.setRequestDriver(driver)
+
+    const request = new TestRequest()
+    request.setConcurrency({ mode: RequestConcurrencyMode.REPLACE, key: 'replace-test' })
+
+    const resolvers: Array<(value: ResponseHandlerContract) => void> = []
+    ;(driver.send as ReturnType<typeof vi.fn>).mockImplementation(() =>
+      new Promise<ResponseHandlerContract>((resolve) => {
+        resolvers.push(resolve)
+      })
+    )
+
+    const firstPromise = request.send()
+    const firstConfig = (driver.send as ReturnType<typeof vi.fn>).mock.calls[0][4]
+
+    const secondPromise = request.send()
+
+    expect(firstConfig?.abortSignal?.aborted).toBe(true)
+
+    resolvers[0](createResponseHandler())
+    resolvers[1](createResponseHandler())
+
+    await Promise.allSettled([firstPromise, secondPromise])
+  })
+
+  it('invokes ErrorHandler when a ResponseException is thrown', async () => {
+    const responseHandler = createResponseHandler()
+    const responseException = new ResponseException(responseHandler)
+
+    const driver: RequestDriverContract = {
+      send: vi.fn().mockRejectedValue(responseException),
+    }
+    BaseRequest.setRequestDriver(driver)
+
+    const handleSpy = vi.spyOn(ErrorHandler.prototype, 'handle').mockResolvedValue(undefined as never)
+
+    const request = new TestRequest()
+
+    await expect(request.send()).rejects.toBe(responseException)
+    expect(handleSpy).toHaveBeenCalledTimes(1)
+  })
+})

package/tests/service/requests/BodiesAndFactories.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import { JsonBody } from '../../../src/requests/bodies/JsonBody'
+import { JsonBodyFactory } from '../../../src/requests/factories/JsonBodyFactory'
+import { FormDataFactory } from '../../../src/requests/factories/FormDataFactory'
+import { FormDataBody } from '../../../src/requests/bodies/FormDataBody'
+
+describe('Request bodies and factories', () => {
+  it('JsonBody returns headers and JSON content', () => {
+    const body = new JsonBody({ hello: 'world' })
+
+    expect(body.getHeaders()).toEqual({ 'Content-Type': 'application/json' })
+    expect(body.getContent()).toBe('{"hello":"world"}')
+  })
+
+  it('JsonBodyFactory returns JsonBody', () => {
+    const factory = new JsonBodyFactory<{ foo: string }>()
+    const body = factory.make({ foo: 'bar' })
+
+    expect(body).toBeInstanceOf(JsonBody)
+  })
+
+  it('FormDataFactory returns FormDataBody', () => {
+    const factory = new FormDataFactory<{ name: string }>()
+    const body = factory.make({ name: 'alice' })
+
+    expect(body).toBeInstanceOf(FormDataBody)
+  })
+})

package/tests/service/requests/Enums.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+import { RequestMethodEnum } from '../../../src/requests/RequestMethod.enum'
+import { RequestEvents } from '../../../src/requests/RequestEvents.enum'
+import { RequestConcurrencyMode } from '../../../src/requests/RequestConcurrencyMode.enum'
+import { BulkRequestExecutionMode } from '../../../src/bulkRequests/BulkRequestSender'
+
+
+describe('Enums', () => {
+  it('exposes expected request enums', () => {
+    expect(RequestMethodEnum.GET).toBe('GET')
+    expect(RequestEvents.LOADING).toBe('loading')
+    expect(RequestConcurrencyMode.REPLACE_LATEST).toBe('replace-latest')
+  })
+
+  it('exposes bulk request execution modes', () => {
+    expect(BulkRequestExecutionMode.PARALLEL).toBe('parallel')
+    expect(BulkRequestExecutionMode.SEQUENTIAL).toBe('sequential')
+  })
+})

package/tests/service/requests/ErrorHandler.test.ts

@@ -9,7 +9,22 @@ import {
   ResponseException,
   NoResponseReceivedException,
   ServerErrorException,
-  InvalidJsonException
+  InvalidJsonException,
+  BadRequestException,
+  ForbiddenException,
+  MethodNotAllowedException,
+  RequestTimeoutException,
+  ConflictException,
+  GoneException,
+  PreconditionFailedException,
+  PayloadTooLargeException,
+  UnsupportedMediaTypeException,
+  LockedException,
+  TooManyRequestsException,
+  NotImplementedException,
+  BadGatewayException,
+  ServiceUnavailableException,
+  GatewayTimeoutException
 } from '../../../src/requests/exceptions';
 
 describe('ErrorHandler', () => {
@@ -141,4 +156,33 @@ describe('ErrorHandler', () => {
     await expect(handler.handle()).rejects.toThrow(InvalidJsonException);
     expect(mockResponse.json).toHaveBeenCalled();
   });
+
+  it.each([
+    [400, BadRequestException],
+    [403, ForbiddenException],
+    [405, MethodNotAllowedException],
+    [408, RequestTimeoutException],
+    [409, ConflictException],
+    [410, GoneException],
+    [412, PreconditionFailedException],
+    [413, PayloadTooLargeException],
+    [415, UnsupportedMediaTypeException],
+    [423, LockedException],
+    [429, TooManyRequestsException],
+    [501, NotImplementedException],
+    [502, BadGatewayException],
+    [503, ServiceUnavailableException],
+    [504, GatewayTimeoutException],
+  ])('should throw correct exception for status code %i', async (status, ExceptionType) => {
+    const mockResponse = {
+      getStatusCode: vi.fn().mockReturnValue(status),
+      json: vi.fn().mockResolvedValue({}),
+    };
+
+    const handler = new ErrorHandler(mockResponse as any);
+
+    await expect(handler.handle()).rejects.toThrow(ExceptionType);
+    expect(mockResponse.getStatusCode).toHaveBeenCalled();
+    expect(mockResponse.json).toHaveBeenCalled();
+  });
 });

package/tests/service/requests/RequestErrorRouter.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from 'vitest'
+import { RequestErrorRouter } from '../../../src/requests/RequestErrorRouter'
+import { BadRequestException } from '../../../src/requests/exceptions/BadRequestException'
+
+const mockResponse = {
+  getStatusCode: () => 400,
+  getHeaders: () => ({}),
+  getRawResponse: () => new Response(),
+  json: async () => ({}),
+  text: async () => '',
+  blob: async () => new Blob(),
+}
+
+describe('RequestErrorRouter', () => {
+  it('routes known errors to handlers', async () => {
+    const router = new RequestErrorRouter()
+    const handler = vi.fn()
+
+    router.on(BadRequestException, handler)
+
+    const handled = await router.handle(new BadRequestException(mockResponse as any, { message: 'bad' }))
+
+    expect(handled).toBe(true)
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('uses default handler when no match found', async () => {
+    const router = new RequestErrorRouter()
+    const fallback = vi.fn()
+
+    router.otherwise(fallback)
+
+    const handled = await router.handle(new Error('other'))
+
+    expect(handled).toBe(true)
+    expect(fallback).toHaveBeenCalledTimes(1)
+  })
+
+  it('returns false when no handlers are registered', async () => {
+    const router = new RequestErrorRouter()
+
+    await expect(router.handle(new Error('nope'))).resolves.toBe(false)
+  })
+})

package/tests/service/requests/Responses.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest'
+import { BaseResponse } from '../../../src/requests/responses/BaseResponse'
+import { JsonResponse } from '../../../src/requests/responses/JsonResponse'
+import { PlainTextResponse } from '../../../src/requests/responses/PlainTextResponse'
+import { BlobResponse } from '../../../src/requests/responses/BlobResponse'
+import type { ResponseHandlerContract } from '../../../src/requests/drivers/contracts/ResponseHandlerContract'
+
+class TestResponse extends BaseResponse<string> {
+  public getAcceptHeader(): string {
+    return 'text/plain'
+  }
+
+  protected resolveBody(): Promise<string> {
+    return Promise.resolve('ok')
+  }
+}
+
+const mockResponseHandler: ResponseHandlerContract = {
+  getStatusCode: () => 200,
+  getHeaders: () => ({ 'x-test': 'yes' }),
+  getRawResponse: () => new Response('raw'),
+  json: async () => ({ ok: true }),
+  text: async () => 'plain',
+  blob: async () => new Blob(['blob'], { type: 'text/plain' }),
+}
+
+describe('Response classes', () => {
+  it('BaseResponse throws if body not set', () => {
+    const response = new TestResponse()
+
+    expect(() => response.getBody()).toThrow('Response body is not set')
+  })
+
+  it('BaseResponse stores response metadata and body', async () => {
+    const response = new TestResponse()
+
+    await response.setResponse(mockResponseHandler)
+
+    expect(response.getBody()).toBe('ok')
+    expect(response.getStatusCode()).toBe(200)
+    expect(response.getHeaders()).toEqual({ 'x-test': 'yes' })
+    expect(response.getRawResponse()).toBeInstanceOf(Response)
+  })
+
+  it('JsonResponse resolves JSON body', async () => {
+    const response = new JsonResponse<{ ok: boolean }>()
+
+    await response.setResponse(mockResponseHandler)
+
+    expect(response.getAcceptHeader()).toBe('application/json')
+    expect(response.getBody()).toEqual({ ok: true })
+  })
+
+  it('PlainTextResponse resolves text body', async () => {
+    const response = new PlainTextResponse()
+
+    await response.setResponse(mockResponseHandler)
+
+    expect(response.getAcceptHeader()).toBe('text/plain')
+    expect(response.getBody()).toBe('plain')
+  })
+
+  it('BlobResponse resolves blob body and uses mime type', async () => {
+    const response = new BlobResponse('application/pdf')
+
+    await response.setResponse(mockResponseHandler)
+
+    expect(response.getAcceptHeader()).toBe('application/pdf')
+    expect(response.getBody()).toBeInstanceOf(Blob)
+  })
+
+  it('throws when resolveBody is called without a response', () => {
+    const response = new JsonResponse()
+
+    expect(() => (response as any).resolveBody()).toThrow('Response is not set')
+
+    const plain = new PlainTextResponse()
+    expect(() => (plain as any).resolveBody()).toThrow('Response is not set')
+
+    const blob = new BlobResponse()
+    expect(() => (blob as any).resolveBody()).toThrow('Response is not set')
+  })
+})

package/tests/service/requests/exceptions/Exceptions.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { ResponseException } from '../../../../src/requests/exceptions/ResponseException'
+import { ResponseBodyException } from '../../../../src/requests/exceptions/ResponseBodyException'
+import { BadRequestException } from '../../../../src/requests/exceptions/BadRequestException'
+import { StaleResponseException } from '../../../../src/requests/exceptions/StaleResponseException'
+
+const mockResponse = {
+  getStatusCode: () => 400,
+  getHeaders: () => ({}),
+  getRawResponse: () => new Response(),
+  json: async () => ({}),
+  text: async () => '',
+  blob: async () => new Blob(),
+}
+
+describe('Request exceptions', () => {
+  it('ResponseException stores response', () => {
+    const exception = new ResponseException(mockResponse as any)
+
+    expect(exception.getResponse()).toBe(mockResponse)
+  })
+
+  it('ResponseBodyException stores response and body', () => {
+    const exception = new ResponseBodyException(mockResponse as any, { error: 'bad' })
+
+    expect(exception.getResponse()).toBe(mockResponse)
+    expect(exception.getBody()).toEqual({ error: 'bad' })
+  })
+
+  it('BadRequestException extends ResponseBodyException', () => {
+    const exception = new BadRequestException(mockResponse as any, { error: 'bad' })
+
+    expect(exception).toBeInstanceOf(ResponseBodyException)
+  })
+
+  it('StaleResponseException exposes cause', () => {
+    const cause = new Error('root')
+    const exception = new StaleResponseException('stale', cause)
+
+    expect(exception.message).toBe('stale')
+    expect(exception.getCause()).toBe(cause)
+  })
+})

package/tests/service/requests/fetch/FetchDriver.test.ts

@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { FetchDriver } from '../../../../src/requests/drivers/fetch/FetchDriver'
+import { FetchResponse } from '../../../../src/requests/drivers/fetch/FetchResponse'
+import { RequestMethodEnum } from '../../../../src/requests/RequestMethod.enum'
+import { ResponseException } from '../../../../src/requests/exceptions/ResponseException'
+import type { BodyContract } from '../../../../src/requests/contracts/BodyContract'
+
+const createBody = (content: string): BodyContract => ({
+  getHeaders: () => ({ 'Content-Type': 'application/json' }),
+  getContent: () => content,
+})
+
+describe('FetchDriver', () => {
+  const originalFetch = global.fetch
+
+  beforeEach(() => {
+    global.fetch = vi.fn()
+  })
+
+  afterEach(() => {
+    global.fetch = originalFetch
+    vi.restoreAllMocks()
+  })
+
+  it('sends requests with merged headers and body', async () => {
+    const response = new Response('{"ok":true}', {
+      status: 200,
+      headers: { 'X-Response': 'yes' },
+    })
+
+    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
+
+    const driver = new FetchDriver({ headers: { 'X-Global': 'a' }, corsWithCredentials: true })
+
+    const result = await driver.send(
+      'https://example.com',
+      RequestMethodEnum.POST,
+      { 'X-Req': 'b', 'X-Fn': () => 'c', 'X-Ignore': undefined },
+      createBody('{"name":"test"}')
+    )
+
+    expect(result).toBeInstanceOf(FetchResponse)
+
+    const [, config] = (global.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0]
+    expect(config.method).toBe('POST')
+    expect(config.credentials).toBe('include')
+    expect(config.headers).toEqual({
+      'X-Global': 'a',
+      'X-Req': 'b',
+      'X-Fn': 'c',
+      'Content-Type': 'application/json',
+    })
+    expect(config.body).toBe('{"name":"test"}')
+  })
+
+  it('omits body for GET/HEAD requests', async () => {
+    const response = new Response('ok', { status: 200 })
+    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
+
+    const driver = new FetchDriver()
+
+    await driver.send('https://example.com', RequestMethodEnum.GET, {}, createBody('data'))
+
+    const [, config] = (global.fetch as unknown as ReturnType<typeof vi.fn>).mock.calls[0]
+    expect(config.body).toBeUndefined()
+  })
+
+  it('throws ResponseException when response is not ok', async () => {
+    const response = new Response('fail', { status: 500 })
+    ;(global.fetch as unknown as ReturnType<typeof vi.fn>).mockResolvedValue(response)
+
+    const driver = new FetchDriver()
+
+    await expect(driver.send('https://example.com', RequestMethodEnum.GET, {})).rejects.toBeInstanceOf(ResponseException)
+  })
+})