...

Chrono/Tests/DatabaseServiceTests.cs

@@ -1,6 +1,8 @@
+using API.Services;
 using Cloud.Models;
 using DatabaseTest.Models;
 using DatabaseTest.Services;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging.Abstractions;
 using Model;
@@ -283,4 +285,129 @@ public class DatabaseServiceTests
         Assert.That(description, Does.Contain("Password=******"));
         Assert.That(description, Does.Not.Contain("secret_password"));
     }
+
+    [Test]
+    public async Task AddNewUser_ValidationAndTrimming_WorksCorrectly()
+    {
+        // Empty username fails
+        var emptyUser = new User { Username = "   ", Password = "valid_password" };
+        var emptyRes = await _dbService.SaveUserAsync(emptyUser, true);
+        Assert.That(emptyRes.Success, Is.False);
+        Assert.That(emptyRes.Message, Does.Contain("Username is required"));
+
+        // Empty password fails
+        var noPassUser = new User { Username = "valid_user", Password = "  " };
+        var noPassRes = await _dbService.SaveUserAsync(noPassUser, true);
+        Assert.That(noPassRes.Success, Is.False);
+        Assert.That(noPassRes.Message, Does.Contain("Password is required"));
+
+        // Valid user with padding gets trimmed and created
+        var paddedUser = new User { Username = "  trimmed_user  ", Password = "  pass123  " };
+        var okRes = await _dbService.SaveUserAsync(paddedUser, true);
+        Assert.That(okRes.Success, Is.True);
+
+        var savedUser = await _dbService.GetUserAsync("trimmed_user");
+        Assert.That(savedUser, Is.Not.Null);
+        Assert.That(savedUser!.Username, Is.EqualTo("trimmed_user"));
+        Assert.That(savedUser.Password, Is.EqualTo("pass123"));
+    }
+
+    [Test]
+    public async Task AddNewNote_ValidationAndTrimming_WorksCorrectly()
+    {
+        // Empty card name fails
+        var emptyCard = new CardNote { CardName = "   ", Username = "user1", Note = "Some note" };
+        var emptyRes = await _dbService.SaveCardNoteAsync(emptyCard, true);
+        Assert.That(emptyRes.Success, Is.False);
+        Assert.That(emptyRes.Message, Does.Contain("Card name is required"));
+
+        // Valid note with padding gets trimmed and created
+        var paddedNote = new CardNote { CardName = "  Arcane Spell  ", Username = "  player2  ", Note = "  Important note  " };
+        var okRes = await _dbService.SaveCardNoteAsync(paddedNote, true);
+        Assert.That(okRes.Success, Is.True);
+
+        var savedNote = await _dbService.GetCardNoteAsync("Arcane Spell", "player2");
+        Assert.That(savedNote, Is.Not.Null);
+        Assert.That(savedNote!.CardName, Is.EqualTo("Arcane Spell"));
+        Assert.That(savedNote.Username, Is.EqualTo("player2"));
+        Assert.That(savedNote.Note, Is.EqualTo("Important note"));
+    }
+
+    [Test]
+    public void DatabaseTest_Migrations_IncludesAddUsersAndSyncCardNotes()
+    {
+        var migrations = typeof(Cloud.AppDbContext).Assembly.GetTypes()
+            .Where(t => typeof(Microsoft.EntityFrameworkCore.Migrations.Migration).IsAssignableFrom(t) && !t.IsAbstract)
+            .Select(t => t.Name)
+            .ToList();
+
+        Assert.That(migrations, Does.Contain("AddUsersAndSyncCardNotes"));
+    }
+
+    [Test]
+    public async Task CreateAccount_WithRandomCredentials_AgainstPostgreSql_AndTestAgainstLoginApi()
+    {
+        var config = new ConfigurationBuilder().Build();
+        var postgresConfigService = new DatabaseConfigService(config);
+        postgresConfigService.SetProvider(DatabaseProviderType.PostgreSQL);
+
+        var postgresDbService = new DatabaseService(postgresConfigService, NullLogger<DatabaseService>.Instance);
+        var health = await postgresDbService.CheckHealthAsync();
+        if (!health.IsConnected)
+        {
+            Assert.Ignore($"PostgreSQL database is not reachable at {postgresConfigService.ConnectionString}. Error: {health.ErrorMessage}");
+        }
+
+        await postgresDbService.ApplyMigrationsAsync();
+
+        var randomUsername = $"user_{Guid.NewGuid():N}";
+        var randomPassword = $"P@ss_{Guid.NewGuid():N}";
+        var newUser = new User
+        {
+            Username = randomUsername,
+            Password = randomPassword,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        try
+        {
+            // 1. Add account to PostgreSQL database using DatabaseTest service
+            var saveResult = await postgresDbService.SaveUserAsync(newUser, true);
+            Assert.That(saveResult.Success, Is.True, $"Failed to create user in PostgreSQL: {saveResult.Message}");
+
+            // 2. Verify account exists in the database
+            var fetchedUser = await postgresDbService.GetUserAsync(randomUsername);
+            Assert.That(fetchedUser, Is.Not.Null);
+            Assert.That(fetchedUser!.Username, Is.EqualTo(randomUsername));
+            Assert.That(fetchedUser.Password, Is.EqualTo(randomPassword));
+
+            // 3. Test against Login API using API's AppDbContext connected to the same PostgreSQL DB
+            var apiDbOptions = new DbContextOptionsBuilder<API.Data.AppDbContext>()
+                .UseNpgsql(postgresConfigService.ConnectionString)
+                .Options;
+            await using var apiDb = new API.Data.AppDbContext(apiDbOptions);
+
+            var tokenService = new TokenService();
+            var mutation = new API.GraphQL.Mutation();
+
+            // Test login with incorrect password
+            var invalidLogin = await mutation.Login(apiDb, tokenService, randomUsername, "wrong_" + randomPassword);
+            Assert.That(invalidLogin.Success, Is.False, "Login should fail with invalid password");
+            Assert.That(invalidLogin.Token, Is.Null);
+
+            // Test login with correct password
+            var validLogin = await mutation.Login(apiDb, tokenService, randomUsername, randomPassword);
+            Assert.That(validLogin.Success, Is.True, $"Login failed: {validLogin.Message}");
+            Assert.That(validLogin.Username, Is.EqualTo(randomUsername));
+            Assert.That(validLogin.Token, Is.Not.Null.And.Not.Empty);
+
+            var validatedUsername = tokenService.ValidateToken(validLogin.Token);
+            Assert.That(validatedUsername, Is.EqualTo(randomUsername));
+        }
+        finally
+        {
+            // Cleanup test user
+            await postgresDbService.DeleteUserAsync(randomUsername);
+        }
+    }
 }