Added testing to ReusableNestedUnit & fixed bugs.

Author: Dr. Safi

module/reusableNestedUnit/Controller.class.js

@@ -39,7 +39,7 @@ module.exports = ({
         }
 
         static initializeStaticClass() {
-            if(methodInstanceName) {
+            if(methodInstanceName && superclass && superclass.eventEmitter) {
                 superclass.eventEmitter.on('initializationEnd', () => {
                     let ClassObject = {}
                     ClassObject[`${methodInstanceName}`] = self

module/reusableNestedUnit/entrypoint.js

@@ -15,7 +15,11 @@ function createStaticInstanceClasses({
     cacheName = false /* {Boolean || String} */
 }) {
     // Used as caching key.
-    if(cacheName) cacheName = (typeof cacheName == 'boolean') ? implementationType : cacheName;
+    let automaticCacheNaming;
+    if(cacheName && typeof cacheName == 'boolean') {
+        automaticCacheNaming = true
+        cacheName = implementationType
+    }
 
     // load specific implementation functions (class producers).
     let implementationConfig;
@@ -36,7 +40,7 @@ function createStaticInstanceClasses({
     }
 
     // Choose to create a cached context or anonymous garbage collected one.
-    const MC = ModuleContext({ referenceName: cacheName })
+    const MC = ModuleContext({ referenceName: implementationType /*  used to combine all related contexts under same object */ })
 
     // Create new context for the modules using proxy.
     let ControllerFunc = new MC({ target: ControllerFunction })
@@ -45,15 +49,23 @@ function createStaticInstanceClasses({
     const SpecificNestedUnitFunc = new MC({ target: implementationConfig.NestedUnitFunction })
     const SpecificUnitFunc = new MC({ target: implementationConfig.UnitFunction })
 
-    // Choose unique names to cache the related classes with.
     if(cacheName) {
-        counter[cacheName] = counter[cacheName] || 0
-        ControllerFunc.moduleContext.cacheName = `${cacheName}ReusableController${counter[cacheName]}`
-        NestedUnitFunc.moduleContext.cacheName = `${cacheName}ReusableNestedUnit${counter[cacheName]}`
-        UnitFunc.moduleContext.cacheName = `${cacheName}ReusableUnit${counter[cacheName]}`
-        SpecificNestedUnitFunc.moduleContext.cacheName = `${cacheName}SpecificNestedUnit${counter[cacheName]}`
-        SpecificUnitFunc.moduleContext.cacheName = `${cacheName}SpecificUnit${counter[cacheName]}`
-        counter[cacheName] ++ 
+        // Choose unique names to cache the related classes with.
+        ControllerFunc.moduleContext.cacheName = `${cacheName}ReusableController`
+        NestedUnitFunc.moduleContext.cacheName = `${cacheName}ReusableNestedUnit`
+        UnitFunc.moduleContext.cacheName = `${cacheName}ReusableUnit`
+        SpecificNestedUnitFunc.moduleContext.cacheName = `${cacheName}SpecificNestedUnit`
+        SpecificUnitFunc.moduleContext.cacheName = `${cacheName}SpecificUnit`
+    
+        if(automaticCacheNaming) {
+            counter[cacheName] = counter[cacheName] || 0
+            ControllerFunc.moduleContext.cacheName += `${counter[cacheName]}`
+            NestedUnitFunc.moduleContext.cacheName += `${counter[cacheName]}`
+            UnitFunc.moduleContext.cacheName += `${counter[cacheName]}`
+            SpecificNestedUnitFunc.moduleContext.cacheName += `${counter[cacheName]}`
+            SpecificUnitFunc.moduleContext.cacheName += `${counter[cacheName]}`
+            counter[cacheName] ++         
+        }
     }
 
     // Call class producer functions to return a new class with the specific connections.

module/reusableNestedUnit/entrypoint.test.js

@@ -1,9 +1,86 @@
 import assert from 'assert'
-import ReusableModule from './entrypoint.js'
+import createStaticInstanceClasses from './entrypoint.js'
 
 describe('Connecting class inhiritance dynamically', () => {
+
+    describe('Creating static classes without cache', () => {
+        
+        let Controller1 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: false
+        })
+        let Controller2 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: false
+        })
+
+        it('Should return different class references', () => {
+            assert.notStrictEqual(Controller1, Controller2)
+        })
+    
+    })
+    
+    describe('Caching static classes using automatic naming', () => {
+
+        let Controller1 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: true
+        })
+        let Controller2 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: true
+        })
+
+        it('Should return different class references', () => {
+            assert.notStrictEqual(Controller1, Controller2)
+        })
 
-    describe('', () => {
+    })
+        
+    describe('Caching static classes using different passed cacheName', () => {
+        
+        let Controller1 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: 'X'
+        })
+        let Controller2 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: 'Y'
+        })
+
+        it('Should return different class references', () => {
+            assert.notStrictEqual(Controller1, Controller2)
+        })
+    
+    })
+
+    describe('Caching static classes using different same passed cacheName', () => {
+        
+        let Controller1 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: 'X'
+        })
+        let Controller2 = createStaticInstanceClasses({ 
+            superclass: null, 
+            implementationType: 'Middleware',
+            cacheName: 'X'
+        })
+
+        it('Should return same class references', () => {
+            assert.strictEqual(Controller1, Controller2)
+        })
+
+        it('Should return same subclass references', () => {
+            assert.strictEqual(Controller1.extendedSubclass.static['NestedUnit'], Controller1.extendedSubclass.static['NestedUnit'])
+            assert.strictEqual(Controller1.extendedSubclass.static['UnitImplementation'], Controller1.extendedSubclass.static['UnitImplementation'])
+        })
 
     })