MVP: Imperative Event Emitter

packages/imperative/src/events/__tests__/__integration__/ImperativeEventEmitter.integration.test.ts

@@ -9,7 +9,7 @@
 *
 */
 
-import { IImperativeEventJson, ImperativeEventEmitter, ImperativeSharedEvents, ImperativeUserEvents } from "../../..";
+import { IImperativeEventJson, ImperativeEventEmitter, ImperativeSharedEvents } from "../../..";
 import { ITestEnvironment } from "../../../../__tests__/__src__/environment/doc/response/ITestEnvironment";
 import { TestLogger } from "../../../../__tests__/src/TestLogger";
 import * as TestUtil from "../../../../__tests__/src/TestUtil";
@@ -19,7 +19,6 @@
 
 let TEST_ENVIRONMENT: ITestEnvironment;
 const iee = ImperativeEventEmitter;
-const iee_u = ImperativeUserEvents;
 const iee_s = ImperativeSharedEvents;
 let cwd = '';
 
@@ -84,19 +83,19 @@
 
             expect(subSpy).toHaveBeenCalled();
         });
         it("should trigger subscriptions for all instances watching for onCredentialManagerChanged", () => { });
         it("should not affect subscriptions from another instance when unsubscribing from events", () => { });
     });
 
     describe("User Events", () => {
         it("should create an event file upon first subscription if the file does not exist", () => { });
         it("should trigger subscriptions for all instances watching for onVaultChanged", () => { });
         it("should not affect subscriptions from another instance when unsubscribing from events", () => { });
     });
 
     describe("Custom Events", () => {
         it("should create an event file upon first subscription if the file does not exist", () => { });
         it("should trigger subscriptions for all instances watching for onMyCustomEvent", () => { });
         it("should not affect subscriptions from another instance when unsubscribing from events", () => { });
     });
 });

packages/imperative/src/events/__tests__/__unit__/ImperativeEventEmitter.unit.test.ts

@@ -15,6 +15,8 @@ import { homedir } from "os";
 import { Logger } from "../../../logger/src/Logger";
 import { ImperativeEventEmitter, ImperativeSharedEvents, ImperativeUserEvents } from "../..";
 
