Add common helpers to manage configuration and logging

Author: kzu

src/AI.Tests/Extensions/Attributes.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Configuration;
+using Xunit;
+
+namespace Xunit;
+
+public class SecretsFactAttribute : FactAttribute
+{
+    public static IConfiguration Configuration { get; set; } = new ConfigurationBuilder()
+        .AddEnvironmentVariables()
+        .AddUserSecrets<SecretsFactAttribute>()
+        .Build();
+
+    public SecretsFactAttribute(params string[] secrets)
+    {
+        var missing = new HashSet<string>();
+
+        foreach (var secret in secrets)
+        {
+            if (string.IsNullOrEmpty(Configuration[secret]))
+                missing.Add(secret);
+        }
+
+        if (missing.Count > 0)
+            Skip = "Missing user secrets: " + string.Join(',', missing);
+    }
+}
+
+public class LocalFactAttribute : SecretsFactAttribute
+{
+    public LocalFactAttribute(params string[] secrets) : base(secrets)
+    {
+        if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
+            Skip = "Non-CI test";
+    }
+}
+
+public class CIFactAttribute : FactAttribute
+{
+    public CIFactAttribute()
+    {
+        if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
+            Skip = "CI-only test";
+    }
+}
+
+public class SecretsTheoryAttribute : TheoryAttribute
+{
+    public SecretsTheoryAttribute(params string[] secrets)
+    {
+        var missing = new HashSet<string>();
+
+        foreach (var secret in secrets)
+        {
+            if (string.IsNullOrEmpty(SecretsFactAttribute.Configuration[secret]))
+                missing.Add(secret);
+        }
+
+        if (missing.Count > 0)
+            Skip = "Missing user secrets: " + string.Join(',', missing);
+    }
+}
+
+public class LocalTheoryAttribute : SecretsTheoryAttribute
+{
+    public LocalTheoryAttribute(params string[] secrets) : base(secrets)
+    {
+        if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
+            Skip = "Non-CI test";
+    }
+}
+
+public class CITheoryAttribute : SecretsTheoryAttribute
+{
+    public CITheoryAttribute(params string[] secrets) : base(secrets)
+    {
+        if (string.IsNullOrEmpty(Environment.GetEnvironmentVariable("CI")))
+            Skip = "CI-only test";
+    }
+}
+
+public class DebuggerFactAttribute : FactAttribute
+{
+    public DebuggerFactAttribute()
+    {
+        if (!System.Diagnostics.Debugger.IsAttached)
+            Skip = "Only running in the debugger";
+    }
+}
+
+public class DebuggerTheoryAttribute : TheoryAttribute
+{
+    public DebuggerTheoryAttribute()
+    {
+        if (!System.Diagnostics.Debugger.IsAttached)
+            Skip = "Only running in the debugger";
+    }
+}

src/AI.Tests/Extensions/Configuration.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+public static class ConfigurationExtensions
+{
+    public static IConfiguration Configuration { get; } = new ConfigurationBuilder()
+        .AddEnvironmentVariables()
+        .AddUserSecrets(Assembly.GetExecutingAssembly())
+        .Build();
+
+    public static TOptions GetOptions<TOptions>(this IConfiguration configuration, string name)
+        where TOptions : class, new()
+        => new ServiceCollection()
+            .Configure<TOptions>(configuration.GetSection(name))
+            .BuildServiceProvider()
+            .GetRequiredService<IOptions<TOptions>>()
+            .Value;
+
+    public static TOptions GetOptions<TOptions>(this IConfiguration configuration)
+        where TOptions : class, new()
+    {
+        var name = typeof(TOptions).Name;
+        if (name.EndsWith("Options"))
+            return configuration.GetOptions<TOptions>(name[..^7]);
+
+        return configuration.GetOptions<TOptions>(name);
+    }
+}

src/AI.Tests/Extensions/LoggerFactory.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+public static class LoggerFactoryExtensions
+{
+    public static ILoggerFactory AsLoggerFactory(this ITestOutputHelper output) => new LoggerFactory(output);
+}
+
+public class LoggerFactory(ITestOutputHelper output) : ILoggerFactory
+{
+    public ILogger CreateLogger(string categoryName) => new TestOutputLogger(output, categoryName);
+    public void AddProvider(ILoggerProvider provider) { }
+    public void Dispose() { }
+
+    // create ilogger implementation over testoutputhelper
+    public class TestOutputLogger(ITestOutputHelper output, string categoryName) : ILogger
+    {
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null!;
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            if (formatter == null) throw new ArgumentNullException(nameof(formatter));
+            if (state == null) throw new ArgumentNullException(nameof(state));
+            output.WriteLine($"{logLevel}: {categoryName}: {formatter(state, exception)}");
+        }
+    }
+}

src/AI.Tests/OpenAIOptions.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Devlooped.Extensions.AI;
+
+record OpenAIOptions(string Key, string[] Vectors)
+{
+    public static OpenAIOptions Empty { get; } = new();
+
+    public OpenAIOptions() : this("", []) { }
+}