refactor event processor

Author: raju-opti

lib/core/decision_service/index.tests.js

@@ -25,14 +25,14 @@ import {
   DECISION_SOURCES,
 } from '../../utils/enums';
 import { createLogger } from '../../plugins/logger';
-import { createForwardingEventProcessor } from '../../plugins/event_processor/forwarding_event_processor';
+import { getForwardingEventProcessor } from '../../event_processor/forwarding_event_processor';
 import { createNotificationCenter } from '../notification_center';
 import Optimizely from '../../optimizely';
 import OptimizelyUserContext from '../../optimizely_user_context';
 import projectConfig, { createProjectConfig } from '../../project_config/project_config';
 import AudienceEvaluator from '../audience_evaluator';
 import errorHandler from '../../plugins/error_handler';
-import eventDispatcher from '../../plugins/event_dispatcher/index.node';
+import eventDispatcher from '../../event_processor/default_dispatcher.browser';
 import * as jsonSchemaValidator from '../../utils/json_schema_validator';
 import { getMockProjectConfigManager } from '../../tests/mock/mock_project_config_manager';
 
@@ -1075,7 +1075,7 @@ describe('lib/core/decision_service', function() {
         jsonSchemaValidator: jsonSchemaValidator,
         isValidInstance: true,
         logger: createdLogger,
-        eventProcessor: createForwardingEventProcessor(eventDispatcher),
+        eventProcessor: getForwardingEventProcessor(eventDispatcher),
         notificationCenter: createNotificationCenter(createdLogger, errorHandler),
         errorHandler: errorHandler,
       });

lib/core/event_builder/build_event_v1.ts

@@ -17,7 +17,7 @@ import {
   EventTags,
   ConversionEvent,
   ImpressionEvent,
-} from '../../modules/event_processor';
+} from '../../event_processor';
 
 import { Event } from '../../shared_types';
 

lib/core/event_builder/index.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { LoggerFacade } from '../../modules/logging';
-import { EventV1 as CommonEventParams } from '../../modules/event_processor';
+import { EventV1 as CommonEventParams } from '../../event_processor';
 
 import fns from '../../utils/fns';
 import { CONTROL_ATTRIBUTES, RESERVED_EVENT_KEYWORDS } from '../../utils/enums';

lib/event_processor/default_dispatcher.browser.spec.ts

@@ -0,0 +1,33 @@
+import { vi, expect, it, describe, afterAll } from 'vitest';
+
+vi.mock('./default_dispatcher', () => {
+  const DefaultEventDispatcher = vi.fn();
+  return { DefaultEventDispatcher };
+});
+
+vi.mock('../utils/http_request_handler/browser_request_handler', () => {
+  const BrowserRequestHandler = vi.fn();
+  return { BrowserRequestHandler };
+});
+
+import { DefaultEventDispatcher } from './default_dispatcher';
+import { BrowserRequestHandler } from '../utils/http_request_handler/browser_request_handler';
+import eventDispatcher from './default_dispatcher.browser';
+
+describe('eventDispatcher', () => {
+  afterAll(() => {
+    MockDefaultEventDispatcher.mockReset();
+    MockBrowserRequestHandler.mockReset();
+  });
+  const MockBrowserRequestHandler = vi.mocked(BrowserRequestHandler);
+  const MockDefaultEventDispatcher = vi.mocked(DefaultEventDispatcher);
+
+  it('creates and returns the instance by calling DefaultEventDispatcher', () => {
+    expect(Object.is(eventDispatcher, MockDefaultEventDispatcher.mock.instances[0])).toBe(true);
+  });
+
+  it('users a BrowserRequestHandler', () => {
+    expect(Object.is(eventDispatcher, MockDefaultEventDispatcher.mock.instances[0])).toBe(true);
+    expect(Object.is(MockDefaultEventDispatcher.mock.calls[0][0], MockBrowserRequestHandler.mock.instances[0])).toBe(true);
+  });
+});

