@webex/contact-center 0.0.0-next.1

package/test/unit/spec/metrics/MetricsManager.ts

@@ -0,0 +1,491 @@
+import {PRODUCT_NAME} from '../../../../src/constants';
+import MetricsManager from '../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+import {WebexSDK} from '../../../../src/types';
+import {EventPayload} from '@webex/internal-plugin-metrics/src/metrics.types';
+import LoggerProxy from '../../../../src/logger-proxy';
+
+describe('MetricsManagerImplementation', () => {
+  let webex: WebexSDK;
+  let metricsManager: MetricsManager;
+
+  beforeEach(() => {
+    webex = {
+      internal: {
+        newMetrics: {
+          submitBehavioralEvent: jest.fn(),
+          submitOperationalEvent: jest.fn(),
+          submitBusinessEvent: jest.fn(),
+        },
+      },
+      once: jest.fn(),
+      ready: true,
+    } as unknown as WebexSDK;
+
+    MetricsManager.resetInstance();
+    metricsManager = MetricsManager.getInstance({webex});
+    metricsManager.setMetricsDisabled(false);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe('trackEvent', () => {
+    it('should submit a behavioral, operational and business event when newMetrics is available', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.trackEvent(eventName, data, ['behavioral', 'operational', 'business']);
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(1);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(1);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(1);
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledWith({
+        product: PRODUCT_NAME,
+        agent: 'user',
+        target: 'station_login',
+        verb: 'complete',
+        payload: data,
+      });
+
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledWith({
+        name: PRODUCT_NAME.toUpperCase() + "_" + METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS.replace(/ /g, '_').toUpperCase(),
+        payload: data,
+      });
+
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledWith({
+        name: PRODUCT_NAME.toUpperCase() + "_" + METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS.replace(/ /g, '_').toUpperCase(),
+        payload: data,
+        metadata: {
+          appType: PRODUCT_NAME,
+        }
+      });
+    });
+
+    it('should not submit a behavioral, operational and business event if array is invalid', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.trackEvent(eventName, data, ['nonexistent']);
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not submit a behavioral, operational and business event if metricsDisabled is true', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.setMetricsDisabled(true);
+      metricsManager.trackEvent(eventName, data, ['behavioral', 'operational', 'business']);
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not submit a behavioral event if metricsDisabled is true', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.setMetricsDisabled(true);
+      metricsManager.trackBehavioralEvent(eventName, data);
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not submit a operational event if metricsDisabled is true', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.setMetricsDisabled(true);
+      metricsManager.trackOperationalEvent(eventName, data);
+
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(0);
+    });
+
+    it('should not submit a business event if metricsDisabled is true', () => {
+      const eventName = METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS;
+      const data: EventPayload = {key: 'value'};
+
+      metricsManager.setMetricsDisabled(true);
+      metricsManager.trackBusinessEvent(eventName, data);
+
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('clearPendingEvents', () => {
+    it('should clear pending events', () => {
+      metricsManager['pendingBehavioralEvents'] = [
+        {taxonomy: {product: 'wxcc_sdk', agent: 'user', target: 'test', verb: 'get'}, payload: {}},
+      ];
+      metricsManager['pendingOperationalEvents'] = [{name: 'TEST', payload: {}}];
+      metricsManager['pendingBusinessEvents'] = [{name: 'TEST', payload: {}}];
+      metricsManager['readyToSubmitEvents'] = true;
+      metricsManager['submittingEvents'] = true;
+      metricsManager['clearPendingEvents']();
+      expect(metricsManager['pendingBehavioralEvents']).toEqual([]);
+      expect(metricsManager['pendingOperationalEvents']).toEqual([]);
+      expect(metricsManager['pendingBusinessEvents']).toEqual([]);
+    });
+  });
+
+  describe('setMetricsDisabled', () => {
+    it('should set metricsDisabled to true', () => {
+      const clearPendingEventsSpy = jest.spyOn(
+        MetricsManager.prototype as any,
+        'clearPendingEvents'
+      );
+
+      metricsManager.setMetricsDisabled(true);
+
+      expect(clearPendingEventsSpy).toHaveBeenCalled();
+      expect(metricsManager['metricsDisabled']).toBe(true);
+    });
+  });
+
+  describe('submitPendingEvents', () => {
+    it('should return if submittingEvents is true', async () => {
+      metricsManager['submittingEvents'] = true;
+      await metricsManager['submitPendingEvents']();
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(0);
+    });
+
+    it('should submit pending events if there are any', async () => {
+      metricsManager['pendingBehavioralEvents'] = [
+        {taxonomy: {product: 'wxcc_sdk', agent: 'user', target: 'test', verb: 'get'}, payload: {}},
+      ];
+      metricsManager['pendingOperationalEvents'] = [{name: 'TEST', payload: {}}];
+      metricsManager['pendingBusinessEvents'] = [{name: 'TEST', payload: {}}];
+      metricsManager['readyToSubmitEvents'] = true;
+
+      await metricsManager['submitPendingEvents']();
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(1);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(1);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(1);
+    });
+
+    it('should not submit events if there are none', async () => {
+      metricsManager['pendingBehavioralEvents'] = [];
+      metricsManager['pendingOperationalEvents'] = [];
+      metricsManager['pendingBusinessEvents'] = [];
+      metricsManager['readyToSubmitEvents'] = true;
+
+      await metricsManager['submitPendingEvents']();
+
+      expect(webex.internal.newMetrics.submitBehavioralEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitOperationalEvent).toHaveBeenCalledTimes(0);
+      expect(webex.internal.newMetrics.submitBusinessEvent).toHaveBeenCalledTimes(0);
+    });
+  });
+
+  describe('getInstance', () => {
+    it('should return the same instance', () => {
+      const instance1 = MetricsManager.getInstance({webex});
+      const instance2 = MetricsManager.getInstance({webex});
+
+      expect(instance1).toBe(instance2);
+    });
+
+    it('should create a new instance if none exists', () => {
+      MetricsManager['instance'] = undefined;
+
+      const instance = MetricsManager.getInstance({webex});
+
+      expect(instance).toBeInstanceOf(MetricsManager);
+    });
+  });
+
+  describe('timeEvent', () => {
+    it('should not set the event if metrics are disabled', () => {
+      jest.spyOn(MetricsManager.prototype as any, 'isMetricsDisabled').mockReturnValue(true);
+      const eventName = 'testEvent';
+
+      metricsManager.timeEvent(eventName);
+
+      expect(metricsManager['runningEvents'][eventName]).toBeUndefined();
+    });
+
+    it('should set the event with the current timestamp if metrics are enabled', () => {
+      jest.spyOn(MetricsManager.prototype as any, 'isMetricsDisabled').mockReturnValue(false);
+      const eventName = 'testEvent';
+      const mockTimestamp = 1234567890;
+      jest.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      metricsManager.timeEvent(eventName);
+
+      expect(metricsManager['runningEvents'][eventName]['startTime']).toBe(mockTimestamp);
+    });
+
+    it('should set the event with the current timestamp if a single event name is provided and metrics are enabled', () => {
+      jest.spyOn(MetricsManager.prototype as any, 'isMetricsDisabled').mockReturnValue(false);
+      const eventName = 'testEvent';
+      const mockTimestamp = 1234567890;
+      jest.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+      metricsManager.timeEvent(eventName);
+
+      expect(metricsManager['runningEvents'][eventName]).toEqual({
+        startTime: mockTimestamp,
+        keys: new Set([eventName]),
+      });
+    });
+
+    it('should set the event with an array of keys when metrics are enabled', () => {
+      jest.spyOn(MetricsManager.prototype as any, 'isMetricsDisabled').mockReturnValue(false);
+      const eventArray = ['eventSuccess', 'eventFailed'];
+      const mockTimestamp = 987654321;
+      jest.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+      metricsManager.timeEvent(eventArray);
+
+      // The generic key is the first element of the array.
+      expect(metricsManager['runningEvents'][eventArray[0]]).toEqual({
+        startTime: mockTimestamp,
+        keys: new Set(eventArray),
+      });
+    });
+  });
+
+  describe('addDurationIfTimed', () => {
+    it('should return options when event name is not in runningEvents', () => {
+      const options: EventPayload = {key: 'value'};
+      const result = metricsManager['addDurationIfTimed']('event1', options);
+      expect(result).toEqual(options);
+    });
+
+    it('should add duration to options when event name is in runningEvents and options is provided', () => {
+      metricsManager['runningEvents']['event1'] = {
+        startTime: 500,
+        keys: new Set(['event1']),
+      };
+      jest.spyOn(Date, 'now').mockImplementation(() => 1000);
+      const options: EventPayload = {key: 'value'};
+      const result = metricsManager['addDurationIfTimed']('event1', options);
+      expect(result).toEqual({key: 'value', duration_ms: 500});
+    });
+
+    it('should create a new payload with duration when event name is in runningEvents and options is not provided', () => {
+      metricsManager['runningEvents']['event1'] = {
+        startTime: 500,
+        keys: new Set(['event1']),
+      };
+      jest.spyOn(Date, 'now').mockImplementation(() => 1000);
+      const result = metricsManager['addDurationIfTimed']('event1');
+      expect(result).toEqual({duration_ms: 500});
+    });
+
+    it('should return options when options is provided but event name is not in runningEvents', () => {
+      const options: EventPayload = {key: 'value'};
+      jest.spyOn(Date, 'now').mockImplementation(() => 1000);
+      const result = metricsManager['addDurationIfTimed']('event2', options);
+      expect(result).toEqual(options);
+    });
+
+    it('should return an empty object when neither options is provided nor event name is in runningEvents', () => {
+      const result = metricsManager['addDurationIfTimed']('event3');
+      expect(result).toEqual({});
+    });
+  });
+});
+
+describe('MetricsManagerInstantiation', () => {
+  let webexMock: WebexSDK;
+
+  beforeEach(() => {
+    MetricsManager.resetInstance();
+    webexMock = {
+      once: jest.fn(),
+      internal: {
+        newMetrics: {
+          submitBehavioralEvent: jest.fn(),
+          submitOperationalEvent: jest.fn(),
+          submitBusinessEvent: jest.fn(),
+        },
+      },
+      ready: false,
+    } as unknown as WebexSDK;
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+    MetricsManager.resetInstance();
+  });
+
+  afterAll(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+    MetricsManager.resetInstance();
+  });
+
+  it('should call setReadyToSubmitEvents if webex is ready', () => {
+    webexMock.ready = true;
+    const setReadyToSubmitEventsSpy = jest.spyOn(
+      MetricsManager.prototype as any,
+      'setReadyToSubmitEvents'
+    );
+
+    MetricsManager.getInstance({webex: webexMock});
+
+    expect(setReadyToSubmitEventsSpy).toHaveBeenCalled();
+  });
+
+  it('should call setReadyToSubmitEvents when webex emits ready event', () => {
+    webexMock.ready = false;
+    const setReadyToSubmitEventsSpy = jest.spyOn(
+      MetricsManager.prototype as any,
+      'setReadyToSubmitEvents'
+    );
+
+    MetricsManager.getInstance({webex: webexMock});
+    expect(webexMock.once).toHaveBeenCalledWith('ready', expect.any(Function));
+    const readyCallback = (webexMock.once as jest.Mock).mock.calls[0][1];
+    readyCallback();
+
+    expect(setReadyToSubmitEventsSpy).toHaveBeenCalled();
+    webexMock.ready = true;
+  });
+
+  it('should store metrics in queue when instantiated without webex and later emit metrics when webex is provided', () => {
+
+    const instance = MetricsManager.getInstance();
+    expect(instance).toBeDefined();
+    expect(instance['pendingBehavioralEvents'].length).toBe(0);
+    instance.trackEvent(METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS, {key: 'value'}, ['behavioral']);
+    expect(instance['pendingBehavioralEvents'].length).toBe(1);
+
+    const setReadyToSubmitEventsSpy = jest.spyOn(
+      MetricsManager.prototype as any,
+      'setReadyToSubmitEvents'
+    );
+
+    MetricsManager.getInstance({webex: webexMock});
+    expect(webexMock.once).toHaveBeenCalledWith('ready', expect.any(Function));
+    const readyCallback = (webexMock.once as jest.Mock).mock.calls[0][1];
+    readyCallback();
+
+    expect(setReadyToSubmitEventsSpy).toHaveBeenCalled();
+  });
+});
+
+describe('getCommonTrackingFieldForAQMResponse', () => {
+  it('should extract common tracking fields from a response with nested data', () => {
+    const response = {
+      data: {
+        agentId: 'agent1',
+        agentSessionId: 'session1',
+        teamId: 'team1',
+        siteId: 'site1',
+        orgId: 'org1',
+        trackingId: 'track1'
+      },
+      trackingId: 'notifTrack1',
+      type: 'some_event'
+    };
+    const expected = {
+      agentId: 'agent1',
+      agentSessionId: 'session1',
+      teamId: 'team1',
+      siteId: 'site1',
+      orgId: 'org1',
+      eventType: 'some_event',
+      trackingId: 'track1',
+      notifTrackingId: 'notifTrack1'
+    };
+    const result = MetricsManager.getCommonTrackingFieldForAQMResponse(response);
+    expect(result).toEqual(expected);
+  });
+
+  it('should extract common tracking fields from a flat response', () => {
+    const response = {
+      agentId: 'agent2',
+      agentSessionId: 'session2',
+      teamId: 'team2',
+      siteId: 'site2',
+      orgId: 'org2',
+      type: 'event_type',
+      trackingId: 'notifTrack2'
+    };
+    const expected = {
+      agentId: 'agent2',
+      agentSessionId: 'session2',
+      teamId: 'team2',
+      siteId: 'site2',
+      orgId: 'org2',
+      eventType: 'event_type',
+      trackingId: undefined,
+      notifTrackingId: 'notifTrack2'
+    };
+    const result = MetricsManager.getCommonTrackingFieldForAQMResponse(response);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle responses with missing fields gracefully', () => {
+    const response = {};
+    const expected = {
+      agentId: undefined,
+      agentSessionId: undefined,
+      teamId: undefined,
+      siteId: undefined,
+      orgId: undefined,
+      eventType: undefined,
+      trackingId: undefined,
+      notifTrackingId: undefined
+    };
+    const result = MetricsManager.getCommonTrackingFieldForAQMResponse(response);
+    expect(result).toEqual(expected);
+  });
+});
+
+describe('getCommonTrackingFieldForAQMResponseFailed', () => {
+  it('should extract common tracking fields from a failure response with complete fields', () => {
+    const failureResponse = {
+      data: {
+        agentId: 'agent1',
+        reason: 'Some reason',
+        reasonCode: 'R001'
+      },
+      trackingId: 'notifTrack1',
+      orgId: 'org1',
+      type: 'failure_event'
+    };
+    const expected = {
+      agentId: 'agent1',
+      trackingId: 'notifTrack1',
+      notifTrackingId: 'notifTrack1',
+      orgId: 'org1',
+      failureType: 'failure_event',
+      failureReason: 'Some reason',
+      reasonCode: 'R001'
+    };
+    const result = MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failureResponse);
+    expect(result).toEqual(expected);
+  });
+
+  it('should handle failure responses with missing fields gracefully', () => {
+    const failureResponse = {
+      data: {},
+      trackingId: undefined,
+      orgId: 'org2',
+      type: undefined
+    };
+    const expected = {
+      agentId: undefined,
+      trackingId: undefined,
+      notifTrackingId: undefined,
+      orgId: 'org2',
+      failureType: undefined,
+      failureReason: undefined,
+      reasonCode: undefined
+    };
+    const result = MetricsManager.getCommonTrackingFieldForAQMResponseFailed(failureResponse);
+    expect(result).toEqual(expected);
+  });
+});

package/test/unit/spec/metrics/behavioral-events.ts

@@ -0,0 +1,102 @@
+import {PRODUCT_NAME as product} from '../../../../src/constants';
+import {getEventTaxonomy} from '../../../../src/metrics/behavioral-events';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+
+describe('metrics/behavioral-events', () => {
+  describe('getEventTaxonomy', () => {
+    it('returns the correct taxonomy for the given event', () => {
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.AGENT_RONA)).toEqual({
+        product,
+        agent: 'service',
+        target: 'agent_rona',
+        verb: 'set',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_login',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_LOGIN_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_login',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_LOGOUT_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_logout',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_LOGOUT_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_logout',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_RELOGIN_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_relogin',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_RELOGIN_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'station_relogin',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.AGENT_STATE_CHANGE_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'state_change',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.AGENT_STATE_CHANGE_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'state_change',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'buddy_agents_fetch',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.FETCH_BUDDY_AGENTS_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'buddy_agents_fetch',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'websocket_register',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.WEBSOCKET_REGISTER_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'websocket_register',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy('' as METRIC_EVENT_NAMES)).toEqual(undefined);
+    });
+  });
+});