Reorganize tests by API and service concerns

RpgRoller.Tests/Services/DiceRulesTests.cs

@@ -0,0 +1,36 @@
+using RpgRoller.Services;
+
+namespace RpgRoller.Tests;
+
+public sealed class DiceRulesTests
+{
+    [Fact]
+    public void DiceRules_CoversParsingAndMappingBranches()
+    {
+        Assert.Equal(RulesetKind.D6, DiceRules.TryParseRulesetId("d6"));
+        Assert.Equal(RulesetKind.Dnd5e, DiceRules.TryParseRulesetId("dnd5e"));
+        Assert.Null(DiceRules.TryParseRulesetId("unknown"));
+
+        var d6 = DiceRules.ParseExpression(RulesetKind.D6, "5D+4");
+        var dnd = DiceRules.ParseExpression(RulesetKind.Dnd5e, "2d12+2");
+        var emptyExpression = DiceRules.ParseExpression(RulesetKind.Dnd5e, "");
+        var badFormat = DiceRules.ParseExpression(RulesetKind.Dnd5e, "abc");
+        var tooManyDice = DiceRules.ParseExpression(RulesetKind.D6, "51D+1");
+        var tooManySides = DiceRules.ParseExpression(RulesetKind.Dnd5e, "1d1001");
+        var tooLargeModifier = DiceRules.ParseExpression(RulesetKind.Dnd5e, "1d20+1001");
+        var unknownRulesetExpression = DiceRules.ParseExpression((RulesetKind)99, "1d20+1");
+
+        Assert.True(d6.Succeeded);
+        Assert.True(dnd.Succeeded);
+        Assert.False(emptyExpression.Succeeded);
+        Assert.False(badFormat.Succeeded);
+        Assert.False(tooManyDice.Succeeded);
+        Assert.False(tooManySides.Succeeded);
+        Assert.False(tooLargeModifier.Succeeded);
+        Assert.False(unknownRulesetExpression.Succeeded);
+
+        Assert.Equal("d6", DiceRules.ToRulesetId(RulesetKind.D6));
+        Assert.Equal("dnd5e", DiceRules.ToRulesetId(RulesetKind.Dnd5e));
+        Assert.Throws<ArgumentOutOfRangeException>(() => DiceRules.ToRulesetId((RulesetKind)99));
+    }
+}

RpgRoller.Tests/Services/RandomDiceRollerTests.cs

@@ -0,0 +1,17 @@
+using RpgRoller.Services;
+
+namespace RpgRoller.Tests;
+
+public sealed class RandomDiceRollerTests
+{
+    [Fact]
+    public void RandomDiceRoller_ProducesValueWithinRange()
+    {
+        var roller = new RandomDiceRoller();
+        for (var i = 0; i < 64; i += 1)
+        {
+            var value = roller.Roll(12);
+            Assert.InRange(value, 1, 12);
+        }
+    }
+}

RpgRoller.Tests/Services/ServiceAuthTests.cs

@@ -0,0 +1,59 @@
+namespace RpgRoller.Tests;
+
+public sealed class ServiceAuthTests
+{
+    [Fact]
+    public void Register_ValidatesRequiredFieldsAndDuplicates()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+
+        var invalidUsername = service.Register(new RegisterCommand("", "Password123", "Display"));
+        var invalidDisplay = service.Register(new RegisterCommand("user", "Password123", ""));
+        var invalidPassword = service.Register(new RegisterCommand("user", "short", "Display"));
+        var valid = service.Register(new RegisterCommand("user", "Password123", "Display"));
+        var duplicate = service.Register(new RegisterCommand("user", "Password123", "Display 2"));
+
+        Assert.False(invalidUsername.Succeeded);
+        Assert.False(invalidDisplay.Succeeded);
+        Assert.False(invalidPassword.Succeeded);
+        Assert.True(valid.Succeeded);
+        Assert.False(duplicate.Succeeded);
+    }
+
+    [Fact]
+    public void Login_ValidatesCredentialsAndSessionLookup()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+        service.Register(new RegisterCommand("user", "Password123", "Display"));
+
+        var invalidUser = service.Login(new LoginCommand("missing", "Password123"));
+        var invalidPassword = service.Login(new LoginCommand("user", "bad-password"));
+        var valid = service.Login(new LoginCommand("user", "Password123"));
+
+        Assert.False(invalidUser.Succeeded);
+        Assert.False(invalidPassword.Succeeded);
+        Assert.True(valid.Succeeded);
+
+        var sessionUser = service.GetUserBySession(valid.Value.SessionToken);
+        Assert.NotNull(sessionUser);
+
+        service.Logout(valid.Value.SessionToken);
+        Assert.Null(service.GetUserBySession(valid.Value.SessionToken));
+    }
+
+    [Fact]
+    public void Login_RehashesPasswordWhenHasherRequestsIt()
+    {
+        var hasher = new ServiceTestSupport.RehashingPasswordHasher();
+        using var harness = ServiceTestSupport.CreateHarness(hasher);
+        var service = harness.Service;
+
+        service.Register(new RegisterCommand("user", "Password123", "Display"));
+        var login = service.Login(new LoginCommand("user", "Password123"));
+
+        Assert.True(login.Succeeded);
+        Assert.Equal(2, hasher.HashCalls);
+    }
+}

