ScadaBridge/tests/ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests/Persistence/ArtifactStorageTests.cs

using Microsoft.Extensions.Logging.Abstractions;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Persistence;
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Repositories;

namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Persistence;

/// <summary>
/// WP-33: Local Artifact Storage tests — shared scripts, external systems,
/// database connections, notification lists.
/// </summary>
public class ArtifactStorageTests : IAsyncLifetime, IDisposable
{
    private readonly string _dbFile;
    private SiteStorageService _storage = null!;

    public ArtifactStorageTests()
    {
        _dbFile = Path.Combine(Path.GetTempPath(), $"artifact-test-{Guid.NewGuid():N}.db");
    }

    public async Task InitializeAsync()
    {
        _storage = new SiteStorageService(
            $"Data Source={_dbFile}",
            NullLogger<SiteStorageService>.Instance);
        await _storage.InitializeAsync();
    }

    public Task DisposeAsync() => Task.CompletedTask;

    public void Dispose()
    {
        try { File.Delete(_dbFile); } catch { /* cleanup */ }
    }

    // ── Shared Script Storage ──

    [Fact]
    public async Task StoreSharedScript_RoundTrips()
    {
        await _storage.StoreSharedScriptAsync("CalcAvg", "return 42;", "{}", "int");

        var scripts = await _storage.GetAllSharedScriptsAsync();
        Assert.Single(scripts);
        Assert.Equal("CalcAvg", scripts[0].Name);
        Assert.Equal("return 42;", scripts[0].Code);
        Assert.Equal("{}", scripts[0].ParameterDefinitions);
        Assert.Equal("int", scripts[0].ReturnDefinition);
    }

    [Fact]
    public async Task StoreSharedScript_Upserts_OnConflict()
    {
        await _storage.StoreSharedScriptAsync("CalcAvg", "return 1;", null, null);
        await _storage.StoreSharedScriptAsync("CalcAvg", "return 2;", "{\"x\":\"int\"}", "int");

        var scripts = await _storage.GetAllSharedScriptsAsync();
        Assert.Single(scripts);
        Assert.Equal("return 2;", scripts[0].Code);
        Assert.Equal("{\"x\":\"int\"}", scripts[0].ParameterDefinitions);
    }

    [Fact]
    public async Task StoreSharedScript_MultipleScripts()
    {
        await _storage.StoreSharedScriptAsync("Script1", "1", null, null);
        await _storage.StoreSharedScriptAsync("Script2", "2", null, null);
        await _storage.StoreSharedScriptAsync("Script3", "3", null, null);

        var scripts = await _storage.GetAllSharedScriptsAsync();
        Assert.Equal(3, scripts.Count);
    }

    [Fact]
    public async Task StoreSharedScript_NullableFields()
    {
        await _storage.StoreSharedScriptAsync("Simple", "42", null, null);

        var scripts = await _storage.GetAllSharedScriptsAsync();
        Assert.Single(scripts);
        Assert.Null(scripts[0].ParameterDefinitions);
        Assert.Null(scripts[0].ReturnDefinition);
    }

    // ── External System Storage ──

    [Fact]
    public async Task StoreExternalSystem_DoesNotThrow()
    {
        await _storage.StoreExternalSystemAsync(
            "WeatherAPI", "https://api.weather.com",
            "ApiKey", "{\"key\":\"abc\"}", "{\"getForecast\":{}}");

        // No exception = success. Query verification would need a Get method.
    }

    [Fact]
    public async Task StoreExternalSystem_Upserts()
    {
        await _storage.StoreExternalSystemAsync("API1", "https://v1", "Basic", null, null);
        await _storage.StoreExternalSystemAsync("API1", "https://v2", "ApiKey", "{}", null);

        // Upsert should not throw
    }

    // ── Database Connection Storage ──

    [Fact]
    public async Task StoreDatabaseConnection_DoesNotThrow()
    {
        await _storage.StoreDatabaseConnectionAsync(
            "MainDB", "Server=localhost;Database=main", 3, TimeSpan.FromSeconds(1));
    }

    [Fact]
    public async Task StoreDatabaseConnection_Upserts()
    {
        await _storage.StoreDatabaseConnectionAsync(
            "DB1", "Server=old", 3, TimeSpan.FromSeconds(1));
        await _storage.StoreDatabaseConnectionAsync(
            "DB1", "Server=new", 5, TimeSpan.FromSeconds(2));

        // Upsert should not throw
    }

    // ── Notification List Storage ──

    [Fact]
    public async Task StoreNotificationList_DoesNotThrow()
    {
        await _storage.StoreNotificationListAsync(
            "Ops Team", ["ops@example.com", "admin@example.com"]);
    }

    [Fact]
    public async Task StoreNotificationList_Upserts()
    {
        await _storage.StoreNotificationListAsync("Team1", ["a@b.com"]);
        await _storage.StoreNotificationListAsync("Team1", ["x@y.com", "z@w.com"]);

        // Upsert should not throw
    }

    // ── DeploymentManager-025 / SiteRuntime-031: central-only notif/SMTP purge ──

    [Fact]
    public async Task PurgeCentralOnlyNotificationConfig_RemovesPersistedNotificationListsAndSmtpRows()
    {
        // Simulate a pre-fix build that already shipped a notification list and an
        // SMTP config (with a plaintext password) to the site.
        await _storage.StoreNotificationListAsync("Ops Team", ["ops@example.com"]);
        await _storage.StoreSmtpConfigurationAsync(
            "smtp.example.com:587", "smtp.example.com", 587, "BasicAuth",
            "noreply@example.com", "smtpuser", "PLAINTEXT-SECRET", null);

        var repo = new SiteNotificationRepository(_storage);
        Assert.NotEmpty(await repo.GetAllNotificationListsAsync());
        Assert.NotEmpty(await repo.GetAllSmtpConfigurationsAsync());

        // The fix: every artifact apply/deploy purges these central-only rows.
        await _storage.PurgeCentralOnlyNotificationConfigAsync();

        // Both tables are now empty — the plaintext SMTP credential is gone.
        Assert.Empty(await repo.GetAllNotificationListsAsync());
        Assert.Empty(await repo.GetAllSmtpConfigurationsAsync());
    }

    [Fact]
    public async Task PurgeCentralOnlyNotificationConfig_IsIdempotent_OnEmptyTables()
    {
        // No rows present — purge must not throw and must leave the tables empty.
        await _storage.PurgeCentralOnlyNotificationConfigAsync();
        await _storage.PurgeCentralOnlyNotificationConfigAsync();

        var repo = new SiteNotificationRepository(_storage);
        Assert.Empty(await repo.GetAllNotificationListsAsync());
        Assert.Empty(await repo.GetAllSmtpConfigurationsAsync());
    }

    // ── Schema includes all WP-33 tables ──

    [Fact]
    public async Task Initialize_CreatesAllArtifactTables()
    {
        // The initialize already ran. Verify by storing to each table.
        await _storage.StoreSharedScriptAsync("s", "code", null, null);
        await _storage.StoreExternalSystemAsync("e", "url", "None", null, null);
        await _storage.StoreDatabaseConnectionAsync("d", "connstr", 1, TimeSpan.Zero);
        await _storage.StoreNotificationListAsync("n", ["email@test.com"]);

        // All succeeded without exceptions = tables exist
    }
}