test(manager): add tests for manager assignment and propagation

tests/unit/manager.test.ts

@@ -1,7 +1,9 @@
 import {expect, jest, test} from '@jest/globals';
 import { Manager } from '../../src/manager';
 import { Logger, RootLogger } from '../../src/logger';
-import { WARNING, DEBUG, NOTSET } from '../../src/log-level';
+import { Handler } from '../../src/handler';
+import { LogRecord } from '../../src/log-record';
+import { WARNING, DEBUG, INFO, NOTSET } from '../../src/log-level';
 
 function makeManager(): Manager {
     return new Manager(new RootLogger(WARNING));
@@ -117,6 +119,79 @@ describe('Manager', () => {
         });
     });
 
+    describe('getLogger - manager assignment', () => {
+        test('sets manager on newly created loggers', () => {
+            const manager = makeManager();
+            const logger = manager.getLogger('app');
+            expect(logger.manager).toBe(manager);
+        });
+
+        test('sets manager on loggers created from placeholders', () => {
+            const manager = makeManager();
+            manager.getLogger('a.b.c');
+            const mid = manager.getLogger('a.b');
+            expect(mid.manager).toBe(manager);
+        });
+
+        test('isEnabledFor respects manager.disable via getLogger', () => {
+            const manager = makeManager();
+            const logger = manager.getLogger('app');
+            logger.setLevel(DEBUG);
+
+            expect(logger.isEnabledFor(DEBUG)).toBe(true);
+
+            manager.disable = WARNING;
+            logger.clear();
+
+            expect(logger.isEnabledFor(DEBUG)).toBe(false);
+            expect(logger.isEnabledFor(WARNING)).toBe(false);
+        });
+    });
+
+    describe('propagation through hierarchy', () => {
+        test('child logger propagates records to parent handler', () => {
+            const manager = makeManager();
+            const parent = manager.getLogger('app');
+            const child = manager.getLogger('app.module');
+
+            parent.setLevel(DEBUG);
+            child.setLevel(DEBUG);
+
+            const emitted: string[] = [];
+            const handler = new (class extends Handler {
+                emit(record: LogRecord) {
+                    emitted.push(record.msg);
+                }
+            })(DEBUG);
+
+            parent.addHandler(handler);
+            child.info('propagated message');
+
+            expect(emitted).toContain('propagated message');
+        });
+
+        test('child does not propagate to unrelated logger', () => {
+            const manager = makeManager();
+            const unrelated = manager.getLogger('other');
+            const child = manager.getLogger('app.module');
+
+            unrelated.setLevel(DEBUG);
+            child.setLevel(DEBUG);
+
+            const emitted: string[] = [];
+            const handler = new (class extends Handler {
+                emit(record: LogRecord) {
+                    emitted.push(record.msg);
+                }
+            })(DEBUG);
+
+            unrelated.addHandler(handler);
+            child.info('should not reach');
+
+            expect(emitted).not.toContain('should not reach');
+        });
+    });
+
     describe('clear', () => {
         test('clears logger caches', () => {
             const manager = makeManager();
@@ -124,5 +199,11 @@ describe('Manager', () => {
             logger.isEnabledFor(DEBUG);
             manager.clear();
         });
+
+        test('does not throw when placeholders exist', () => {
+            const manager = makeManager();
+            manager.getLogger('a.b.c');
+            expect(() => manager.clear()).not.toThrow();
+        });
     });
 });