Catch invalid type & action for sendOdpEvent + patch tests

Author: opti-jnguyen

packages/optimizely-sdk/lib/core/odp/odp_manager.ts

@@ -166,6 +166,12 @@ export abstract class OdpManager implements IOdpManager {
    * @param {OdpEvent}  > ODP Event to send to event manager
    */
   sendEvent({ type, action, identifiers, data }: OdpEvent): void {
+    let mType = type;
+
+    if (typeof mType !== 'string' || mType === '') {
+      mType = 'fullstack';
+    }
+
     if (!this.enabled) {
       throw new Error(ERROR_MESSAGES.ODP_NOT_ENABLED);
     }
@@ -182,7 +188,10 @@ export abstract class OdpManager implements IOdpManager {
       throw new Error(ERROR_MESSAGES.ODP_SEND_EVENT_FAILED_EVENT_MANAGER_MISSING);
     }
 
-    this.eventManager.sendEvent(new OdpEvent(type, action, identifiers, data));
+    if (typeof action !== 'string' || action === '') {
+      throw new Error('ODP action is not valid (cannot be empty).');
+    }
+
   }
 
   abstract isVuidEnabled(): boolean;

packages/optimizely-sdk/lib/index.browser.tests.js

@@ -30,6 +30,7 @@ import { BrowserOdpManager } from './plugins/odp_manager/index.browser';
 import { OdpConfig } from './core/odp/odp_config';
 import { BrowserOdpEventManager } from './plugins/odp/event_manager/index.browser';
 import { BrowserOdpEventApiManager } from './plugins/odp/event_api_manager/index.browser';
+import { OdpEvent } from './core/odp/odp_event';
 
 var LocalStoragePendingEventsDispatcher = eventProcessor.LocalStoragePendingEventsDispatcher;
 
@@ -771,7 +772,7 @@ describe('javascript-sdk (Browser)', function() {
         sinon.assert.called(fakeEventManager.start);
       });
 
-      it('should send an odp event with sendOdpEvent', async () => {
+      it('should send an odp event when calling sendOdpEvent with valid parameters', async () => {
         const fakeEventManager = {
           updateSettings: sinon.spy(),
           start: sinon.spy(),
@@ -803,6 +804,80 @@ describe('javascript-sdk (Browser)', function() {
         sinon.assert.called(fakeEventManager.sendEvent);
       });
 
+      it('should throw an error and not send an odp event when calling sendOdpEvent with an invalid action input', async () => {
+        const fakeEventManager = {
+          updateSettings: sinon.spy(),
+          start: sinon.spy(),
+          stop: sinon.spy(),
+          registerVuid: sinon.spy(),
+          identifyUser: sinon.spy(),
+          sendEvent: sinon.spy(),
+          flush: sinon.spy(),
+        };
+
+        const client = optimizelyFactory.createInstance({
+          datafile: testData.getOdpIntegratedConfigWithSegments(),
+          errorHandler: fakeErrorHandler,
+          eventDispatcher: fakeEventDispatcher,
+          eventBatchSize: null,
+          logger,
+          odpOptions: {
+            eventManager: fakeEventManager,
+          },
+        });
+
+        const readyData = await client.onReady();
+        assert.equal(readyData.success, true);
+        assert.isUndefined(readyData.reason);
+
+        client.sendOdpEvent('');
+        sinon.assert.called(logger.error);
+
+        client.sendOdpEvent(null);
+        sinon.assert.calledTwice(logger.error);
+
+        client.sendOdpEvent(undefined);
+        sinon.assert.calledThrice(logger.error);
+
+        sinon.assert.notCalled(fakeEventManager.sendEvent);
+      });
+
+      it('should use fullstack as a fallback value for the odp event when calling sendOdpEvent with an empty type input', async () => {
+        const fakeEventManager = {
+          updateSettings: sinon.spy(),
+          start: sinon.spy(),
+          stop: sinon.spy(),
+          registerVuid: sinon.spy(),
+          identifyUser: sinon.spy(),
+          sendEvent: sinon.spy(),
+          flush: sinon.spy(),
+        };
+
+        const client = optimizelyFactory.createInstance({
+          datafile: testData.getOdpIntegratedConfigWithSegments(),
+          errorHandler: fakeErrorHandler,
+          eventDispatcher: fakeEventDispatcher,
+          eventBatchSize: null,
+          logger,
+          odpOptions: {
+            eventManager: fakeEventManager,
+          },
+        });
+
+        const readyData = await client.onReady();
+        assert.equal(readyData.success, true);
+        assert.isUndefined(readyData.reason);
+
+        client.sendOdpEvent('dummy-action', '');
+
+        sinon.assert.calledWith(fakeEventManager.sendEvent, {
+          action: 'dummy-action',
+          type: 'fullstack',
+          identifiers: new Map(),
+          data: new Map(),
+        });
+      });
+
       it('should log an error when attempting to send an odp event when odp is disabled', async () => {
         const client = optimizelyFactory.createInstance({
           datafile: testData.getTestProjectConfigWithFeatures(),

packages/optimizely-sdk/lib/plugins/odp/event_manager/index.browser.ts

@@ -1,16 +1,20 @@
-import { OdpEventManager } from "../../../../lib/core/odp/odp_event_manager";
+import { IOdpEventManager, OdpEventManager } from '../../../../lib/core/odp/odp_event_manager';
 import { LogLevel } from '../../../modules/logging';
 
 const DEFAULT_BROWSER_QUEUE_SIZE = 100;
 
-export class BrowserOdpEventManager extends OdpEventManager {
-  protected initParams(batchSize: number | undefined, queueSize: number | undefined, flushInterval: number | undefined): void {
+export class BrowserOdpEventManager extends OdpEventManager implements IOdpEventManager {
+  protected initParams(
+    batchSize: number | undefined,
+    queueSize: number | undefined,
+    flushInterval: number | undefined
+  ): void {
     this.queueSize = queueSize || DEFAULT_BROWSER_QUEUE_SIZE;
 
     // disable event batching for browser
     this.batchSize = 1;
     this.flushInterval = 0;
-    
+
     if (typeof batchSize !== 'undefined' && batchSize !== 1) {
       this.getLogger().log(LogLevel.WARNING, 'ODP event batch size must be 1 in the browser.');
     }
@@ -24,4 +28,4 @@ export class BrowserOdpEventManager extends OdpEventManager {
     // in Browser/client-side context, give debug message but leave events in queue
     this.getLogger().log(LogLevel.DEBUG, 'ODPConfig not ready. Leaving events in queue.');
   }
-}
+}

packages/optimizely-sdk/lib/plugins/odp/event_manager/index.node.ts

@@ -1,14 +1,17 @@
-
-import { OdpEvent } from "../../../../lib/core/odp/odp_event";
-import { OdpEventManager } from "../../../../lib/core/odp/odp_event_manager";
-import { LogLevel } from "../../../../lib/modules/logging";
+import { OdpEvent } from '../../../../lib/core/odp/odp_event';
+import { IOdpEventManager, OdpEventManager } from '../../../../lib/core/odp/odp_event_manager';
+import { LogLevel } from '../../../../lib/modules/logging';
 
 const DEFAULT_BATCH_SIZE = 10;
 const DEFAULT_FLUSH_INTERVAL_MSECS = 1000;
 const DEFAULT_SERVER_QUEUE_SIZE = 10000;
 
-export class NodeOdpEventManager extends OdpEventManager {
-  protected initParams(batchSize: number | undefined, queueSize: number | undefined, flushInterval: number | undefined): void {
+export class NodeOdpEventManager extends OdpEventManager implements IOdpEventManager {
+  protected initParams(
+    batchSize: number | undefined,
+    queueSize: number | undefined,
+    flushInterval: number | undefined
+  ): void {
     this.queueSize = queueSize || DEFAULT_SERVER_QUEUE_SIZE;
     this.batchSize = batchSize || DEFAULT_BATCH_SIZE;
 
@@ -26,4 +29,4 @@ export class NodeOdpEventManager extends OdpEventManager {
     this.getLogger().log(LogLevel.WARNING, 'ODPConfig not ready. Discarding events in queue.');
     this.queue = new Array<OdpEvent>();
   }
-}
+}