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

package/tests/HttpService.test.ts

@@ -1,303 +0,0 @@
-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');
-    });
-  });
-});

package/tests/setup.ts

@@ -1,76 +0,0 @@
-// Jest setup file for global test configuration
-
-import { jest } from '@jest/globals';
-
-// Mock global fetch with proper Response structure
-const mockFetch = jest.fn(async (url: string, config?: RequestInit) => {
-  // Create a proper Headers object mock
-  const mockHeaders = {
-    get: (name: string) => {
-      if (name === 'CORNERSTONE-API-BASEURL') return 'https://api.example.com';
-      if (name === 'content-type') return 'application/json';
-      return null;
-    },
-    forEach: (callback: (value: string, key: string) => void) => {
-      callback('application/json', 'content-type');
-      if (url === window.location.href || url === './') {
-        callback('https://api.example.com', 'CORNERSTONE-API-BASEURL');
-      }
-    },
-  };
-
-  // Default successful response
-  const mockResponse = {
-    ok: true,
-    status: 200,
-    statusText: 'OK',
-    headers: mockHeaders,
-    json: jest.fn<() => Promise<any>>().mockResolvedValue({}),
-    text: jest.fn<() => Promise<string>>().mockResolvedValue(''),
-    blob: jest.fn<() => Promise<Blob>>().mockResolvedValue(new Blob()),
-    arrayBuffer: jest.fn<() => Promise<ArrayBuffer>>().mockResolvedValue(new ArrayBuffer(0)),
-  };
-
-  // Handle websettings.json requests
-  if (url.includes('websettings.json')) {
-    return {
-      ...mockResponse,
-      status: 404,
-      ok: false,
-      statusText: 'Not Found',
-    };
-  }
-
-  return mockResponse;
-});
-
-global.fetch = mockFetch as any;
-
-// Mock window.location for tests that might use it
-Object.defineProperty(window, 'location', {
-  value: {
-    href: 'http://localhost:3000',
-    origin: 'http://localhost:3000',
-    protocol: 'http:',
-    host: 'localhost:3000',
-    hostname: 'localhost',
-    port: '3000',
-    pathname: '/',
-    search: '',
-    hash: '',
-    assign: jest.fn(),
-    replace: jest.fn(),
-    reload: jest.fn(),
-  },
-  writable: true,
-});
-
-// Mock console methods to reduce noise in tests
-global.console = {
-  ...console,
-  log: jest.fn(),
-  debug: jest.fn(),
-  info: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-};