baseline: OpenMU upstream b5a0961 (fresh source)

tests/MUnique.OpenMU.Tests/Offline/OfflinePlayerManagerTests.cs

@@ -0,0 +1,146 @@
+// <copyright file="OfflinePlayerManagerTests.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.Tests.Offline;
+
+using MUnique.OpenMU.AttributeSystem;
+using MUnique.OpenMU.DataModel.Configuration;
+using MUnique.OpenMU.GameLogic;
+using MUnique.OpenMU.GameLogic.Attributes;
+using MUnique.OpenMU.GameLogic.Offline;
+using MUnique.OpenMU.Persistence;
+
+/// <summary>
+/// Tests for <see cref="OfflinePlayerManager"/>.
+/// </summary>
+[TestFixture]
+public class OfflinePlayerManagerTests
+{
+    private const string TestUserLoginName = "test";
+    private const string TestCharacterName = "testChar";
+
+    private IGameContext _gameContext = null!;
+    private IPersistenceContextProvider _contextProvider = null!;
+
+    /// <summary>
+    /// Sets up a fresh game context before each test.
+    /// </summary>
+    [SetUp]
+    public void SetUp()
+    {
+        this._gameContext = GameContextTestHelper.CreateGameContext();
+        this._contextProvider = this._gameContext.PersistenceContextProvider;
+    }
+
+    /// <summary>
+    /// Tests that <see cref="OfflinePlayerManager.StartAsync"/> returns true on success.
+    /// </summary>
+    [Test]
+    public async ValueTask StartAsync_WithValidPlayer_ReturnsTrueAsync()
+    {
+        // Arrange
+        var manager = new OfflinePlayerManager();
+        var realPlayer = await this.CreatePlayerWithPersistedAccountAsync().ConfigureAwait(false);
+        realPlayer.TryAddMoney(1_000_000);
+        realPlayer.Attributes![Stats.Level] = 100;
+
+        // Act
+        var result = await manager.StartAsync(realPlayer, TestUserLoginName).ConfigureAwait(false);
+
+        // Assert
+        Assert.That(result, Is.True);
+        Assert.That(manager.IsActive(TestUserLoginName), Is.True);
+    }
+
+    /// <summary>
+    /// Tests that <see cref="OfflinePlayerManager.StartAsync"/> fails if the player has insufficient Zen.
+    /// </summary>
+    [Test]
+    public async ValueTask StartAsync_WithInsufficientZen_ReturnsFalseAsync()
+    {
+        // Arrange
+        var manager = new OfflinePlayerManager();
+        var realPlayer = await this.CreatePlayerWithPersistedAccountAsync().ConfigureAwait(false);
+        realPlayer.Money = 0; // No money
+        realPlayer.Attributes![Stats.Level] = 100;
+
+        // Act
+        var result = await manager.StartAsync(realPlayer, TestUserLoginName).ConfigureAwait(false);
+
+        // Assert
+        Assert.That(result, Is.False);
+        Assert.That(manager.IsActive(TestUserLoginName), Is.False);
+    }
+
+    /// <summary>
+    /// Tests that <see cref="OfflinePlayerManager.StopAsync"/> successfully stops a session.
+    /// </summary>
+    [Test]
+    public async ValueTask StopAsync_WhenSessionActive_StopsSuccessfullyAsync()
+    {
+        // Arrange
+        var manager = new OfflinePlayerManager();
+        var realPlayer = await this.CreatePlayerWithPersistedAccountAsync().ConfigureAwait(false);
+        realPlayer.TryAddMoney(1_000_000);
+        realPlayer.Attributes![Stats.Level] = 100;
+
+        var started = await manager.StartAsync(realPlayer, TestUserLoginName).ConfigureAwait(false);
+        Assert.That(started, Is.True);
+        Assert.That(manager.IsActive(TestUserLoginName), Is.True);
+
+        // Act
+        await manager.StopAsync(TestUserLoginName).ConfigureAwait(false);
+
+        // Assert
+        Assert.That(manager.IsActive(TestUserLoginName), Is.False);
+    }
+
+    /// <summary>
+    /// Creates a player whose account is stored in the in-memory repository,
+    /// so that <see cref="OfflinePlayer.InitializeAsync"/> can find it.
+    /// </summary>
+    private async ValueTask<Player> CreatePlayerWithPersistedAccountAsync()
+    {
+        var config = this._gameContext.Configuration;
+
+        // Create persisted account + character in the in-memory repository.
+        using (var ctx = this._contextProvider.CreateNewPlayerContext(config))
+        {
+            var account = ctx.CreateNew<MUnique.OpenMU.DataModel.Entities.Account>();
+            account.LoginName = TestUserLoginName;
+
+            var character = ctx.CreateNew<MUnique.OpenMU.DataModel.Entities.Character>();
+            character.Name = TestCharacterName;
+
+            if (config.CharacterClasses.FirstOrDefault() is { } existingClass)
+            {
+                character.CharacterClass = existingClass;
+            }
+            else
+            {
+                // Build a minimal CharacterClass so OnPlayerEnteredWorldAsync does not throw.
+                var characterClass = ctx.CreateNew<MUnique.OpenMU.DataModel.Configuration.CharacterClass>();
+                characterClass.HomeMap = config.Maps.FirstOrDefault();
+                character.CharacterClass = characterClass;
+            }
+
+            account.Characters.Add(character);
+            await ctx.SaveChangesAsync().ConfigureAwait(false);
+        }
+
+        var player = await PlayerTestHelper.CreatePlayerAsync(this._gameContext).ConfigureAwait(false);
+        player.Account!.LoginName = TestUserLoginName;
+
+        // Ensure the mock character name matches the persisted one.
+        var mockCharacter = player.SelectedCharacter!;
+        mockCharacter.Name = TestCharacterName;
+        mockCharacter.CharacterClass ??= player.Account.UnlockedCharacterClasses.FirstOrDefault();
+        if (mockCharacter.CharacterClass is null && config.CharacterClasses.FirstOrDefault() is { } cc)
+        {
+            mockCharacter.CharacterClass = cc;
+        }
+
+        return player;
+    }
+}