@futdevpro/nts-dynamo 1.15.2 → 1.15.5

package/src/_modules/usage/usage.data-service.spec.ts

@@ -0,0 +1,332 @@
+
+import { DyNTS_Usage_DataService } from './usage.data-service';
+import { DyFM_RelativeDate } from '@futdevpro/fsm-dynamo';
+import { DyFM_UsageSession, DyFM_UsageData } from '@futdevpro/fsm-dynamo/usage';
+import { DyNTS_GlobalService } from '../../_services/core/global.service';
+import { DyNTS_DBService } from '../../_services/base/db.service';
+import { DyNTS_Shared } from '../../_services/shared.static-service';
+import { Request } from 'express';
+
+describe('| DyNTS_Usage_DataService', () => {
+  let service: DyNTS_Usage_DataService;
+  let mockDBService: jasmine.SpyObj<DyNTS_DBService<DyFM_UsageSession>>;
+  let mockRequest: Partial<Request>;
+
+  beforeEach(() => {
+    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
+      'getAll',
+      'getDataById',
+      'find',
+      'createData',
+      'modifyData',
+    ]);
+
+    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService);
+
+    mockRequest = {
+      ip: '127.0.0.1',
+      headers: {
+        'x-forwarded-for': '192.168.1.1',
+      },
+    };
+
+    service = new DyNTS_Usage_DataService({
+      usageSession: new DyFM_UsageSession({
+        _id: 'session-id',
+        sessionStart: new Date(),
+      }),
+      usageData: [],
+      issuer: 'test-issuer',
+    });
+  });
+
+  it('| should create service instance', () => {
+    expect(service).toBeDefined();
+    expect(service.data).toBeDefined();
+    expect(service.usageData).toEqual([]);
+    expect(service.simplifiedDailyUsage).toEqual([]);
+  });
+
+  it('| should initialize with usage data', () => {
+    const usageData: DyFM_UsageData[] = [
+      {
+        page: '/test',
+        opened: new Date(),
+        timeSpentOnPage: 1000,
+      },
+    ];
+
+    const serviceWithData = new DyNTS_Usage_DataService({
+      usageData,
+      issuer: 'test-issuer',
+    });
+
+    expect(serviceWithData.usageData).toEqual(usageData);
+  });
+
+  describe('| getLocationDataFromRequest', () => {
+    it('| should get location data from request', () => {
+      spyOn(DyNTS_Shared, 'getIpFromRequest').and.returnValue('192.168.1.1');
+      spyOn(DyNTS_Shared, 'getLocationDataByRequest').and.returnValue({
+        range: [0, 0],
+        country: 'US',
+        region: 'NY',
+        eu: '0',
+        timezone: 'America/New_York',
+        city: 'New York',
+        ll: [40.7128, -74.0060],
+        metro: 0,
+        area: 0,
+      });
+
+      service.getLocationDataFromRequest(mockRequest as Request);
+
+      expect(service.data.address).toBe('192.168.1.1');
+      expect(service.data.locationData).toBeDefined();
+      expect(service.data.locationData?.country).toBe('US');
+    });
+
+    it('| should throw error when location data retrieval fails', () => {
+      spyOn(DyNTS_Shared, 'getIpFromRequest').and.throwError('IP retrieval failed');
+
+      expect(() => {
+        service.getLocationDataFromRequest(mockRequest as Request);
+      }).toThrow();
+    });
+  });
+
+  describe('| getUsage', () => {
+    it('| should get usage data for range', async () => {
+      const mockSessions = [
+        new DyFM_UsageSession({
+          _id: 'session-1',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 5000,
+          locationData: {
+            range: [0, 0],
+            country: 'HU',
+            region: 'BU',
+            eu: '1',
+            timezone: 'Europe/Budapest',
+            city: 'Budapest',
+            ll: [47.4979, 19.0402],
+            metro: 0,
+            area: 0,
+          },
+        }),
+        new DyFM_UsageSession({
+          _id: 'session-2',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 3000,
+          locationData: {
+            range: [0, 0],
+            country: 'US',
+            region: 'NY',
+            eu: '0',
+            timezone: 'America/New_York',
+            city: 'New York',
+            ll: [40.7128, -74.0060],
+            metro: 0,
+            area: 0,
+          },
+        }),
+      ];
+      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
+
+      await service.getUsage(DyFM_RelativeDate.lastWeek);
+
+      expect(service.dataList.length).toBe(2);
+      expect(service.simplifiedDailyUsage.length).toBe(1);
+      expect(service.simplifiedDailyUsage[0].date).toBe('2024-01-01');
+      expect(service.simplifiedDailyUsage[0].visitorsHun).toBe(1);
+      expect(service.simplifiedDailyUsage[0].visitorsElse).toBe(1);
+      expect(service.simplifiedDailyUsage[0].totalVisitTime).toBe(8000);
+    });
+
+    it('| should group sessions by date', async () => {
+      const mockSessions = [
+        new DyFM_UsageSession({
+          _id: 'session-1',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 5000,
+        }),
+        new DyFM_UsageSession({
+          _id: 'session-2',
+          date: '2024-01-02',
+          sessionStart: new Date('2024-01-02'),
+          totalSessionTime: 3000,
+        }),
+      ];
+      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
+
+      await service.getUsage(DyFM_RelativeDate.lastWeek);
+
+      expect(service.simplifiedDailyUsage.length).toBe(2);
+    });
+
+    it('| should calculate average visit time', async () => {
+      const mockSessions = [
+        new DyFM_UsageSession({
+          _id: 'session-1',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 5000,
+        }),
+        new DyFM_UsageSession({
+          _id: 'session-2',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 3000,
+        }),
+      ];
+      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
+
+      await service.getUsage(DyFM_RelativeDate.lastWeek);
+
+      // Average is (5000 + 3000) / 2 = 4000 ms, then Math.round(4000 * 100) / 100 = 4000
+      expect(service.simplifiedDailyUsage[0].averageVisitTime).toBe(4000);
+    });
+
+    it('| should sort daily usage by date descending', async () => {
+      const mockSessions = [
+        new DyFM_UsageSession({
+          _id: 'session-1',
+          date: '2024-01-01',
+          sessionStart: new Date('2024-01-01'),
+          totalSessionTime: 5000,
+        }),
+        new DyFM_UsageSession({
+          _id: 'session-2',
+          date: '2024-01-02',
+          sessionStart: new Date('2024-01-02'),
+          totalSessionTime: 3000,
+        }),
+      ];
+      mockDBService.find.and.returnValue(Promise.resolve(mockSessions));
+
+      await service.getUsage(DyFM_RelativeDate.lastWeek);
+
+      expect(service.simplifiedDailyUsage[0].date).toBe('2024-01-02');
+      expect(service.simplifiedDailyUsage[1].date).toBe('2024-01-01');
+    });
+  });
+
+  describe('| updateUsageData', () => {
+    it('| should update usage data', async () => {
+      const existingSession = new DyFM_UsageSession({
+        _id: 'session-id',
+        sessionStart: new Date(),
+        usageData: [],
+      });
+      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'getLocationDataFromRequest');
+
+      service.usageData = [
+        {
+          page: '/test',
+          opened: new Date(),
+          timeSpentOnPage: 1000,
+        },
+        {
+          page: '/test2',
+          opened: new Date(),
+          timeSpentOnPage: 2000,
+        },
+      ];
+
+      await service.updateUsageData(mockRequest as Request);
+
+      expect(service.saveData).toHaveBeenCalled();
+      expect(existingSession.totalSessionTime).toBe(3000);
+    });
+
+    it('| should throw error when session not found', async () => {
+      mockDBService.getDataById.and.returnValue(Promise.resolve(null));
+
+      await expectAsync(
+        service.updateUsageData(mockRequest as Request)
+      ).toBeRejected();
+    });
+
+    it('| should get location data if not present', async () => {
+      const existingSession = new DyFM_UsageSession({
+        _id: 'session-id',
+        sessionStart: new Date(),
+        usageData: [],
+      });
+      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
+      const getLocationSpy = spyOn(service, 'getLocationDataFromRequest');
+
+      await service.updateUsageData(mockRequest as Request);
+
+      expect(getLocationSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('| closeSession', () => {
+    it('| should close session', async () => {
+      const sessionStart = new Date('2024-01-01T10:00:00');
+      const existingSession = new DyFM_UsageSession({
+        _id: 'session-id',
+        sessionStart,
+        usageData: [
+          {
+            page: '/test',
+            opened: sessionStart,
+            timeSpentOnPage: 1000,
+          },
+        ],
+        totalSessionTime: 1000,
+      });
+      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'getLocationDataFromRequest');
+
+      await service.closeSession(mockRequest as Request);
+
+      expect(existingSession.sessionEnd).toBeDefined();
+      expect(service.saveData).toHaveBeenCalled();
+    });
+
+    it('| should calculate total session time', async () => {
+      const sessionStart = new Date('2024-01-01T10:00:00');
+      const sessionEnd = new Date('2024-01-01T10:00:10');
+      const existingSession = new DyFM_UsageSession({
+        _id: 'session-id',
+        sessionStart,
+        usageData: [
+          {
+            page: '/test',
+            opened: sessionStart,
+            timeSpentOnPage: 1000,
+          },
+        ],
+        totalSessionTime: 1000,
+      });
+      mockDBService.getDataById.and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(existingSession));
+      spyOn(service, 'getLocationDataFromRequest');
+      jasmine.clock().install();
+      jasmine.clock().mockDate(sessionEnd);
+
+      await service.closeSession(mockRequest as Request);
+
+      expect(existingSession.totalSessionTime).toBe(10000);
+      jasmine.clock().uninstall();
+    });
+
+    it('| should throw error when session not found', async () => {
+      mockDBService.getDataById.and.returnValue(Promise.resolve(null));
+
+      await expectAsync(
+        service.closeSession(mockRequest as Request)
+      ).toBeRejected();
+    });
+  });
+});
+

