@intellegens/cornerstone-client 0.0.9999-alpha-9 → 0.0.9999-alpha-10

package/src/services/auth/client/AuthorizationManagementControllerClient/index.ts

@@ -0,0 +1,165 @@
+import { apiInitializationService, IHttpService } from '@services';
+import { ApiErrorResponseDto, ApiResponseDto, ApiSuccessResponseDto, EmptyMetadataDto, ErrorCode, ReadMetadataDto, RoleDto } from '@data';
+import { fail, ok } from '@utils/result';
+
+/**
+ * Client for authorization management operations
+ *
+ * @export
+ * @class AuthorizationManagementControllerClient
+ */
+export class AuthorizationManagementControllerClient {
+  /**
+   * Constructor
+   * @param baseControllerPath Base path to API controller
+   * @param httpService HTTP service implementation to use for requests
+   */
+  constructor(
+    protected readonly baseControllerPath: string = 'AuthorizationManagement',
+    httpService?: IHttpService,
+  ) {
+    this._httpService = httpService;
+  }
+
+  // #region HTTP service
+  private readonly _httpService?: IHttpService = undefined;
+
+  /**
+   * Gets globally selected HTTP service
+   */
+  protected get httpService(): IHttpService {
+    return this._httpService || apiInitializationService._getHttpService();
+  }
+
+  // #endregion
+
+  /**
+   * Gets all roles in the system
+   * @param includeClaims - Whether to include claims in the response
+   * @param signal - Optional cancellation signal
+   * @returns List of all roles
+   */
+  public async getAllRoles(includeClaims: boolean, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto[], ReadMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
+      const res = await this.httpService.request(url, {
+        credentials: 'include',
+        signal,
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error fetching all roles',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Gets a role with its claims
+   * @param roleName - The name of the role
+   * @param signal
+   * @returns The role with its claims
+   */
+  public async getRoleWithClaims(roleName: string, signal?: AbortSignal): Promise<ApiResponseDto<RoleDto, ReadMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
+      const res = await this.httpService.request(url, {
+        credentials: 'include',
+        signal,
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error fetching role with claims',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Creates or updates a role
+   * @param roleDto - The role to create or update
+   * @returns The created or updated role
+   */
+  public async upsertRole(roleDto: RoleDto): Promise<ApiResponseDto<RoleDto, EmptyMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/UpsertRole`);
+      const res = await this.httpService.request(url, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(roleDto),
+        credentials: 'include',
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: 'Unknown error upserting role',
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+
+  /**
+   * Deletes a role
+   * @param roleName - The name of the role to delete
+   * @returns Promise that resolves when the role is deleted successfully
+   */
+  public async deleteRole(roleName: string): Promise<ApiResponseDto<undefined, EmptyMetadataDto>> {
+    try {
+      const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
+      const res = await this.httpService.request(url, {
+        method: 'DELETE',
+        credentials: 'include',
+      });
+
+      if (!res.ok) {
+        return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>(await res.json());
+      }
+
+      return ok<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>(undefined);
+    } catch (err) {
+      console.error(err);
+
+      return fail<ApiSuccessResponseDto<undefined, EmptyMetadataDto>, ApiErrorResponseDto>({
+        error: {
+          code: ErrorCode.UnknownError,
+          message: `Unknown error while deleting the role ${roleName}`,
+          metadata: {} as EmptyMetadataDto,
+        },
+      });
+    }
+  }
+}

package/src/services/auth/client/index.ts

@@ -0,0 +1,2 @@
+export * from './AuthorizationManagementControllerClient';
+export * from './AuthService';

package/src/services/auth/index.ts

@@ -0,0 +1 @@
+export * from './client';

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from './api';
+export * from './auth';

package/src/utils/authorization/index.ts

@@ -0,0 +1,47 @@
+import { IPolicy, PolicyBase } from '@data';
+
+/**
+ * Checks if a policy is valid for the given parameters.
+ *
+ * @param policy Policy to check, either an instance or a class.
+ * @param params Parameters to pass to the policy check function.
+ * @returns A promise that resolves if the policy is valid, rejects otherwise.
+ */
+export async function check<TParams extends unknown[]>(policy: IPolicy<TParams> | (new () => IPolicy<TParams>), ...params: TParams): Promise<boolean> {
+  // If passed an instance of a policy
+  if (policy instanceof PolicyBase) {
+    return (policy as IPolicy<TParams>).check(...params);
+  }
+  // If passed a policy class
+  else {
+    return new (policy as new () => IPolicy<TParams>)().check(...params);
+  }
+}
+
+/**
+ * Composes multiple policies into a single policy.
+ *
+ * @param composition Composition method, either 'AND' or 'OR'.
+ * @param policies Policies to compose.
+ * @returns A new policy that represents the composition of the policies.
+ */
+export function compose<TParams extends unknown[]>(composition: 'AND' | 'OR', ...policies: IPolicy<TParams>[]): IPolicy<TParams> {
+  return {
+    check: async (...params: TParams): Promise<boolean> => {
+      // Check all policies
+      if (composition === 'AND') {
+        const results = await Promise.allSettled(policies.map(policy => policy.check(...params)));
+        return results.every(result => result);
+      }
+      // Check any policies, exit as soon as any are true
+      else if (composition === 'OR') {
+        const results = await Promise.allSettled(policies.map(policy => policy.check(...params)));
+        return results.some(result => result);
+      }
+      // Invalid composition
+      else {
+        throw new Error('Invalid composition');
+      }
+    },
+  };
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './search';

package/src/utils/result/index.ts

@@ -0,0 +1,25 @@
+type TResultBase = { readonly ok: boolean };
+
+/**
+ * Represents a result of an operation.
+ * It can be either a success or an error.
+ */
+export type Result<TSuccess extends TResultBase, TError extends TResultBase> = TSuccess | TError;
+
+/**
+ * Creates a success result from the given argument.
+ * @param arg - The argument to create a success result from.
+ * @returns A success result.
+ */
+export function ok<TSuccess extends TResultBase, TError extends TResultBase>(arg?: Omit<TSuccess, 'ok'>): Result<TSuccess, TError> {
+    return {ok: true, ...arg} as TSuccess;
+}
+
+/**
+ * Creates an error result from the given argument.
+ * @param arg - The argument to create an error result from.
+ * @returns An error result.
+ */
+export function fail<TSuccess extends TResultBase, TError extends TResultBase>(arg: Omit<TError, 'ok'>): Result<TSuccess, TError> {
+    return {ok: false, ...arg} as TError;
+}

package/src/utils/search/index.ts

@@ -0,0 +1,150 @@
+import {
+  ReadSelectedComparisonOperator,
+  ReadSelectedLogicalOperator,
+  ReadSelectedPropertyType,
+  ReadSelectedSearchDefinitionDto,
+  ReadSelectedSearchPropertyDefinitionDto,
+} from '@data';
+
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all ReadSelectedSearchPropertyDefinitionDto property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - propertyName: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export function condition<T>(
+  logicalOperator: ReadSelectedLogicalOperator,
+  ...conditions: Array<{
+    propertyName: keyof T;
+    operator: ReadSelectedComparisonOperator;
+    value: unknown;
+    valueType: ReadSelectedPropertyType;
+  }>
+): ReadSelectedSearchDefinitionDto<T> {
+  return {
+    logicalOperator: logicalOperator,
+    propertyCriteria: conditions.map(
+      condition =>
+        ({
+          propertyName: toPascalCase(condition.propertyName),
+          comparisonOperator: condition.operator,
+          valueType: condition.valueType,
+          value: condition.value,
+        }) as ReadSelectedSearchPropertyDefinitionDto<T, keyof T>,
+    ),
+  };
+}
+
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T> {
+  return {
+    logicalOperator: ReadSelectedLogicalOperator.And,
+    searches: definitions,
+  };
+}
+
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or<T>(...definitions: ReadSelectedSearchDefinitionDto<T>[]): ReadSelectedSearchDefinitionDto<T> {
+  return {
+    logicalOperator: ReadSelectedLogicalOperator.Or,
+    searches: definitions,
+  };
+}
+
+/**
+ * Preset implementation for filtering by searchTerm. String types will search by provided `textSearchableProperties` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchableProperties`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export function searchTerm<T>(
+  searchTerm: string,
+  textSearchableProperties: (keyof T)[],
+  numericSearchableProperties: (keyof T)[],
+): void | ReadSelectedSearchDefinitionDto<T> {
+  let comparisonOperator: ReadSelectedComparisonOperator;
+  let valueType: ReadSelectedPropertyType;
+  let searchableProperties: (keyof T)[];
+  let searchValue: string | number;
+  try {
+    const numericValue = parseInt(searchTerm);
+
+    if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
+      comparisonOperator = ReadSelectedComparisonOperator.Equal;
+      valueType = ReadSelectedPropertyType.Int;
+      searchableProperties = numericSearchableProperties;
+      searchValue = numericValue;
+    } else {
+      comparisonOperator = ReadSelectedComparisonOperator.Contains;
+      valueType = ReadSelectedPropertyType.String;
+      searchableProperties = textSearchableProperties;
+      searchValue = searchTerm;
+    }
+
+    const searchConditions = searchableProperties.map(propertyName => ({
+      propertyName: toPascalCase(propertyName),
+      operator: comparisonOperator,
+      value: searchValue,
+      valueType: valueType,
+    }));
+
+    return condition(ReadSelectedLogicalOperator.Or, ...searchConditions);
+  } catch {
+    return;
+  }
+}
+
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchableProperty`.
+ */
+export function dateInterval<T>(
+  fromDate: Date,
+  toDate: Date,
+  fromDateComparisonOperator: ReadSelectedComparisonOperator,
+  toDateComparisonOperator: ReadSelectedComparisonOperator,
+  valueType: ReadSelectedPropertyType,
+  searchableProperty: keyof T,
+): void | ReadSelectedSearchDefinitionDto<T> {
+  try {
+    if (
+      !(
+        valueType === ReadSelectedPropertyType.DateOnly ||
+        valueType === ReadSelectedPropertyType.DateTime ||
+        valueType === ReadSelectedPropertyType.DateTimeOffset
+      )
+    ) {
+      return;
+    }
+
+    return condition(
+      ReadSelectedLogicalOperator.And,
+      {
+        propertyName: toPascalCase(searchableProperty),
+        operator: fromDateComparisonOperator,
+        value: fromDate,
+        valueType: valueType,
+      },
+      {
+        propertyName: toPascalCase(searchableProperty),
+        operator: toDateComparisonOperator,
+        value: toDate,
+        valueType: valueType,
+      },
+    );
+  } catch {
+    return;
+  }
+}
+
+export function toPascalCase<T>(str: keyof T): keyof T {
+  if (typeof str !== 'string') {
+    return str;
+  }
+
+  return (str.charAt(0).toUpperCase() + str.slice(1)) as keyof T;
+}

package/tests/ApiClients.test.ts

@@ -0,0 +1,284 @@
+import { ApiReadControllerClient, ApiCrudControllerClient, UserManagementControllerClient, IHttpService, HttpResponse } from '../src';
+import { jest } from '@jest/globals';
+import { ReadSelectedLogicalOperator } from '../src/data';
+
+// Mock HTTP Service for testing
+class MockHttpService implements IHttpService {
+  private mockResponses = new Map<string, HttpResponse>();
+  public requestLog: Array<{ url: string; config?: any }> = [];
+
+  setMockResponse(url: string, response: HttpResponse) {
+    this.mockResponses.set(url, response);
+  }
+
+  clearMockResponses() {
+    this.mockResponses.clear();
+    this.requestLog = [];
+  }
+
+  async request<T = any>(url: string, config?: any): Promise<HttpResponse<T>> {
+    this.requestLog.push({ url, config });
+
+    const mockResponse = this.mockResponses.get(url);
+    if (mockResponse) {
+      return mockResponse as HttpResponse<T>;
+    }
+
+    // Default successful response
+    return {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      headers: {},
+      json: async () => ({ success: true }) as T,
+      text: async () => '{"success":true}',
+    };
+  }
+}
+
+// Mock API Initialization Service
+jest.unstable_mockModule('../src/services/api/ApiInitializationService/index', () => ({
+  apiInitializationService: {
+    getApiUrl: jest.fn((...paths: string[]) => Promise.resolve(`https://api.example.com${paths.join('')}`)),
+  },
+}));
+
+describe('API Clients with HTTP Service Abstraction', () => {
+  let mockHttpService: MockHttpService;
+
+  beforeEach(() => {
+    mockHttpService = new MockHttpService();
+    jest.clearAllMocks();
+  });
+
+  describe('ApiReadControllerClient', () => {
+    let client: ApiReadControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new ApiReadControllerClient('/api/test', mockHttpService);
+    });
+
+    it('should use injected HTTP service for readAll', async () => {
+      const mockData = [
+        { id: 1, name: 'Test' },
+        { id: 2, name: 'Test2' },
+      ];
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readAll();
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadAll');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for readSingle', async () => {
+      const mockData = { id: 1, name: 'Test' };
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSingle?id=1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readSingle(1);
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSingle?id=1');
+    });
+
+    it('should use injected HTTP service for readSelected', async () => {
+      const mockData = [{ id: 1, name: 'Test' }];
+      const definition = {
+        searchDefinition: {
+          searches: [],
+          logicalOperator: ReadSelectedLogicalOperator.And,
+        },
+      };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadSelected', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockData, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockData, metadata: {} }),
+      });
+
+      const result = await client.readSelected(definition);
+
+      expect(result).toEqual({ result: mockData, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/test/ReadSelected');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
+      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(definition));
+    });
+
+    it('should handle HTTP errors properly', async () => {
+      mockHttpService.setMockResponse('https://api.example.com/api/test/ReadAll', {
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+        headers: {},
+        json: async () => ({ error: 'Server error' }),
+        text: async () => '{"error":"Server error"}',
+      });
+
+      try {
+        await client.readAll();
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toContain('Unknown error fetching all records');
+      }
+    });
+  });
+
+  describe('ApiCrudControllerClient', () => {
+    let client: ApiCrudControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new ApiCrudControllerClient('/api/crud', mockHttpService);
+    });
+
+    it('should use injected HTTP service for create', async () => {
+      const newItem = { id: 0, name: 'New Item' };
+      const createdItem = { id: 1, name: 'New Item' };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Create', {
+        ok: true,
+        status: 201,
+        statusText: 'Created',
+        headers: {},
+        json: async () => ({ success: true, result: createdItem, metadata: {} }),
+        text: async () => JSON.stringify({ result: createdItem, metadata: {} }),
+      });
+
+      const result = await client.create(newItem);
+
+      expect(result).toEqual({ result: createdItem, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Create');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('POST');
+      expect(mockHttpService.requestLog[0].config?.body).toBe(JSON.stringify(newItem));
+    });
+
+    it('should use injected HTTP service for update', async () => {
+      const updateItem = { id: 1, name: 'Updated Item' };
+
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Update?id=1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: updateItem, metadata: {} }),
+        text: async () => JSON.stringify({ result: updateItem, metadata: {} }),
+      });
+
+      const result = await client.update(1, updateItem);
+
+      expect(result).toEqual({ result: updateItem, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Update?id=1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('PUT');
+    });
+
+    it('should use injected HTTP service for delete', async () => {
+      mockHttpService.setMockResponse('https://api.example.com/api/crud/Delete?id=1', {
+        ok: true,
+        status: 204,
+        statusText: 'No Content',
+        headers: {},
+        json: async () => ({}),
+        text: async () => '',
+      });
+
+      await client.delete(1);
+
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/crud/Delete?id=1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('DELETE');
+    });
+  });
+
+  describe('UserManagementControllerClient', () => {
+    let client: UserManagementControllerClient<number, any>;
+
+    beforeEach(() => {
+      client = new UserManagementControllerClient('/api/users', mockHttpService);
+    });
+
+    it('should use injected HTTP service for getUserRoles', async () => {
+      const mockRoles = ['admin', 'user'];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserRoles/1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
+      });
+
+      const result = await client.getUserRoles(1);
+
+      expect(result).toEqual({ result: mockRoles, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserRoles/1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for getUserClaims', async () => {
+      const mockClaims = [
+        { type: 'role', value: 'admin' },
+        { type: 'department', value: 'IT' },
+      ];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetUserClaims/1', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockClaims, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockClaims, metadata: {} }),
+      });
+
+      const result = await client.getUserClaims(1);
+
+      expect(result).toEqual({ result: mockClaims, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetUserClaims/1');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+
+    it('should use injected HTTP service for getAllRoles', async () => {
+      const mockRoles = ['admin', 'user', 'moderator'];
+
+      mockHttpService.setMockResponse('https://api.example.com/api/users/GetAllRoles', {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        json: async () => ({ success: true, result: mockRoles, metadata: {} }),
+        text: async () => JSON.stringify({ result: mockRoles, metadata: {} }),
+      });
+
+      const result = await client.getAllRoles();
+
+      expect(result).toEqual({ result: mockRoles, metadata: {} });
+      expect(mockHttpService.requestLog.length).toBe(1);
+      expect(mockHttpService.requestLog[0].url).toBe('https://api.example.com/api/users/GetAllRoles');
+      expect(mockHttpService.requestLog[0].config?.method).toBe('GET');
+    });
+  });
+});