KoogleApp/test/Koogle.Tests/Unit/Store/ClubStateTests.cs

using Koogle.Application.DTOs;
using Koogle.Domain.Enums;
using Koogle.Tests.Common;
using Koogle.Web.Store.ClubState;

namespace Koogle.Tests.Unit.Store;

/// <summary>
/// Unit tests for ClubState reducers.
/// </summary>
public class ClubStateTests
{
    #region Initial State Tests

    [Fact]
    public void Initial_HasEmptyClubsList()
    {
        // Act
        var state = ClubState.Initial;

        // Assert
        state.Clubs.Should().BeEmpty();
    }

    [Fact]
    public void Initial_HasNullSelectedClub()
    {
        // Act
        var state = ClubState.Initial;

        // Assert
        state.SelectedClub.Should().BeNull();
    }

    [Fact]
    public void Initial_IsNotLoading()
    {
        // Act
        var state = ClubState.Initial;

        // Assert
        state.IsLoading.Should().BeFalse();
    }

    [Fact]
    public void Initial_HasNoError()
    {
        // Act
        var state = ClubState.Initial;

        // Assert
        state.Error.Should().BeNull();
    }

    #endregion

    #region LoadClubs Tests

    [Fact]
    public void OnLoadClubs_SetsIsLoadingTrue()
    {
        // Arrange
        var state = ClubState.Initial;

        // Act
        var result = ClubReducers.OnLoadClubs(state);

        // Assert
        result.IsLoading.Should().BeTrue();
    }

    [Fact]
    public void OnLoadClubs_ClearsError()
    {
        // Arrange
        var state = ClubState.Initial with { Error = "Previous error" };

        // Act
        var result = ClubReducers.OnLoadClubs(state);

        // Assert
        result.Error.Should().BeNull();
    }

    [Fact]
    public void OnLoadClubs_PreservesExistingClubs()
    {
        // Arrange
        var clubs = TestDataGenerator.CreateClubDtos(2);
        var state = ClubState.Initial with { Clubs = clubs };

        // Act
        var result = ClubReducers.OnLoadClubs(state);

        // Assert
        result.Clubs.Should().BeEquivalentTo(clubs);
    }

    [Fact]
    public void OnLoadClubsSuccess_SetsClubsList()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var clubs = TestDataGenerator.CreateClubDtos(3);
        var action = new LoadClubsSuccessAction(clubs);

        // Act
        var result = ClubReducers.OnLoadClubsSuccess(state, action);

