tests

Author: raju-opti

lib/project_config/config_manager_factory.ts

@@ -1,6 +1,6 @@
 import { RequestHandler } from "../utils/http_request_handler/http";
 import { Transformer } from "../utils/type";
-import { DatafileManagerConfig } from "./datafileManager";
+import { DatafileManagerConfig } from "./datafile_manager";
 import { ProjectConfigManagerImpl, ProjectConfigManager } from "./project_config_manager";
 import { HttpPollingDatafileManager } from "./httpPollingDatafileManager";
 import PersistentKeyValueCache from "../plugins/key_value_cache/persistentKeyValueCache";

lib/project_config/datafileManager.ts renamed to lib/project_config/datafile_manager.ts

@@ -16,7 +16,7 @@
 
 import { getLogger } from '../modules/logging';
 import { sprintf } from '../utils/fns';
-import { DatafileManager, DatafileManagerConfig } from './datafileManager';
+import { DatafileManager, DatafileManagerConfig } from './datafile_manager';
 import { EventEmitter } from '../utils/event_emitter/eventEmitter';
 import { DEFAULT_UPDATE_INTERVAL, MIN_UPDATE_INTERVAL, DEFAULT_URL_TEMPLATE, UPDATE_INTERVAL_BELOW_MINIMUM_MESSAGE } from './config';
 import PersistentKeyValueCache from '../plugins/key_value_cache/persistentKeyValueCache';

lib/project_config/httpPollingDatafileManager.ts

@@ -13,29 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { getLogger, LoggerFacade } from '../modules/logging';
+import { LoggerFacade } from '../modules/logging';
 import { sprintf } from '../utils/fns';
 
 import { ERROR_MESSAGES } from '../utils/enums';
 import { createOptimizelyConfig } from '../core/optimizely_config';
 import {  OptimizelyConfig } from '../shared_types';
-import { DatafileManager } from './datafileManager';
+import { DatafileManager } from './datafile_manager';
 import { ProjectConfig, toDatafile, tryCreatingProjectConfig } from '../project_config';
 import { scheduleMicrotask } from '../utils/microtask';
 import { Service, ServiceState, BaseService } from '../service';
 import { Consumer, Fn, Transformer } from '../utils/type';
 import { EventEmitter } from '../utils/event_emitter/eventEmitter';
 
