551 lines
23 KiB
C#
551 lines
23 KiB
C#
using ChatBot.Data;
|
|
using ChatBot.Data.Interfaces;
|
|
using ChatBot.Data.Repositories;
|
|
using ChatBot.Models.Configuration;
|
|
using ChatBot.Models.Configuration.Validators;
|
|
using ChatBot.Services;
|
|
using ChatBot.Services.Interfaces;
|
|
using ChatBot.Services.Telegram.Commands;
|
|
using ChatBot.Services.Telegram.Interfaces;
|
|
using ChatBot.Services.Telegram.Services;
|
|
using ChatBot.Tests.TestUtilities;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Diagnostics.HealthChecks;
|
|
using Microsoft.Extensions.Hosting;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Microsoft.Extensions.Options;
|
|
using Moq;
|
|
using Telegram.Bot;
|
|
|
|
namespace ChatBot.Tests.Integration;
|
|
|
|
public class ProgramIntegrationTests : TestBase
|
|
{
|
|
protected override void ConfigureServices(IServiceCollection services)
|
|
{
|
|
// Add configuration
|
|
var configuration = new ConfigurationBuilder()
|
|
.AddInMemoryCollection(
|
|
new Dictionary<string, string?>
|
|
{
|
|
["TelegramBot:BotToken"] = "test_token",
|
|
["Ollama:Url"] = "http://localhost:11434",
|
|
["Ollama:DefaultModel"] = "llama2",
|
|
["AI:MaxTokens"] = "1000",
|
|
["AI:Temperature"] = "0.7",
|
|
["Database:ConnectionString"] =
|
|
"Host=localhost;Port=5432;Database=test_chatbot;Username=postgres;Password=postgres",
|
|
["Database:CommandTimeout"] = "30",
|
|
["Database:EnableSensitiveDataLogging"] = "false",
|
|
}
|
|
)
|
|
.Build();
|
|
|
|
services.AddSingleton<IConfiguration>(configuration);
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
services.AddSingleton(typeof(ILogger<>), typeof(NullLogger<>));
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
services.AddLogging(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Debug));
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_SuccessfulConfigurationPipeline_ShouldBuildAndValidate()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
|
|
var configuration = new ConfigurationBuilder()
|
|
.AddInMemoryCollection(
|
|
new Dictionary<string, string?>
|
|
{
|
|
["TelegramBot:BotToken"] = "1234567890123456789012345678901234567890",
|
|
["Ollama:Url"] = "http://localhost:11434",
|
|
["Ollama:DefaultModel"] = "llama3",
|
|
["AI:CompressionThreshold"] = "100",
|
|
["Database:ConnectionString"] =
|
|
"Host=localhost;Port=5432;Database=test;Username=test;Password=test",
|
|
["Database:CommandTimeout"] = "30",
|
|
["Database:EnableSensitiveDataLogging"] = "false",
|
|
}
|
|
)
|
|
.Build();
|
|
|
|
services.AddSingleton<IConfiguration>(configuration);
|
|
services.AddLogging(builder => builder.AddDebug());
|
|
|
|
// Configure options and validators similar to Program.cs
|
|
services.Configure<TelegramBotSettings>(configuration.GetSection("TelegramBot"));
|
|
services.AddSingleton<
|
|
IValidateOptions<TelegramBotSettings>,
|
|
TelegramBotSettingsValidator
|
|
>();
|
|
|
|
services.Configure<OllamaSettings>(configuration.GetSection("Ollama"));
|
|
services.AddSingleton<IValidateOptions<OllamaSettings>, OllamaSettingsValidator>();
|
|
|
|
services.Configure<AISettings>(configuration.GetSection("AI"));
|
|
services.AddSingleton<IValidateOptions<AISettings>, AISettingsValidator>();
|
|
|
|
services.Configure<DatabaseSettings>(configuration.GetSection("Database"));
|
|
services.AddSingleton<IValidateOptions<DatabaseSettings>, DatabaseSettingsValidator>();
|
|
|
|
// Register health checks similar to Program.cs
|
|
services
|
|
.AddHealthChecks()
|
|
.AddCheck<ChatBot.Services.HealthChecks.OllamaHealthCheck>("ollama")
|
|
.AddCheck<ChatBot.Services.HealthChecks.TelegramBotHealthCheck>("telegram");
|
|
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
|
|
// Act & Assert - validate options using validators
|
|
var telegramValidator = serviceProvider.GetRequiredService<
|
|
IValidateOptions<TelegramBotSettings>
|
|
>();
|
|
var ollamaValidator = serviceProvider.GetRequiredService<
|
|
IValidateOptions<OllamaSettings>
|
|
>();
|
|
var aiValidator = serviceProvider.GetRequiredService<IValidateOptions<AISettings>>();
|
|
var dbValidator = serviceProvider.GetRequiredService<IValidateOptions<DatabaseSettings>>();
|
|
|
|
var telegram = serviceProvider.GetRequiredService<IOptions<TelegramBotSettings>>().Value;
|
|
var ollama = serviceProvider.GetRequiredService<IOptions<OllamaSettings>>().Value;
|
|
var ai = serviceProvider.GetRequiredService<IOptions<AISettings>>().Value;
|
|
var db = serviceProvider.GetRequiredService<IOptions<DatabaseSettings>>().Value;
|
|
|
|
Assert.True(telegramValidator.Validate("TelegramBot", telegram).Succeeded);
|
|
Assert.True(ollamaValidator.Validate("Ollama", ollama).Succeeded);
|
|
Assert.True(aiValidator.Validate("AI", ai).Succeeded);
|
|
Assert.True(dbValidator.Validate("Database", db).Succeeded);
|
|
|
|
// Assert health checks are registered
|
|
var hcOptions = serviceProvider
|
|
.GetRequiredService<IOptions<HealthCheckServiceOptions>>()
|
|
.Value;
|
|
var registrations = hcOptions.Registrations.Select(r => r.Name).ToList();
|
|
Assert.Contains("ollama", registrations);
|
|
Assert.Contains("telegram", registrations);
|
|
}
|
|
|
|
[Fact]
|
|
public void ServiceRegistrations_ShouldIncludeCoreServicesAndHealthCheckTags()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
|
|
var configuration = new ConfigurationBuilder()
|
|
.AddInMemoryCollection(
|
|
new Dictionary<string, string?>
|
|
{
|
|
["TelegramBot:BotToken"] = "1234567890123456789012345678901234567890",
|
|
["Ollama:Url"] = "http://localhost:11434",
|
|
["Ollama:DefaultModel"] = "llama3",
|
|
["AI:CompressionThreshold"] = "100",
|
|
["Database:ConnectionString"] =
|
|
"Host=localhost;Port=5432;Database=test;Username=test;Password=test",
|
|
["Database:CommandTimeout"] = "30",
|
|
["Database:EnableSensitiveDataLogging"] = "false",
|
|
}
|
|
)
|
|
.Build();
|
|
|
|
services.AddSingleton<IConfiguration>(configuration);
|
|
|
|
// Options + validators
|
|
services.Configure<TelegramBotSettings>(configuration.GetSection("TelegramBot"));
|
|
services.AddSingleton<
|
|
IValidateOptions<TelegramBotSettings>,
|
|
TelegramBotSettingsValidator
|
|
>();
|
|
|
|
services.Configure<OllamaSettings>(configuration.GetSection("Ollama"));
|
|
services.AddSingleton<IValidateOptions<OllamaSettings>, OllamaSettingsValidator>();
|
|
|
|
services.Configure<AISettings>(configuration.GetSection("AI"));
|
|
services.AddSingleton<IValidateOptions<AISettings>, AISettingsValidator>();
|
|
|
|
services.Configure<DatabaseSettings>(configuration.GetSection("Database"));
|
|
services.AddSingleton<IValidateOptions<DatabaseSettings>, DatabaseSettingsValidator>();
|
|
|
|
// DbContext (in-memory for test)
|
|
services.AddDbContext<ChatBotDbContext>(options => options.UseInMemoryDatabase("test-db"));
|
|
|
|
// Repository and session storage
|
|
services.AddSingleton<ILogger<ChatSessionRepository>>(_ =>
|
|
NullLogger<ChatSessionRepository>.Instance
|
|
);
|
|
services.AddScoped<IChatSessionRepository, ChatSessionRepository>();
|
|
services.AddSingleton<ILogger<DatabaseSessionStorage>>(_ =>
|
|
NullLogger<DatabaseSessionStorage>.Instance
|
|
);
|
|
services.AddScoped<ISessionStorage, DatabaseSessionStorage>();
|
|
|
|
// Core services
|
|
services.AddSingleton<ILogger<ModelService>>(_ => NullLogger<ModelService>.Instance);
|
|
services.AddSingleton<ModelService>();
|
|
services.AddSingleton<ILogger<SystemPromptService>>(_ =>
|
|
NullLogger<SystemPromptService>.Instance
|
|
);
|
|
services.AddSingleton<SystemPromptService>();
|
|
services.AddSingleton<IHistoryCompressionService, HistoryCompressionService>();
|
|
services.AddSingleton<ILogger<HistoryCompressionService>>(_ =>
|
|
NullLogger<HistoryCompressionService>.Instance
|
|
);
|
|
services.AddSingleton<ILogger<AIService>>(_ => NullLogger<AIService>.Instance);
|
|
services.AddSingleton<IAIService, AIService>();
|
|
services.AddSingleton<ILogger<ChatService>>(_ => NullLogger<ChatService>.Instance);
|
|
services.AddScoped<ChatService>();
|
|
|
|
// IOllamaClient
|
|
services.AddSingleton<IOllamaClient>(sp =>
|
|
{
|
|
var opts = sp.GetRequiredService<IOptions<OllamaSettings>>();
|
|
return new OllamaClientAdapter(opts.Value.Url);
|
|
});
|
|
|
|
// Telegram services and commands
|
|
services.AddSingleton<ITelegramBotClient>(_ => new Mock<ITelegramBotClient>().Object);
|
|
services.AddSingleton<ILogger<TelegramMessageSender>>(_ =>
|
|
NullLogger<TelegramMessageSender>.Instance
|
|
);
|
|
services.AddSingleton<ITelegramMessageSenderWrapper>(_ =>
|
|
new Mock<ITelegramMessageSenderWrapper>().Object
|
|
);
|
|
services.AddSingleton<ITelegramMessageSender, TelegramMessageSender>();
|
|
services.AddSingleton<ILogger<TelegramErrorHandler>>(_ =>
|
|
NullLogger<TelegramErrorHandler>.Instance
|
|
);
|
|
services.AddSingleton<ITelegramErrorHandler, TelegramErrorHandler>();
|
|
services.AddSingleton<ILogger<CommandRegistry>>(_ => NullLogger<CommandRegistry>.Instance);
|
|
services.AddScoped<CommandRegistry>();
|
|
services.AddSingleton<ILogger<BotInfoService>>(_ => NullLogger<BotInfoService>.Instance);
|
|
services.AddSingleton<BotInfoService>();
|
|
services.AddSingleton<ILogger<TelegramCommandProcessor>>(_ =>
|
|
NullLogger<TelegramCommandProcessor>.Instance
|
|
);
|
|
services.AddScoped<ITelegramCommandProcessor, TelegramCommandProcessor>();
|
|
services.AddSingleton<ILogger<TelegramMessageHandler>>(_ =>
|
|
NullLogger<TelegramMessageHandler>.Instance
|
|
);
|
|
services.AddScoped<ITelegramMessageHandler, TelegramMessageHandler>();
|
|
services.AddScoped<ITelegramCommand, StartCommand>();
|
|
services.AddScoped<ITelegramCommand, HelpCommand>();
|
|
services.AddScoped<ITelegramCommand, ClearCommand>();
|
|
services.AddScoped<ITelegramCommand, SettingsCommand>();
|
|
services.AddScoped<ITelegramCommand, StatusCommand>();
|
|
|
|
// Hosted service simulation for Telegram bot service
|
|
services.AddSingleton<ILogger<TelegramBotService>>(_ =>
|
|
NullLogger<TelegramBotService>.Instance
|
|
);
|
|
services.AddSingleton<ITelegramBotService, TelegramBotService>();
|
|
services.AddSingleton<IHostedService>(sp =>
|
|
(IHostedService)sp.GetRequiredService<ITelegramBotService>()
|
|
);
|
|
|
|
// Simulate HealthCheck registrations via options to avoid bringing in DefaultHealthCheckService
|
|
var hcOptions = new HealthCheckServiceOptions();
|
|
hcOptions.Registrations.Add(
|
|
new HealthCheckRegistration(
|
|
"ollama",
|
|
sp => new Mock<IHealthCheck>().Object,
|
|
null,
|
|
new[] { "api", "ollama" }
|
|
)
|
|
);
|
|
hcOptions.Registrations.Add(
|
|
new HealthCheckRegistration(
|
|
"telegram",
|
|
sp => new Mock<IHealthCheck>().Object,
|
|
null,
|
|
new[] { "api", "telegram" }
|
|
)
|
|
);
|
|
services.AddSingleton<IOptions<HealthCheckServiceOptions>>(Options.Create(hcOptions));
|
|
|
|
// ILogger for health checks is provided by AddLogging above; no direct registration for internal types
|
|
|
|
var sp = services.BuildServiceProvider();
|
|
|
|
// Assert: core services can be resolved
|
|
Assert.NotNull(sp.GetRequiredService<ChatBotDbContext>());
|
|
Assert.NotNull(sp.GetRequiredService<IChatSessionRepository>());
|
|
Assert.NotNull(sp.GetRequiredService<ISessionStorage>());
|
|
Assert.NotNull(sp.GetRequiredService<ModelService>());
|
|
Assert.NotNull(sp.GetRequiredService<SystemPromptService>());
|
|
Assert.NotNull(sp.GetRequiredService<IHistoryCompressionService>());
|
|
Assert.NotNull(sp.GetRequiredService<IAIService>());
|
|
Assert.NotNull(sp.GetRequiredService<ChatService>());
|
|
Assert.NotNull(sp.GetRequiredService<IOllamaClient>());
|
|
|
|
// Assert: Telegram stack resolves
|
|
Assert.NotNull(sp.GetRequiredService<ITelegramBotClient>());
|
|
Assert.NotNull(sp.GetRequiredService<ITelegramMessageSender>());
|
|
Assert.NotNull(sp.GetRequiredService<ITelegramErrorHandler>());
|
|
Assert.NotNull(sp.GetRequiredService<ITelegramCommandProcessor>());
|
|
Assert.NotNull(sp.GetRequiredService<ITelegramMessageHandler>());
|
|
Assert.NotEmpty(sp.GetServices<ITelegramCommand>());
|
|
Assert.NotNull(sp.GetRequiredService<IHostedService>());
|
|
|
|
// Assert: health checks names and tags
|
|
var hcResolved = sp.GetRequiredService<IOptions<HealthCheckServiceOptions>>().Value;
|
|
var regDict = hcResolved.Registrations.ToDictionary(r => r.Name, r => r.Tags);
|
|
Assert.True(regDict.ContainsKey("ollama"));
|
|
Assert.True(regDict.ContainsKey("telegram"));
|
|
Assert.Contains("api", regDict["ollama"]);
|
|
Assert.Contains("ollama", regDict["ollama"]);
|
|
Assert.Contains("api", regDict["telegram"]);
|
|
Assert.Contains("telegram", regDict["telegram"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveRequiredUsingStatements()
|
|
{
|
|
// This test verifies that Program.cs has the necessary using statements
|
|
// by checking if the types can be resolved
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
|
|
// Verify that key services can be resolved
|
|
Assert.NotNull(serviceProvider.GetService<IConfiguration>());
|
|
Assert.NotNull(serviceProvider.GetService<ILoggerFactory>());
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldConfigureTelegramBotSettings()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
|
|
// Assert
|
|
var botToken = serviceProvider.GetRequiredService<IConfiguration>()["TelegramBot:BotToken"];
|
|
Assert.Equal("test_token", botToken);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldConfigureOllamaSettings()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert
|
|
var ollamaUrl = configuration["Ollama:Url"];
|
|
var defaultModel = configuration["Ollama:DefaultModel"];
|
|
Assert.Equal("http://localhost:11434", ollamaUrl);
|
|
Assert.Equal("llama2", defaultModel);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldConfigureAISettings()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert
|
|
var maxTokens = configuration["AI:MaxTokens"];
|
|
var temperature = configuration["AI:Temperature"];
|
|
Assert.Equal("1000", maxTokens);
|
|
Assert.Equal("0.7", temperature);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldConfigureDatabaseSettings()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert
|
|
var connectionString = configuration["Database:ConnectionString"];
|
|
var commandTimeout = configuration["Database:CommandTimeout"];
|
|
|
|
Assert.Equal(
|
|
"Host=localhost;Port=5432;Database=test_chatbot;Username=postgres;Password=postgres",
|
|
connectionString
|
|
);
|
|
Assert.Equal("30", commandTimeout);
|
|
Assert.Equal("false", configuration["Database:EnableSensitiveDataLogging"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHandleEnvironmentVariables()
|
|
{
|
|
// Arrange
|
|
Environment.SetEnvironmentVariable("TELEGRAM_BOT_TOKEN", "env_token");
|
|
Environment.SetEnvironmentVariable("OLLAMA_URL", "http://env:11434");
|
|
Environment.SetEnvironmentVariable("OLLAMA_DEFAULT_MODEL", "env_model");
|
|
Environment.SetEnvironmentVariable("DB_HOST", "env_host");
|
|
Environment.SetEnvironmentVariable("DB_PORT", "8080");
|
|
Environment.SetEnvironmentVariable("DB_NAME", "env_db");
|
|
Environment.SetEnvironmentVariable("DB_USER", "env_user");
|
|
Environment.SetEnvironmentVariable("DB_PASSWORD", "env_pass");
|
|
|
|
try
|
|
{
|
|
// Act
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Assert
|
|
Assert.Equal("env_token", Environment.GetEnvironmentVariable("TELEGRAM_BOT_TOKEN"));
|
|
Assert.Equal("http://env:11434", Environment.GetEnvironmentVariable("OLLAMA_URL"));
|
|
Assert.Equal("env_model", Environment.GetEnvironmentVariable("OLLAMA_DEFAULT_MODEL"));
|
|
Assert.Equal("env_host", Environment.GetEnvironmentVariable("DB_HOST"));
|
|
Assert.Equal("8080", Environment.GetEnvironmentVariable("DB_PORT"));
|
|
Assert.Equal("env_db", Environment.GetEnvironmentVariable("DB_NAME"));
|
|
Assert.Equal("env_user", Environment.GetEnvironmentVariable("DB_USER"));
|
|
Assert.Equal("env_pass", Environment.GetEnvironmentVariable("DB_PASSWORD"));
|
|
}
|
|
finally
|
|
{
|
|
// Cleanup
|
|
Environment.SetEnvironmentVariable("TELEGRAM_BOT_TOKEN", null);
|
|
Environment.SetEnvironmentVariable("OLLAMA_URL", null);
|
|
Environment.SetEnvironmentVariable("OLLAMA_DEFAULT_MODEL", null);
|
|
Environment.SetEnvironmentVariable("DB_HOST", null);
|
|
Environment.SetEnvironmentVariable("DB_PORT", null);
|
|
Environment.SetEnvironmentVariable("DB_NAME", null);
|
|
Environment.SetEnvironmentVariable("DB_USER", null);
|
|
Environment.SetEnvironmentVariable("DB_PASSWORD", null);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveValidConfigurationStructure()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert - Check that all required configuration sections exist
|
|
Assert.NotNull(configuration.GetSection("TelegramBot"));
|
|
Assert.NotNull(configuration.GetSection("Ollama"));
|
|
Assert.NotNull(configuration.GetSection("AI"));
|
|
Assert.NotNull(configuration.GetSection("Database"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveRequiredConfigurationValues()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert - Check that all required configuration values are present
|
|
Assert.NotNull(configuration["TelegramBot:BotToken"]);
|
|
Assert.NotNull(configuration["Ollama:Url"]);
|
|
Assert.NotNull(configuration["Ollama:DefaultModel"]);
|
|
Assert.NotNull(configuration["AI:MaxTokens"]);
|
|
Assert.NotNull(configuration["AI:Temperature"]);
|
|
Assert.NotNull(configuration["Database:ConnectionString"]);
|
|
Assert.NotNull(configuration["Database:CommandTimeout"]);
|
|
Assert.NotNull(configuration["Database:EnableSensitiveDataLogging"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveValidNumericConfigurationValues()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert - Check that numeric values can be parsed
|
|
var maxTokensValue = configuration["AI:MaxTokens"];
|
|
Assert.NotNull(maxTokensValue);
|
|
Assert.True(int.TryParse(maxTokensValue, out var maxTokens));
|
|
Assert.True(maxTokens > 0);
|
|
|
|
var temperatureValue = configuration["AI:Temperature"];
|
|
Assert.NotNull(temperatureValue);
|
|
Assert.True(
|
|
double.TryParse(
|
|
temperatureValue,
|
|
System.Globalization.NumberStyles.Float,
|
|
System.Globalization.CultureInfo.InvariantCulture,
|
|
out var temperature
|
|
)
|
|
);
|
|
Assert.True(temperature >= 0 && temperature <= 2);
|
|
|
|
Assert.True(int.TryParse(configuration["Database:CommandTimeout"], out var commandTimeout));
|
|
Assert.True(commandTimeout > 0);
|
|
|
|
Assert.True(bool.TryParse(configuration["Database:EnableSensitiveDataLogging"], out _));
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveValidUrlConfigurationValues()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert - Check that URL values are valid
|
|
var ollamaUrl = configuration["Ollama:Url"];
|
|
Assert.NotNull(ollamaUrl);
|
|
Assert.True(Uri.TryCreate(ollamaUrl, UriKind.Absolute, out var uri));
|
|
Assert.True(uri.Scheme == "http" || uri.Scheme == "https");
|
|
}
|
|
|
|
[Fact]
|
|
public void Program_ShouldHaveValidDatabaseConnectionString()
|
|
{
|
|
// Arrange
|
|
var services = new ServiceCollection();
|
|
ConfigureServices(services);
|
|
|
|
// Act
|
|
var serviceProvider = services.BuildServiceProvider();
|
|
var configuration = serviceProvider.GetRequiredService<IConfiguration>();
|
|
|
|
// Assert - Check that connection string has required components
|
|
var connectionString = configuration["Database:ConnectionString"];
|
|
Assert.NotNull(connectionString);
|
|
Assert.Contains("Host=", connectionString);
|
|
Assert.Contains("Port=", connectionString);
|
|
Assert.Contains("Database=", connectionString);
|
|
Assert.Contains("Username=", connectionString);
|
|
Assert.Contains("Password=", connectionString);
|
|
}
|
|
}
|