@futdevpro/fsm-dynamo 1.16.33 → 1.16.34

package/src/_collections/utils/stack.util.spec.ts

@@ -1,373 +1,373 @@
-import { DyFM_getConstructionStackLocation, DyFM_getLocalStackLocation } from './stack.util';
-import { DyFM_Log } from './log.util';
-
-describe('| Stack Utility Functions', () => {
-
-  // Mock the DyFM_Log.warn method
-  let warnSpy: jasmine.Spy;
-
-  beforeEach(() => {
-    warnSpy = spyOn(DyFM_Log, 'warn');
-  });
-
-  afterEach(() => {
-    warnSpy.calls.reset();
-  });
-
-  describe('| DyFM_getConstructionStackLocation', () => {
-
-    it('| should return stack location for constructor call with default level', () => {
-      // Create a test class to simulate constructor call
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // The result should contain the test file path
-      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
-      // TestClass might not appear in the stack due to compilation
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-    it('| should return stack location for constructor call with level 1', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation(1);
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // The result should be a valid stack location
-      expect(testInstance.stackLocation).toBeTruthy();
-      expect(typeof testInstance.stackLocation).toBe('string');
-    });
-
-    it('| should throw error for invalid level parameter', () => {
-      expect(() => {
-        DyFM_getConstructionStackLocation(NaN);
-      }).toThrowError('level must be a number');
-    });
-
-    it('| should handle level parameter correctly', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation(0);
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-    it('| should filter out node_modules and node:internal from stack', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // Should not contain node_modules or node:internal
-      expect(testInstance.stackLocation).not.toContain('node_modules');
-      expect(testInstance.stackLocation).not.toContain('node:internal');
-    });
-
-    it('| should filter out getStackLocation and new keywords', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // The result should not contain filtered keywords
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-    it('| should return empty string when no valid stack line found', () => {
-      // Mock Error.stack to return problematic stack
-      const originalError = Error;
-      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)\n    at Module._compile (node:internal/modules/cjs/loader.js:1:1)';
-      
-      const mockError = function() {
-        return { stack: mockStack };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getConstructionStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      // Restore original Error
-      (global as any).Error = originalError;
-    });
-
-    it('| should handle undefined stack gracefully', () => {
-      const originalError = Error;
-      const mockError = function() {
-        return { stack: undefined };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getConstructionStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      (global as any).Error = originalError;
-    });
-
-    it('| should handle null stack gracefully', () => {
-      const originalError = Error;
-      const mockError = function() {
-        return { stack: null };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getConstructionStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      (global as any).Error = originalError;
-    });
-
-    it('| should parse stack line with parentheses correctly', () => {
-      // This test verifies that the function can handle stack traces with parentheses
-      // The actual parsing is tested through the real stack trace in other tests
-      const result = DyFM_getConstructionStackLocation();
-      
-      // The function should return a valid stack location
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe('string');
-    });
-
-    it('| should handle stack line without parentheses', () => {
-      // This test verifies that the function can handle stack traces without parentheses
-      // The actual parsing is tested through the real stack trace in other tests
-      const result = DyFM_getConstructionStackLocation();
-      
-      // The function should return a valid stack location
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe('string');
-    });
-
-    it('| should handle multiple levels correctly', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getConstructionStackLocation(2);
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-  });
-
-  describe('| DyFM_getLocalStackLocation', () => {
-
-    it('| should return stack location with minimal filtering', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getLocalStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
-      // TestClass might not appear in the stack due to compilation
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-    it('| should return stack location with level parameter', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getLocalStackLocation(1);
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
-    });
-
-    it('| should throw error for invalid level parameter', () => {
-      expect(() => {
-        DyFM_getLocalStackLocation(NaN);
-      }).toThrowError('level must be a number');
-    });
-
-    it('| should filter out node_modules and node:internal from stack', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getLocalStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // Should not contain node_modules or node:internal
-      expect(testInstance.stackLocation).not.toContain('node_modules');
-      expect(testInstance.stackLocation).not.toContain('node:internal');
-    });
-
-    it('| should return empty string when no valid stack line found', () => {
-      const originalError = Error;
-      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)\n    at Module._compile (node:internal/modules/cjs/loader.js:1:1)';
-      
-      const mockError = function() {
-        return { stack: mockStack };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getLocalStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      (global as any).Error = originalError;
-    });
-
-    it('| should handle undefined stack gracefully', () => {
-      const originalError = Error;
-      const mockError = function() {
-        return { stack: undefined };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getLocalStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      (global as any).Error = originalError;
-    });
-
-    it('| should handle null stack gracefully', () => {
-      const originalError = Error;
-      const mockError = function() {
-        return { stack: null };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const result = DyFM_getLocalStackLocation();
-      
-      expect(result).toBe('');
-      expect(warnSpy).toHaveBeenCalled();
-      
-      (global as any).Error = originalError;
-    });
-
-    it('| should parse stack line with parentheses correctly', () => {
-      // This test verifies that the function can handle stack traces with parentheses
-      // The actual parsing is tested through the real stack trace in other tests
-      const result = DyFM_getLocalStackLocation();
-      
-      // The function should return a valid stack location
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe('string');
-    });
-
-    it('| should handle stack line without parentheses', () => {
-      // This test verifies that the function can handle stack traces without parentheses
-      // The actual parsing is tested through the real stack trace in other tests
-      const result = DyFM_getLocalStackLocation();
-      
-      // The function should return a valid stack location
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe('string');
-    });
-
-    it('| should handle multiple levels correctly', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getLocalStackLocation(2);
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-    it('| should not filter out constructor-related calls like getConstructionStackLocation does', () => {
-      class TestClass {
-        constructor() {
-          this.stackLocation = DyFM_getLocalStackLocation();
-        }
-        stackLocation: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // Should still return a valid result even though it might contain constructor-related calls
-      expect(testInstance.stackLocation).toBeTruthy();
-    });
-
-  });
-
-  describe('| Function Comparison', () => {
-
-    it('| should have different filtering behavior between the two functions', () => {
-      class TestClass {
-        constructor() {
-          this.constructionStack = DyFM_getConstructionStackLocation();
-          this.localStack = DyFM_getLocalStackLocation();
-        }
-        constructionStack: string;
-        localStack: string;
-      }
-
-      const testInstance = new TestClass();
-      
-      // Both should return valid results
-      expect(testInstance.constructionStack).toBeTruthy();
-      expect(testInstance.localStack).toBeTruthy();
-      
-      // They might be different due to different filtering logic
-      // This test ensures both functions work correctly
-      expect(typeof testInstance.constructionStack).toBe('string');
-      expect(typeof testInstance.localStack).toBe('string');
-    });
-
-    it('| should handle edge cases consistently', () => {
-      const originalError = Error;
-      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)';
-      
-      const mockError = function() {
-        return { stack: mockStack };
-      };
-      spyOn(global, 'Error').and.returnValue(mockError as any);
-
-      const constructionResult = DyFM_getConstructionStackLocation();
-      const localResult = DyFM_getLocalStackLocation();
-      
-      // Both should return empty string for this problematic stack
-      expect(constructionResult).toBe('');
-      expect(localResult).toBe('');
-      expect(warnSpy).toHaveBeenCalledTimes(2);
-      
-      (global as any).Error = originalError;
-    });
-
-  });
-
+import { DyFM_getConstructionStackLocation, DyFM_getLocalStackLocation } from './stack.util';
+import { DyFM_Log } from './log.util';
+
+describe('| Stack Utility Functions', () => {
+
+  // Mock the DyFM_Log.warn method
+  let warnSpy: jasmine.Spy;
+
+  beforeEach(() => {
+    warnSpy = spyOn(DyFM_Log, 'warn');
+  });
+
+  afterEach(() => {
+    warnSpy.calls.reset();
+  });
+
+  describe('| DyFM_getConstructionStackLocation', () => {
+
+    it('| should return stack location for constructor call with default level', () => {
+      // Create a test class to simulate constructor call
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // The result should contain the test file path
+      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
+      // TestClass might not appear in the stack due to compilation
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+    it('| should return stack location for constructor call with level 1', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation(1);
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // The result should be a valid stack location
+      expect(testInstance.stackLocation).toBeTruthy();
+      expect(typeof testInstance.stackLocation).toBe('string');
+    });
+
+    it('| should throw error for invalid level parameter', () => {
+      expect(() => {
+        DyFM_getConstructionStackLocation(NaN);
+      }).toThrowError('level must be a number');
+    });
+
+    it('| should handle level parameter correctly', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation(0);
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+    it('| should filter out node_modules and node:internal from stack', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // Should not contain node_modules or node:internal
+      expect(testInstance.stackLocation).not.toContain('node_modules');
+      expect(testInstance.stackLocation).not.toContain('node:internal');
+    });
+
+    it('| should filter out getStackLocation and new keywords', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // The result should not contain filtered keywords
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+    it('| should return empty string when no valid stack line found', () => {
+      // Mock Error.stack to return problematic stack
+      const originalError = Error;
+      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)\n    at Module._compile (node:internal/modules/cjs/loader.js:1:1)';
+      
+      const mockError = function() {
+        return { stack: mockStack };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getConstructionStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      // Restore original Error
+      (global as any).Error = originalError;
+    });
+
+    it('| should handle undefined stack gracefully', () => {
+      const originalError = Error;
+      const mockError = function() {
+        return { stack: undefined };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getConstructionStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      (global as any).Error = originalError;
+    });
+
+    it('| should handle null stack gracefully', () => {
+      const originalError = Error;
+      const mockError = function() {
+        return { stack: null };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getConstructionStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      (global as any).Error = originalError;
+    });
+
+    it('| should parse stack line with parentheses correctly', () => {
+      // This test verifies that the function can handle stack traces with parentheses
+      // The actual parsing is tested through the real stack trace in other tests
+      const result = DyFM_getConstructionStackLocation();
+      
+      // The function should return a valid stack location
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('| should handle stack line without parentheses', () => {
+      // This test verifies that the function can handle stack traces without parentheses
+      // The actual parsing is tested through the real stack trace in other tests
+      const result = DyFM_getConstructionStackLocation();
+      
+      // The function should return a valid stack location
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('| should handle multiple levels correctly', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getConstructionStackLocation(2);
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+  });
+
+  describe('| DyFM_getLocalStackLocation', () => {
+
+    it('| should return stack location with minimal filtering', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getLocalStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
+      // TestClass might not appear in the stack due to compilation
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+    it('| should return stack location with level parameter', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getLocalStackLocation(1);
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      expect(testInstance.stackLocation).toContain('stack.util.spec.js');
+    });
+
+    it('| should throw error for invalid level parameter', () => {
+      expect(() => {
+        DyFM_getLocalStackLocation(NaN);
+      }).toThrowError('level must be a number');
+    });
+
+    it('| should filter out node_modules and node:internal from stack', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getLocalStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // Should not contain node_modules or node:internal
+      expect(testInstance.stackLocation).not.toContain('node_modules');
+      expect(testInstance.stackLocation).not.toContain('node:internal');
+    });
+
+    it('| should return empty string when no valid stack line found', () => {
+      const originalError = Error;
+      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)\n    at Module._compile (node:internal/modules/cjs/loader.js:1:1)';
+      
+      const mockError = function() {
+        return { stack: mockStack };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getLocalStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      (global as any).Error = originalError;
+    });
+
+    it('| should handle undefined stack gracefully', () => {
+      const originalError = Error;
+      const mockError = function() {
+        return { stack: undefined };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getLocalStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      (global as any).Error = originalError;
+    });
+
+    it('| should handle null stack gracefully', () => {
+      const originalError = Error;
+      const mockError = function() {
+        return { stack: null };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const result = DyFM_getLocalStackLocation();
+      
+      expect(result).toBe('');
+      expect(warnSpy).toHaveBeenCalled();
+      
+      (global as any).Error = originalError;
+    });
+
+    it('| should parse stack line with parentheses correctly', () => {
+      // This test verifies that the function can handle stack traces with parentheses
+      // The actual parsing is tested through the real stack trace in other tests
+      const result = DyFM_getLocalStackLocation();
+      
+      // The function should return a valid stack location
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('| should handle stack line without parentheses', () => {
+      // This test verifies that the function can handle stack traces without parentheses
+      // The actual parsing is tested through the real stack trace in other tests
+      const result = DyFM_getLocalStackLocation();
+      
+      // The function should return a valid stack location
+      expect(result).toBeTruthy();
+      expect(typeof result).toBe('string');
+    });
+
+    it('| should handle multiple levels correctly', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getLocalStackLocation(2);
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+    it('| should not filter out constructor-related calls like getConstructionStackLocation does', () => {
+      class TestClass {
+        constructor() {
+          this.stackLocation = DyFM_getLocalStackLocation();
+        }
+        stackLocation: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // Should still return a valid result even though it might contain constructor-related calls
+      expect(testInstance.stackLocation).toBeTruthy();
+    });
+
+  });
+
+  describe('| Function Comparison', () => {
+
+    it('| should have different filtering behavior between the two functions', () => {
+      class TestClass {
+        constructor() {
+          this.constructionStack = DyFM_getConstructionStackLocation();
+          this.localStack = DyFM_getLocalStackLocation();
+        }
+        constructionStack: string;
+        localStack: string;
+      }
+
+      const testInstance = new TestClass();
+      
+      // Both should return valid results
+      expect(testInstance.constructionStack).toBeTruthy();
+      expect(testInstance.localStack).toBeTruthy();
+      
+      // They might be different due to different filtering logic
+      // This test ensures both functions work correctly
+      expect(typeof testInstance.constructionStack).toBe('string');
+      expect(typeof testInstance.localStack).toBe('string');
+    });
+
+    it('| should handle edge cases consistently', () => {
+      const originalError = Error;
+      const mockStack = 'Error: Test\n    at Object.<anonymous> (node_modules/test.js:1:1)';
+      
+      const mockError = function() {
+        return { stack: mockStack };
+      };
+      spyOn(global, 'Error').and.returnValue(mockError as any);
+
+      const constructionResult = DyFM_getConstructionStackLocation();
+      const localResult = DyFM_getLocalStackLocation();
+      
+      // Both should return empty string for this problematic stack
+      expect(constructionResult).toBe('');
+      expect(localResult).toBe('');
+      expect(warnSpy).toHaveBeenCalledTimes(2);
+      
+      (global as any).Error = originalError;
+    });
+
+  });
+
 });