vrcauthproxy/Tests/Unit/RedisServiceTests.cs

using System.Text.Json;
using FluentAssertions;
using VRCAuthProxy.Services;
using Xunit;

namespace VRCAuthProxy.Tests.Unit
{
    public class RedisServiceTests
    {
        // Using a minimal implementation for testing
        private class InMemoryRedisService
        {
            private readonly Dictionary<string, Dictionary<string, string>> _store = new();

            public Task SaveAuthToken(string username, Dictionary<string, string> cookies)
            {
                _store[username] = new Dictionary<string, string>(cookies);
                return Task.CompletedTask;
            }

            public Task<Dictionary<string, string>?> GetAuthToken(string username)
            {
                if (_store.TryGetValue(username, out var cookies))
                    return Task.FromResult<Dictionary<string, string>?>(new Dictionary<string, string>(cookies));
                
                return Task.FromResult<Dictionary<string, string>?>(null);
            }

            public Task<Dictionary<string, Dictionary<string, string>>> GetAllAuthTokens()
            {
                var result = new Dictionary<string, Dictionary<string, string>>();
                
                foreach (var pair in _store)
                {
                    result[pair.Key] = new Dictionary<string, string>(pair.Value);
                }
                
                return Task.FromResult(result);
            }

            public Task RemoveAuthToken(string username)
            {
                _store.Remove(username);
                return Task.CompletedTask;
            }
        }

        private readonly InMemoryRedisService _redisService;

        public RedisServiceTests()
        {
            _redisService = new InMemoryRedisService();
        }

        [Fact]
        public async Task SaveAndGetAuthToken_ShouldStoreAndRetrieveTokens()
        {
            // Arrange
            var username = "testuser";
            var cookies = new Dictionary<string, string>
            {
                { "auth", "test-auth-token" },
                { "session", "test-session-token" }
            };

            // Act - Save token
            await _redisService.SaveAuthToken(username, cookies);

            // Act - Retrieve token
            var retrievedCookies = await _redisService.GetAuthToken(username);

            // Assert
            retrievedCookies.Should().NotBeNull();
            if (retrievedCookies != null)
            {
                retrievedCookies.Should().ContainKey("auth");
                retrievedCookies.Should().ContainKey("session");
                retrievedCookies["auth"].Should().Be("test-auth-token");
                retrievedCookies["session"].Should().Be("test-session-token");
            }
        }

        [Fact]
        public async Task GetAuthToken_WhenTokenDoesNotExist_ShouldReturnNull()
        {
            // Arrange
            var username = "nonexistentuser";

            // Act
            var result = await _redisService.GetAuthToken(username);

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

        [Fact]
        public async Task GetAllAuthTokens_ShouldReturnAllStoredTokens()
        {
            // Arrange
            var user1 = "testuser1";
            var user2 = "testuser2";
            
            // Clear any existing tokens
            await _redisService.RemoveAuthToken(user1);
            await _redisService.RemoveAuthToken(user2);
            
            // Add test data
            await _redisService.SaveAuthToken(user1, new Dictionary<string, string> { { "auth", "token1" } });
            await _redisService.SaveAuthToken(user2, new Dictionary<string, string> { { "auth", "token2" } });

            // Act
            var allTokens = await _redisService.GetAllAuthTokens();

            // Assert
            allTokens.Should().ContainKey(user1);
            allTokens.Should().ContainKey(user2);
            allTokens[user1]["auth"].Should().Be("token1");
            allTokens[user2]["auth"].Should().Be("token2");
        }

        [Fact]
        public async Task RemoveAuthToken_ShouldDeleteToken()
        {
            // Arrange
            var username = "testuser";
            var cookies = new Dictionary<string, string>
            {
                { "auth", "token-to-delete" }
            };
            await _redisService.SaveAuthToken(username, cookies);
            
            // Verify token exists
            var tokenBeforeDelete = await _redisService.GetAuthToken(username);
            tokenBeforeDelete.Should().NotBeNull();

            // Act
            await _redisService.RemoveAuthToken(username);
            
            // Assert
            var tokenAfterDelete = await _redisService.GetAuthToken(username);
            tokenAfterDelete.Should().BeNull();
        }
    }
}