JonathanMcCaffrey/ChronoCCG
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Test

Browse Source
This commit is contained in:
6d486f49
2026-08-14 15:56:17 -04:00
parent af64b9e95c
commit 09a8adfc4a
827 changed files with 65045 additions and 71849 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Chrono/DatabaseTest/Services/DatabaseService.cs
+972
View File
@@ -0,0 +1,972 @@
using System.Diagnostics;
using System.Text.Json;
using Cloud;
using Cloud.Models;
using DatabaseTest.Models;
using Microsoft.EntityFrameworkCore;
using Model;
namespace DatabaseTest.Services;
public interface IDatabaseService
{
Task<DatabaseHealthStatus> CheckHealthAsync();
Task<MigrationReport> GetMigrationStatusAsync();
Task<OperationResult> ApplyMigrationsAsync();
Task<OperationResult> EnsureDatabaseCreatedAsync();
Task<OperationResult> ResetDatabaseAsync();
Task<SeedResult> SeedSampleDataAsync();
// Card Notes
Task<List<CardNote>> GetCardNotesAsync(string? search = null);
Task<CardNote?> GetCardNoteAsync(string cardName);
Task<OperationResult> SaveCardNoteAsync(CardNote note, bool isNew);
Task<OperationResult> DeleteCardNoteAsync(string cardName);
// User Decks
Task<List<UserDeck>> GetUserDecksAsync(string? search = null);
Task<UserDeck?> GetUserDeckAsync(Guid id);
Task<OperationResult> SaveUserDeckAsync(UserDeck deck, bool isNew);
Task<OperationResult> DeleteUserDeckAsync(Guid id);
// Passkey Credentials
Task<List<PasskeyCredential>> GetPasskeysAsync(string? search = null);
Task<PasskeyCredential?> GetPasskeyAsync(int id);
Task<OperationResult> SavePasskeyAsync(PasskeyCredential passkey, bool isNew);
Task<OperationResult> DeletePasskeyAsync(int id);
// Automated Test Suite
Task<List<DatabaseTestCaseResult>> RunAllTestsAsync(Action<string>? progressCallback = null);
}
public class DatabaseService : IDatabaseService
{
private readonly IDatabaseConfigService _configService;
private readonly ILogger<DatabaseService> _logger;
public DatabaseService(IDatabaseConfigService configService, ILogger<DatabaseService> logger)
{
_configService = configService;
_logger = logger;
}
public async Task<DatabaseHealthStatus> CheckHealthAsync()
{
var status = new DatabaseHealthStatus
{
ProviderType = _configService.ProviderType,
ProviderName = _configService.ProviderType.ToString(),
ConnectionString = _configService.ConnectionString,
CheckedAt = DateTime.UtcNow
};
var sw = Stopwatch.StartNew();
try
{
await using var db = _configService.CreateDbContext();
var canConnect = await db.Database.CanConnectAsync();
sw.Stop();
status.ResponseTimeMs = sw.ElapsedMilliseconds;
status.IsConnected = canConnect;
if (canConnect)
{
if (_configService.ProviderType == DatabaseProviderType.PostgreSQL)
{
var pending = await db.Database.GetPendingMigrationsAsync();
var applied = await db.Database.GetAppliedMigrationsAsync();
status.PendingMigrationsCount = pending.Count();
status.AppliedMigrationsCount = applied.Count();
}
try
{
status.CardNotesCount = await db.CardNotes.CountAsync();
status.UserDecksCount = await db.UserDecks.CountAsync();
status.PasskeysCount = await db.PasskeyCredentials.CountAsync();
}
catch (Exception ex)
{
status.ErrorMessage = $"Connected, but table count failed (migrations may be pending): {ex.Message}";
}
}
else
{
status.ErrorMessage = "Unable to connect to database. Verify connection string and server status.";
}
}
catch (Exception ex)
{
sw.Stop();
status.ResponseTimeMs = sw.ElapsedMilliseconds;
status.IsConnected = false;
status.ErrorMessage = ex.Message;
}
return status;
}
public async Task<MigrationReport> GetMigrationStatusAsync()
{
var report = new MigrationReport
{
ProviderType = _configService.ProviderType
};
if (_configService.ProviderType != DatabaseProviderType.PostgreSQL)
{
report.SupportsMigrations = false;
return report;
}
report.SupportsMigrations = true;
try
{
await using var db = _configService.CreateDbContext();
report.AppliedMigrations = (await db.Database.GetAppliedMigrationsAsync()).ToList();
report.PendingMigrations = (await db.Database.GetPendingMigrationsAsync()).ToList();
}
catch (Exception ex)
{
report.Error = ex.Message;
}
return report;
}
public async Task<OperationResult> ApplyMigrationsAsync()
{
try
{
await using var db = _configService.CreateDbContext();
if (_configService.ProviderType == DatabaseProviderType.PostgreSQL)
{
var pending = (await db.Database.GetPendingMigrationsAsync()).ToList();
if (!pending.Any())
{
return OperationResult.Ok("Database schema is already up-to-date. No pending migrations.");
}
await db.Database.MigrateAsync();
return OperationResult.Ok($"Successfully applied {pending.Count} migration(s): {string.Join(", ", pending)}");
}
else
{
await db.Database.EnsureCreatedAsync();
return OperationResult.Ok("In-memory database schema ensured.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to apply migrations.");
return OperationResult.Fail("Failed to apply migrations: " + ex.Message, ex.ToString());
}
}
public async Task<OperationResult> EnsureDatabaseCreatedAsync()
{
try
{
await using var db = _configService.CreateDbContext();
var created = await db.Database.EnsureCreatedAsync();
return OperationResult.Ok(created ? "Database created successfully." : "Database already exists.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to ensure database creation.");
return OperationResult.Fail("Failed to ensure database created: " + ex.Message, ex.ToString());
}
}
public async Task<OperationResult> ResetDatabaseAsync()
{
try
{
await using var db = _configService.CreateDbContext();
if (_configService.ProviderType == DatabaseProviderType.PostgreSQL)
{
// Delete rows from all tables
db.CardNotes.RemoveRange(db.CardNotes);
db.UserDecks.RemoveRange(db.UserDecks);
db.PasskeyCredentials.RemoveRange(db.PasskeyCredentials);
await db.SaveChangesAsync();
return OperationResult.Ok("All database tables cleared successfully.");
}
else
{
await db.Database.EnsureDeletedAsync();
await db.Database.EnsureCreatedAsync();
return OperationResult.Ok("In-memory database wiped and recreated successfully.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to reset database.");
return OperationResult.Fail("Failed to reset database: " + ex.Message, ex.ToString());
}
}
public async Task<SeedResult> SeedSampleDataAsync()
{
var result = new SeedResult();
try
{
await using var db = _configService.CreateDbContext();
if (_configService.ProviderType == DatabaseProviderType.PostgreSQL)
{
await db.Database.MigrateAsync();
}
else
{
await db.Database.EnsureCreatedAsync();
}
// 1. Seed Card Notes
var existingNoteNames = (await db.CardNotes.Select(n => n.CardName).ToListAsync()).ToHashSet();
var sampleNotes = new List<CardNote>
{
new() { CardName = "Kaelen, Arcane Weaver", Note = "Key combo enabler for control decks. High priority removal target." },
new() { CardName = "Valkyrie Ascendant", Note = "Strong mid-game aerial presence. Synergizes well with Divine Shield buffs." },
new() { CardName = "Chronos, Time Shifter", Note = "Turn rewind capability allows recovering from early tempo loss." },
new() { CardName = "Cyber Samurai", Note = "Fast aggro card with stealth. Great opener." },
new() { CardName = "Temporal Rift", Note = "Essential spell for board reset in late game." }
};
foreach (var note in sampleNotes.Where(n => !existingNoteNames.Contains(n.CardName)))
{
db.CardNotes.Add(note);
result.CardNotesSeeded++;
}
// 2. Seed User Decks
var existingDeckNames = (await db.UserDecks.Select(d => d.Name).ToListAsync()).ToHashSet();
var sampleDecks = new List<UserDeck>
{
new()
{
Id = Guid.NewGuid(),
Name = "Chrono Temporal Control",
Notes = "Built around time-shift mechanics and spell stalling.",
Season = "Season 1",
UpdatedAt = DateTime.UtcNow,
Cards = new List<string>
{
"Chronos, Time Shifter",
"Chronos, Time Shifter",
"Temporal Rift",
"Temporal Rift",
"Temporal Rift",
"Kaelen, Arcane Weaver",
"Kaelen, Arcane Weaver"
},
Divers = new List<string> { "Chronos, Time Shifter" }
},
new()
{
Id = Guid.NewGuid(),
Name = "Valkyrie Aggro Burst",
Notes = "Fast tempo rush deck targeting rapid face damage.",
Season = "Season 1",
UpdatedAt = DateTime.UtcNow,
Cards = new List<string>
{
"Valkyrie Ascendant",
"Valkyrie Ascendant",
"Valkyrie Ascendant",
"Cyber Samurai",
"Cyber Samurai",
"Cyber Samurai"
},
Divers = new List<string>()
}
};
foreach (var deck in sampleDecks.Where(d => !existingDeckNames.Contains(d.Name)))
{
db.UserDecks.Add(deck);
result.UserDecksSeeded++;
}
// 3. Seed Passkey Credentials
var existingPasskeyCount = await db.PasskeyCredentials.CountAsync();
if (existingPasskeyCount == 0)
{
var samplePasskeys = new List<PasskeyCredential>
{
new()
{
CredentialId = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0x01, 0x02, 0x03, 0x04, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80 },
PublicKey = new byte[] { 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 },
UserHandle = new byte[] { 0xDE, 0xAD, 0xBE, 0xEF, 0x01, 0x02, 0x03, 0x04 },
AaGuid = Guid.NewGuid().ToString(),
SignCount = 42
},
new()
{
CredentialId = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00 },
PublicKey = new byte[] { 0x04, 0x1F, 0x2E, 0x3D, 0x4C, 0x5B, 0x6A, 0x79, 0x88, 0x97, 0xA6, 0xB5, 0xC4, 0xD3, 0xE2, 0xF1 },
UserHandle = new byte[] { 0xCA, 0xFE, 0xBA, 0xBE, 0x05, 0x06, 0x07, 0x08 },
AaGuid = Guid.NewGuid().ToString(),
SignCount = 100
}
};
db.PasskeyCredentials.AddRange(samplePasskeys);
result.PasskeysSeeded += samplePasskeys.Count;
}
await db.SaveChangesAsync();
result.Success = true;
result.Message = $"Sample data seeded: {result.CardNotesSeeded} notes, {result.UserDecksSeeded} decks, {result.PasskeysSeeded} passkeys.";
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to seed sample data.");
result.Success = false;
result.Message = "Failed to seed data: " + ex.Message;
}
return result;
}
// ── Card Notes CRUD ────────────────────────────────────────────────────────
public async Task<List<CardNote>> GetCardNotesAsync(string? search = null)
{
await using var db = _configService.CreateDbContext();
var query = db.CardNotes.AsNoTracking().AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{
var s = search.Trim().ToLower();
query = query.Where(n => n.CardName.ToLower().Contains(s) || n.Note.ToLower().Contains(s));
}
return await query.OrderBy(n => n.CardName).ToListAsync();
}
public async Task<CardNote?> GetCardNoteAsync(string cardName)
{
await using var db = _configService.CreateDbContext();
return await db.CardNotes.AsNoTracking().FirstOrDefaultAsync(n => n.CardName == cardName);
}
public async Task<OperationResult> SaveCardNoteAsync(CardNote note, bool isNew)
{
if (string.IsNullOrWhiteSpace(note.CardName))
return OperationResult.Fail("Card name is required.");
try
{
await using var db = _configService.CreateDbContext();
if (isNew)
{
var exists = await db.CardNotes.AnyAsync(n => n.CardName == note.CardName);
if (exists)
return OperationResult.Fail($"A note for card '{note.CardName}' already exists.");
db.CardNotes.Add(note);
await db.SaveChangesAsync();
return OperationResult.Ok($"Created note for '{note.CardName}'.");
}
else
{
var existing = await db.CardNotes.FirstOrDefaultAsync(n => n.CardName == note.CardName);
if (existing == null)
return OperationResult.Fail($"Note for card '{note.CardName}' was not found.");
existing.Note = note.Note;
await db.SaveChangesAsync();
return OperationResult.Ok($"Updated note for '{note.CardName}'.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to save card note {CardName}", note.CardName);
return OperationResult.Fail($"Error saving card note: {ex.Message}", ex.ToString());
}
}
public async Task<OperationResult> DeleteCardNoteAsync(string cardName)
{
try
{
await using var db = _configService.CreateDbContext();
var existing = await db.CardNotes.FirstOrDefaultAsync(n => n.CardName == cardName);
if (existing == null)
return OperationResult.Fail($"Note for '{cardName}' not found.");
db.CardNotes.Remove(existing);
await db.SaveChangesAsync();
return OperationResult.Ok($"Deleted note for '{cardName}'.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to delete card note {CardName}", cardName);
return OperationResult.Fail($"Error deleting note: {ex.Message}", ex.ToString());
}
}
// ── User Decks CRUD ────────────────────────────────────────────────────────
public async Task<List<UserDeck>> GetUserDecksAsync(string? search = null)
{
await using var db = _configService.CreateDbContext();
var query = db.UserDecks.AsNoTracking().AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{
var s = search.Trim().ToLower();
query = query.Where(d => d.Name.ToLower().Contains(s)
|| (d.Notes != null && d.Notes.ToLower().Contains(s))
|| (d.Season != null && d.Season.ToLower().Contains(s)));
}
return await query.OrderByDescending(d => d.UpdatedAt).ToListAsync();
}
public async Task<UserDeck?> GetUserDeckAsync(Guid id)
{
await using var db = _configService.CreateDbContext();
return await db.UserDecks.AsNoTracking().FirstOrDefaultAsync(d => d.Id == id);
}
public async Task<OperationResult> SaveUserDeckAsync(UserDeck deck, bool isNew)
{
if (string.IsNullOrWhiteSpace(deck.Name))
return OperationResult.Fail("Deck name is required.");
try
{
await using var db = _configService.CreateDbContext();
deck.UpdatedAt = DateTime.UtcNow;
if (isNew)
{
if (deck.Id == Guid.Empty)
deck.Id = Guid.NewGuid();
db.UserDecks.Add(deck);
await db.SaveChangesAsync();
return OperationResult.Ok($"Created deck '{deck.Name}'.");
}
else
{
var existing = await db.UserDecks.FirstOrDefaultAsync(d => d.Id == deck.Id);
if (existing == null)
return OperationResult.Fail($"Deck with ID {deck.Id} was not found.");
existing.Name = deck.Name;
existing.Notes = deck.Notes;
existing.Season = deck.Season;
existing.Cards = deck.Cards ?? [];
existing.Divers = deck.Divers ?? [];
existing.UpdatedAt = DateTime.UtcNow;
await db.SaveChangesAsync();
return OperationResult.Ok($"Updated deck '{deck.Name}'.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to save deck {DeckName}", deck.Name);
return OperationResult.Fail($"Error saving deck: {ex.Message}", ex.ToString());
}
}
public async Task<OperationResult> DeleteUserDeckAsync(Guid id)
{
try
{
await using var db = _configService.CreateDbContext();
var existing = await db.UserDecks.FirstOrDefaultAsync(d => d.Id == id);
if (existing == null)
return OperationResult.Fail($"Deck with ID {id} was not found.");
var name = existing.Name;
db.UserDecks.Remove(existing);
await db.SaveChangesAsync();
return OperationResult.Ok($"Deleted deck '{name}'.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to delete deck {DeckId}", id);
return OperationResult.Fail($"Error deleting deck: {ex.Message}", ex.ToString());
}
}
// ── Passkey Credentials CRUD ───────────────────────────────────────────────
public async Task<List<PasskeyCredential>> GetPasskeysAsync(string? search = null)
{
await using var db = _configService.CreateDbContext();
var query = db.PasskeyCredentials.AsNoTracking().AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{
var s = search.Trim().ToLower();
query = query.Where(p => (p.AaGuid != null && p.AaGuid.ToLower().Contains(s))
|| p.Id.ToString().Contains(s)
|| p.SignCount.ToString().Contains(s));
}
return await query.OrderBy(p => p.Id).ToListAsync();
}
public async Task<PasskeyCredential?> GetPasskeyAsync(int id)
{
await using var db = _configService.CreateDbContext();
return await db.PasskeyCredentials.AsNoTracking().FirstOrDefaultAsync(p => p.Id == id);
}
public async Task<OperationResult> SavePasskeyAsync(PasskeyCredential passkey, bool isNew)
{
if (passkey.CredentialId == null || passkey.CredentialId.Length == 0)
return OperationResult.Fail("Credential ID bytes are required.");
if (passkey.PublicKey == null || passkey.PublicKey.Length == 0)
return OperationResult.Fail("Public Key bytes are required.");
if (passkey.UserHandle == null || passkey.UserHandle.Length == 0)
return OperationResult.Fail("User Handle bytes are required.");
try
{
await using var db = _configService.CreateDbContext();
if (isNew)
{
db.PasskeyCredentials.Add(passkey);
await db.SaveChangesAsync();
return OperationResult.Ok($"Created Passkey credential #{passkey.Id}.");
}
else
{
var existing = await db.PasskeyCredentials.FirstOrDefaultAsync(p => p.Id == passkey.Id);
if (existing == null)
return OperationResult.Fail($"Passkey with ID {passkey.Id} was not found.");
existing.CredentialId = passkey.CredentialId;
existing.PublicKey = passkey.PublicKey;
existing.UserHandle = passkey.UserHandle;
existing.AaGuid = passkey.AaGuid;
existing.SignCount = passkey.SignCount;
await db.SaveChangesAsync();
return OperationResult.Ok($"Updated Passkey credential #{passkey.Id}.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to save passkey credential {Id}", passkey.Id);
return OperationResult.Fail($"Error saving passkey: {ex.Message}", ex.ToString());
}
}
public async Task<OperationResult> DeletePasskeyAsync(int id)
{
try
{
await using var db = _configService.CreateDbContext();
var existing = await db.PasskeyCredentials.FirstOrDefaultAsync(p => p.Id == id);
if (existing == null)
return OperationResult.Fail($"Passkey with ID {id} was not found.");
db.PasskeyCredentials.Remove(existing);
await db.SaveChangesAsync();
return OperationResult.Ok($"Deleted Passkey credential #{id}.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Failed to delete passkey credential {Id}", id);
return OperationResult.Fail($"Error deleting passkey: {ex.Message}", ex.ToString());
}
}
// ── Automated Test Suite Runner ───────────────────────────────────────────
public async Task<List<DatabaseTestCaseResult>> RunAllTestsAsync(Action<string>? progressCallback = null)
{
var results = new List<DatabaseTestCaseResult>();
// 1. Connection Test
results.Add(await RunTestCaseAsync("DB-01", "Database Connectivity", "Connection",
"Validates socket/connection pool access to the target database server.",
async test =>
{
test.AddLog($"Connecting to {_configService.GetActiveProviderDescription()}...");
await using var db = _configService.CreateDbContext();
var canConnect = await db.Database.CanConnectAsync();
if (!canConnect)
throw new InvalidOperationException("Failed to establish a connection to the database.");
test.AddLog("Database connection established successfully.");
}, progressCallback));
// 2. Migrations & Schema Check
results.Add(await RunTestCaseAsync("DB-02", "Schema & Migrations", "Schema",
"Verifies applied EF Core migrations and checks that all tables exist.",
async test =>
{
await using var db = _configService.CreateDbContext();
if (_configService.ProviderType == DatabaseProviderType.PostgreSQL)
{
test.AddLog("Querying EF Core migration history...");
var applied = (await db.Database.GetAppliedMigrationsAsync()).ToList();
test.AddLog($"Applied migrations count: {applied.Count}");
foreach (var m in applied) test.AddLog($" - Applied: {m}");
var pending = (await db.Database.GetPendingMigrationsAsync()).ToList();
if (pending.Any())
{
test.AddLog($"Warning: {pending.Count} pending migrations detected. Applying them now...");
await db.Database.MigrateAsync();
test.AddLog("Pending migrations applied successfully.");
}
else
{
test.AddLog("No pending migrations. Schema is up to date.");
}
}
else
{
test.AddLog("In-memory provider: Ensuring database schema is created...");
await db.Database.EnsureCreatedAsync();
test.AddLog("In-memory schema verified.");
}
}, progressCallback));
// 3. CardNote CRUD Test
results.Add(await RunTestCaseAsync("DB-03", "CardNote Full CRUD Lifecycle", "CardNotes",
"Tests Insert, Query, Update, and Delete operations on the CardNotes entity.",
async test =>
{
var testCardName = $"__Test_Card_{Guid.NewGuid():N}";
var initialNote = "Initial test note description";
var updatedNote = "Updated test note content with extra details";
await using (var db = _configService.CreateDbContext())
{
test.AddLog($"1. Creating test CardNote for '{testCardName}'...");
db.CardNotes.Add(new CardNote { CardName = testCardName, Note = initialNote });
await db.SaveChangesAsync();
test.AddLog("CardNote inserted successfully.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("2. Querying inserted CardNote from database...");
var fetched = await db.CardNotes.FirstOrDefaultAsync(n => n.CardName == testCardName);
if (fetched == null || fetched.Note != initialNote)
throw new Exception($"Expected note '{initialNote}', but retrieved '{fetched?.Note}'");
test.AddLog("CardNote retrieved and validated.");
test.AddLog("3. Updating CardNote text...");
fetched.Note = updatedNote;
await db.SaveChangesAsync();
test.AddLog("CardNote updated in database.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("4. Verifying persisted updated note...");
var fetched = await db.CardNotes.FirstOrDefaultAsync(n => n.CardName == testCardName);
if (fetched == null || fetched.Note != updatedNote)
throw new Exception($"Expected updated note '{updatedNote}', but found '{fetched?.Note}'");
test.AddLog("Update persistence verified.");
test.AddLog("5. Deleting test CardNote...");
db.CardNotes.Remove(fetched);
await db.SaveChangesAsync();
test.AddLog("CardNote deleted.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("6. Verifying CardNote is deleted...");
var exists = await db.CardNotes.AnyAsync(n => n.CardName == testCardName);
if (exists)
throw new Exception("CardNote still exists after deletion.");
test.AddLog("CardNote deletion verified.");
}
}, progressCallback));
// 4. UserDeck CRUD & JSONB Serialization Test
results.Add(await RunTestCaseAsync("DB-04", "UserDeck CRUD & JSONB Mapping", "UserDecks",
"Validates JSON column mapping for Cards and Divers collections in PostgreSQL/EF Core.",
async test =>
{
var testDeckId = Guid.NewGuid();
var testDeckName = $"Test Deck {Guid.NewGuid():N}";
var initialCards = new List<string>
{
"Agent Alpha",
"Agent Alpha",
"Agent Alpha",
"Spell Omega",
"Spell Omega"
};
var initialDivers = new List<string> { "Agent Alpha" };
await using (var db = _configService.CreateDbContext())
{
test.AddLog($"1. Inserting UserDeck '{testDeckName}' with {initialCards.Count} cards and {initialDivers.Count} divers...");
var deck = new UserDeck
{
Id = testDeckId,
Name = testDeckName,
Notes = "Automated test deck notes",
Season = "Test Season 1",
UpdatedAt = DateTime.UtcNow,
Cards = initialCards,
Divers = initialDivers
};
db.UserDecks.Add(deck);
await db.SaveChangesAsync();
test.AddLog("UserDeck saved with JSON structures.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("2. Querying UserDeck and checking deserialized JSON lists...");
var fetched = await db.UserDecks.FirstOrDefaultAsync(d => d.Id == testDeckId);
if (fetched == null) throw new Exception("UserDeck not found after insertion.");
if (fetched.Cards == null || fetched.Cards.Count != 5)
throw new Exception($"Expected 5 cards in deck, found {fetched.Cards?.Count ?? 0}");
if (fetched.Divers == null || fetched.Divers.Count != 1 || fetched.Divers[0] != "Agent Alpha")
throw new Exception($"Diver entry deserialization mismatch.");
test.AddLog("JSON properties successfully verified.");
test.AddLog("3. Modifying cards list in UserDeck...");
fetched.Cards.Add("Added Card Gamma");
fetched.Divers.Add("Added Diver");
fetched.Name = testDeckName + " (Updated)";
await db.SaveChangesAsync();
test.AddLog("Updated deck with additional cards and divers.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("4. Validating updated cards and divers...");
var fetched = await db.UserDecks.FirstOrDefaultAsync(d => d.Id == testDeckId);
if (fetched == null || fetched.Cards?.Count != 6 || fetched.Divers?.Count != 2)
throw new Exception("Updated JSON collections did not persist correctly.");
test.AddLog("Updated JSON verified.");
test.AddLog("5. Deleting UserDeck...");
db.UserDecks.Remove(fetched);
await db.SaveChangesAsync();
test.AddLog("UserDeck deleted.");
}
await using (var db = _configService.CreateDbContext())
{
var exists = await db.UserDecks.AnyAsync(d => d.Id == testDeckId);
if (exists) throw new Exception("UserDeck still exists after deletion.");
test.AddLog("UserDeck deletion confirmed.");
}
}, progressCallback));
// 5. PasskeyCredential Binary Handling Test
results.Add(await RunTestCaseAsync("DB-05", "PasskeyCredential Binary Storage", "Passkeys",
"Validates byte array (byte[]) handling for CredentialId, PublicKey, and UserHandle.",
async test =>
{
var credId = new byte[] { 0x01, 0x02, 0x03, 0x04, 0xAA, 0xBB, 0xCC, 0xDD, 0x10, 0x20, 0x30, 0x40 };
var pubKey = new byte[] { 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86 };
var userHandle = new byte[] { 0xFE, 0xDC, 0xBA, 0x98 };
var aaGuid = Guid.NewGuid().ToString();
long signCount = 100;
int savedId = 0;
await using (var db = _configService.CreateDbContext())
{
test.AddLog("1. Creating PasskeyCredential with raw byte arrays...");
var passkey = new PasskeyCredential
{
CredentialId = credId,
PublicKey = pubKey,
UserHandle = userHandle,
AaGuid = aaGuid,
SignCount = signCount
};
db.PasskeyCredentials.Add(passkey);
await db.SaveChangesAsync();
savedId = passkey.Id;
test.AddLog($"Passkey stored with generated ID: {savedId}");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("2. Querying Passkey and verifying byte-for-byte exact equality...");
var fetched = await db.PasskeyCredentials.FirstOrDefaultAsync(p => p.Id == savedId);
if (fetched == null) throw new Exception("Passkey not found after insertion.");
if (!fetched.CredentialId.SequenceEqual(credId))
throw new Exception("CredentialId byte array does not match original bytes.");
if (!fetched.PublicKey.SequenceEqual(pubKey))
throw new Exception("PublicKey byte array does not match original bytes.");
if (!fetched.UserHandle.SequenceEqual(userHandle))
throw new Exception("UserHandle byte array does not match original bytes.");
if (fetched.SignCount != signCount)
throw new Exception($"SignCount mismatch: expected {signCount}, got {fetched.SignCount}");
test.AddLog("Binary fields verified successfully.");
test.AddLog("3. Incrementing SignCount...");
fetched.SignCount += 1;
await db.SaveChangesAsync();
test.AddLog($"Updated SignCount to {fetched.SignCount}.");
}
await using (var db = _configService.CreateDbContext())
{
var fetched = await db.PasskeyCredentials.FirstOrDefaultAsync(p => p.Id == savedId);
if (fetched == null || fetched.SignCount != 101)
throw new Exception("SignCount increment was not persisted.");
test.AddLog("4. Deleting Passkey...");
db.PasskeyCredentials.Remove(fetched);
await db.SaveChangesAsync();
test.AddLog("Passkey deleted.");
}
await using (var db = _configService.CreateDbContext())
{
var exists = await db.PasskeyCredentials.AnyAsync(p => p.Id == savedId);
if (exists) throw new Exception("Passkey still exists after deletion.");
test.AddLog("Passkey deletion confirmed.");
}
}, progressCallback));
// 6. Primary Key & Duplicate Key Constraint Test
results.Add(await RunTestCaseAsync("DB-06", "Primary Key & Duplicate Constraints", "Integrity",
"Verifies that attempting to insert a duplicate primary key throws DbUpdateException.",
async test =>
{
var duplicateKey = $"__DupTest_{Guid.NewGuid():N}";
await using (var db = _configService.CreateDbContext())
{
test.AddLog($"1. Inserting initial record with key '{duplicateKey}'...");
db.CardNotes.Add(new CardNote { CardName = duplicateKey, Note = "First note" });
await db.SaveChangesAsync();
test.AddLog("Initial record created.");
}
try
{
await using (var db = _configService.CreateDbContext())
{
test.AddLog("2. Attempting to insert duplicate record with same primary key...");
db.CardNotes.Add(new CardNote { CardName = duplicateKey, Note = "Second duplicate note" });
await db.SaveChangesAsync();
}
throw new Exception("Expected exception on duplicate primary key, but operation succeeded!");
}
catch (DbUpdateException dbEx)
{
test.AddLog($"Expected DbUpdateException caught: {dbEx.Message}");
}
catch (ArgumentException argEx)
{
test.AddLog($"Expected ArgumentException caught: {argEx.Message}");
}
catch (InvalidOperationException invEx)
{
test.AddLog($"Expected key constraint exception caught: {invEx.Message}");
}
finally
{
// Cleanup
await using var db = _configService.CreateDbContext();
var toClean = await db.CardNotes.FirstOrDefaultAsync(n => n.CardName == duplicateKey);
if (toClean != null)
{
db.CardNotes.Remove(toClean);
await db.SaveChangesAsync();
test.AddLog("Cleaned up test record.");
}
}
}, progressCallback));
// 7. Transaction Rollback Verification
results.Add(await RunTestCaseAsync("DB-07", "Transaction Rollback Support", "Transactions",
"Verifies that uncommitted transactions roll back changes cleanly on failure.",
async test =>
{
if (_configService.ProviderType != DatabaseProviderType.PostgreSQL)
{
test.AddLog("Transaction testing requires relational provider (PostgreSQL). Skipping for In-Memory.");
return;
}
var transCard = $"__Trans_{Guid.NewGuid():N}";
await using (var db = _configService.CreateDbContext())
{
test.AddLog("1. Beginning transaction...");
await using var transaction = await db.Database.BeginTransactionAsync();
test.AddLog($"2. Inserting card '{transCard}' inside transaction...");
db.CardNotes.Add(new CardNote { CardName = transCard, Note = "Transaction Note" });
await db.SaveChangesAsync();
test.AddLog("3. Rolling back transaction explicitly without committing...");
await transaction.RollbackAsync();
test.AddLog("Transaction rolled back.");
}
await using (var db = _configService.CreateDbContext())
{
test.AddLog("4. Verifying that the rolled back card note was NOT persisted...");
var exists = await db.CardNotes.AnyAsync(n => n.CardName == transCard);
if (exists)
throw new Exception("Record was persisted despite transaction rollback!");
test.AddLog("Rollback verified: record does not exist in database.");
}
}, progressCallback));
return results;
}
private static async Task<DatabaseTestCaseResult> RunTestCaseAsync(
string id,
string name,
string category,
string description,
Func<DatabaseTestCaseResult, Task> testAction,
Action<string>? progressCallback)
{
var test = new DatabaseTestCaseResult
{
Id = id,
Name = name,
Category = category,
Description = description,
Status = TestStatus.Running
};
progressCallback?.Invoke($"Running {name}...");
var sw = Stopwatch.StartNew();
try
{
await testAction(test);
sw.Stop();
test.DurationMs = sw.ElapsedMilliseconds;
test.Status = TestStatus.Passed;
test.AddLog($"Test PASSED in {test.DurationMs}ms.");
progressCallback?.Invoke($"Passed {name} ({test.DurationMs}ms)");
}
catch (Exception ex)
{
sw.Stop();
test.DurationMs = sw.ElapsedMilliseconds;
test.Status = TestStatus.Failed;
test.ErrorMessage = ex.Message;
test.StackTrace = ex.StackTrace;
test.AddLog($"Test FAILED: {ex.Message}");
progressCallback?.Invoke($"Failed {name}: {ex.Message}");
}
return test;
}
}