http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/request-manager-services/http-manager.service.spec.ts

@@ -0,0 +1,353 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
+import { HTTPManagerService } from './http-manager.service';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { HttpErrorResponse, provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
+
+import { ToastMessageDisplayService } from 'toast-message-display';
+
+
+interface TestData {
+  id?: string | number;
+  name: string;
+}
+
+describe('HTTPManagerService', () => {
+  let service: HTTPManagerService<TestData>;
+  let httpMock: HttpTestingController;
+  let toastMessageServiceSpy: jasmine.SpyObj<ToastMessageDisplayService>;
+  let objectMergerServiceSpy: jasmine.SpyObj<ObjectMergerService>;
+
+  const mockConfig = {
+    httpRequestOptions: {
+      server: 'http://test-api.com',
+      path: [],
+      headers: {}
+    }
+  };
+
+  beforeEach(() => {
+    toastMessageServiceSpy = jasmine.createSpyObj('ToastMessageDisplayService', ['toastMessage']);
+    objectMergerServiceSpy = jasmine.createSpyObj('ObjectMergerService', ['mergeOptions']);
+    objectMergerServiceSpy.mergeOptions.and.callFake((options?: ApiRequest) => {
+      return options || ApiRequest.adapt();
+    });
+
+    TestBed.configureTestingModule({
+    imports: [],
+    providers: [
+        HTTPManagerService,
+        { provide: ToastMessageDisplayService, useValue: toastMessageServiceSpy },
+        { provide: ObjectMergerService, useValue: objectMergerServiceSpy },
+        { provide: CONFIG_SETTINGS_TOKEN, useValue: mockConfig },
+        provideHttpClient(withInterceptorsFromDi()),
+        provideHttpClientTesting()
+    ]
+});
+
+    service = TestBed.inject(HTTPManagerService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('getRequest', () => {
+    it('should make a GET request and handle success', (done) => {
+      const testData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        displayError: true
+      });
+
+      service.getRequest<TestData>(options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      expect(req.request.method).toBe('GET');
+      req.flush(testData);
+    });
+  });
+
+  describe('postRequest', () => {
+    it('should make a POST request and handle success', (done) => {
+      const testData: TestData = { id: undefined, name: 'Test' };
+      const responseData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test']
+      });
+
+      service.postRequest<TestData>(testData, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(responseData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body).toEqual(testData);
+      req.flush(responseData);
+    });
+  });
+
+  describe('putRequest', () => {
+    it('should make a PUT request and handle success', (done) => {
+      const testData: TestData = { id: 1, name: 'Updated Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test', 1]
+      });
+
+      service.putRequest<TestData>(testData, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test/1');
+      expect(req.request.method).toBe('PUT');
+      expect(req.request.body).toEqual(testData);
+      req.flush(testData);
+    });
+  });
+
+  describe('deleteRequest', () => {
+    it('should make a DELETE request and handle success', (done) => {
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test', 1]
+      });
+
+      service.deleteRequest(options).subscribe({
+        next: (response) => {
+          expect(response).toBeNull();
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test/1');
+      expect(req.request.method).toBe('DELETE');
+      req.flush(null);
+    });
+  });
+
+  describe('Polling', () => {
+    let clock: jasmine.Clock;
+
+    beforeEach(() => {
+      clock = jasmine.clock();
+      clock.install();
+    });
+
+    afterEach(() => {
+      clock.uninstall();
+    });
+
+    it('should handle polling requests', (done) => {
+      const testData: TestData = { id: 1, name: 'Test' };
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        polling: 5
+      });
+
+      let callCount = 0;
+
+      // Force synchronous execution of observables
+      jasmine.clock().mockDate(new Date());
+
+      const subscription = service.getRequest<TestData>(options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(testData);
+          callCount++;
+
+          if (callCount === 1) {
+            // Trigger the next polling cycle
+            clock.tick(5000);
+          }
+
+          if (callCount === 2) {
+            subscription.unsubscribe();
+            service['stopPolling']();
+            done();
+          }
+        },
+        error: (error) => {
+          subscription.unsubscribe();
+          done.fail(error);
+        }
+      });
+
+      // Handle first request
+      const req1 = httpMock.expectOne('http://test-api.com/test');
+      expect(req1.request.method).toBe('GET');
+      req1.flush(testData);
+
+      // Wait for the next polling cycle
+      clock.tick(5000);
+
+      // Handle second request
+      const req2 = httpMock.expectOne('http://test-api.com/test');
+      expect(req2.request.method).toBe('GET');
+      req2.flush(testData);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle network errors', (done) => {
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['test'],
+        displayError: true
+      });
+
+      service.getRequest<TestData>(options).subscribe({
+        error: (error) => {
+          expect(error instanceof HttpErrorResponse).toBeTrue();
+          expect(service.isPending.getValue()).toBeFalse();
+          expect(toastMessageServiceSpy.toastMessage).toHaveBeenCalled();
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/test');
+      req.error(new ErrorEvent('Network error'));
+    });
+  });
+
+  describe('uploadRequest', () => {
+    it('should upload a single file with POST', (done) => {
+      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload']
+      });
+      const responseData = { id: 1, name: 'test.txt' };
+
+      service.uploadRequest<TestData>(file, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(responseData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/upload');
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body instanceof FormData).toBeTrue();
+      req.flush(responseData);
+    });
+
+    it('should upload multiple files', (done) => {
+      const files = [
+        new File(['content1'], 'test1.txt', { type: 'text/plain' }),
+        new File(['content2'], 'test2.txt', { type: 'text/plain' })
+      ];
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload']
+      });
+      const responseData = { count: 2 };
+
+      service.uploadRequest<any>(files, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(responseData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/upload');
+      expect(req.request.method).toBe('POST');
+      req.flush(responseData);
+    });
+
+    it('should use PUT method when specified', (done) => {
+      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload'],
+        uploadHttpMethod: 'PUT'
+      });
+      const responseData = { id: 1, name: 'test.txt' };
+
+      service.uploadRequest<TestData>(file, options).subscribe({
+        next: (response) => {
+          expect(response).toEqual(responseData);
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/upload');
+      expect(req.request.method).toBe('PUT');
+      req.flush(responseData);
+    });
+
+    it('should validate file types', (done) => {
+      const file = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload'],
+        allowedTypes: ['image/*']
+      });
+
+      service.uploadRequest<TestData>(file, options).subscribe({
+        error: (error) => {
+          expect(error).toBeTruthy();
+          httpMock.expectNone('http://test-api.com/upload');
+          done();
+        }
+      });
+    });
+
+    it('should validate file size', (done) => {
+      const file = new File(['x'.repeat(1024 * 1024)], 'large.txt', { type: 'text/plain' });
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload'],
+        maxFileSize: 1024
+      });
+
+      service.uploadRequest<TestData>(file, options).subscribe({
+        error: (error) => {
+          expect(error).toBeTruthy();
+          httpMock.expectNone('http://test-api.com/upload');
+          done();
+        }
+      });
+    });
+
+    it('should handle upload errors', (done) => {
+      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
+      const options = ApiRequest.adapt({
+        server: 'http://test-api.com',
+        path: ['upload'],
+        displayError: true
+      });
+
+      service.uploadRequest<TestData>(file, options).subscribe({
+        error: (error) => {
+          expect(error instanceof HttpErrorResponse).toBeTrue();
+          expect(service.isPending.getValue()).toBeFalse();
+          done();
+        }
+      });
+
+      const req = httpMock.expectOne('http://test-api.com/upload');
+      req.error(new ErrorEvent('Upload error'));
+    });
+  });
+});