add tests

ChatBot.Tests/Integration/ProgramIntegrationTests.cs

@@ -0,0 +1,280 @@
+using ChatBot.Tests.TestUtilities;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+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.AddConsole().SetMinimumLevel(LogLevel.Debug));
+    }
+
+    [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);
+    }
+}