ChronoCCG/Chrono/Tests/DatabaseServiceTests.cs

using Cloud.Models;
using DatabaseTest.Models;
using DatabaseTest.Services;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging.Abstractions;
using Model;

namespace Tests;

[TestFixture]
public class DatabaseServiceTests
{
    private IDatabaseConfigService _configService = null!;
    private IDatabaseService _dbService = null!;
    private string _testDbName = null!;

    [SetUp]
    public async Task Setup()
    {
        _testDbName = $"chrono_test_{Guid.NewGuid():N}";
        var config = new ConfigurationBuilder().Build();
        var configService = new DatabaseConfigService(config);
        configService.SetProvider(DatabaseProviderType.InMemory);
        configService.SetInMemoryDbName(_testDbName);

        _configService = configService;
        _dbService = new DatabaseService(configService, NullLogger<DatabaseService>.Instance);

        await _dbService.EnsureDatabaseCreatedAsync();
    }

    [Test]
    public async Task CheckHealth_InMemory_ReturnsConnected()
    {
        var health = await _dbService.CheckHealthAsync();
        Assert.That(health.IsConnected, Is.True);
        Assert.That(health.ProviderType, Is.EqualTo(DatabaseProviderType.InMemory));
    }

    [Test]
    public async Task CardNotes_FullCrudLifecycle()
    {
        var cardName = "Test Hero " + Guid.NewGuid().ToString("N");
        var initialNote = new CardNote { CardName = cardName, Note = "Initial note text" };

        // 1. Create
        var createResult = await _dbService.SaveCardNoteAsync(initialNote, isNew: true);
        Assert.That(createResult.Success, Is.True);

        // 2. Read
        var fetched = await _dbService.GetCardNoteAsync(cardName);
        Assert.That(fetched, Is.Not.Null);
        Assert.That(fetched!.Note, Is.EqualTo("Initial note text"));

        // 3. Update
        fetched.Note = "Updated note text";
        var updateResult = await _dbService.SaveCardNoteAsync(fetched, isNew: false);
        Assert.That(updateResult.Success, Is.True);

        var updated = await _dbService.GetCardNoteAsync(cardName);
        Assert.That(updated!.Note, Is.EqualTo("Updated note text"));

        // 4. Delete
        var deleteResult = await _dbService.DeleteCardNoteAsync(cardName);
        Assert.That(deleteResult.Success, Is.True);

        var deleted = await _dbService.GetCardNoteAsync(cardName);
        Assert.That(deleted, Is.Null);
    }

    [Test]
    public async Task DuplicateCardNote_ReturnsFailureResult()
    {
        var cardName = "Unique Card " + Guid.NewGuid().ToString("N");
        var note1 = new CardNote { CardName = cardName, Note = "First" };
        var note2 = new CardNote { CardName = cardName, Note = "Second" };

        var res1 = await _dbService.SaveCardNoteAsync(note1, isNew: true);
        Assert.That(res1.Success, Is.True);

        var res2 = await _dbService.SaveCardNoteAsync(note2, isNew: true);
        Assert.That(res2.Success, Is.False);
        Assert.That(res2.Message, Does.Contain("already exists"));
    }

    [Test]
    public async Task UserDecks_FullCrudLifecycle_WithJsonCollections()
    {
        var deckId = Guid.NewGuid();
        var deck = new UserDeck
        {
            Id = deckId,
            Name = "Control Deck",
            Season = "Season 1",
            Notes = "Strategic combo control",
            Cards = new List<string> { "Chronos, Time Shifter", "Temporal Rift", "Chronos, Time Shifter" },
            Divers = new List<string> { "Chronos, Time Shifter" }
        };

        // 1. Create
        var createResult = await _dbService.SaveUserDeckAsync(deck, isNew: true);
        Assert.That(createResult.Success, Is.True);

        // 2. Read
        var fetched = await _dbService.GetUserDeckAsync(deckId);
        Assert.That(fetched, Is.Not.Null);
        Assert.That(fetched!.Name, Is.EqualTo("Control Deck"));
        Assert.That(fetched.Cards.Count, Is.EqualTo(3));
        Assert.That(fetched.Divers.Count, Is.EqualTo(1));

        // 3. Update
        fetched.Cards.Add("Added Card");
        fetched.Name = "Control Deck v2";
        var updateResult = await _dbService.SaveUserDeckAsync(fetched, isNew: false);
        Assert.That(updateResult.Success, Is.True);

        var updated = await _dbService.GetUserDeckAsync(deckId);
        Assert.That(updated!.Name, Is.EqualTo("Control Deck v2"));
        Assert.That(updated.Cards.Count, Is.EqualTo(4));

        // 4. Delete
        var deleteResult = await _dbService.DeleteUserDeckAsync(deckId);
        Assert.That(deleteResult.Success, Is.True);

        var deleted = await _dbService.GetUserDeckAsync(deckId);
        Assert.That(deleted, Is.Null);
    }

