d-logger/test/logger.util-format.test.js

import { assertEquals, assertMatch } from "@std/assert";
import Logger from '../lib/logger.ts';

Deno.test("Logger util.format functionality - Format specifiers - should handle %s string formatting", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('User %s logged in', 'john');

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'User john logged in');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Format specifiers - should handle %d number formatting", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('User has %d points', 100);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'User has 100 points');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Format specifiers - should handle %i integer formatting", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Value: %i', 42.7);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Value: 42');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Format specifiers - should handle %f float formatting", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Price: %f', 19.99);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Price: 19.99');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Format specifiers - should handle %j JSON formatting", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const obj = { name: 'test', value: 42 };
    logger.info('Config: %j', obj);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Config: {"name":"test","value":42}');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Format specifiers - should handle %% literal percentage", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Progress: 50%% complete');

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Progress: 50%% complete');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Multiple format specifiers - should handle multiple format specifiers", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info(
      'User %s has %d points and %f%% completion',
      'alice',
      150,
      75.5
    );

    const output = JSON.parse(capturedOutput);
    assertEquals(
      output.msg,
      'User alice has 150 points and 75.5% completion'
    );
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Multiple format specifiers - should handle mixed format specifiers with JSON", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const config = { debug: true, port: 3000 };
    logger.info(
      'Server %s running on port %d with config %j',
      'api',
      8080,
      config
    );

    const output = JSON.parse(capturedOutput);
    assertEquals(
      output.msg,
      'Server api running on port 8080 with config {"debug":true,"port":3000}'
    );
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Multiple arguments without format specifiers - should handle multiple arguments without format specifiers", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Message', 'arg1', 'arg2', 123);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Message arg1 arg2 123');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Multiple arguments without format specifiers - should handle mixed objects and primitives", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const obj = { key: 'value' };
    logger.info('Data:', obj, 42, true);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, "Data: { key: 'value' } 42 true");
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Edge cases - should handle more format specifiers than arguments", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Hello %s, you are %d years old', 'John');

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Hello John, you are %d years old');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Edge cases - should handle more arguments than format specifiers", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Hello %s', 'John', 'extra', 'args', 123);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Hello John extra args 123');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Edge cases - should handle null and undefined values", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    logger.info('Values: %s %s %d', null, undefined, null);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Values: null undefined 0');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Edge cases - should handle arrays and objects without %j", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const arr = [1, 2, 3];
    const obj = { a: 1 };
    logger.info('Data %s and %s', arr, obj);

    const output = JSON.parse(capturedOutput);
    assertEquals(output.msg, 'Data [ 1, 2, 3 ] and { a: 1 }');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Simple format output - should format messages correctly in simple format", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'simple' });
    logger.info('User %s has %d points', 'bob', 200);

    assertMatch(capturedOutput, /User bob has 200 points/);
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Simple format output - should handle JSON formatting in simple format", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'simple' });
    const data = { status: 'active', count: 5 };
    logger.warn('Status: %j', data);

    assertMatch(capturedOutput, /Status: {"status":"active","count":5}/);
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Error handling in util.format - should handle objects that throw during toString", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const problematicObj = {
      toString() {
        throw new Error('toString failed');
      },
    };

    // The logger might handle the error gracefully, so let's test the actual output
    logger.info('Object: %s', problematicObj);

    // Check that something was logged (the logger should handle the error)
    const output = JSON.parse(capturedOutput);
    assertEquals(typeof output.msg, 'string');
  } finally {
    console.log = originalLog;
  }
});

Deno.test("Logger util.format functionality - Error handling in util.format - should handle circular references with %j", () => {
  let capturedOutput = '';
  const originalLog = console.log;
  console.log = (message) => {
    capturedOutput = message;
  };

  try {
    const logger = new Logger({ format: 'json' });
    const circular = { name: 'test' };
    circular.self = circular;

    logger.info('Circular: %j', circular);

    const output = JSON.parse(capturedOutput);
    assertMatch(output.msg, /Circular: \[Circular\]/);
  } finally {
    console.log = originalLog;
  }
});