+jest.mock("fs");
+
 describe("Event Emitter", () => {
     const iee = ImperativeEventEmitter;
     const sharedDir = join(__dirname, ".zowe", ".events");
@@ -148,9 +150,9 @@ describe("Event Emitter", () => {
                 () => { iee.instance.emitCustomEvent(ImperativeSharedEvents.ON_CREDENTIAL_MANAGER_CHANGED); },
 
                 // Subscribing should fail if IEE is not initialized
-                () => { iee.instance.subscribe("dummy", jest.fn); },
-                () => { iee.instance.subscribe(ImperativeUserEvents.ON_VAULT_CHANGED, jest.fn); },
-                () => { iee.instance.subscribe(ImperativeSharedEvents.ON_CREDENTIAL_MANAGER_CHANGED, jest.fn); },
+                () => { iee.instance.subscribe("dummy", jest.fn()); },
+                () => { iee.instance.subscribe(ImperativeUserEvents.ON_VAULT_CHANGED, jest.fn()); },
+                () => { iee.instance.subscribe(ImperativeSharedEvents.ON_CREDENTIAL_MANAGER_CHANGED, jest.fn()); },
                 () => { iee.instance.unsubscribe("dummy"); },
                 () => { iee.instance.unsubscribe(ImperativeUserEvents.ON_VAULT_CHANGED); },
                 () => { iee.instance.unsubscribe(ImperativeSharedEvents.ON_CREDENTIAL_MANAGER_CHANGED); },
@@ -167,7 +169,7 @@ describe("Event Emitter", () => {
 
             const theEvent = ImperativeUserEvents.ON_VAULT_CHANGED;
             try {
-                iee.instance.subscribe(theEvent, jest.fn);
+                iee.instance.subscribe(theEvent, jest.fn());
             } catch (err) {
                 expect(err.message).toContain("Unable to create '.events' directory.");
             }
@@ -177,7 +179,7 @@ describe("Event Emitter", () => {
             jest.spyOn(fs, "closeSync").mockImplementation(() => { throw "FILE"; });
 
             try {
-                iee.instance.subscribe(theEvent, jest.fn);
+                iee.instance.subscribe(theEvent, jest.fn());
             } catch (err) {
                 expect(err.message).toContain("Unable to create event file.");
             }
@@ -249,5 +251,40 @@ describe("Event Emitter", () => {
             iee.instance.unsubscribe("dummy");
             expect(closeWatcher).toHaveBeenCalled();
         });
+
+        it("should teardown the Event Emitter instance successfully", () => {
+            expect((iee as any).initialized).toBeFalsy();
+            iee.teardown();
+            expect((iee as any).initialized).toBeFalsy();
+
+            iee.initialize("zowe", {logger: jest.fn() as any});
+            expect((iee as any).initialized).toBeTruthy();
+
+            const dummyMap = {
+                has: () => (true),
+                delete: jest.fn(),
+                keys: () => ["dummy"],
+                get: () => ([{ removeAllListeners }, jest.fn()])
+            };
+            // Mocked map of subscriptions
+            (iee.instance as any).subscriptions = dummyMap;
+            (iee.instance as any).eventTimes = dummyMap;
+
+            iee.teardown();
+            expect(closeWatcher).toHaveBeenCalled();
+            expect((iee as any).initialized).toBeFalsy();
+        });
+
+        it("should retrieve event contents successfully", () => {
+            jest.spyOn(fs, "existsSync").mockReturnValueOnce(false);
+            iee.initialize("zowe");
+            let contents = iee.instance.getEventContents(ImperativeUserEvents.ON_VAULT_CHANGED);
+            expect(contents).toEqual("");
+
+            jest.spyOn(fs, "existsSync").mockReturnValueOnce(true);
+            jest.spyOn(fs, "readFileSync").mockReturnValueOnce("dummy");
+            contents = iee.instance.getEventContents(ImperativeUserEvents.ON_VAULT_CHANGED);
+            expect(contents).toEqual("dummy");
+        });
     });
 });

packages/imperative/src/events/src/ImperativeEventEmitter.ts

@@ -18,13 +18,13 @@
 import { ImperativeEvent } from "./ImperativeEvent";
 import { Logger } from "../../logger/src/Logger";
 import { LoggerManager } from "../../logger/src/LoggerManager";
-import { IImperativeRegisteredAction, IImperativeEventEmitterOpts, IImperativeEventJson } from "./doc";
+import { IImperativeRegisteredAction, IImperativeEventEmitterOpts, IImperativeEventJson, ImperativeEventCallback } from "./doc";
 import { ConfigUtils } from "../../config/src/ConfigUtils";
 
 export class ImperativeEventEmitter {
     private static mInstance: ImperativeEventEmitter;
     private static initialized = false;
-    private subscriptions: Map<string, [fs.FSWatcher, Function[]]>;
+    private subscriptions: Map<string, [fs.FSWatcher, ImperativeEventCallback[]]>;
     private eventTimes: Map<string, string>;
     public appName: string;
     public logger: Logger;
@@ -129,7 +129,7 @@
      * @param callbacks list of all callbacks for this watcher
      * @returns The FSWatcher instance created
      */
-    private setupWatcher(eventName: string, callbacks: Function[] = []): fs.FSWatcher {
+    private setupWatcher(eventName: string, callbacks: ImperativeEventCallback[] = []): fs.FSWatcher {
         const dir = this.getEventDir(eventName);
         this.ensureEventsDirExists(dir);
         this.ensureEventFileExists(join(dir, eventName));
@@ -140,10 +140,10 @@
             const eventTime = eventContents.length === 0 ? "" : (JSON.parse(eventContents) as IImperativeEventJson).time;
 
             if (this.eventTimes.get(eventName) !== eventTime) {
                 this.logger.debug(`ImperativeEventEmitter: Event "${event}" emitted: ${eventName}`);
                 // Promise.all(callbacks)
                 callbacks.forEach(cb => cb());
                 this.eventTimes.set(eventName, eventTime);
             }
         });
         this.subscriptions.set(eventName, [watcher, callbacks]);
@@ -181,14 +181,14 @@
     /**
      * ZOWE HOME directory to search for system wide ImperativeEvents like `configChanged`
      */
-    public getSharedEventDir(): string {
+    private getSharedEventDir(): string {
         return join(ImperativeConfig.instance.cliHome, ".events");
     }
 
     /**
      * USER HOME directory to search for user specific ImperativeEvents like `vaultChanged`
      */
-    public getUserEventDir(): string {
+    private getUserEventDir(): string {
         return join(homedir(), ".zowe", ".events");
     }
 
@@ -254,7 +254,7 @@
      * @param eventName Type of event to register
      * @param callback Action to be registered to the given event
      */
-    public subscribe(eventName: string, callback: Function): IImperativeRegisteredAction {
+    public subscribe(eventName: string, callback: ImperativeEventCallback): IImperativeRegisteredAction {
         this.ensureClassInitialized();
 
         let watcher: fs.FSWatcher;
@@ -277,7 +277,7 @@
         this.ensureClassInitialized();
 
         if (this.subscriptions.has(eventName)) {
             const [watcherToClose, _callbacks] = this.subscriptions.get(eventName);
             watcherToClose.removeAllListeners(eventName).close();
             this.subscriptions.delete(eventName);
         }

packages/imperative/src/events/src/doc/IImperativeEventJson.ts

@@ -40,3 +40,5 @@ export interface IImperativeEventJson {
      */
     user?: boolean;
 }
+
+export type ImperativeEventCallback = () => void | Promise<void>;

packages/imperative/src/events/src/doc/IImperativeEventParms.ts

@@ -29,13 +29,13 @@ export interface IImperativeEventParms {
      * @type {ImperativeEventType}
      * @memberof IImperativeEventParms
      */
-    eventName: ImperativeEventType | string
+    eventName: ImperativeEventType | string;
     /**
      * Specifies whether this is a user event or not
      * @type {ImperativeEventType}
      * @memberof IImperativeEventParms
      */
-    isUser: boolean
+    isUser: boolean;
     /**
      * The logger to use when logging the imperative event that occurred
      * @type {Logger}