sharp-basic/test/Log.Test/Test1.cs

using System.Text;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Sharp.Log.Extensions;
using Sharp.Log.Middleware;

namespace Log.Test;

[TestClass]
public sealed class Test1
{
    [TestMethod]
    public async Task Logging_Default_Writes_File()
    {
        var temp = CreateTempDir();
        var host = Host.CreateDefaultBuilder()
            .ConfigureLogging(b =>
            {
                b.ClearProviders();
                b.AddSharpLog(opt =>
                {
                    opt.UseConsole = false;
                    opt.File.Path = Path.Combine(temp, "default-.log");
                    opt.File.Json = false;
                });
            })
            .Build();

        var logger = host.Services.GetRequiredService<ILogger<Test1>>();
        const string message = "Hello_Default_File";
        logger.LogInformation("{Msg}", message);

        await host.StopAsync();
        host.Dispose();

        var file = AwaitLatestLogFile(temp, "default-");
        Assert.IsNotNull(file, "log file not created");
        var text = File.ReadAllText(file!, Encoding.UTF8);
        StringAssert.Contains(text, message);
    }

    [TestMethod]
    public async Task Logging_Respects_MinLevel_Override()
    {
        var temp = CreateTempDir();
        var host = Host.CreateDefaultBuilder()
            .ConfigureLogging(b =>
            {
                b.ClearProviders();
                b.AddSharpLog(opt =>
                {
                    opt.UseConsole = false;
                    opt.MinLevel = LogLevel.Error;
                    opt.File.Path = Path.Combine(temp, "level-.log");
                    opt.File.Json = false;
                });
            })
            .Build();

        var logger = host.Services.GetRequiredService<ILogger<Test1>>();
        const string shouldNot = "ShouldNotLog_Info";
        const string should = "ShouldLog_Error";
        logger.LogInformation("{Msg}", shouldNot);
        logger.LogError("{Msg}", should);

        await host.StopAsync();
        host.Dispose();

        var file = AwaitLatestLogFile(temp, "level-");
        Assert.IsNotNull(file, "log file not created");
        var text = File.ReadAllText(file!, Encoding.UTF8);
        StringAssert.Contains(text, should);
        Assert.IsFalse(text.Contains(shouldNot));
    }

    [TestMethod]
    public async Task Middleware_Logs_Request()
    {
        var temp = CreateTempDir();

        var builder = WebApplication.CreateBuilder();
        builder.WebHost.UseTestServer();
        builder.Logging.ClearProviders();
        builder.Logging.AddSharpLog(opt =>
        {
            opt.UseConsole = false;
            opt.File.Path = Path.Combine(temp, "mw-.log");
            opt.File.Json = false;
        });

        var app = builder.Build();
        app.UseSharpRequestLogging();
        app.MapGet("/", () => Results.Ok("ok"));

        await app.StartAsync();
        var client = app.GetTestClient();
        var res = await client.GetAsync("/");
        res.EnsureSuccessStatusCode();
        await app.StopAsync();
        await app.DisposeAsync();

        var file = AwaitLatestLogFile(temp, "mw-");
        Assert.IsNotNull(file, "log file not created");
        var text = File.ReadAllText(file!, Encoding.UTF8);
        StringAssert.Contains(text, "HTTP GET /");
    }

    private static string CreateTempDir()
    {
        var path = Path.Combine(Path.GetTempPath(), "SharpLogTests", Guid.NewGuid().ToString("n"));
        Directory.CreateDirectory(path);
        return path;
    }

    private static string? AwaitLatestLogFile(string dir, string prefix)
    {
        var sw = System.Diagnostics.Stopwatch.StartNew();
        string? found = null;
        while (sw.ElapsedMilliseconds < 3000)
        {
            var files = Directory.Exists(dir)
                ? Directory.GetFiles(dir, prefix + "*.log").OrderByDescending(f => f).ToArray()
                : Array.Empty<string>();
            if (files.Length > 0)
            {
                found = files[0];
                break;
            }

            Thread.Sleep(50);
        }

        return found;
    }
}