package/src/_services/base/api.service-base.spec.ts

@@ -0,0 +1,125 @@
+
+import { DyNTS_ApiService_Base } from './api.service-base';
+import { DyNTS_ApiService } from '../core/api.service';
+import { DyFM_Error, DyFM_HttpCallType, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_ApiCall_Params } from '../../_models/control-models/api-call-params.control-model';
+
+class TestApiService extends DyNTS_ApiService_Base {
+  get baseUrl(): string {
+    return 'https://api.example.com';
+  }
+
+  get testEndpoint(): string {
+    return '/test';
+  }
+
+  get connectingSystemName(): string {
+    return 'TestSystem';
+  }
+
+  static getInstance(): TestApiService {
+    return TestApiService.getSingletonInstance();
+  }
+}
+
+describe('| DyNTS_ApiService_Base', () => {
+  let service: TestApiService;
+
+  beforeEach(() => {
+    service = TestApiService.getInstance();
+  });
+
+  it('| should be a singleton instance', () => {
+    const instance1 = TestApiService.getInstance();
+    const instance2 = TestApiService.getInstance();
+
+    expect(instance1).toBe(instance2);
+    expect(instance1).toBeInstanceOf(TestApiService);
+  });
+
+  describe('| runApiCallWithAvailabilityCheck', () => {
+    it('| should return result when api call succeeds', async () => {
+      const apiCall = jasmine.createSpy('apiCall').and.returnValue(Promise.resolve('success'));
+
+      const result = await service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123');
+
+      expect(result).toBe('success');
+      expect(apiCall).toHaveBeenCalled();
+    });
+
+    it('| should check server availability when api call fails', async () => {
+      const apiCall = jasmine.createSpy('apiCall').and.returnValue(
+        Promise.reject(new Error('API call failed'))
+      );
+      spyOn(service, 'checkServerAvailability').and.returnValue(Promise.resolve());
+
+      await expectAsync(
+        service.runApiCallWithAvailabilityCheck(apiCall, 'issuer-123')
+      ).toBeRejectedWithError('API call failed');
+
+      expect(service.checkServerAvailability).toHaveBeenCalledWith('issuer-123');
+    });
+  });
+
+  describe('| checkServerAvailability', () => {
+    it('| should succeed when testGet succeeds', async () => {
+      spyOn(service, 'testGet').and.returnValue(Promise.resolve());
+      const logSpy = spyOn(DyFM_Log, 'success');
+
+      await service.checkServerAvailability('issuer-123');
+
+      expect(service.testGet).toHaveBeenCalledWith('issuer-123');
+    });
+
+    it('| should throw error when testGet fails', async () => {
+      spyOn(service, 'testGet').and.returnValue(
+        Promise.reject(new Error('Test failed'))
+      );
+
+      try {
+        await service.checkServerAvailability('issuer-123');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._message).toContain('TestSystem server is not available');
+        expect((error as DyFM_Error)._message).toContain('baseUrl: https://api.example.com');
+        expect((error as DyFM_Error).__userMessage).toContain('TestSystem server is not available');
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-ASB-CSA0');
+      }
+    });
+  });
+
+  describe('| testGet', () => {
+    it('| should call ApiService.startApiCall with correct parameters', async () => {
+      const startApiCallSpy = spyOn(DyNTS_ApiService, 'startApiCall').and.returnValue(
+        Promise.resolve()
+      );
+      const logSpy = spyOn(DyFM_Log, 'success');
+
+      await service.testGet('issuer-123');
+
+      expect(startApiCallSpy).toHaveBeenCalledWith(
+        jasmine.any(DyNTS_ApiCall_Params)
+      );
+      const callParams = startApiCallSpy.calls.mostRecent().args[0] as DyNTS_ApiCall_Params;
+      expect(callParams.type).toBe(DyFM_HttpCallType.get);
+      expect(callParams.baseUrl).toBe('https://api.example.com');
+      expect(callParams.endpoint).toBe('/test');
+      expect(logSpy).toHaveBeenCalled();
+    });
+
+    it('| should throw error when testEndpoint is not set', async () => {
+      const serviceWithoutEndpoint = new (class extends DyNTS_ApiService_Base {
+        get baseUrl(): string { return 'https://api.example.com'; }
+        get testEndpoint(): string { return ''; }
+        get connectingSystemName(): string { return 'TestSystem'; }
+        static getInstance() { return this.getSingletonInstance(); }
+      } as any)();
+
+      await expectAsync(
+        serviceWithoutEndpoint.testGet('issuer-123')
+      ).toBeRejected();
+    });
+  });
+});
+