lib/event_processor/default_dispatcher.browser.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2016-2017, 2020-2022, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { BrowserRequestHandler } from "../utils/http_request_handler/browser_request_handler";
+import { EventDispatcher } from '../event_processor';
+import { DefaultEventDispatcher } from './default_dispatcher';
+
+const eventDispatcher: EventDispatcher = new DefaultEventDispatcher(new BrowserRequestHandler());
+
+export default eventDispatcher;

lib/event_processor/default_dispatcher.node.spec.ts

@@ -0,0 +1,34 @@
+import { vi, expect, it, describe, afterAll } from 'vitest';
+
+vi.mock('./default_dispatcher', () => {
+  const DefaultEventDispatcher = vi.fn();
+  return { DefaultEventDispatcher };
+});
+
+vi.mock('../utils/http_request_handler/node_request_handler', () => {
+  const NodeRequestHandler = vi.fn();
+  return { NodeRequestHandler };
+});
+
+import { DefaultEventDispatcher } from './default_dispatcher';
+import { NodeRequestHandler } from '../utils/http_request_handler/node_request_handler';
+import eventDispatcher from './default_dispatcher.node';
+
+describe('eventDispatcher', () => {
+  const MockNodeRequestHandler = vi.mocked(NodeRequestHandler);
+  const MockDefaultEventDispatcher = vi.mocked(DefaultEventDispatcher);
+
+  afterAll(() => {
+    MockDefaultEventDispatcher.mockReset();
+    MockNodeRequestHandler.mockReset();
+  })
+
+  it('creates and returns the instance by calling DefaultEventDispatcher', () => {
+    expect(Object.is(eventDispatcher, MockDefaultEventDispatcher.mock.instances[0])).toBe(true);
+  });
+
+  it('users a NodeRequestHandler', () => {
+    expect(Object.is(eventDispatcher, MockDefaultEventDispatcher.mock.instances[0])).toBe(true);
+    expect(Object.is(MockDefaultEventDispatcher.mock.calls[0][0], MockNodeRequestHandler.mock.instances[0])).toBe(true);
+  });
+});

lib/event_processor/default_dispatcher.node.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright 2016-2018, 2020-2021, 2024 Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { EventDispatcher } from '../event_processor';
+import { NodeRequestHandler } from '../utils/http_request_handler/node_request_handler';
+import { DefaultEventDispatcher } from './default_dispatcher';
+
+const eventDispatcher: EventDispatcher = new DefaultEventDispatcher(new NodeRequestHandler());
+
+export default eventDispatcher;

lib/event_processor/default_dispatcher.spec.ts

