@intellegens/cornerstone-client 0.0.9999-alpha-30 → 0.0.9999-alpha-31

package/dist/services/auth/client/AuthorizationManagementControllerClient/index.integration.test.js

@@ -0,0 +1,89 @@
+import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { AuthorizationManagementControllerClient } from '.';
+import fetchOrig from 'node-fetch';
+import fetchCookie from 'fetch-cookie';
+import { CookieJar } from 'tough-cookie';
+// Create a fetch instance that handles auth cookies
+const jar = new CookieJar();
+const cookieFetch = fetchCookie(fetchOrig, jar);
+// Custom IHttpService implementation for tests
+class CookieFetchHttpService {
+    async request(url, config) {
+        const response = await cookieFetch(url, {
+            method: config?.method || 'GET',
+            headers: config?.headers,
+            body: config?.body,
+            signal: config?.signal,
+        });
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            json: () => response.json(),
+            text: () => response.text(),
+        };
+    }
+}
+const credentials = {
+    username: 'admin@test.com',
+    password: 'Password1234!',
+};
+const baseUrl = 'http://localhost:5000/api';
+describe('AuthorizationManagementControllerClient', () => {
+    let client;
+    let fetchService = new CookieFetchHttpService();
+    beforeAll(async () => {
+        await fetchService.request(`${baseUrl}/auth/signin`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(credentials),
+        });
+    });
+    beforeEach(() => {
+        client = new AuthorizationManagementControllerClient('/AuthorizationManagement', fetchService);
+    });
+    it('should fetch all roles', async () => {
+        const result = (await client.getAllRoles(false));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+    });
+    it('should fetch all roles with claims', async () => {
+        const result = (await client.getAllRoles(true));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result[0].claims).toBeDefined();
+    });
+    it('should return role with claims by name', async () => {
+        const newRole = { name: 'New Role Test Claims', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+        const create = (await client.upsertRole(newRole));
+        expect(create.ok).toBe(true);
+        const result = (await client.getRoleWithClaims(newRole.name));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.claims).toBeDefined();
+        expect(result.result.name).toBe(newRole.name);
+        expect(result.result.claims.length).toBe(newRole.claims.length);
+        expect(result.result.claims).toEqual(newRole.claims);
+    });
+    it('should create a new role with claims', async () => {
+        const newRole = { name: 'New Role', claims: [{ type: 'Test Claim Type', value: 'Test Claim Value' }] };
+        const result = (await client.upsertRole(newRole));
+        expect(result.ok).toBe(true);
+        expect(result.result).toBeDefined();
+        expect(result.result.name).toBe(newRole.name);
+        expect(result.result.claims.length).toBe(newRole.claims.length);
+        expect(result.result.claims).toEqual(newRole.claims);
+    });
+    it('should delete role', async () => {
+        const role = { name: 'Temp Role', claims: [] };
+        const create = (await client.upsertRole(role));
+        expect(create.ok).toBe(true);
+        const deleteResult = await client.deleteRole(role.name);
+        expect(deleteResult.ok).toBe(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellegens/cornerstone-client",
-  "version": "0.0.9999-alpha-30",
+  "version": "0.0.9999-alpha-31",
   "private": false,
   "publishable": true,
   "main": "./dist/index.js",
@@ -15,22 +15,18 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.21.0",
-    "@jest/globals": "^30.2.0",
     "@types/express": "^5.0.0",
-    "@types/jest": "^29.5.12",
     "@types/node": "^22.13.9",
     "eslint": "^9.21.0",
     "eslint-config-prettier": "^10.0.1",
     "express": "^4.21.2",
     "globals": "^16.0.0",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
     "prettier": "^3.5.2",
     "rxjs": "~7.8.0",
-    "ts-jest": "^29.1.2",
     "tsc-alias": "^1.8.11",
     "typescript-eslint": "^8.26.0",
     "vite": "6.3.4",
+    "vitest": "^3.2.4",
     "zod": "^3.24.2"
   },
   "dependencies": {
@@ -39,8 +35,10 @@
   },
   "scripts": {
     "clean": "pnpx rimraf '{dist}'",
-    "test": "jest",
-    "coverage": "jest --coverage",
+    "test": "vitest run --passWithNoTests",
+    "test:unit": "vitest run --project unit --passWithNoTests",
+    "test:integration": "vitest run --project integration --passWithNoTests",
+    "coverage": "vitest run --coverage",
     "build": "pnpm run clean && tsc && tsc-alias",
     "start": "pnpm run build && pnpx vite build && pnpx tsx ./demo"
   }

package/src/adapters/CollectionViewAdapter/index.integration.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { CollectionViewAdapter, CollectionViewAdapterOptions } from '.';
+import { ReadSelectedComparisonOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '@/data';
+import { dateInterval, searchTerm } from '@/utils';
+
+type TestDto = { id: number; name: string; dateOfBirth: string; rowVersion: string };
+
+describe('CollectionViewAdapter', () => {
+  let data: TestDto[] | undefined;
+  let error: string | undefined;
+  let isLoading: boolean | undefined;
+
+  const callback = vi.fn((_isLoading: boolean, _data: TestDto[] | undefined, _error: string | undefined) => {
+    isLoading = _isLoading;
+    data = _data;
+    error = _error;
+  });
+
+  const options: CollectionViewAdapterOptions<TestDto> = {
+    pagination: { useTotalItemCount: true, pageSize: 5, pageNumber: 1 },
+    ordering: { maxActiveOrderingColumns: 1, orderByPaths: [] },
+    search: { textSearchableProperties: ['name'], numericSearchableProperties: ['id'] },
+  };
+
+  let adapter: CollectionViewAdapter<number, TestDto, TestDto>;
+
+  const waitForData = async (timeout = 2000) => {
+    const start = Date.now();
+    while (isLoading !== false && Date.now() - start < timeout) {
+      await new Promise(res => setTimeout(res, 50));
+    }
+  };
+
+  const resetAdapterState = () => {
+    data = undefined;
+    error = undefined;
+    isLoading = undefined;
+  };
+
+  beforeEach(() => {
+    data = undefined;
+    error = undefined;
+    isLoading = undefined;
+  });
+
+  it('callback returns correct loading status and collection data', async () => {
+    options.pagination.useTotalItemCount = true;
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+
+    expect(callback).toHaveBeenNthCalledWith(1, true, undefined, undefined);
+    expect(callback).toHaveBeenLastCalledWith(false, data, undefined);
+    expect(data).toBeDefined();
+  });
+
+  it('adapter options set correct ordering', async () => {
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['name'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+  });
+
+  it('text search is applied to adapter', async () => {
+    const searchDefinition = searchTerm('Flu', ['name'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBeGreaterThan(0);
+    for (const item of data!) {
+      expect(item.name).toMatch(/flu/i);
+    }
+  });
+
+  it('numeric search is applied to adapter', async () => {
+    const searchDefinition = searchTerm('10000001', ['id'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBe(1);
+    for (const item of data!) {
+      expect(item.id).toBe(10000001);
+    }
+  });
+
+  it('applies date range filter from-to on the same date type property', async () => {
+    adapter = new CollectionViewAdapter('PetsSlim', callback, options);
+    const from = new Date('2017-01-01T00:00:00.000Z');
+    const to = new Date('2017-12-31T00:00:00.000Z');
+
+    const searchDefinition = dateInterval<TestDto>(
+      from,
+      to,
+      ReadSelectedComparisonOperator.GreaterOrEqual,
+      ReadSelectedComparisonOperator.LessOrEqual,
+      ReadSelectedPropertyType.DateOnly,
+      'dateOfBirth',
+    );
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    await waitForData();
+    resetAdapterState();
+    adapter.setSearchDefinition(searchDefinition);
+    await waitForData();
+
+    expect(data).toBeDefined();
+  });
+
+  it('applies pagination: page size and jump to page set skip/limit', async () => {
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    const firstPageData = data;
+    resetAdapterState();
+    adapter.jumpToPage(3);
+    await waitForData();
+
+    expect(data).toBeDefined();
+    expect(data!.length).toBe(5);
+    // Check that data is different from first page
+    expect(data).not.toEqual(firstPageData);
+  });
+
+  it('calculates total when useTotalItemCount=false and last page is partial', async () => {
+    options.pagination.useTotalItemCount = false;
+    options.pagination.pageSize = 10;
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    await waitForData();
+    const firstPageData = data;
+    resetAdapterState();
+    adapter.jumpToPage(2);
+    await waitForData();
+
+    expect(adapter.totalItemCount).toBe(firstPageData!.length + data!.length);
+  });
+
+  it('setOrdering correctly handles PropertyPathDto array comparison and limits columns', async () => {
+    options.ordering.maxActiveOrderingColumns = 2;
+    // Add first ordering
+    adapter = new CollectionViewAdapter('AnythingManuallyMappedRead', callback, options);
+    adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['name'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // Add second ordering
+    adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Ascending);
+    await waitForData();
+
+    // Should have both orderings, with 'id' first (most recent)
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['id'],
+        orderDirection: ReadSelectedOrderingDirection.Ascending,
+      },
+      {
+        orderByPath: ['name'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+    ]);
+
+    // // Add third ordering - should remove the oldest one (name)
+    adapter.setOrdering(['description'], ReadSelectedOrderingDirection.Descending);
+    await waitForData();
+
+    expect(adapter.getCurrentOrdering()).toEqual([
+      {
+        orderByPath: ['description'],
+        orderDirection: ReadSelectedOrderingDirection.Descending,
+      },
+      {
+        orderByPath: ['id'],
+        orderDirection: ReadSelectedOrderingDirection.Ascending,
+      },
+    ]);
+  });
+});

package/src/adapters/SearchAdapter/index.ts

@@ -41,28 +41,41 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
   public onChange = new SingularEventTarget<string>();
   // inputs
   private _readClient!: ApiReadControllerClient<TKey, TDto, TDto>;
-  private _options!: SearchAdapterOptions<TDto>;
+  public options!: SearchAdapterOptions<TDto>;
   private _isLoading = false;
   private _currentAbortController?: AbortController;
-  private _lastSearchedValue = '';
+  private _lastSearchedValue: string | undefined = undefined;
   private _typesToSearch: string[] = [];
   private _fetchResultsDataTimeout?: any;
   private _fetchResultsPromises: {
     resolve: (value: TDto[] | PromiseLike<TDto[]>) => void;
     reject: (reason?: unknown) => void;
   }[] = [];
+  private _totalCount = 0;
 
   constructor(options: SearchAdapterOptions<TDto>) {
-    this._options = options;
+    this.options = options;
     this._readClient = new ApiReadControllerClient<TKey, TDto, TDto>(options.controllerName);
   }
 
   public get searchTriggerMinLength() {
-    return this._options.searchTriggerMinLength;
+    return this.options.searchTriggerMinLength;
   }
 
   public get multiselect() {
-    return this._options.multiselect;
+    return this.options.multiselect;
+  }
+
+  public get isLoading() {
+    return this._isLoading;
+  }
+
+  public get totalCount() {
+    return this._totalCount;
+  }
+
+  public get hasMoreRecords() {
+    return this._totalCount > this._searchResults.length;
   }
 
   private _searchText: string = '';
@@ -105,7 +118,7 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
     }
 
     // selection mode
-    if (this._options.multiselect) {
+    if (this.options.multiselect) {
       if (!this._selectedItems.find(s => s.id === item.id)) {
         this.selectedItems = [...this.selectedItems, item];
       }
@@ -134,20 +147,22 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
   }
 
   private async _trySearch() {
-    const options = this._options;
+    const options = this.options;
 
     this.searchResults = [];
     if (this._searchText.length < options.searchTriggerMinLength) return;
-    if (this._searchText == this._lastSearchedValue) return;
+    if (this._searchText === this._lastSearchedValue) return;
     this._lastSearchedValue = this._searchText;
 
     this._typesToSearch =
-      options.limitSearchToSelectedType && this._selectedItems.length ? [(this._selectedItems[0] as TDto).type] : this._options.typesToSearch;
+      options.limitSearchToSelectedType && this._selectedItems.length ? [(this._selectedItems[0] as TDto).type] : this.options.typesToSearch;
 
     this.searchResults = this._sortByName(await this._fetchResults(options.searchDebounceDelay));
   }
 
   private async _fetchResults(debounceDelay: number): Promise<TDto[]> {
+    this._isLoading = true;
+
     return new Promise((resolve, reject) => {
       this._fetchResultsPromises.push({ resolve, reject });
       if (this._fetchResultsDataTimeout !== undefined) {
@@ -167,7 +182,6 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
   }
 
   private async _fetchResultsDebounced(): Promise<TDto[]> {
-    this._isLoading = true;
     let abortController: AbortController | undefined;
     let caughtError: unknown;
 
@@ -190,6 +204,9 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
         throw response.error;
       }
 
+      // Update total count from response metadata
+      this._totalCount = response.metadata?.totalCount ?? response.result.length;
+
       // Filter out selected items from new results
       const selectedIds = new Set((this.selectedItems || []).map(item => item.id));
       return response.result.filter(item => !selectedIds.has(item.id));
@@ -222,7 +239,7 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
     const definition: ReadSelectedDefinitionDto<TDto> = {
       paginationDefinition: {
         skip: 0,
-        limit: this._options.resultsLimit,
+        limit: this.options.resultsLimit,
       },
     };
 
@@ -268,8 +285,8 @@ export class SearchAdapter<TKey, TDto extends IGlobalSearchable<TKey>> {
       ];
     }
 
-    if (this._options.additionalSearchDefinitions && this._options.additionalSearchDefinitions.length > 0) {
-      definition.searchDefinition.searches = [...(definition.searchDefinition.searches ?? []), ...this._options.additionalSearchDefinitions];
+    if (this.options.additionalSearchDefinitions && this.options.additionalSearchDefinitions.length > 0) {
+      definition.searchDefinition.searches = [...(definition.searchDefinition.searches ?? []), ...this.options.additionalSearchDefinitions];
     }
 
     return definition;

package/src/data/api/dto/response/ApiSuccessResponseDto.ts

@@ -7,7 +7,7 @@
  * @property {TMetadata} metadata - Metadata about the result
  */
 export type ApiSuccessResponseDto<T, TMetadata> = {
-    ok: true;
+  ok: true;
   result: T;
   metadata: TMetadata;
 };

package/src/data/auth/dto/index.ts

@@ -2,3 +2,4 @@ export * from './ClaimDto';
 export * from './UserDto';
 export * from './UserInfoDto';
 export * from './RoleDto';
+export * from './RegisterRequestDto';

package/src/services/api/ApiCrudControllerClient/index.integration.test.ts

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ApiCrudControllerClient } from '.';
+import { FetchHttpService } from '../HttpService';
+
+type VehicleSlimDto = { id: number; brand: string; model: string };
+
+describe('ApiCrudControllerClient', () => {
+  let client: ApiCrudControllerClient<number, any, any, any, any>;
+  let fetchService: FetchHttpService;
+  const testId = 100;
+
+  beforeEach(() => {
+    fetchService = new FetchHttpService();
+    client = new ApiCrudControllerClient('/VehiclesSlim', fetchService);
+  });
+
+  it('should use injected HTTP service for create', async () => {
+    const newVehicle: VehicleSlimDto = { id: testId, brand: 'New Brand', model: 'New Model' };
+
+    const result = (await client.create(newVehicle)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(result.result.id).toBe(newVehicle.id);
+    expect(result.result.brand).toBe(newVehicle.brand);
+    expect(result.result.model).toBe(newVehicle.model);
+  });
+
+  it('should use injected HTTP service for update', async () => {
+    const updateVehicle: VehicleSlimDto = { id: testId, brand: 'Updated Brand', model: 'Updated Model' };
+
+    const result = (await client.update(testId, updateVehicle)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(result.result.id).toBe(updateVehicle.id);
+    expect(result.result.brand).toBe(updateVehicle.brand);
+    expect(result.result.model).toBe(updateVehicle.model);
+  });
+
+  it('should use injected HTTP service for delete', async () => {
+    const result = await client.delete(testId);
+
+    expect(result.ok).toBe(true);
+  });
+});

package/src/services/api/ApiReadControllerClient/index.integration.test.ts

@@ -0,0 +1,71 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { ApiReadControllerClient } from '.';
+import { FetchHttpService } from '../HttpService';
+import { ReadSelectedComparisonOperator, ReadSelectedDefinitionDto, ReadSelectedLogicalOperator, ReadSelectedPropertyType } from '@/data';
+
+type VehicleSlimDto = { Id: number; Brand: string; Model: string; Year: number; RowVersion: string };
+
+describe('ApiReadControllerClient', () => {
+  let client: ApiReadControllerClient<number, any, any>;
+  let fetchService: FetchHttpService;
+
+  beforeEach(() => {
+    fetchService = new FetchHttpService();
+    client = new ApiReadControllerClient('/VehiclesSlim', fetchService);
+  });
+
+  it('should use injected HTTP service for readAll', async () => {
+    const result = (await client.readAll()) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+  });
+
+  it('should use injected HTTP service for readSingle', async () => {
+    const testId = 1;
+    const result = (await client.readSingle(testId)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+    expect(typeof result.result).toBe('object');
+    expect(result.result.id).toBe(testId);
+  });
+
+  it('should use injected HTTP service for readSelected', async () => {
+    const definition: ReadSelectedDefinitionDto<VehicleSlimDto> = {
+      searchDefinition: {
+        searches: [
+          {
+            propertyCriteria: [
+              {
+                propertyName: 'Brand',
+                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                valueType: ReadSelectedPropertyType.String,
+                value: 'Audi',
+              },
+              {
+                propertyName: 'Brand',
+                comparisonOperator: ReadSelectedComparisonOperator.Equal,
+                valueType: ReadSelectedPropertyType.String,
+                value: 'BMW',
+              },
+            ],
+            logicalOperator: ReadSelectedLogicalOperator.Or,
+          },
+        ],
+        logicalOperator: ReadSelectedLogicalOperator.And,
+      },
+    };
+
+    const result = (await client.readSelected(definition)) as { ok: boolean; result: any };
+
+    expect(result.ok).toBe(true);
+    expect(result.result).toBeDefined();
+  });
+
+  it('should handle HTTP errors properly', async () => {
+    const invalidClient = new ApiReadControllerClient('/InvalidPath', fetchService);
+    const result = await invalidClient.readAll();
+    expect(result.ok).toBe(false);
+  });
+});

package/src/services/api/HttpService/FetchHttpService.integration.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { FetchHttpService } from './FetchHttpService';
+
+const baseUrl = 'http://localhost:5000/api';
+const credentials = {
+  username: 'admin@test.com',
+  password: 'Password1234!',
+};
+
+describe('FetchHttpService', () => {
+  let fetchService: FetchHttpService;
+
+  beforeEach(() => {
+    fetchService = new FetchHttpService();
+  });
+
+  it('should make a GET request successfully', async () => {
+    const result = await fetchService.request(`${baseUrl}/AnythingManuallyMappedRead/ReadAll`);
+
+    expect(result.ok).toBe(true);
+    expect(result.status).toBe(200);
+    expect(result.statusText).toBe('OK');
+
+    const jsonData = await result.json();
+    expect(jsonData.result).toBeDefined();
+    expect(jsonData.error).toBeNull();
+  });
+
+  it('should make a POST request with body', async () => {
+    const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(credentials),
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.status).toBe(204);
+  });
+
+  it('should handle non-ok responses', async () => {
+    const result = await fetchService.request(`${baseUrl}/auth/signin`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: credentials.username, password: `${credentials.password}wrong` }),
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(400);
+    expect(result.statusText).toBe('Bad Request');
+
+    const jsonData = await result.json();
+    expect(jsonData.result).toBeNull();
+    expect(jsonData.error).toBeDefined();
+    expect(jsonData.error.code).toBe(400);
+    expect(jsonData.error.message).toBe('Invalid email or password');
+  });
+
+  it('should handle fetch errors from backend', async () => {
+    const result = await fetchService.request('http://localhost:5000/api/error');
+
+    expect(result.ok).toBe(false);
+    expect(result.status).toBe(404);
+    expect(result.statusText).toBe('Not Found');
+  });
+});