Version 2.0.7

* Added test coverage reporting

Author: cliffhall

README.md

@@ -24,7 +24,7 @@ npm i @puremvc/puremvc-typescript-multicore-framework
 * [React Native](https://en.wikipedia.org/wiki/React_Native)
 
 ## Status
-Production - [Version 2.0.6](https://github.com/PureMVC/puremvc-typescript-multicore-framework/blob/master/VERSION)
+Production - [Version 2.0.7](https://github.com/PureMVC/puremvc-typescript-multicore-framework/blob/master/VERSION)
 
 ## License
 * PureMVC MultiCore Framework for TypeScript - Copyright © 2025 [Saad Shams](https://www.linkedin.com/in/muizz)

VERSION

@@ -4,7 +4,7 @@ Release Date: 2/27/25
     Platform: TypeScript
      Version: 2
     Revision: 0
-       Minor: 6
+       Minor: 7
       Authors: Saad Shams <[email protected]>
 --------------------------------------------------------------------------
 2.0.0 - Brand new implementation of ported code, equivalent to AS3 MultiCore Version 1.0.5.
@@ -15,3 +15,4 @@ Release Date: 2/27/25
         and Mediator (viewComponent type any, not Object)
 2.0.5 - Fix package.json for importing types properly
 2.0.6 - Add test coverage reporting
+2.0.7 - Increase test coverage

docs/classes/Controller.html

@@ -19,7 +19,7 @@
 <li><a href="https://en.wikipedia.org/wiki/React_(JavaScript_library)" target="_blank" class="external">React</a></li>
 <li><a href="https://en.wikipedia.org/wiki/React_Native" target="_blank" class="external">React Native</a></li>
 </ul>
-<a id="md:status" class="tsd-anchor"></a><h2 class="tsd-anchor-link">Status<a href="#md:status" aria-label="Permalink" class="tsd-anchor-icon"><svg viewBox="0 0 24 24"><use href="assets/icons.svg#icon-anchor"></use></svg></a></h2><p>Production - <a href="https://github.com/PureMVC/puremvc-typescript-multicore-framework/blob/master/VERSION" target="_blank" class="external">Version 2.0.5</a></p>
+<a id="md:status" class="tsd-anchor"></a><h2 class="tsd-anchor-link">Status<a href="#md:status" aria-label="Permalink" class="tsd-anchor-icon"><svg viewBox="0 0 24 24"><use href="assets/icons.svg#icon-anchor"></use></svg></a></h2><p>Production - <a href="https://github.com/PureMVC/puremvc-typescript-multicore-framework/blob/master/VERSION" target="_blank" class="external">Version 2.0.7</a></p>
 <a id="md:license" class="tsd-anchor"></a><h2 class="tsd-anchor-link">License<a href="#md:license" aria-label="Permalink" class="tsd-anchor-icon"><svg viewBox="0 0 24 24"><use href="assets/icons.svg#icon-anchor"></use></svg></a></h2><ul>
 <li>
 <p>PureMVC MultiCore Framework for TypeScript - Copyright © 2025 <a href="https://www.linkedin.com/in/muizz" target="_blank" class="external">Saad Shams</a></p>

docs/classes/Facade.html

@@ -1,6 +1,6 @@
 {
   "name": "@puremvc/puremvc-typescript-multicore-framework",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "PureMVC MultiCore Framework for TypeScript",
   "main": "./bin/cjs/index.js",
   "module": "./bin/esm/index.js",

docs/classes/MacroCommand.html

@@ -126,35 +126,49 @@ describe("ControllerTest", () => {
      * test will fail.
      */
     test("testReregisterAndExecuteCommand", () => {
-        // Fetch the controller, register the ControllerTestCommand2 to handle 'ControllerTest2' notes
         const controller: IController = Controller.getInstance("ControllerTestKey5", (key: string) => new Controller(key));
         controller.registerCommand("ControllerTest2", () => new ControllerTestCommand2());
 
         // Remove the Command from the Controller
         controller.removeCommand("ControllerTest2");
 
-        // Re-register the Command with the Controller
+        // Re-register the Command, ensure it's only firing once per notification
         controller.registerCommand("ControllerTest2", () => new ControllerTestCommand2());
 
-        // Create a 'ControllerTest2' note
         const vo = new ControllerTestVO(12);
         const note = new Notification("ControllerTest2", vo);
 
-        // retrieve a reference to the View from the same core.
-        const view = View.getInstance("ControllerTestKey5", (key: string) => new View((key)));
+        const view = View.getInstance("ControllerTestKey5", (key: string) => new View(key));
 
-        // send the Notification
+        // Sending notification; expecting the command to be executed starting at zero and multiplying input to 24
         view.notifyObservers(note);
-
-        // test assertions
-        // if the command is executed once the value will be 24
         expect(vo.result).toBe(24);
 
-        // Prove that accumulation works in the VO by sending the notification again
+        // Send the notification again; should now evaluate to 48
         view.notifyObservers(note);
-
-        // if the command is executed twice the value will be 48
         expect(vo.result).toBe(48);
     });
 
+    // Additional test case for constructing Controller with an existing key
+    test("testConstructorWithExistingKey", () => {
+        const key = "ControllerTestKeyExisting";
+        const controller1: IController = Controller.getInstance(key, (key: string) => new Controller(key));
+        expect(controller1).toBeDefined();
+        expect(() => {
+            new Controller(key);
+        }).toThrow(Error("Controller instance for this Multiton key already constructed!"));
+    });
+
+    // Test for removing a command twice
+    test("testRemoveCommandTwice", () => {
+        const controller: IController = Controller.getInstance("ControllerTestKeyTwice", k => new Controller(k));
+
+        controller.registerCommand("TestCommand", () => new ControllerTestCommand());
+
+        controller.removeCommand("TestCommand");
+        
+        // Removing it again should not cause issues and should silently do nothing.
+        controller.removeCommand("TestCommand");
+    });
+
 });

docs/classes/Mediator.html

@@ -32,7 +32,7 @@ describe("ModelTest", () => {
      * Tests `registerProxy` and `retrieveProxy` in the same test.
      * These methods cannot currently be tested separately
      * in any meaningful way other than to show that the
-     * methods do not throw exception when called. 
+     * methods do not throw exception when called.
      */
     test("testRegisterAndRetrieveProxy", () => {
         // register a proxy and retrieve it.
@@ -116,4 +116,26 @@ describe("ModelTest", () => {
         expect(proxy.data).toBe(ModelTestProxy.ON_REMOVE_CALLED);
     });
 
+    // Test for constructor with an existing key
+    test("testModelConstructorWithExistingKeyThrowsError", () => {
+        const key = "ExistingModelKey";
+        Model.getInstance(key, k => new Model(k));
+
+        expect(() => new Model(key)).toThrow("Model instance for this Multiton key already constructed!");
+    });
+
+    // Test for removing a proxy twice
+    test("testRemoveProxyTwice", () => {
+        const model: IModel = Model.getInstance("ModelTestKeyTwice", k => new Model(k));
+
+        const proxy: IProxy = new Proxy("testProxy", {});
+        model.registerProxy(proxy);
+
+        const removedProxy = model.removeProxy("testProxy");
+        expect(removedProxy).toBe(proxy);
+
+        const secondRemovedProxy = model.removeProxy("testProxy");
+        expect(secondRemovedProxy).toBeNull();
+    });
+
 });

docs/classes/Model.html

@@ -354,4 +354,35 @@ describe("ViewTest", () => {
         expect(obj.counter).toBe(0);
     });
 
+    // Test for removing a mediator twice
+    test("testRemoveMediatorTwice", () => {
+        // Get the Multiton View instance
+        const view = View.getInstance("ViewTestKey12", (key: string) => new View(key));
+
+        // Create and register the test mediator
+        const mediator: IMediator = new Mediator("testMediator", {});
+        view.registerMediator(mediator);
+
+        // Remove the mediator
+        const removedMediator = view.removeMediator("testMediator");
+
+        // Assert that the mediator is removed
+        expect(removedMediator).toBe(mediator);
+
+        // Attempt to remove the mediator again and expect `null`
+        const secondRemovedMediator = view.removeMediator("testMediator");
+        expect(secondRemovedMediator).toBe(null);
+    });
+
+    // Test for notifyObservers with no registrations
+    test("testNotifyObserversWithNoRegistrations", () => {
+        const view: IView = View.getInstance("ViewTestKeyNoObservers", (key: string) => new View(key));
+
+        const notification = new Notification("UnusedNotification");
+
+        // Call notifyObservers on a notification with no registered observers
+        // Should not throw an error and should be handled gracefully
+        expect(() => view.notifyObservers(notification)).not.toThrow();
+    });
+
 });

docs/classes/Notification.html

@@ -6,61 +6,31 @@
 //  Your reuse is governed by the BSD-3-Clause License
 //
 
-import {Notification} from "../../../src";
-import {MacroCommandTestVO} from "./MacroCommandTestVO";
-import {MacroCommandTestCommand} from "./MacroCommandTestCommand";
+import { MacroCommand } from "../../../src/patterns/command/MacroCommand";
+import { Notification } from "../../../src/patterns/observer/Notification";
 
 /**
- * Test the PureMVC SimpleCommand class.
+ * Test the PureMVC MacroCommand class.
  *
- * @see MacroCommandTestVO
- * @see MacroCommandTestCommand
+ * @see MacroCommand
  */
 describe("MacroCommandTest", () => {
 
-    /**
-     * Tests operation of a `MacroCommand`.
-     *
-     * This test creates a new `Notification`, adding a
-     * `MacroCommandTestVO` as the body.
-     * It then creates a `MacroCommandTestCommand` and invokes
-     * its `execute` method, passing in the
-     * `Notification`.
-     *
-     * The `MacroCommandTestCommand` has defined an
-     * `initializeMacroCommand` method, which is
-     * called automatically by its constructor. In this method
-     * the `MacroCommandTestCommand` adds 2 SubCommands
-     * to itself, `MacroCommandTestSub1Command` and
-     * `MacroCommandTestSub2Command`.
-     *
-     * The `MacroCommandTestVO` has 2 result properties,
-     * one is set by `MacroCommandTestSub1Command` by
-     * multiplying the input property by 2, and the other is set
-     * by `MacroCommandTestSub2Command` by multiplying
-     * the input property by itself.
-     *
-     * Success is determined by evaluating the 2 result properties
-     * on the `MacroCommandTestVO` that was passed to
-     * the `MacroCommandTestCommand` on the Notification
-     * body.
-     */
-    test("testMacroCommandExecute", () => {
-        // Create the VO
-        const vo: MacroCommandTestVO = new MacroCommandTestVO(5);
-
-        // Create the Notification
-        const notification = new Notification("MacroCommandTest", vo);
-
-        // Create the SimpleCommand
-        const command: MacroCommandTestCommand = new MacroCommandTestCommand();
-
-        // Execute the SimpleCommand
-        command.execute(notification);
-
-        // test assertions
-        expect(vo.result1).toBe(10);
-        expect(vo.result2).toBe(25);
+    test("testExecuteWithUndefinedSubCommand", () => {
+        class TestMacroCommand extends MacroCommand {
+            public initializeMacroCommand(): void {
+                this.addSubCommand(undefined as any); // intentionally adding undefined
+            }
+        }
+
+        const macroCommand = new TestMacroCommand();
+        const notification = new Notification("TestNotification");
+        
+        // Call execute and ensure it handles the undefined command gracefully
+        expect(() => macroCommand.execute(notification)).not.toThrow();
+
+        // Since the subcommand was undefined, no ICommand should be executed, thus, nothing to assert on command effects
+        // Additional assertions might include verifying that no state was changed
     });
 
 });