package/src/_services/base/archive-data.service.spec.ts

@@ -0,0 +1,196 @@
+
+import { DyNTS_ArchiveDataService } from './archive-data.service';
+import { DyFM_DataModel_Params, DyFM_Metadata, DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_GlobalService } from '../core/global.service';
+import { DyNTS_DBService } from './db.service';
+import { DyNTS_getArchivedDBName } from '../../_collections/archive.util';
+
+class TestMetadata extends DyFM_Metadata {
+  name: string;
+}
+
+describe('| DyNTS_ArchiveDataService', () => {
+  let mockDataParams: DyFM_DataModel_Params<TestMetadata>;
+  let mockOriginalDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
+  let mockArchivedDBService: jasmine.SpyObj<DyNTS_DBService<TestMetadata>>;
+
+  beforeEach(() => {
+    mockDataParams = {
+      dataName: 'test_data',
+      addArchive: true,
+      constructed: () => true,
+      properties: {},
+    } as any;
+
+    mockOriginalDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('OriginalDBService', [
+      'getDataById',
+      'trueDeleteDataById',
+    ]);
+
+    mockArchivedDBService = jasmine.createSpyObj<DyNTS_DBService<TestMetadata>>('ArchivedDBService', [
+      'createData',
+      'getDataById',
+    ]);
+
+    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockOriginalDBService);
+  });
+
+  it('| should throw error when addArchive is missing from dataParams', () => {
+    const dataParamsWithoutArchive = {
+      ...mockDataParams,
+      addArchive: false,
+    } as any;
+
+    const data = new TestMetadata();
+
+    expect(() => {
+      new DyNTS_ArchiveDataService(data, dataParamsWithoutArchive, 'issuer-123');
+    }).toThrowError('addArchive is missing from dataParams!');
+  });
+
+  it('| should create service with archived data name', () => {
+    const data = new TestMetadata();
+
+    const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+    expect(service).toBeInstanceOf(DyNTS_ArchiveDataService);
+    expect(service.originalDBService).toBe(mockOriginalDBService);
+    expect(service.dataParams.dataName).toBe('test_data_archived');
+  });
+
+  describe('| archiveDataById', () => {
+    it('| should throw error when id is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveDataById('')
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data not found', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(null));
+
+      await expectAsync(
+        service.archiveDataById('non-existent-id')
+      ).toBeRejected();
+    });
+
+    it('| should archive data when found', async () => {
+      const data = new TestMetadata({ _id: 'test-id' });
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.getDataById.and.returnValue(Promise.resolve(data));
+      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
+      spyOn(service, 'archiveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.archiveDataById('test-id');
+
+      expect(mockOriginalDBService.getDataById).toHaveBeenCalledWith('test-id');
+      expect(service.archiveData).toHaveBeenCalledWith(data);
+      expect(result).toBe(data);
+    });
+  });
+
+  describe('| getDataByOriginalId', () => {
+    it('| should find data by original id', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      const archivedData = new TestMetadata({ _originalId: 'original-id' });
+      spyOn(service, 'findData').and.returnValue(Promise.resolve(archivedData));
+
+      const result = await service.getDataByOriginalId('original-id');
+
+      expect(service.findData).toHaveBeenCalled();
+      expect(result).toBe(archivedData);
+    });
+
+    it('| should throw error on find failure', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      spyOn(service, 'findData').and.returnValue(Promise.reject(new Error('Find failed')));
+
+      await expectAsync(
+        service.getDataByOriginalId('original-id')
+      ).toBeRejected();
+    });
+  });
+
+  describe('| archiveData', () => {
+    it('| should throw error when originalId already exists', async () => {
+      const data = new TestMetadata({ _id: 'test-id', _originalId: 'existing-original-id' } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data is already archived', async () => {
+      const data = new TestMetadata({ _id: 'test-id', _archived: new Date() } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when id is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.archiveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should archive data successfully', async () => {
+      const data = new TestMetadata({ _id: 'test-id' });
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      mockOriginalDBService.trueDeleteDataById.and.returnValue(Promise.resolve());
+      spyOn(service, 'saveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.archiveData(data);
+
+      expect(mockOriginalDBService.trueDeleteDataById).toHaveBeenCalledWith('test-id');
+      expect(data._originalId).toBe('test-id');
+      expect(data._archived).toBeInstanceOf(Date);
+      expect(data._id).toBeUndefined();
+      expect(service.saveData).toHaveBeenCalled();
+      expect(result).toBe(data);
+    });
+  });
+
+  describe('| saveData', () => {
+    it('| should throw error when originalId is missing', async () => {
+      const data = new TestMetadata();
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.saveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should throw error when data is not archived', async () => {
+      const data = new TestMetadata({ _originalId: 'original-id' } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+
+      await expectAsync(
+        service.saveData(data)
+      ).toBeRejected();
+    });
+
+    it('| should save archived data successfully', async () => {
+      const data = new TestMetadata({ _originalId: 'original-id', _archived: new Date() } as TestMetadata);
+      const service = new DyNTS_ArchiveDataService(data, mockDataParams, 'issuer-123');
+      const parentSaveDataSpy = spyOn(Object.getPrototypeOf(DyNTS_ArchiveDataService.prototype), 'saveData').and.returnValue(Promise.resolve(data));
+
+      const result = await service.saveData(data);
+
+      expect(parentSaveDataSpy).toHaveBeenCalled();
+      expect(result).toBe(data);
+    });
+  });
+});
+