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

package/tests/CollectionViewAdapter.test.ts

@@ -0,0 +1,392 @@
+const mockReadSelectedAsync = jest.fn<(definition: unknown) => Promise<unknown>>();
+
+jest.mock('@services', () => {
+  return {
+    ApiReadControllerClient: jest.fn().mockImplementation(() => ({
+      readSelectedAsync: mockReadSelectedAsync,
+    })),
+  };
+});
+
+jest.mock('@intellegens/cornerstone-client', () => {
+  return {
+    ReadSelectedOrderingDirection: {
+      Ascending: 'Ascending',
+      Descending: 'Descending',
+    },
+    ReadSelectedLogicalOperator: {
+      And: 'And',
+      Or: 'Or',
+    },
+    ReadSelectedComparisonOperator: {
+      Contains: 'Contains',
+      Equal: 'Equal',
+      GreaterOrEqual: 'GreaterOrEqual',
+      LessOrEqual: 'LessOrEqual',
+    },
+    ReadSelectedPropertyType: {
+      String: 'String',
+      Int: 'Int',
+      DateTimeOffset: 'DateTimeOffset',
+    },
+  };
+});
+
+import { jest, expect, describe, test, beforeEach, afterEach } from '@jest/globals';
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedOrderingDirection, ReadSelectedPropertyType } from '../src/data';
+import { CollectionViewAdapter, CollectionViewAdapterOptions } from '../src/adapters';
+import { dateInterval, searchTerm } from '../src/utils';
+
+type TestDto = { id: number; name: string; createdAt: string; rowVersion: string };
+
+const makeItems = (n: number): TestDto[] =>
+  Array.from({ length: n }, (_, i) => ({
+    id: i + 1,
+    name: `Item ${i + 1}`,
+    createdAt: new Date(2024, 0, i + 1).toISOString(),
+    rowVersion: '1',
+  }));
+
+const fetchData = async () => {
+  // _fetchCurrentPageData() in CollectionViewAdapter has 50ms timeout set
+  jest.advanceTimersByTime(60);
+  // allow any pending microtasks to resolve
+  await Promise.resolve();
+};
+
+describe('CollectionViewAdapter', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    mockReadSelectedAsync.mockReset();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  // overrides?: Partial for passing options properties from test:
+  // const { adapter, callback } = setup({ useTotalItemCount: true });
+  const setup = (overrides?: Partial<CollectionViewAdapterOptions<TestDto>>) => {
+    const options: CollectionViewAdapterOptions<TestDto> = {
+      pagination: {
+        useTotalItemCount: true,
+        pageSize: 10,
+        pageNumber: 1,
+        ...overrides?.pagination,
+      },
+      ordering: {
+        maxActiveOrderingColumns: 1,
+        orderByPaths: [],
+        ...overrides?.ordering,
+      },
+      search: {
+        textSearchableProperties: ['name'],
+        numericSearchableProperties: ['id'],
+        ...overrides?.search,
+      },
+    };
+
+    const callback = jest.fn();
+    const adapter = new CollectionViewAdapter<number, TestDto>('ControllerName', callback, options);
+
+    return { adapter, callback };
+  };
+
+  test('callback returns correct loading status and collection data', async () => {
+    const data = makeItems(10);
+    mockReadSelectedAsync.mockResolvedValueOnce({ result: data, metadata: { totalCount: 123 } });
+
+    const { adapter, callback } = setup({ pagination: { useTotalItemCount: true } });
+
+    await fetchData();
+
+    expect(callback).toHaveBeenNthCalledWith(1, true, []);
+    expect(callback).toHaveBeenLastCalledWith(false, data);
+    expect(adapter.totalItemCount).toBe(123);
+  });
+
+  test('adapter options set correct ordering', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
+
+    const { adapter } = setup();
+    const promise = adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        orderingDefinition: {
+          order: [
+            {
+              propertyPath: ['Name'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+          ],
+        },
+      }),
+      undefined, // The abort signal parameter
+    );
+
+    expect(adapter.getCurrentOrdering()).toEqual({
+      orderByPath: ['name'],
+      orderDirection: ReadSelectedOrderingDirection.Descending,
+    });
+  });
+
+  test('text search is applied to adapter', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
+
+    const { adapter } = setup({ search: { textSearchableProperties: ['name'] } });
+
+    const searchDefinition = searchTerm('Waldo', ['name'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    const promise = adapter.setSearchDefinition(searchDefinition);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        searchDefinition: expect.objectContaining({
+          logicalOperator: expect.any(Number),
+          propertyCriteria: expect.arrayContaining([
+            expect.objectContaining({
+              propertyPath: 'Name',
+              comparisonOperator: ReadSelectedComparisonOperator.Contains,
+              valueType: ReadSelectedPropertyType.String,
+              value: 'Waldo',
+            }),
+          ]),
+        }),
+      }),
+      undefined, // The abort signal parameter
+    );
+  });
+
+  test('numeric search is applied to adapter', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
+
+    const { adapter } = setup({ search: { textSearchableProperties: ['id'] } });
+
+    const searchDefinition = searchTerm('42', ['name'], ['id']);
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    const promise = adapter.setSearchDefinition(searchDefinition);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        searchDefinition: expect.objectContaining({
+          logicalOperator: expect.any(Number),
+          propertyCriteria: expect.arrayContaining([
+            expect.objectContaining({
+              propertyPath: ['Id'],
+              comparisonOperator: ReadSelectedComparisonOperator.Equal,
+              valueType: ReadSelectedPropertyType.Int,
+              value: 42,
+            }),
+          ]),
+        }),
+      }),
+      undefined,
+    );
+  });
+
+  test('applies date range filter from-to on the same date type property', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(1), metadata: {} });
+
+    const { adapter } = setup();
+    const from = new Date('2024-01-05T00:00:00.000Z');
+    const to = new Date('2024-01-20T00:00:00.000Z');
+
+    const searchDefinition = dateInterval<TestDto>(
+      from,
+      to,
+      ReadSelectedComparisonOperator.GreaterOrEqual,
+      ReadSelectedComparisonOperator.LessOrEqual,
+      ReadSelectedPropertyType.DateTimeOffset,
+      'createdAt',
+    );
+    if (!searchDefinition) throw new Error('searchDefinition is undefined');
+    const promise = adapter.setSearchDefinition(searchDefinition);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        searchDefinition: expect.objectContaining({
+          logicalOperator: ReadSelectedLogicalOperator.And,
+          propertyCriteria: expect.arrayContaining([
+            expect.objectContaining({
+              propertyPath: ['DateProperty'],
+              comparisonOperator: ReadSelectedComparisonOperator.GreaterOrEqual,
+              valueType: ReadSelectedPropertyType.DateTimeOffset,
+              value: expect.any(Object),
+            }),
+            expect.objectContaining({
+              propertyPath: ['DateProperty'],
+              comparisonOperator: ReadSelectedComparisonOperator.LessOrEqual,
+              valueType: ReadSelectedPropertyType.DateTimeOffset,
+              value: expect.any(Object),
+            }),
+          ]),
+        }),
+      }),
+      undefined, // The abort signal parameter
+    );
+  });
+
+  test('applies pagination: page size and jump to page set skip/limit', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(5), metadata: {} });
+
+    const { adapter } = setup({ pagination: { useTotalItemCount: true, pageSize: 5, pageNumber: 1 } });
+
+    const promise = adapter.jumpToPage(3);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      // ReadSelectedDefinitionDto
+      expect.objectContaining({
+        paginationDefinition: { skip: 10, limit: 5 },
+        searchDefinition: undefined,
+      }),
+      undefined, // The abort signal parameter
+    );
+  });
+
+  test('calculates total when useTotalItemCount=false and last page is partial', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
+
+    const { adapter } = setup({ pagination: { useTotalItemCount: false, pageSize: 5, pageNumber: 2 } });
+
+    await fetchData();
+
+    expect(adapter.totalItemCount).toBe(8); // 3 items on page 2 (5 skipped on first page) ... 5+3=8
+  });
+
+  test('setOrdering correctly handles PropertyPathDto array comparison and limits columns', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
+
+    const { adapter } = setup({ ordering: { maxActiveOrderingColumns: 2, orderByPaths: [] } });
+
+    // Add first ordering
+    let promise = adapter.setOrdering(['name'], ReadSelectedOrderingDirection.Descending);
+    await fetchData();
+    await promise;
+
+    expect(adapter.getCurrentOrdering()).toEqual({
+      orderByPath: ['name'],
+      orderDirection: ReadSelectedOrderingDirection.Descending,
+    });
+
+    // Add second ordering
+    promise = adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Ascending);
+    await fetchData();
+    await promise;
+
+    // Should have both orderings, with 'id' first (most recent)
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        orderingDefinition: {
+          order: [
+            {
+              propertyPath: ['Id'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Ascending,
+            },
+            {
+              propertyPath: ['Name'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+          ],
+        },
+      }),
+      undefined,
+    );
+
+    // Add third ordering - should remove the oldest one (name)
+    promise = adapter.setOrdering(['createdAt'], ReadSelectedOrderingDirection.Descending);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        orderingDefinition: {
+          order: [
+            {
+              propertyPath: ['CreatedAt'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+            {
+              propertyPath: ['Id'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Ascending,
+            },
+          ],
+        },
+      }),
+      undefined,
+    );
+
+    // Update existing ordering - should replace, not add
+    promise = adapter.setOrdering(['id'], ReadSelectedOrderingDirection.Descending);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        orderingDefinition: {
+          order: [
+            {
+              propertyPath: ['Id'], // PascalCased - updated direction
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+            {
+              propertyPath: ['CreatedAt'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+          ],
+        },
+      }),
+      undefined,
+    );
+  });
+
+  test('setOrdering correctly compares complex PropertyPathDto arrays', async () => {
+    mockReadSelectedAsync.mockResolvedValue({ result: makeItems(3), metadata: {} });
+
+    const { adapter } = setup({ ordering: { maxActiveOrderingColumns: 3, orderByPaths: [] } });
+
+    // Add ordering with nested property path
+    let promise = adapter.setOrdering(['user', 'profile', 'name'], ReadSelectedOrderingDirection.Ascending);
+    await fetchData();
+    await promise;
+
+    // Add different nested path
+    promise = adapter.setOrdering(['user', 'settings', 'theme'], ReadSelectedOrderingDirection.Descending);
+    await fetchData();
+    await promise;
+
+    // Update the first nested path - should replace it, not add new
+    promise = adapter.setOrdering(['user', 'profile', 'name'], ReadSelectedOrderingDirection.Descending);
+    await fetchData();
+    await promise;
+
+    expect(mockReadSelectedAsync).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        orderingDefinition: {
+          order: [
+            {
+              propertyPath: ['User', 'Profile', 'Name'], // PascalCased - updated direction
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+            {
+              propertyPath: ['User', 'Settings', 'Theme'], // PascalCased
+              direction: ReadSelectedOrderingDirection.Descending,
+            },
+          ],
+        },
+      }),
+      undefined,
+    );
+  });
+});

