added missing test

Author: mertcanaltin

test/parallel/test-log-basic.js

@@ -463,6 +463,97 @@ describe('multiple consumers', () => {
   });
 });
 
+describe('LogConsumer level enabled getter', () => {
+  it('should have enabled property for each level', () => {
+    const consumer = new LogConsumer({ level: 'warn' });
+    assert.strictEqual(consumer.trace.enabled, false);
+    assert.strictEqual(consumer.debug.enabled, false);
+    assert.strictEqual(consumer.info.enabled, false);
+    assert.strictEqual(consumer.warn.enabled, true);
+    assert.strictEqual(consumer.error.enabled, true);
+    assert.strictEqual(consumer.fatal.enabled, true);
+  });
+
+  it('should have all levels enabled when level is trace', () => {
+    const consumer = new LogConsumer({ level: 'trace' });
+    assert.strictEqual(consumer.trace.enabled, true);
+    assert.strictEqual(consumer.debug.enabled, true);
+    assert.strictEqual(consumer.info.enabled, true);
+    assert.strictEqual(consumer.warn.enabled, true);
+    assert.strictEqual(consumer.error.enabled, true);
+    assert.strictEqual(consumer.fatal.enabled, true);
+  });
+
+  it('should have only fatal enabled when level is fatal', () => {
+    const consumer = new LogConsumer({ level: 'fatal' });
+    assert.strictEqual(consumer.trace.enabled, false);
+    assert.strictEqual(consumer.debug.enabled, false);
+    assert.strictEqual(consumer.info.enabled, false);
+    assert.strictEqual(consumer.warn.enabled, false);
+    assert.strictEqual(consumer.error.enabled, false);
+    assert.strictEqual(consumer.fatal.enabled, true);
+  });
+});
+
+describe('JSONConsumer stream options', () => {
+  it('should accept a writable stream object', () => {
+    const stream = new TestStream();
+    const consumer = new JSONConsumer({ stream, level: 'info' });
+    consumer.attach();
+    const logger = new Logger({ level: 'info' });
+
+    logger.info('stream object test');
+    consumer.flushSync();
+
+    assert.strictEqual(stream.logs.length, 1);
+    assert.strictEqual(stream.logs[0].msg, 'stream object test');
+  });
+
+  it('should throw for invalid stream type', () => {
+    assert.throws(() => {
+      new JSONConsumer({ stream: true, level: 'info' });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+  });
+
+  it('should accept a file descriptor number', () => {
+    // fd 1 is stdout - just verify no throw on construction
+    const consumer = new JSONConsumer({ stream: 1, level: 'info' });
+    assert.ok(consumer);
+  });
+
+  it('should throw for invalid consumer level', () => {
+    assert.throws(() => {
+      new JSONConsumer({ level: 'invalid' });
+    }, {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+  });
+});
+
+describe('JSONConsumer flush and end', () => {
+  it('should call flush with callback', (_, done) => {
+    const stream = new TestStream();
+    const consumer = new JSONConsumer({ stream, level: 'info' });
+    consumer.flush(() => {
+      done();
+    });
+  });
+
+  it('should call flushSync without error', () => {
+    const stream = new TestStream();
+    const consumer = new JSONConsumer({ stream, level: 'info' });
+    consumer.flushSync();
+  });
+
+  it('should call end without error', () => {
+    const stream = new TestStream();
+    const consumer = new JSONConsumer({ stream, level: 'info' });
+    consumer.end();
+  });
+});
+
 describe('channels export', () => {
   it('should export channel objects for all levels', () => {
     assert.strictEqual(typeof channels, 'object');

test/parallel/test-logger-serializers.js

@@ -177,6 +177,48 @@ describe('Logger serializers', () => {
       assert.strictEqual(log.err.cause.message, 'Root cause');
       assert.ok(log.err.cause.stack);
     });
+
+    it('should handle circular error cause', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      const logger = new Logger({ level: 'info' });
+
+      const error = new Error('Circular error');
+      error.cause = error; // Self-referencing cause
+
+      logger.error(error);
+      consumer.flushSync();
+
+      const log = stream.logs[0];
+      assert.strictEqual(log.err.message, 'Circular error');
+      assert.strictEqual(log.err.cause, '[Circular]');
+    });
+
+    it('should handle deeply nested circular error causes', () => {
+      const stream = new TestStream();
+      const consumer = new JSONConsumer({ stream, level: 'info' });
+      consumer.attach();
+
+      const logger = new Logger({ level: 'info' });
+
+      const err1 = new Error('Error 1');
+      const err2 = new Error('Error 2');
+      const err3 = new Error('Error 3');
+      err1.cause = err2;
+      err2.cause = err3;
+      err3.cause = err1; // Circular back to err1
+
+      logger.error(err1);
+      consumer.flushSync();
+
+      const log = stream.logs[0];
+      assert.strictEqual(log.err.message, 'Error 1');
+      assert.strictEqual(log.err.cause.message, 'Error 2');
+      assert.strictEqual(log.err.cause.cause.message, 'Error 3');
+      assert.strictEqual(log.err.cause.cause.cause, '[Circular]');
+    });
   });
 
   describe('serializer with fields parameter', () => {