@@ -0,0 +1,102 @@
+import { expect, vi, describe, it } from 'vitest';
+import { DefaultEventDispatcher } from './default_dispatcher';
+import { EventV1 } from '../event_processor';
+
+const getEvent = (): EventV1 => {
+  return {
+    account_id: 'string',
+    project_id: 'string',
+    revision: 'string',
+    client_name: 'string',
+    client_version: 'string',
+    anonymize_ip: true,
+    enrich_decisions: false,
+    visitors: [],
+  };
+};
+
+describe('DefaultEventDispatcher', () => {
+  it('reject the response promise if the eventObj.httpVerb is not POST', async () => {
+    const eventObj = {
+      url: 'https://cdn.com/event',
+      params: getEvent(),
+      httpVerb: 'GET' as const,
+    };
+
+    const requestHnadler = {
+      makeRequest: vi.fn().mockReturnValue({
+        abort: vi.fn(),
+        responsePromise: Promise.resolve({ statusCode: 203 }),
+      }),
+    };
+
+    const dispatcher = new DefaultEventDispatcher(requestHnadler);
+    await expect(dispatcher.dispatchEvent(eventObj)).rejects.toThrow();
+  });
+
+  it('sends correct headers and data to the requestHandler', async () => {
+    const eventObj = {
+      url: 'https://cdn.com/event',
+      params: getEvent(),
+      httpVerb: 'POST' as const,
+    };
+
+    const requestHnadler = {
+      makeRequest: vi.fn().mockReturnValue({
+        abort: vi.fn(),
+        responsePromise: Promise.resolve({ statusCode: 203 }),
+      }),
+    };
+
+    const dispatcher = new DefaultEventDispatcher(requestHnadler);
+    await dispatcher.dispatchEvent(eventObj);
+
+    expect(requestHnadler.makeRequest).toHaveBeenCalledWith(
+      eventObj.url,
+      {
+        'content-type': 'application/json',
+        'content-length': JSON.stringify(eventObj.params).length.toString(),
+      },
+      'POST',
+      JSON.stringify(eventObj.params)
+    );
+  });
+
+  it('returns a promise that resolves with correct value if the response of the requestHandler resolves', async () => {
+    const eventObj = {
+      url: 'https://cdn.com/event',
+      params: getEvent(),
+      httpVerb: 'POST' as const,
+    };
+
+    const requestHnadler = {
+      makeRequest: vi.fn().mockReturnValue({
+        abort: vi.fn(),
+        responsePromise: Promise.resolve({ statusCode: 203 }),
+      }),
+    };
+
+    const dispatcher = new DefaultEventDispatcher(requestHnadler);
+    const response = await dispatcher.dispatchEvent(eventObj);
+
+    expect(response.statusCode).toEqual(203);
+  });
+
+  it('returns a promise that rejects if the response of the requestHandler rejects', async () => {
+    const eventObj = {
+      url: 'https://cdn.com/event',
+      params: getEvent(),
+      httpVerb: 'POST' as const,
+    };
+
+    const requestHnadler = {
+      makeRequest: vi.fn().mockReturnValue({
+        abort: vi.fn(),
+        responsePromise: Promise.reject(new Error('error')),
+      }),
+    };
+
+    const dispatcher = new DefaultEventDispatcher(requestHnadler);
+    await expect(dispatcher.dispatchEvent(eventObj)).rejects.toThrow();
+  });
+});

lib/event_processor/default_dispatcher.ts

@@ -0,0 +1,30 @@
+
+import { RequestHandler } from '../utils/http_request_handler/http';
+import { EventDispatcher, EventDispatcherResponse, EventV1Request } from '../event_processor';
+
+export class DefaultEventDispatcher implements EventDispatcher {
+  private requestHandler: RequestHandler;
+
+  constructor(requestHandler: RequestHandler) {
+    this.requestHandler = requestHandler;
+  }
+
+  async dispatchEvent(
+    eventObj: EventV1Request
+  ): Promise<EventDispatcherResponse> {
+    // Non-POST requests not supported
+    if (eventObj.httpVerb !== 'POST') {
+      return Promise.reject(new Error('Only POST requests are supported'));
+    }
+  
+    const dataString = JSON.stringify(eventObj.params);
+  
+    const headers = {
+      'content-type': 'application/json',
+      'content-length': dataString.length.toString(),
+    };
+  
+    const abortableRequest = this.requestHandler.makeRequest(eventObj.url, headers, 'POST', dataString);
+    return abortableRequest.responsePromise;
+  }
+}

lib/modules/event_processor/eventDispatcher.ts renamed to lib/event_processor/eventDispatcher.ts

@@ -16,13 +16,11 @@
 import { EventV1 } from "./v1/buildEventV1";
 
 export type EventDispatcherResponse = {
-  statusCode: number  
+  statusCode?: number  
 }
 
-export type EventDispatcherCallback = (response: EventDispatcherResponse) => void
-
 export interface EventDispatcher {
-  dispatchEvent(event: EventV1Request, callback: EventDispatcherCallback): void
+  dispatchEvent(event: EventV1Request): Promise<EventDispatcherResponse>
 }
 
 export interface EventV1Request {