-
-const logger = getLogger();
 const MODULE_NAME = 'PROJECT_CONFIG_MANAGER';
 
 interface ProjectConfigManagerConfig {
-  // TODO[OASIS-6649]: Don't use object type
+  // TODO: Don't use object type
   // eslint-disable-next-line  @typescript-eslint/ban-types
   datafile?: string | object;
   jsonSchemaValidator?: Transformer<unknown, boolean>,
   datafileManager?: DatafileManager;
+  logger?: LoggerFacade;
 }
 
 export interface ProjectConfigManager extends Service {
@@ -63,7 +62,7 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
 
   constructor(config: ProjectConfigManagerConfig) {
     super();
-
+    this.logger = config.logger;
     this.jsonSchemaValidator = config.jsonSchemaValidator;
     this.datafile = config.datafile;
     this.datafileManager = config.datafileManager;
@@ -73,18 +72,6 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
     this.logger = logger;
   }
 
-  getState(): ServiceState {
-    return this.state;
-  }
-
-  onRunning(): Promise<void> {
-    return this.startPromise.promise;
-  }
-
-  onTerminated(): Promise<void> {
-    return this.stopPromise.promise;
-  }
-
   start() {
     if (!this.datafile && !this.datafileManager) {
       this.handleInitError(new Error('You must provide at least one of sdkKey or datafile'));
@@ -96,99 +83,30 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
     }
 
     this.datafileManager?.start();
-    this.datafileManager?.onUpdate((this.handleNewDatafile.bind(this)));
+    this.datafileManager?.onUpdate(this.handleNewDatafile.bind(this));
+
+    // If the datafile manager runs successfully, it will emit a onUpdate event. We can
+    // handle the success case in the onUpdate handler. Hanlding the error case in the.
+    // catch callback
     this.datafileManager?.onRunning().catch((err) => {
       this.handleDatafileManagerError(err);
     });
   }
 
-    // try {
-    //   if (!config.datafile && !config.sdkKey) {
-    //     const datafileAndSdkKeyMissingError = new Error(
-    //       sprintf(ERROR_MESSAGES.DATAFILE_AND_SDK_KEY_MISSING, MODULE_NAME)
-    //     );
-    //     this.readyPromise = Promise.resolve({
-    //       success: false,
-    //       reason: getErrorMessage(datafileAndSdkKeyMissingError),
-    //     });
-    //     logger.error(datafileAndSdkKeyMissingError);
-    //     return;
-    //   }
-
-    //   let handleNewDatafileException = null;
-    //   if (config.datafile) {
-    //     handleNewDatafileException = this.handleNewDatafile(config.datafile);
-    //   }
-
-    //   if (config.sdkKey && config.datafileManager) {
-    //     this.datafileManager = config.datafileManager;
-    //     this.datafileManager.start();
-
-    //     this.readyPromise = this.datafileManager
-    //       .onReady()
-    //       .then(this.onDatafileManagerReadyFulfill.bind(this), this.onDatafileManagerReadyReject.bind(this));
-    //     this.datafileManager.on('update', this.onDatafileManagerUpdate.bind(this));
-    //   } else if (this.projectConfig) {
-    //     this.readyPromise = Promise.resolve({
-    //       success: true,
-    //     });
-    //   } else {
-    //     this.readyPromise = Promise.resolve({
-    //       success: false,
-    //       reason: getErrorMessage(handleNewDatafileException, 'Invalid datafile'),
-    //     });
-    //   }
-    // } catch (ex) {
-    //   logger.error(ex);
-    //   this.readyPromise = Promise.resolve({
-    //     success: false,
-    //     reason: getErrorMessage(ex, 'Error in initialize'),
-    //   });
-    // }
-  // }
-
   private handleInitError(error: Error): void {
-    logger.error(error);
+    this.logger?.error(error);
     this.state = ServiceState.Failed;
     this.datafileManager?.stop();
     this.startPromise.reject(error);
     this.stopPromise.reject(error);
   }
 
-  /**
-   * Respond to datafile manager's onReady promise becoming fulfilled.
-   * If there are validation or parse failures using the datafile provided by
-   * DatafileManager, ProjectConfigManager's ready promise is resolved with an
-   * unsuccessful result. Otherwise, ProjectConfigManager updates its own project
-   * config object from the new datafile, and its ready promise is resolved with a
-   * successful result.
-   */
-  // private onDatafileManagerReadyFulfill(): OnReadyResult {
-  //   if (this.datafileManager) {
-  //     const newDatafileError = this.handleNewDatafile(this.datafileManager.get());
-  //     if (newDatafileError) {
-  //       return {
-  //         success: false,
-  //         reason: getErrorMessage(newDatafileError),
-  //       };
-  //     }
-  //     return { success: true };
-  //   }
-
-  //   return {
-  //     success: false,
-  //     reason: getErrorMessage(null, 'Datafile manager is not provided'),
-  //   };
-  // }
-
   /**
    * Respond to datafile manager's onRunning promise becoming rejected.
    * When DatafileManager's onReady promise is rejected, if a datafile was not provided and therefore
    * the projectConfigManager is still in New state, there is no possibility
    * of obtaining a datafile. In this case, ProjectConfigManager's ready promise
    * is fulfilled with an unsuccessful result.
-   * @param   {Error}   err
-   * @returns {Object}
    */
   private handleDatafileManagerError(err: Error): void {
     if (this.isNew()) {
@@ -201,18 +119,16 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
    * the new config object's revision is newer than the current one, sets/updates the project config
    * and optimizely config object instance variables and returns null for the error. If unsuccessful,
    * the project config and optimizely config objects will not be updated, and the error is returned.
-   * @param   {string | object}        newDatafile
-   * @returns {Error|null}    error or null
    */
   private handleNewDatafile(newDatafile: string | object): void {
     const configOrError = tryCreatingProjectConfig({
       datafile: newDatafile,
       jsonSchemaValidator: this.jsonSchemaValidator,
-      logger: logger,
+      logger: this.logger,
     });
 
     if (configOrError instanceof Error) {
-      logger.error(configOrError);
+      this.logger?.error(configOrError);
       // the provided datafile is invalid
       // and no datafile manager is provided
       // so there is no way to recover
@@ -238,22 +154,14 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
     }
   }
 
-  /**
-   * Returns the current project config object, or null if no project config object
-   * is available
-   * @return {ProjectConfig|null}
-   */
+
   getConfig(): ProjectConfig | undefined {
     return this.projectConfig;
   }
 
-  /**
-   * Returns the optimizely config object or null
-   * @return {OptimizelyConfig|null}
-   */
   getOptimizelyConfig(): OptimizelyConfig | undefined {
     if (!this.optimizelyConfig && this.projectConfig) {
-      this.optimizelyConfig = createOptimizelyConfig(this.projectConfig, toDatafile(this.projectConfig), logger);
+      this.optimizelyConfig = createOptimizelyConfig(this.projectConfig, toDatafile(this.projectConfig), this.logger);
     }
     return this.optimizelyConfig;
   }

lib/project_config/project_config_manager.spec.ts

@@ -0,0 +1,58 @@
+import { Consumer } from '../../utils/type';
+import { vi } from 'vitest';
+import { DatafileManager } from '../../project_config/datafile_manager';
+import { EventEmitter } from '../../utils/event_emitter/eventEmitter';
+import { BaseService } from '../../service';
+
+type MockConfig = {
+  datafile?: string | object;
+  onRunning?: Promise<void>,
+  onTerminated?: Promise<void>,
+}
+
+class MockDatafileManager extends BaseService implements DatafileManager {
+  eventEmitter: EventEmitter<{ update: string}> = new EventEmitter();
+  datafile: string | object | undefined;
+
+  constructor(opt: MockConfig) {
+    super();
+    this.datafile = opt.datafile;
+    this.startPromise.resolve(opt.onRunning || Promise.resolve());
+    this.stopPromise.resolve(opt.onTerminated || Promise.resolve());
+  }
+  
+  start(): void {
+    return;
+  }
+
+  stop(): void {
+    return;
+  }
+  
+  get(): string | undefined {
+    if (typeof this.datafile === 'object') {
+      return JSON.stringify(this.datafile);
+    }
+    return this.datafile;
+  }
+
+  setDatafile(datafile: string): void {
+    this.datafile = datafile;
+  }
+
+  onUpdate(listener: Consumer<string>): () => void {
+    return this.eventEmitter.on('update', listener)
+  }
+
+  pushUpdate(datafile: string | object): void {
+    if (typeof datafile === 'object') {
+      datafile = JSON.stringify(datafile);
+    }
+    this.datafile = datafile;
+    this.eventEmitter.emit('update', datafile);
+  }
+}
+
+export const getMockDatafileManager = (opt: MockConfig): MockDatafileManager => {
+  return new MockDatafileManager(opt);
+};

lib/project_config/project_config_manager.tests.js

@@ -0,0 +1,12 @@
+import { vi } from 'vitest';
+import { LoggerFacade } from '../../modules/logging';
+
+export const mockLogger = () : LoggerFacade => {
+  return {
+    info: vi.fn(),
+    log: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  };
+};

lib/project_config/project_config_manager.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import cloneDeep from 'lodash/cloneDeep';
+const cloneDeep = (x: any) => JSON.parse(JSON.stringify(x));
 
-var config = {
+const config: any = {
   revision: '42',
   version: '2',
   events: [

lib/tests/mock/mockDatafileManager.ts

@@ -4,7 +4,7 @@ export default defineConfig({
   test: {
     onConsoleLog: () => true,
     environment: 'happy-dom',
-    include: ["**/service.spec.ts"],
+    include: ["**/project_config_manager.spec.ts"],
     typecheck: {
       tsconfig: 'tsconfig.spec.json',
       exclude: ['**/index.react_native.spec.ts'],