RpgRoller.Tests/Services/ServiceCampaignTests.cs

@@ -0,0 +1,100 @@
+namespace RpgRoller.Tests;
+
+public sealed class ServiceCampaignTests
+{
+    [Fact]
+    public void CampaignAndCharacterOperations_CheckUnauthorizedAndNotFoundCases()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+
+        var unauthorizedCampaign = service.CreateCampaign("missing", new CreateCampaignCommand("Name", "d6"));
+        Assert.False(unauthorizedCampaign.Succeeded);
+
+        service.Register(new RegisterCommand("gm", "Password123", "GM"));
+        var gmSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("gm", "Password123"))).SessionToken;
+        var campaign = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Name", "d6")));
+
+        var invalidRuleset = service.CreateCampaign(gmSession, new CreateCampaignCommand("Name 2", "unknown"));
+        Assert.False(invalidRuleset.Succeeded);
+
+        var noCampaignCharacter = service.CreateCharacter(gmSession, new CreateCharacterCommand("Hero", Guid.NewGuid()));
+        Assert.False(noCampaignCharacter.Succeeded);
+
+        var character = ServiceTestSupport.GetValue(service.CreateCharacter(gmSession, new CreateCharacterCommand("Hero", campaign.Id)));
+
+        var missingCharacterActivate = service.ActivateCharacter(gmSession, Guid.NewGuid());
+        Assert.False(missingCharacterActivate.Succeeded);
+
+        var activateSuccess = service.ActivateCharacter(gmSession, character.Id);
+        Assert.True(activateSuccess.Succeeded);
+
+        var currentCharacters = service.GetCurrentCampaignCharacters(gmSession);
+        Assert.True(currentCharacters.Succeeded);
+        Assert.Single(ServiceTestSupport.GetValue(currentCharacters));
+
+        var missingCampaignGet = service.GetCampaign(gmSession, Guid.NewGuid());
+        Assert.False(missingCampaignGet.Succeeded);
+    }
+
+    [Fact]
+    public void CurrentCampaignCharacters_ReturnsNoActiveCharacterWhenUnset()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+        service.Register(new RegisterCommand("user", "Password123", "User"));
+        var sessionToken = ServiceTestSupport.GetValue(service.Login(new LoginCommand("user", "Password123"))).SessionToken;
+
+        var result = service.GetCurrentCampaignCharacters(sessionToken);
+        Assert.False(result.Succeeded);
+    }
+
+    [Fact]
+    public void GetCampaigns_ReturnsOwnedAndParticipatingCampaigns()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+        service.Register(new RegisterCommand("gm", "Password123", "GM"));
+        service.Register(new RegisterCommand("player", "Password123", "Player"));
+        var gmSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("gm", "Password123"))).SessionToken;
+        var playerSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("player", "Password123"))).SessionToken;
+
+        var gmCampaign = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Owned", "d6")));
+        _ = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Owned 2", "d6")));
+        _ = service.CreateCharacter(playerSession, new CreateCharacterCommand("Joiner", gmCampaign.Id));
+
+        var playerCampaigns = service.GetCampaigns(playerSession);
+        Assert.True(playerCampaigns.Succeeded);
+        var campaigns = ServiceTestSupport.GetValue(playerCampaigns);
+        Assert.Single(campaigns);
+        Assert.Equal(gmCampaign.Id, campaigns[0].Id);
+    }
+
+    [Fact]
+    public void GetCampaign_ForNonGm_ReturnsOnlyOwnedCharactersAndSkills()
+    {
+        using var harness = ServiceTestSupport.CreateHarness();
+        var service = harness.Service;
+
+        service.Register(new RegisterCommand("gm", "Password123", "GM"));
+        service.Register(new RegisterCommand("owner", "Password123", "Owner"));
+        service.Register(new RegisterCommand("other", "Password123", "Other"));
+
+        var gmSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("gm", "Password123"))).SessionToken;
+        var ownerSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("owner", "Password123"))).SessionToken;
+        var otherSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("other", "Password123"))).SessionToken;
+
+        var campaign = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Main", "d6")));
+        var ownerCharacter = ServiceTestSupport.GetValue(service.CreateCharacter(ownerSession, new CreateCharacterCommand("Owner Character", campaign.Id)));
+        var otherCharacter = ServiceTestSupport.GetValue(service.CreateCharacter(otherSession, new CreateCharacterCommand("Other Character", campaign.Id)));
+
+        var ownerSkill = ServiceTestSupport.GetValue(service.CreateSkill(ownerSession, ownerCharacter.Id, new CreateSkillCommand("Stealth", "2D+1")));
+        _ = ServiceTestSupport.GetValue(service.CreateSkill(otherSession, otherCharacter.Id, new CreateSkillCommand("Perception", "1D+2")));
+
+        var ownerView = ServiceTestSupport.GetValue(service.GetCampaign(ownerSession, campaign.Id));
+        Assert.Single(ownerView.Characters);
+        Assert.Equal(ownerCharacter.Id, ownerView.Characters[0].Id);
+        Assert.Single(ownerView.Skills);
+        Assert.Equal(ownerSkill.Id, ownerView.Skills[0].Id);
+    }
+}

