gameauthapi/GameAuthApi.Tests/PlayerControllerTests.cs

using GameAuthApi.Controllers;
using GameAuthApi.Models;
using GameAuthApi.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using System.Security.Claims;

public class PlayerControllerTests
{
    private static IConfiguration cfg = new ConfigurationBuilder()
        .AddInMemoryCollection(new Dictionary<string,string>
        {
            {"MongoDB:ConnectionString","mongodb://localhost"},
            {"MongoDB:DatabaseName","test"}
        }).Build();

    private static ControllerContext ContextWithUser(string id, string role="USER")
    {
        var ctx = new DefaultHttpContext();
        ctx.User = new ClaimsPrincipal(new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.NameIdentifier, id),
            new Claim(ClaimTypes.Role, role)
        }, "mock"));
        return new ControllerContext { HttpContext = ctx };
    }

    [Fact]
    public async Task Create_ReturnsOk()
    {
        var playerService = new Mock<PlayerService>(cfg);
        playerService.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync((Player?)null);
        playerService.Setup(p => p.CreateAsync(It.IsAny<Player>())).Returns(Task.CompletedTask).Verifiable();
        var locSvc = new Mock<LocationService>(cfg);
        locSvc.Setup(l => l.GetSpawnLocationAsync()).ReturnsAsync((Location?)null);
        locSvc.Setup(l => l.CreateAsync(It.IsAny<Location>())).Returns(Task.CompletedTask);
        var controller = new PlayerController(playerService.Object, locSvc.Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.Create(new CreatePlayerRequest { Name = "p" });

        Assert.IsType<OkObjectResult>(result);
        playerService.Verify();
    }

    [Fact]
    public async Task Delete_NotFound()
    {
        var playerService = new Mock<PlayerService>(cfg);
        playerService.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync((Player?)null);
        var controller = new PlayerController(playerService.Object, new Mock<LocationService>(cfg).Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.Delete();

        Assert.IsType<NotFoundObjectResult>(result);
    }

    [Fact]
    public async Task Update_PlayerNotFound()
    {
        var svc = new Mock<PlayerService>(cfg);
        svc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync((Player?)null);
        var controller = new PlayerController(svc.Object, new Mock<LocationService>(cfg).Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.Update(new UpdatePlayerRequest { Name="n", Climbing=1 });

        Assert.IsType<NotFoundObjectResult>(result);
    }

    [Fact]
    public async Task AdminTeleport_PlayerNotFound()
    {
        var playerService = new Mock<PlayerService>(cfg);
        playerService.Setup(p => p.GetByIdAsync("p")).ReturnsAsync((Player?)null);
        var controller = new PlayerController(playerService.Object, new Mock<LocationService>(cfg).Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("admin", "SUPER")
        };

        var result = await controller.AdminTeleport(new TeleportRequest { PlayerId = "p", LocationId = "l" });

        Assert.IsType<NotFoundObjectResult>(result);
    }

    [Fact]
    public async Task Move_PlayerNotFound()
    {
        var playerService = new Mock<PlayerService>(cfg);
        playerService.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync((Player?)null);
        var controller = new PlayerController(playerService.Object, new Mock<LocationService>(cfg).Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.Move(new MoveRequest { Direction = "N" });

        Assert.IsType<NotFoundObjectResult>(result);
    }

    [Fact]
    public async Task PerformAction_PlayerNotFound()
    {
        var svc = new Mock<PlayerService>(cfg);
        svc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync((Player?)null);
        var controller = new PlayerController(svc.Object, new Mock<LocationService>(cfg).Object, new Mock<SpawnableService>(cfg).Object, new Mock<ItemService>(cfg).Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.PerformAction(new PerformActionRequest { Action = "gather" });

        Assert.IsType<NotFoundObjectResult>(result);
    }

    [Fact]
    public async Task PerformAction_ReturnsOutcome()
    {
        var playerSvc = new Mock<PlayerService>(cfg);
        var player = new Player { Id = "p", UserId = "u", LocationId = "loc", InventoryLocationId = "inv" };
        playerSvc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync(player);
        var locSvc = new Mock<LocationService>(cfg);
        var loc = new Location { Id = "loc", Content = new List<string> { "i" } };
        locSvc.Setup(l => l.GetByIdAsync("loc")).ReturnsAsync(loc);
        var itemSvc = new Mock<ItemService>(cfg);
        itemSvc.Setup(i => i.GetByIdAsync("i")).ReturnsAsync(new Item { Id = "i", Name = "wood" });
        var spawnSvc = new Mock<SpawnableService>(cfg);
        spawnSvc.Setup(s => s.GetByNameAsync("wood")).ReturnsAsync(new Spawnable
        {
            Name = "wood",
            CollectAction = "chop",
            CollectResults = new List<CollectOutcome> { new() { Result = "log", SuccessRate = 100 } },
            ConsumeOnSuccess = false
        });

        var controller = new PlayerController(playerSvc.Object, locSvc.Object, spawnSvc.Object, itemSvc.Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        var result = await controller.PerformAction(new PerformActionRequest { Action = "chop" });

        var ok = Assert.IsType<OkObjectResult>(result);
        Assert.Equal("log", ok.Value);
    }

    [Fact]
    public async Task PerformAction_AddsItemToInventory()
    {
        var playerSvc = new Mock<PlayerService>(cfg);
        var player = new Player { Id = "p", UserId = "u", LocationId = "loc", InventoryLocationId = "inv" };
        playerSvc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync(player);
        var locSvc = new Mock<LocationService>(cfg);
        var loc = new Location { Id = "loc", Content = new List<string> { "i" } };
        locSvc.Setup(l => l.GetByIdAsync("loc")).ReturnsAsync(loc);
        locSvc.Setup(l => l.AddItemToLocationAsync("inv", It.IsAny<string>())).Returns(Task.CompletedTask).Verifiable();
        locSvc.Setup(l => l.RemoveItemFromLocationAsync("loc", "i")).Returns(Task.CompletedTask).Verifiable();
        var itemSvc = new Mock<ItemService>(cfg);
        itemSvc.Setup(i => i.GetByIdAsync("i")).ReturnsAsync(new Item { Id = "i", Name = "wood" });
        itemSvc.Setup(i => i.CreateAsync(It.Is<Item>(it => it.Name == "log" && it.LocationId == "inv"))).Returns(Task.CompletedTask).Verifiable();
        itemSvc.Setup(i => i.DeleteAsync("i")).Returns(Task.CompletedTask).Verifiable();
        var spawnSvc = new Mock<SpawnableService>(cfg);
        spawnSvc.Setup(s => s.GetByNameAsync("wood")).ReturnsAsync(new Spawnable
        {
            Name = "wood",
            CollectAction = "chop",
            CollectResults = new List<CollectOutcome> { new() { Result = "log", SuccessRate = 100 } },
            ConsumeOnSuccess = true
        });

        var controller = new PlayerController(playerSvc.Object, locSvc.Object, spawnSvc.Object, itemSvc.Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        await controller.PerformAction(new PerformActionRequest { Action = "chop" });

        locSvc.Verify();
        itemSvc.Verify();
    }

    [Fact]
    public async Task PerformAction_DecrementsUses()
    {
        var playerSvc = new Mock<PlayerService>(cfg);
        var player = new Player { Id = "p", UserId = "u", LocationId = "loc", InventoryLocationId = "inv" };
        playerSvc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync(player);
        var locSvc = new Mock<LocationService>(cfg);
        var loc = new Location { Id = "loc", Content = new List<string> { "i" } };
        locSvc.Setup(l => l.GetByIdAsync("loc")).ReturnsAsync(loc);
        var itemSvc = new Mock<ItemService>(cfg);
        var item = new Item { Id = "i", Name = "wood", UsesRemaining = 2 };
        itemSvc.Setup(i => i.GetByIdAsync("i")).ReturnsAsync(item);
        itemSvc.Setup(i => i.UpdateAsync(It.Is<Item>(it => it.UsesRemaining == 1))).Returns(Task.CompletedTask).Verifiable();
        var spawnSvc = new Mock<SpawnableService>(cfg);
        spawnSvc.Setup(s => s.GetByNameAsync("wood")).ReturnsAsync(new Spawnable
        {
            Name = "wood",
            CollectAction = "chop",
            CollectResults = new List<CollectOutcome> { new() { Result = "log", SuccessRate = 100 } },
            ConsumeOnSuccess = false
        });

        var controller = new PlayerController(playerSvc.Object, locSvc.Object, spawnSvc.Object, itemSvc.Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        await controller.PerformAction(new PerformActionRequest { Action = "chop" });

        itemSvc.Verify();
    }

    [Fact]
    public async Task Move_SpawnableSetsItemUses()
    {
        var playerSvc = new Mock<PlayerService>(cfg);
        var player = new Player { Id = "p", UserId = "u", LocationId = "loc" };
        playerSvc.Setup(p => p.GetByUserIdAsync("u")).ReturnsAsync(player);
        playerSvc.Setup(p => p.UpdateAsync(It.IsAny<Player>())).Returns(Task.CompletedTask);

        var current = new Location { Id = "loc", X = 0, Y = 0, Z = 0 };
        var locSvc = new Mock<LocationService>(cfg);
        locSvc.Setup(l => l.GetByIdAsync("loc")).ReturnsAsync(current);
        locSvc.Setup(l => l.GetByCoordinatesAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>()))
            .ReturnsAsync((Location?)null);
        locSvc.Setup(l => l.CreateAsync(It.IsAny<Location>())).Returns(Task.CompletedTask);
        locSvc.Setup(l => l.UpdateAsync(It.IsAny<Location>())).Returns(Task.CompletedTask);
        locSvc.Setup(l => l.RemovePlayerFromLocationAsync("loc", "p")).Returns(Task.CompletedTask);
        locSvc.Setup(l => l.AddPlayerToLocationAsync(It.IsAny<string>(), "p")).Returns(Task.CompletedTask);

        var spawned = new Spawnable { Name = "wood", SpawnRate = 100, Uses = 3 };
        var spawnSvc = new Mock<SpawnableService>(cfg);
        spawnSvc.Setup(s => s.GetAllAsync()).ReturnsAsync([spawned]);

        var itemSvc = new Mock<ItemService>(cfg);
        Item? created = null;
        itemSvc.Setup(i => i.CreateAsync(It.IsAny<Item>()))
            .Callback<Item>(it => { created = it; it.Id = "i"; })
            .Returns(Task.CompletedTask);
        itemSvc.Setup(i => i.GetByIdAsync("i")).ReturnsAsync(() => created!);
        itemSvc.Setup(i => i.UpdateAsync(It.IsAny<Item>())).Returns(Task.CompletedTask);

        var controller = new PlayerController(playerSvc.Object, locSvc.Object, spawnSvc.Object, itemSvc.Object)
        {
            ControllerContext = ContextWithUser("u")
        };

        await controller.Move(new MoveRequest { Direction = "N" });

        Assert.NotNull(created);
        Assert.Equal(3, created!.UsesRemaining);
    }
}