    [Test]
    public async Task PasskeyCredentials_FullCrudLifecycle_WithBinaryData()
    {
        var credId = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0xAA, 0xBB, 0xCC };
        var pubKey = new byte[] { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 };
        var userHandle = new byte[] { 0xDE, 0xAD, 0xBE, 0xEF };

        var passkey = new PasskeyCredential
        {
            CredentialId = credId,
            PublicKey = pubKey,
            UserHandle = userHandle,
            AaGuid = Guid.NewGuid().ToString(),
            SignCount = 5
        };

        // 1. Create
        var createResult = await _dbService.SavePasskeyAsync(passkey, isNew: true);
        Assert.That(createResult.Success, Is.True);
        Assert.That(passkey.Id, Is.GreaterThan(0));

        // 2. Read & Binary Verification
        var fetched = await _dbService.GetPasskeyAsync(passkey.Id);
        Assert.That(fetched, Is.Not.Null);
        Assert.That(fetched!.CredentialId, Is.EqualTo(credId));
        Assert.That(fetched.PublicKey, Is.EqualTo(pubKey));
        Assert.That(fetched.UserHandle, Is.EqualTo(userHandle));
        Assert.That(fetched.SignCount, Is.EqualTo(5));

        // 3. Update
        fetched.SignCount = 10;
        var updateResult = await _dbService.SavePasskeyAsync(fetched, isNew: false);
        Assert.That(updateResult.Success, Is.True);

        var updated = await _dbService.GetPasskeyAsync(passkey.Id);
        Assert.That(updated!.SignCount, Is.EqualTo(10));

        // 4. Delete
        var deleteResult = await _dbService.DeletePasskeyAsync(passkey.Id);
        Assert.That(deleteResult.Success, Is.True);

        var deleted = await _dbService.GetPasskeyAsync(passkey.Id);
        Assert.That(deleted, Is.Null);
    }

    [Test]
    public async Task SeedAndResetDatabase_WorksCorrectly()
    {
        // 1. Seed
        var seedResult = await _dbService.SeedSampleDataAsync();
        Assert.That(seedResult.Success, Is.True);
        Assert.That(seedResult.CardNotesSeeded, Is.GreaterThan(0));
        Assert.That(seedResult.UserDecksSeeded, Is.GreaterThan(0));
        Assert.That(seedResult.PasskeysSeeded, Is.GreaterThan(0));

        var notes = await _dbService.GetCardNotesAsync();
        var decks = await _dbService.GetUserDecksAsync();
        var passkeys = await _dbService.GetPasskeysAsync();

        Assert.That(notes.Count, Is.GreaterThan(0));
        Assert.That(decks.Count, Is.GreaterThan(0));
        Assert.That(passkeys.Count, Is.GreaterThan(0));

        // 2. Reset
        var resetResult = await _dbService.ResetDatabaseAsync();
        Assert.That(resetResult.Success, Is.True);

        var notesAfterReset = await _dbService.GetCardNotesAsync();
        var decksAfterReset = await _dbService.GetUserDecksAsync();
        var passkeysAfterReset = await _dbService.GetPasskeysAsync();

        Assert.That(notesAfterReset, Is.Empty);
        Assert.That(decksAfterReset, Is.Empty);
        Assert.That(passkeysAfterReset, Is.Empty);
    }

    [Test]
    public async Task RunAllTestsAsync_ExecutesAndPassesCoreTests()
    {
        var testResults = await _dbService.RunAllTestsAsync();
        Assert.That(testResults, Is.Not.Empty);

        var failed = testResults.Where(t => t.Status == TestStatus.Failed).ToList();
        Assert.That(failed, Is.Empty, () => $"Failed tests: {string.Join(", ", failed.Select(f => $"{f.Name}: {f.ErrorMessage}"))}");

        var passedCount = testResults.Count(t => t.Status == TestStatus.Passed);
        Assert.That(passedCount, Is.GreaterThanOrEqualTo(6));
    }
}