RpgRoller.Tests/Services/ServicePersistenceTests.cs

@@ -0,0 +1,94 @@
+namespace RpgRoller.Tests;
+
+public sealed class ServicePersistenceTests
+{
+    [Fact]
+    public void ServiceGuardAndPersistenceBranches_AreHandled()
+    {
+        using var harness = ServiceTestSupport.CreateHarness(2, 3, 4);
+        var service = harness.Service;
+
+        var invalidCredentials = service.Login(new LoginCommand("", ""));
+        Assert.False(invalidCredentials.Succeeded);
+
+        service.Logout("missing-session");
+
+        service.Register(new RegisterCommand("gm", "Password123", "GM"));
+        service.Register(new RegisterCommand("owner", "Password123", "Owner"));
+        service.Register(new RegisterCommand("other", "Password123", "Other"));
+
+        var gmSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("gm", "Password123"))).SessionToken;
+        var ownerSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("owner", "Password123"))).SessionToken;
+        var otherSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("other", "Password123"))).SessionToken;
+
+        var campaign = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Main", "d6")));
+        var ownerCharacter = ServiceTestSupport.GetValue(service.CreateCharacter(ownerSession, new CreateCharacterCommand("Owner Character", campaign.Id)));
+
+        Assert.False(service.GetMe(string.Empty).Succeeded);
+        Assert.False(service.CreateCampaign(gmSession, new CreateCampaignCommand("", "d6")).Succeeded);
+        Assert.False(service.GetCampaigns(string.Empty).Succeeded);
+        Assert.False(service.CreateCharacter(ownerSession, new CreateCharacterCommand("", campaign.Id)).Succeeded);
+        Assert.False(service.CreateCharacter(string.Empty, new CreateCharacterCommand("Name", campaign.Id)).Succeeded);
+        Assert.False(service.UpdateCharacter(string.Empty, ownerCharacter.Id, new UpdateCharacterCommand("Renamed", campaign.Id)).Succeeded);
+        Assert.False(service.UpdateCharacter(ownerSession, Guid.NewGuid(), new UpdateCharacterCommand("Renamed", campaign.Id)).Succeeded);
+        Assert.False(service.ActivateCharacter(string.Empty, ownerCharacter.Id).Succeeded);
+        Assert.False(service.ActivateCharacter(gmSession, ownerCharacter.Id).Succeeded);
+        Assert.False(service.GetCurrentCampaignCharacters(string.Empty).Succeeded);
+        Assert.False(service.CreateSkill(string.Empty, ownerCharacter.Id, new CreateSkillCommand("Stealth", "2D+1")).Succeeded);
+        Assert.False(service.CreateSkill(ownerSession, Guid.NewGuid(), new CreateSkillCommand("Stealth", "2D+1")).Succeeded);
+        Assert.False(service.CreateSkill(otherSession, ownerCharacter.Id, new CreateSkillCommand("Stealth", "2D+1")).Succeeded);
+
+        using (var db = harness.CreateDbContext())
+        {
+            var ownerUser = db.Users.Single(u => u.UsernameNormalized == "OWNER");
+            ownerUser.ActiveCharacterId = Guid.NewGuid();
+            db.SaveChanges();
+        }
+
+        using var staleMeHarness = ServiceTestSupport.CreateHarnessFromPath(harness.DbPath, 2, 3, 4);
+        var staleMeService = staleMeHarness.Service;
+
+        var staleMe = ServiceTestSupport.GetValue(staleMeService.GetMe(ownerSession));
+        Assert.Null(staleMe.ActiveCharacterId);
+        Assert.Null(staleMe.CurrentCampaignId);
+
+        Assert.True(staleMeService.ActivateCharacter(ownerSession, ownerCharacter.Id).Succeeded);
+        var activeMe = ServiceTestSupport.GetValue(staleMeService.GetMe(ownerSession));
+        Assert.Equal(ownerCharacter.Id, activeMe.ActiveCharacterId);
+        Assert.Equal(campaign.Id, activeMe.CurrentCampaignId);
+
+        using (var db = harness.CreateDbContext())
+        {
+            var staleOwner = db.Users.Single(u => u.UsernameNormalized == "OWNER");
+            staleOwner.ActiveCharacterId = Guid.NewGuid();
+            db.SaveChanges();
+        }
+
+        using var staleCurrentHarness = ServiceTestSupport.CreateHarnessFromPath(harness.DbPath, 2, 3, 4);
+        var staleCurrentService = staleCurrentHarness.Service;
+
+        var staleCurrentCampaign = staleCurrentService.GetCurrentCampaignCharacters(ownerSession);
+        Assert.False(staleCurrentCampaign.Succeeded);
+        using (var db = harness.CreateDbContext())
+        {
+            Assert.Null(db.Users.Single(u => u.UsernameNormalized == "OWNER").ActiveCharacterId);
+        }
+
+        var skill = ServiceTestSupport.GetValue(service.CreateSkill(ownerSession, ownerCharacter.Id, new CreateSkillCommand("Stealth", "2D+1")));
+        Assert.False(service.UpdateSkill(ownerSession, skill.Id, new UpdateSkillCommand("", "2D+1")).Succeeded);
+        Assert.False(service.UpdateSkill(string.Empty, skill.Id, new UpdateSkillCommand("Stealth", "2D+1")).Succeeded);
+        Assert.False(service.UpdateSkill(ownerSession, skill.Id, new UpdateSkillCommand("Stealth", "bad")).Succeeded);
+        Assert.False(service.RollSkill(string.Empty, skill.Id, new RollSkillCommand("public")).Succeeded);
+
+        using (var db = harness.CreateDbContext())
+        {
+            var mutableSkill = db.Skills.Single(s => s.Id == skill.Id);
+            mutableSkill.DiceRollDefinition = "bad";
+            db.SaveChanges();
+        }
+
+        using var invalidExpressionHarness = ServiceTestSupport.CreateHarnessFromPath(harness.DbPath, 2, 3, 4);
+        Assert.False(invalidExpressionHarness.Service.RollSkill(ownerSession, skill.Id, new RollSkillCommand("public")).Succeeded);
+        Assert.False(service.GetCampaignLog(string.Empty, campaign.Id).Succeeded);
+    }
+}

