@adaas/a-utils 0.1.18 → 0.1.19

package/tests/A-Logger.test.ts

@@ -118,7 +118,9 @@ describe('A_Logger Component', () => {
             longLogger.log('Test message');
             
             const logs = getCapturedLogs();
-            expect(logs[0]).toContain('VeryLongServiceNameThatExceedsStandardLength');
+            // Long scope names should be truncated to the standard length (20 characters)
+            expect(logs[0]).toContain('VeryLongServiceNameT'); // Truncated to 20 chars
+            expect(logs[0]).toContain('Test message');
         });
 
         test('should maintain consistent alignment across different scope lengths', () => {
@@ -137,9 +139,11 @@ describe('A_Logger Component', () => {
             expect(logs).toHaveLength(3);
             
             // All logs should have similar structure for alignment
-            logs.forEach(log => {
+            logs.forEach((log, index) => {
                 expect(log).toContain('Alignment test');
-                expect(log).toMatch(/\[.*\] \|.*\|/); // Pattern: [scope] |time|
+                // The log format includes ANSI escape codes, so let's test the basic structure
+                expect(log).toMatch(/\[.*\]/); // Has scope brackets
+                expect(log).toMatch(/\|\d{2}:\d{2}:\d{3}\|/); // Has timestamp
             });
         });
     });
@@ -244,7 +248,7 @@ describe('A_Logger Component', () => {
         test('should support all defined colors', () => {
             const colors: Array<keyof typeof A_LOGGER_COLORS> = [
                 'green', 'blue', 'red', 'yellow', 'gray', 
-                'magenta', 'cyan', 'white', 'pink'
+                'magenta', 'cyan'
             ];
 
             colors.forEach(color => {

package/tests/A-Memory.test.ts

@@ -1,169 +1,203 @@
-import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
-import { A_Error } from '@adaas/a-concept';
+import { A_Memory } from '@adaas/a-utils/lib/A-Memory/A-Memory.component';
+import { A_MemoryContext } from '@adaas/a-utils/lib/A-Memory/A-Memory.context';
+import { A_MemoryError } from '@adaas/a-utils/lib/A-Memory/A-Memory.error';
+import { A_Component, A_Concept, A_Container, A_Context, A_Error } from '@adaas/a-concept';
 
 jest.retryTimes(0);
 
 describe('A-Memory tests', () => {
 
-    it('Should allow to create memory instance', () => {
+    beforeEach(() => {
+        A_Context.reset();
+    });
+
+    it('Should allow to create memory instance', async () => {
         const memory = new A_Memory();
-        
+        A_Context.root.register(memory);
+
         expect(memory).toBeInstanceOf(A_Memory);
-        expect(memory.Errors).toBeUndefined();
+        expect(memory).toBeInstanceOf(A_Component);
+        
+        // Test that memory can be initialized
+        await memory.ready;
     });
 
-    it('Should allow to create memory with initial values', () => {
-        const initialValues = {
-            key1: 'value1',
-            key2: 42,
-            key3: { nested: 'object' }
-        };
-        
-        const memory = new A_Memory(initialValues);
-        
-        expect(memory.get('key1')).toBe('value1');
-        expect(memory.get('key2')).toBe(42);
-        expect(memory.get('key3')).toEqual({ nested: 'object' });
+    it('Should allow to initialize and set initial values', async () => {
+        const memory = new A_Memory<{
+            key1: string;
+            key2: number;
+            key3: { nested: string };
+        }>();
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
+        // Set initial values after initialization
+        await memory.set('key1', 'value1');
+        await memory.set('key2', 42);
+        await memory.set('key3', { nested: 'object' });
+
+        expect(await memory.get('key1')).toBe('value1');
+        expect(await memory.get('key2')).toBe(42);
+        expect(await memory.get('key3')).toEqual({ nested: 'object' });
     });
 
     it('Should allow to set and get values', async () => {
-        const memory = new A_Memory<{ 
+        const memory = new A_Memory<{
             stringValue: string;
             numberValue: number;
             objectValue: { prop: string };
         }>();
-        
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
         await memory.set('stringValue', 'test string');
         await memory.set('numberValue', 123);
         await memory.set('objectValue', { prop: 'test' });
-        
-        expect(memory.get('stringValue')).toBe('test string');
-        expect(memory.get('numberValue')).toBe(123);
-        expect(memory.get('objectValue')).toEqual({ prop: 'test' });
+
+        expect(await memory.get('stringValue')).toBe('test string');
+        expect(await memory.get('numberValue')).toBe(123);
+        expect(await memory.get('objectValue')).toEqual({ prop: 'test' });
     });
 
-    it('Should return undefined for non-existent keys', () => {
+    it('Should return undefined for non-existent keys', async () => {
         const memory = new A_Memory<{ existingKey: string }>();
-        
-        expect(memory.get('existingKey')).toBeUndefined();
-        expect(memory.get('nonExistentKey' as any)).toBeUndefined();
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
+        expect(await memory.get('existingKey')).toBeUndefined();
+        expect(await memory.get('nonExistentKey' as any)).toBeUndefined();
     });
 
     it('Should allow to drop values', async () => {
         const memory = new A_Memory<{ key1: string; key2: number }>();
-        
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
         await memory.set('key1', 'value1');
         await memory.set('key2', 42);
-        
-        expect(memory.get('key1')).toBe('value1');
-        expect(memory.get('key2')).toBe(42);
-        
+
+        expect(await memory.get('key1')).toBe('value1');
+        expect(await memory.get('key2')).toBe(42);
+
         await memory.drop('key1');
-        
-        expect(memory.get('key1')).toBeUndefined();
-        expect(memory.get('key2')).toBe(42);
+
+        expect(await memory.get('key1')).toBeUndefined();
+        expect(await memory.get('key2')).toBe(42);
     });
 
     it('Should allow to clear all values', async () => {
         const memory = new A_Memory<{ key1: string; key2: number }>();
-        
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
         await memory.set('key1', 'value1');
         await memory.set('key2', 42);
-        
-        expect(memory.get('key1')).toBe('value1');
-        expect(memory.get('key2')).toBe(42);
-        
+
+        expect(await memory.get('key1')).toBe('value1');
+        expect(await memory.get('key2')).toBe(42);
+
         await memory.clear();
-        
-        expect(memory.get('key1')).toBeUndefined();
-        expect(memory.get('key2')).toBeUndefined();
+
+        expect(await memory.get('key1')).toBeUndefined();
+        expect(await memory.get('key2')).toBeUndefined();
     });
 
-    it('Should handle errors correctly', async () => {
-        const memory = new A_Memory();
-        
-        expect(memory.Errors).toBeUndefined();
-        
-        const error1 = new A_Error({ title: 'Error 1' });
-        const error2 = new A_Error({ title: 'Error 2' });
-        
-        await memory.error(error1);
-        await memory.error(error2);
-        
-        expect(memory.Errors).toBeDefined();
-        expect(memory.Errors?.size).toBe(2);
-        expect(memory.Errors?.has(error1)).toBe(true);
-        expect(memory.Errors?.has(error2)).toBe(true);
+    it('Should check if keys exist with has method', async () => {
+        const memory = new A_Memory<{ key1: string; key2: number }>();
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
+        // Initially, keys should not exist
+        expect(await memory.has('key1')).toBe(false);
+        expect(await memory.has('key2')).toBe(false);
+
+        // Set values
+        await memory.set('key1', 'value1');
+        await memory.set('key2', 42);
+
+        // Now keys should exist
+        expect(await memory.has('key1')).toBe(true);
+        expect(await memory.has('key2')).toBe(true);
+
+        // Drop one key
+        await memory.drop('key1');
+
+        // Should only have key2 now
+        expect(await memory.has('key1')).toBe(false);
+        expect(await memory.has('key2')).toBe(true);
     });
 
-    it('Should verify prerequisites correctly', async () => {
-        const memory = new A_Memory<{ 
-            required1: string;
-            required2: number;
-            optional?: string;
-        }>();
-        
-        // No values set initially
-        expect(await memory.prerequisites(['required1', 'required2'])).toBe(false);
-        
-        // Set one required value
-        await memory.set('required1', 'value1');
-        expect(await memory.prerequisites(['required1', 'required2'])).toBe(false);
-        
-        // Set both required values
-        await memory.set('required2', 42);
-        expect(await memory.prerequisites(['required1', 'required2'])).toBe(true);
+    it('Should destroy and reinitialize correctly', async () => {
+        const memory = new A_Memory<{ key1: string; key2: number }>();
+        A_Context.root.register(memory);
 
-        // Test with empty requirements
-        expect(await memory.prerequisites([])).toBe(true);
+        await memory.ready;
+
+        // Set some values
+        await memory.set('key1', 'value1');
+        await memory.set('key2', 42);
+
+        expect(await memory.get('key1')).toBe('value1');
+        expect(await memory.get('key2')).toBe(42);
+
+        // Destroy memory
+        await memory.destroy();
+
+        // Memory should be ready to reinitialize
+        await memory.ready;
+
+        // After reinitializing, values should be cleared
+        expect(await memory.get('key1')).toBeUndefined();
+        expect(await memory.get('key2')).toBeUndefined();
     });
 
-    it('Should serialize to JSON correctly', async () => {
-        const memory = new A_Memory<{
-            stringProp: string;
-            numberProp: number;
-            objectProp: { nested: string };
-            arrayProp: number[];
-        }>();
+    it('Should return undefined for toJSON when no serialization feature is implemented', async () => {
+        const memory = new A_Memory();
+        await A_Context.root.register(memory);
+        await memory.ready;
         
+        // Set some values
         await memory.set('stringProp', 'test');
         await memory.set('numberProp', 42);
         await memory.set('objectProp', { nested: 'value' });
         await memory.set('arrayProp', [1, 2, 3]);
-        
-        const json = memory.toJSON();
-        
-        expect(json).toEqual({
-            stringProp: 'test',
-            numberProp: 42,
-            objectProp: { nested: 'value' },
-            arrayProp: [1, 2, 3]
-        });
+
+        const json = await memory.toJSON();
+
+        // Since no onSerialize feature is implemented, toJSON returns undefined
+        expect(json).toBeUndefined();
     });
 
-    it('Should handle objects with toJSON method in serialization', async () => {
+    it('Should return undefined for toJSON when no serialization feature is implemented (with complex objects)', async () => {
         class SerializableObject {
-            constructor(private value: string) {}
-            
+            constructor(private value: string) { }
+
             toJSON() {
                 return { serialized: this.value };
             }
         }
-        
+
         const memory = new A_Memory<{
             regular: string;
             serializable: SerializableObject;
         }>();
-        
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
         await memory.set('regular', 'normal value');
         await memory.set('serializable', new SerializableObject('test'));
-        
-        const json = memory.toJSON();
-        
-        expect(json).toEqual({
-            regular: 'normal value',
-            serializable: { serialized: 'test' }
-        });
+
+        const json = await memory.toJSON();
+
+        // Since no onSerialize feature is implemented, toJSON returns undefined
+        expect(json).toBeUndefined();
     });
 
     it('Should handle null and undefined values correctly', async () => {
@@ -172,18 +206,20 @@ describe('A-Memory tests', () => {
             undefinedValue: undefined;
             stringValue: string;
         }>();
-        
+        A_Context.root.register(memory);
+
+        await memory.ready;
+
         await memory.set('nullValue', null);
         await memory.set('undefinedValue', undefined);
         await memory.set('stringValue', 'test');
-        
-        expect(memory.get('nullValue')).toBe(null);
-        expect(memory.get('undefinedValue')).toBe(undefined);
-        expect(memory.get('stringValue')).toBe('test');
-        
-        const json = memory.toJSON();
-        expect(json.nullValue).toBe(null);
-        expect(json.undefinedValue).toBe(undefined);
-        expect(json.stringValue).toBe('test');
+
+        expect(await memory.get('nullValue')).toBe(null);
+        expect(await memory.get('undefinedValue')).toBe(undefined);
+        expect(await memory.get('stringValue')).toBe('test');
+
+        const json = await memory.toJSON();
+        // Since no onSerialize feature is implemented, toJSON returns undefined
+        expect(json).toBeUndefined();
     });
 });

package/tests/A-Schedule.test.ts

@@ -21,7 +21,7 @@ describe('A-Schedule Tests', () => {
             components: [A_Schedule]
         });
 
-        const schedule = testScope.resolve(A_Schedule);
+        const schedule = testScope.resolve(A_Schedule)!;
 
         const start = Date.now();
         let res = '';
@@ -53,7 +53,7 @@ describe('A-Schedule Tests', () => {
             components: [A_Schedule]
         });
 
-        const schedule = testScope.resolve(A_Schedule);
+        const schedule = testScope.resolve(A_Schedule)!;
 
         expect(schedule).toBeInstanceOf(A_Schedule);