package/tests/HttpService.test.ts

@@ -0,0 +1,303 @@
+import { AngularHttpService } from '../../angular/projects/intellegens/cornerstone-client-angular/src/lib/services/AngularHttpService';
+import { FetchHttpService, IHttpService } from '../src';
+import { jest } from '@jest/globals';
+import { of, throwError } from 'rxjs';
+
+// Mock fetch for testing
+const mockFetch = jest.fn() as jest.MockedFunction<typeof fetch>;
+global.fetch = mockFetch;
+
+// Mock Angular HttpClient
+const mockAngularHttpClient = {
+  get: jest.fn(),
+  post: jest.fn(),
+  put: jest.fn(),
+  delete: jest.fn(),
+  patch: jest.fn(),
+};
+
+describe('HttpService Implementations', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('FetchHttpService', () => {
+    let fetchService: FetchHttpService;
+
+    beforeEach(() => {
+      fetchService = new FetchHttpService();
+    });
+
+    it('should make a GET request successfully', async () => {
+      const mockResponse = {
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: new Map([['content-type', 'application/json']]),
+        json: jest.fn<() => Promise<any>>().mockResolvedValue({ data: 'test' }),
+        text: jest.fn<() => Promise<string>>().mockResolvedValue('{"data":"test"}'),
+      };
+
+      // Mock Headers.forEach
+      mockResponse.headers.forEach = jest.fn((callback: (value: string, key: string) => void) => {
+        callback('application/json', 'content-type');
+      });
+
+      mockFetch.mockResolvedValue(mockResponse as any);
+
+      const result = await fetchService.request('https://api.example.com/test');
+
+      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/test', {
+        method: 'GET',
+        headers: undefined,
+        body: undefined,
+        credentials: 'include',
+      });
+
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.statusText).toBe('OK');
+      expect(result.headers).toEqual({ 'content-type': 'application/json' });
+
+      const jsonData = await result.json();
+      expect(jsonData).toEqual({ data: 'test' });
+    });
+
+    it('should make a POST request with body', async () => {
+      const mockResponse = {
+        ok: true,
+        status: 201,
+        statusText: 'Created',
+        headers: new Map(),
+        json: jest.fn<() => Promise<any>>().mockResolvedValue({ id: 1 }),
+        text: jest.fn<() => Promise<string>>().mockResolvedValue('{"id":1}'),
+      };
+
+      mockResponse.headers.forEach = jest.fn();
+      mockFetch.mockResolvedValue(mockResponse as any);
+
+      const testData = { name: 'test' };
+      const result = await fetchService.request('https://api.example.com/create', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(testData),
+        credentials: 'include',
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/create', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(testData),
+        credentials: 'include',
+      });
+
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(201);
+    });
+
+    it('should handle fetch errors', async () => {
+      mockFetch.mockRejectedValue(new Error('Network error'));
+
+      try {
+        await fetchService.request('https://api.example.com/error');
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toBe('Network error');
+      }
+    });
+
+    it('should handle non-ok responses', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        headers: new Map(),
+        json: jest.fn<() => Promise<any>>().mockResolvedValue({ error: 'Not found' }),
+        text: jest.fn<() => Promise<string>>().mockResolvedValue('{"error":"Not found"}'),
+      };
+
+      mockResponse.headers.forEach = jest.fn();
+      mockFetch.mockResolvedValue(mockResponse as any);
+
+      const result = await fetchService.request('https://api.example.com/notfound');
+
+      expect(result.ok).toBe(false);
+      expect(result.status).toBe(404);
+      expect(result.statusText).toBe('Not Found');
+    });
+  });
+
+  describe('AngularHttpService', () => {
+    let angularService: AngularHttpService;
+
+    beforeEach(() => {
+      angularService = new AngularHttpService(mockAngularHttpClient as any);
+    });
+
+    it('should throw error if no HttpClient provided', () => {
+      expect(() => new AngularHttpService(null as any)).toThrow('Angular HttpClient instance is required');
+    });
+
+    it('should make a GET request successfully', async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: 'OK',
+        body: { data: 'test' },
+        headers: {
+          keys: jest.fn().mockReturnValue(['content-type']),
+          get: jest.fn().mockReturnValue('application/json'),
+        },
+      };
+
+      mockAngularHttpClient.get.mockReturnValue(of(mockResponse));
+
+      const result = await angularService.request('https://api.example.com/test');
+
+      expect(mockAngularHttpClient.get).toHaveBeenCalledWith('https://api.example.com/test', {
+        headers: {},
+        withCredentials: false,
+        observe: 'response',
+        responseType: 'json',
+      });
+
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.statusText).toBe('OK');
+      expect(result.headers).toEqual({ 'content-type': 'application/json' });
+
+      const jsonData = await result.json();
+      expect(jsonData).toEqual({ data: 'test' });
+    });
+
+    it('should make a POST request with body', async () => {
+      const mockResponse = {
+        status: 201,
+        statusText: 'Created',
+        body: { id: 1 },
+        headers: {
+          keys: jest.fn().mockReturnValue([]),
+          get: jest.fn(),
+        },
+      };
+
+      mockAngularHttpClient.post.mockReturnValue(of(mockResponse));
+
+      const testData = { name: 'test' };
+      const result = await angularService.request('https://api.example.com/create', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(testData),
+        credentials: 'include',
+      });
+
+      expect(mockAngularHttpClient.post).toHaveBeenCalledWith('https://api.example.com/create', testData, {
+        headers: { 'Content-Type': 'application/json' },
+        withCredentials: true,
+        observe: 'response',
+        responseType: 'json',
+      });
+
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(201);
+    });
+
+    it('should handle PUT requests', async () => {
+      const mockResponse = {
+        status: 200,
+        statusText: 'OK',
+        body: { updated: true },
+        headers: {
+          keys: jest.fn().mockReturnValue([]),
+          get: jest.fn(),
+        },
+      };
+
+      mockAngularHttpClient.put.mockReturnValue(of(mockResponse));
+
+      const result = await angularService.request('https://api.example.com/update', {
+        method: 'PUT',
+        body: JSON.stringify({ id: 1, name: 'updated' }),
+      });
+
+      expect(mockAngularHttpClient.put).toHaveBeenCalled();
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(200);
+    });
+
+    it('should handle DELETE requests', async () => {
+      const mockResponse = {
+        status: 204,
+        statusText: 'No Content',
+        body: null,
+        headers: {
+          keys: jest.fn().mockReturnValue([]),
+          get: jest.fn(),
+        },
+      };
+
+      mockAngularHttpClient.delete.mockReturnValue(of(mockResponse));
+
+      const result = await angularService.request('https://api.example.com/delete/1', {
+        method: 'DELETE',
+      });
+
+      expect(mockAngularHttpClient.delete).toHaveBeenCalled();
+      expect(result.ok).toBe(true);
+      expect(result.status).toBe(204);
+    });
+
+    it('should handle Angular HttpErrorResponse', async () => {
+      const mockError = {
+        status: 400,
+        statusText: 'Bad Request',
+        error: { message: 'Invalid data' },
+        headers: {
+          keys: jest.fn().mockReturnValue(['content-type']),
+          get: jest.fn().mockReturnValue('application/json'),
+        },
+      };
+
+      mockAngularHttpClient.get.mockReturnValue(throwError(() => mockError));
+
+      const result = await angularService.request('https://api.example.com/error');
+
+      expect(result.ok).toBe(false);
+      expect(result.status).toBe(400);
+      expect(result.statusText).toBe('Bad Request');
+      expect(result.headers).toEqual({ 'content-type': 'application/json' });
+
+      const errorData = await result.json();
+      expect(errorData).toEqual({ message: 'Invalid data' });
+    });
+
+    it('should throw error for unsupported HTTP methods', async () => {
+      try {
+        await angularService.request('https://api.example.com/test', { method: 'OPTIONS' as any });
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toContain('Unsupported HTTP method: OPTIONS');
+      }
+    });
+
+    it('should handle non-Angular errors', async () => {
+      mockAngularHttpClient.get.mockReturnValue(throwError(() => new Error('Network error')));
+
+      try {
+        await angularService.request('https://api.example.com/error');
+        fail('Should have thrown an error');
+      } catch (error: any) {
+        expect(error.message).toBe('Network error');
+      }
+    });
+  });
+
+  describe('Interface Compliance', () => {
+    it('should implement IHttpService interface correctly', () => {
+      const fetchService: IHttpService = new FetchHttpService();
+      const angularService: IHttpService = new AngularHttpService(mockAngularHttpClient as any);
+
+      expect(typeof fetchService.request).toBe('function');
+      expect(typeof angularService.request).toBe('function');
+    });
+  });
+});