        // Assert
        result.Clubs.Should().BeEquivalentTo(clubs);
    }

    [Fact]
    public void OnLoadClubsSuccess_SetsIsLoadingFalse()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new LoadClubsSuccessAction([]);

        // Act
        var result = ClubReducers.OnLoadClubsSuccess(state, action);

        // Assert
        result.IsLoading.Should().BeFalse();
    }

    [Fact]
    public void OnLoadClubsFailure_SetsError()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new LoadClubsFailureAction("Network error");

        // Act
        var result = ClubReducers.OnLoadClubsFailure(state, action);

        // Assert
        result.Error.Should().Be("Network error");
    }

    [Fact]
    public void OnLoadClubsFailure_SetsIsLoadingFalse()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new LoadClubsFailureAction("Error");

        // Act
        var result = ClubReducers.OnLoadClubsFailure(state, action);

        // Assert
        result.IsLoading.Should().BeFalse();
    }

    #endregion

    #region CreateClub Tests

    [Fact]
    public void OnCreateClub_SetsIsLoadingTrue()
    {
        // Arrange
        var state = ClubState.Initial;

        // Act
        var result = ClubReducers.OnCreateClub(state);

        // Assert
        result.IsLoading.Should().BeTrue();
    }

    [Fact]
    public void OnCreateClub_ClearsError()
    {
        // Arrange
        var state = ClubState.Initial with { Error = "Previous error" };

        // Act
        var result = ClubReducers.OnCreateClub(state);

        // Assert
        result.Error.Should().BeNull();
    }

    [Fact]
    public void OnCreateClubSuccess_AddsClubToList()
    {
        // Arrange
        var existingClub = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with { Clubs = [existingClub], IsLoading = true };
        var newClub = TestDataGenerator.CreateClubDto();
        var action = new CreateClubSuccessAction(newClub);

        // Act
        var result = ClubReducers.OnCreateClubSuccess(state, action);

        // Assert
        result.Clubs.Should().HaveCount(2);
        result.Clubs.Should().Contain(existingClub);
        result.Clubs.Should().Contain(newClub);
    }

    [Fact]
    public void OnCreateClubSuccess_SetsIsLoadingFalse()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var club = TestDataGenerator.CreateClubDto();
        var action = new CreateClubSuccessAction(club);

        // Act
        var result = ClubReducers.OnCreateClubSuccess(state, action);

        // Assert
        result.IsLoading.Should().BeFalse();
    }

    [Fact]
    public void OnCreateClubFailure_SetsError()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new CreateClubFailureAction("Validation failed");

        // Act
        var result = ClubReducers.OnCreateClubFailure(state, action);

        // Assert
        result.Error.Should().Be("Validation failed");
    }

    #endregion

    #region UpdateClub Tests

    [Fact]
    public void OnUpdateClub_SetsIsLoadingTrue()
    {
        // Arrange
        var state = ClubState.Initial;

        // Act
        var result = ClubReducers.OnUpdateClub(state);

        // Assert
        result.IsLoading.Should().BeTrue();
    }

    [Fact]
    public void OnUpdateClubSuccess_ReplacesClubInList()
    {
        // Arrange
        var clubId = Guid.NewGuid();
        var oldClub = TestDataGenerator.CreateClubDto(id: clubId, name: "Old Name");
        var otherClub = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with { Clubs = [oldClub, otherClub], IsLoading = true };

        var updatedClub = TestDataGenerator.CreateClubDto(id: clubId, name: "New Name");
        var action = new UpdateClubSuccessAction(updatedClub);

        // Act
        var result = ClubReducers.OnUpdateClubSuccess(state, action);

        // Assert
        result.Clubs.Should().HaveCount(2);
        result.Clubs.First(c => c.Id == clubId).Name.Should().Be("New Name");
        result.Clubs.Should().Contain(otherClub);
    }

    [Fact]
    public void OnUpdateClubSuccess_UpdatesSelectedClub_WhenSelected()
    {
        // Arrange
        var clubId = Guid.NewGuid();
        var oldClub = TestDataGenerator.CreateClubDto(id: clubId, name: "Old Name");
        var state = ClubState.Initial with
        {
            Clubs = [oldClub],
            SelectedClub = oldClub,
            IsLoading = true
        };

        var updatedClub = TestDataGenerator.CreateClubDto(id: clubId, name: "New Name");
        var action = new UpdateClubSuccessAction(updatedClub);

        // Act
        var result = ClubReducers.OnUpdateClubSuccess(state, action);

        // Assert
        result.SelectedClub.Should().Be(updatedClub);
    }

    [Fact]
    public void OnUpdateClubSuccess_PreservesSelectedClub_WhenDifferent()
    {
        // Arrange
        var selectedClub = TestDataGenerator.CreateClubDto();
        var clubToUpdate = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with
        {
            Clubs = [selectedClub, clubToUpdate],
            SelectedClub = selectedClub,
            IsLoading = true
        };

        var updatedClub = TestDataGenerator.CreateClubDto(id: clubToUpdate.Id);
        var action = new UpdateClubSuccessAction(updatedClub);

        // Act
        var result = ClubReducers.OnUpdateClubSuccess(state, action);

        // Assert
        result.SelectedClub.Should().Be(selectedClub);
    }

    [Fact]
    public void OnUpdateClubFailure_SetsError()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new UpdateClubFailureAction("Update failed");

        // Act
        var result = ClubReducers.OnUpdateClubFailure(state, action);

        // Assert
        result.Error.Should().Be("Update failed");
        result.IsLoading.Should().BeFalse();
    }

    #endregion

    #region DeleteClub Tests

    [Fact]
    public void OnDeleteClub_SetsIsLoadingTrue()
    {
        // Arrange
        var state = ClubState.Initial;

        // Act
        var result = ClubReducers.OnDeleteClub(state);

        // Assert
        result.IsLoading.Should().BeTrue();
    }

    [Fact]
    public void OnDeleteClubSuccess_RemovesClubFromList()
    {
        // Arrange
        var clubToDelete = TestDataGenerator.CreateClubDto();
        var otherClub = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with
        {
            Clubs = [clubToDelete, otherClub],
            IsLoading = true
        };
        var action = new DeleteClubSuccessAction(clubToDelete.Id);

        // Act
        var result = ClubReducers.OnDeleteClubSuccess(state, action);

        // Assert
        result.Clubs.Should().ContainSingle();
        result.Clubs.Should().Contain(otherClub);
        result.Clubs.Should().NotContain(clubToDelete);
    }

    [Fact]
    public void OnDeleteClubSuccess_ClearsSelectedClub_WhenDeleted()
    {
        // Arrange
        var clubToDelete = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with
        {
            Clubs = [clubToDelete],
            SelectedClub = clubToDelete,
            IsLoading = true
        };
        var action = new DeleteClubSuccessAction(clubToDelete.Id);

        // Act
        var result = ClubReducers.OnDeleteClubSuccess(state, action);

        // Assert
        result.SelectedClub.Should().BeNull();
    }

    [Fact]
    public void OnDeleteClubSuccess_PreservesSelectedClub_WhenDifferent()
    {
        // Arrange
        var selectedClub = TestDataGenerator.CreateClubDto();
        var clubToDelete = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with
        {
            Clubs = [selectedClub, clubToDelete],
            SelectedClub = selectedClub,
            IsLoading = true
        };
        var action = new DeleteClubSuccessAction(clubToDelete.Id);

        // Act
        var result = ClubReducers.OnDeleteClubSuccess(state, action);

        // Assert
        result.SelectedClub.Should().Be(selectedClub);
    }

    [Fact]
    public void OnDeleteClubFailure_SetsError()
    {
        // Arrange
        var state = ClubState.Initial with { IsLoading = true };
        var action = new DeleteClubFailureAction("Delete failed");

        // Act
        var result = ClubReducers.OnDeleteClubFailure(state, action);

        // Assert
        result.Error.Should().Be("Delete failed");
        result.IsLoading.Should().BeFalse();
    }

    #endregion

    #region SelectClub Tests

    [Fact]
    public void OnSelectClub_SetsSelectedClub()
    {
        // Arrange
        var state = ClubState.Initial;
        var club = TestDataGenerator.CreateClubDto();
        var action = new SelectClubAction(club);

        // Act
        var result = ClubReducers.OnSelectClub(state, action);

        // Assert
        result.SelectedClub.Should().Be(club);
    }

    [Fact]
    public void OnSelectClub_ClearsSelectedClub_WhenNull()
    {
        // Arrange
        var selectedClub = TestDataGenerator.CreateClubDto();
        var state = ClubState.Initial with { SelectedClub = selectedClub };
        var action = new SelectClubAction(null);

        // Act
        var result = ClubReducers.OnSelectClub(state, action);

        // Assert
        result.SelectedClub.Should().BeNull();
    }

    #endregion

    #region ClearError Tests

    [Fact]
    public void OnClearError_ClearsError()
    {
        // Arrange
        var state = ClubState.Initial with { Error = "Some error" };

        // Act
        var result = ClubReducers.OnClearError(state);

        // Assert
        result.Error.Should().BeNull();
    }

    [Fact]
    public void OnClearError_PreservesOtherState()
    {
        // Arrange
        var clubs = TestDataGenerator.CreateClubDtos(2);
        var selectedClub = clubs.First();
        var state = ClubState.Initial with
        {
            Clubs = clubs,
            SelectedClub = selectedClub,
            IsLoading = true,
            Error = "Some error"
        };

        // Act
        var result = ClubReducers.OnClearError(state);

        // Assert
        result.Clubs.Should().BeEquivalentTo(clubs);
        result.SelectedClub.Should().Be(selectedClub);
        result.IsLoading.Should().BeTrue();
    }

    #endregion

    #region Immutability Tests

    [Fact]
    public void Reducers_DoNotMutateOriginalState()
    {
        // Arrange
        var originalClubs = TestDataGenerator.CreateClubDtos(2);
        var originalState = ClubState.Initial with
        {
            Clubs = originalClubs,
            IsLoading = false,
            Error = null
        };
        var originalClubCount = originalState.Clubs.Count;

        // Act - perform various operations
        ClubReducers.OnLoadClubs(originalState);
        ClubReducers.OnCreateClubSuccess(originalState, new CreateClubSuccessAction(TestDataGenerator.CreateClubDto()));
        ClubReducers.OnDeleteClubSuccess(originalState, new DeleteClubSuccessAction(originalClubs.First().Id));

        // Assert - original state unchanged
        originalState.Clubs.Should().HaveCount(originalClubCount);
        originalState.IsLoading.Should().BeFalse();
        originalState.Error.Should().BeNull();
    }

    #endregion
}