Merge pull request #547 from RedisInsight/feature/RI-1348-profiler-log-file

add unit tests

Author: arthosofteq

redisinsight/api/config/test.ts

@@ -3,4 +3,7 @@ export default {
     env: 'test',
     requestTimeout: 1000,
   },
+  profiler: {
+    logFileIdleThreshold: parseInt(process.env.PROFILER_LOG_FILE_IDLE_THRESHOLD, 10) || 1000 * 3, // 3sec
+  },
 };

redisinsight/api/src/__mocks__/index.ts

@@ -8,3 +8,4 @@ export * from './redis-info';
 export * from './app-settings';
 export * from './autodiscovery-tools';
 export * from './analytics';
+export * from './profiler';

redisinsight/api/src/__mocks__/monitor.ts

@@ -0,0 +1,94 @@
+import { ILogsEmitter } from 'src/modules/profiler/interfaces/logs-emitter.interface';
+import { ProfilerClient } from 'src/modules/profiler/models/profiler.client';
+import { RedisObserver } from 'src/modules/profiler/models/redis.observer';
+import { IShardObserver } from 'src/modules/profiler/interfaces/shard-observer.interface';
+import { LogFile } from 'src/modules/profiler/models/log-file';
+import { ProfilerAnalyticsService } from 'src/modules/profiler/profiler-analytics.service';
+import { MockType } from 'src/__mocks__/common';
+import { TelemetryEvents } from 'src/constants';
+import * as MockedSocket from 'socket.io-mock';
+import { IMonitorData } from 'src/modules/profiler/interfaces/monitor-data.interface';
+
+export const mockMonitorDataItemEmitted = {
+  time: '14239988881.12341',
+  source: '127.0.0.1',
+  database: 0,
+  args: ['set', 'foo', 'bar'],
+};
+
+export const mockMonitorDataItem: IMonitorData = {
+  ...mockMonitorDataItemEmitted,
+  shardOptions: null,
+};
+
+export const mockSocket = new MockedSocket();
+mockSocket['emit'] = jest.fn();
+//
+// export const mockProfilerClient: MockType<ProfilerClient> = {
+//   id: uuidv4(),
+//   handleOnData: jest.fn(),
+//   handleOnDisconnect: jest.fn(),
+//   addLogsEmitter: jest.fn(),
+//   flushLogs: jest.fn(),
+//   destroy: jest.fn(),
+// };
+
+export const mockRedisObserver: Partial<RedisObserver> = {
+  // status: RedisObserverStatus.Wait,
+  init: jest.fn(),
+  subscribe: jest.fn(),
+  unsubscribe: jest.fn(),
+  getProfilerClientsSize: jest.fn(),
+  clear: jest.fn(),
+  removeShardsListeners: jest.fn(),
+};
+
+export const mockRedisShardObserver: IShardObserver = {
+  addListener: jest.fn(),
+  eventNames: jest.fn(),
+  getMaxListeners: jest.fn(),
+  listenerCount: jest.fn(),
+  listeners: jest.fn(),
+  prependListener: jest.fn(),
+  prependOnceListener: jest.fn(),
+  removeAllListeners: jest.fn(),
+  removeListener: jest.fn(),
+  rawListeners: jest.fn(),
+  setMaxListeners: jest.fn(),
+  on: jest.fn(),
+  emit: jest.fn(),
+  off: jest.fn(),
+  once: jest.fn(),
+  disconnect: jest.fn(),
+};
+
+export const mockProfilerAnalyticsEvents = new Map();
+mockProfilerAnalyticsEvents.set(TelemetryEvents.ProfilerLogDownloaded, jest.fn());
+mockProfilerAnalyticsEvents.set(TelemetryEvents.ProfilerLogDeleted, jest.fn());
+
+export const mockProfilerAnalyticsService: MockType<ProfilerAnalyticsService> = {
+  sendLogDeleted: jest.fn(),
+  sendLogDownloaded: jest.fn(),
+  getEventsEmitters: jest.fn().mockImplementation(() => mockProfilerAnalyticsEvents),
+};
+
+export const mockLogEmitter: ILogsEmitter = {
+  id: 'test',
+  emit: jest.fn(),
+  addProfilerClient: jest.fn(),
+  removeProfilerClient: jest.fn(),
+  flushLogs: jest.fn(),
+};
+
+export const mockWriteStream = {
+  write: jest.fn(),
+};
+export const testLogFileId = 'test-log-file-id';
+export const mockLogFile: LogFile = new LogFile('instanceid', testLogFileId, mockProfilerAnalyticsEvents);
+mockLogFile['getWriteStream'] = jest.fn();
+mockLogFile['addProfilerClient'] = jest.fn();
+mockLogFile['removeProfilerClient'] = jest.fn();
+mockLogFile['destroy'] = jest.fn();
+
+export const mockProfilerClientId = 'profiler-client-id';
+export const mockProfilerClient: ProfilerClient = new ProfilerClient(mockProfilerClientId, mockSocket);