RpgRoller.Tests/Services/ServiceSkillRollTests.cs

@@ -0,0 +1,74 @@
+namespace RpgRoller.Tests;
+
+public sealed class ServiceSkillRollTests
+{
+    [Fact]
+    public void CharacterSkillAndRollOperations_CheckAuthorizationAndValidationBranches()
+    {
+        using var harness = ServiceTestSupport.CreateHarness(3, 4, 5, 6);
+        var service = harness.Service;
+        service.Register(new RegisterCommand("gm", "Password123", "GM"));
+        service.Register(new RegisterCommand("owner", "Password123", "Owner"));
+        service.Register(new RegisterCommand("other", "Password123", "Other"));
+
+        var gmSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("gm", "Password123"))).SessionToken;
+        var ownerSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("owner", "Password123"))).SessionToken;
+        var otherSession = ServiceTestSupport.GetValue(service.Login(new LoginCommand("other", "Password123"))).SessionToken;
+
+        var campaign = ServiceTestSupport.GetValue(service.CreateCampaign(gmSession, new CreateCampaignCommand("Main", "dnd5e")));
+        var character = ServiceTestSupport.GetValue(service.CreateCharacter(ownerSession, new CreateCharacterCommand("Owner Char", campaign.Id)));
+
+        var noPermissionUpdate = service.UpdateCharacter(otherSession, character.Id, new UpdateCharacterCommand("Renamed", campaign.Id));
+        Assert.False(noPermissionUpdate.Succeeded);
+
+        var invalidCharacterName = service.UpdateCharacter(ownerSession, character.Id, new UpdateCharacterCommand("", campaign.Id));
+        Assert.False(invalidCharacterName.Succeeded);
+
+        var missingTargetCampaign = service.UpdateCharacter(ownerSession, character.Id, new UpdateCharacterCommand("Renamed", Guid.NewGuid()));
+        Assert.False(missingTargetCampaign.Succeeded);
+
+        var noSkillName = service.CreateSkill(ownerSession, character.Id, new CreateSkillCommand("", "1d20"));
+        Assert.False(noSkillName.Succeeded);
+
+        var invalidExpression = service.CreateSkill(ownerSession, character.Id, new CreateSkillCommand("Skill", "5D+4"));
+        Assert.False(invalidExpression.Succeeded);
+
+        var skill = ServiceTestSupport.GetValue(service.CreateSkill(ownerSession, character.Id, new CreateSkillCommand("Skill", "1d20+2")));
+
+        var missingSkillUpdate = service.UpdateSkill(ownerSession, Guid.NewGuid(), new UpdateSkillCommand("X", "1d20"));
+        Assert.False(missingSkillUpdate.Succeeded);
+
+        var forbiddenSkillUpdate = service.UpdateSkill(otherSession, skill.Id, new UpdateSkillCommand("X", "1d20"));
+        Assert.False(forbiddenSkillUpdate.Succeeded);
+
+        var gmSkillUpdate = service.UpdateSkill(gmSession, skill.Id, new UpdateSkillCommand("GM Edit", "2d6+1"));
+        Assert.True(gmSkillUpdate.Succeeded);
+
+        var missingRoll = service.RollSkill(ownerSession, Guid.NewGuid(), new RollSkillCommand("public"));
+        Assert.False(missingRoll.Succeeded);
+
+        var invalidVisibility = service.RollSkill(ownerSession, skill.Id, new RollSkillCommand("hidden"));
+        Assert.False(invalidVisibility.Succeeded);
+
+        var forbiddenRoll = service.RollSkill(otherSession, skill.Id, new RollSkillCommand("public"));
+        Assert.False(forbiddenRoll.Succeeded);
+
+        var privateRoll = service.RollSkill(ownerSession, skill.Id, new RollSkillCommand("private"));
+        var publicRoll = service.RollSkill(ownerSession, skill.Id, new RollSkillCommand("public"));
+        Assert.True(privateRoll.Succeeded);
+        Assert.True(publicRoll.Succeeded);
+
+        var ownerLog = service.GetCampaignLog(ownerSession, campaign.Id);
+        var gmLog = service.GetCampaignLog(gmSession, campaign.Id);
+        var outsiderLog = service.GetCampaignLog(otherSession, campaign.Id);
+
+        Assert.Equal(2, ServiceTestSupport.GetValue(ownerLog).Count);
+        Assert.Equal(2, ServiceTestSupport.GetValue(gmLog).Count);
+        Assert.False(outsiderLog.Succeeded);
+
+        var version = service.GetCampaignVersion(ownerSession, campaign.Id);
+        var missingVersion = service.GetCampaignVersion(ownerSession, Guid.NewGuid());
+        Assert.True(version.Succeeded);
+        Assert.False(missingVersion.Succeeded);
+    }
+}