redisinsight/api/src/__mocks__/profiler.ts

@@ -0,0 +1,29 @@
+import { mockSocket } from 'src/__mocks__';
+import { ClientLogsEmitter } from 'src/modules/profiler/emitters/client.logs-emitter';
+import { ProfilerServerEvents } from 'src/modules/profiler/constants';
+import * as MockedSocket from 'socket.io-mock';
+
+describe('ClientLogsEmitter', () => {
+  let emitter: ClientLogsEmitter;
+
+  beforeEach(() => {
+    emitter = new ClientLogsEmitter(mockSocket);
+  });
+
+  it('Initialization', () => {
+    emitter = new ClientLogsEmitter(mockSocket);
+    expect(emitter.id).toEqual(mockSocket.id);
+    expect(emitter['client']).toEqual(mockSocket);
+  });
+
+  it('Emit', async () => {
+    const client = new MockedSocket();
+    client['emit'] = jest.fn();
+
+    const items = [1, 2, 3];
+
+    emitter = new ClientLogsEmitter(client);
+    await emitter.emit(items);
+    expect(emitter['client'].emit).toHaveBeenCalledWith(ProfilerServerEvents.Data, items);
+  });
+});

redisinsight/api/src/modules/profiler/emitters/client.logs-emiter.spec.ts

@@ -0,0 +1,55 @@
+import {
+  mockLogFile,
+  mockMonitorDataItem,
+  mockProfilerClient,
+  mockWriteStream,
+} from 'src/__mocks__';
+import { FileLogsEmitter } from 'src/modules/profiler/emitters/file.logs-emitter';
+
+describe('FileLogsEmitter', () => {
+  let emitter: FileLogsEmitter;
+
+  beforeEach(() => {
+    emitter = new FileLogsEmitter(mockLogFile);
+  });
+
+  it('initialization', () => {
+    expect(emitter.id).toEqual(mockLogFile.id);
+    expect(emitter['logFile']).toEqual(mockLogFile);
+  });
+
+  it('emit', async () => {
+    const items = [mockMonitorDataItem, mockMonitorDataItem];
+
+    emitter['logFile']['getWriteStream'] = jest.fn().mockReturnValue(undefined);
+    await emitter.emit(items);
+    expect(mockWriteStream.write).not.toHaveBeenCalled();
+
+    emitter['logFile']['getWriteStream'] = jest.fn().mockReturnValue(mockWriteStream);
+    await emitter.emit(items);
+    expect(emitter['logFile'].getWriteStream).toHaveBeenCalled();
+    expect(mockWriteStream.write).toHaveBeenCalled();
+  });
+
+  it('emit', async () => {
+    const items = [mockMonitorDataItem, mockMonitorDataItem];
+    await emitter.emit(items);
+    expect(emitter['logFile'].getWriteStream).toHaveBeenCalled();
+    expect(mockWriteStream.write).toHaveBeenCalled();
+  });
+
+  it('addProfilerClient', () => {
+    emitter.addProfilerClient(mockProfilerClient.id);
+    expect(emitter['logFile'].addProfilerClient).toHaveBeenCalledWith(mockProfilerClient.id);
+  });
+
+  it('removeProfilerClient', () => {
+    emitter.removeProfilerClient(mockProfilerClient.id);
+    expect(emitter['logFile'].removeProfilerClient).toHaveBeenCalledWith(mockProfilerClient.id);
+  });
+
+  it('flushLogs', () => {
+    emitter.flushLogs();
+    expect(emitter['logFile'].destroy).toHaveBeenCalled();
+  });
+});

redisinsight/api/src/modules/profiler/emitters/file.logs-emiter.spec.ts

@@ -1,7 +1,7 @@
 import { ILogsEmitter } from 'src/modules/profiler/interfaces/logs-emitter.interface';
 import { LogFile } from 'src/modules/profiler/models/log-file';
 
-class FileLogsEmitter implements ILogsEmitter {
+export class FileLogsEmitter implements ILogsEmitter {
   public readonly id: string;
 
   private readonly logFile: LogFile;
@@ -43,4 +43,3 @@ class FileLogsEmitter implements ILogsEmitter {
     return this.logFile.destroy();
   }
 }
-export default FileLogsEmitter;