vrcauthproxy/Tests/Integration/RedisIntegrationTests.cs

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

namespace VRCAuthProxy.Tests.Integration
{
    [Trait("Category", "Integration")]
    [Collection("Redis")]
    public class RedisIntegrationTests
    {
        private readonly RedisService _redisService;
        private const string TEST_USERNAME = "testuser";

        public RedisIntegrationTests()
        {
            // For integration tests, use the actual Redis service
            // This assumes Redis is running locally or in a Docker container
            // as configured in docker-compose.yml (accessible at localhost:6379)
            _redisService = new RedisService("localhost:6379");
            
            // Clean up any previous test data
            _redisService.RemoveAuthToken(TEST_USERNAME).GetAwaiter().GetResult();
        }

        [Fact(Skip = "Requires Redis instance - for manual integration testing")]
        public async Task SaveAndGetAuthToken_ShouldStoreAndRetrieveTokens()
        {
            // Arrange
            var cookies = new Dictionary<string, string>
            {
                { "auth", "integration-test-token" },
                { "session", "integration-test-session" }
            };

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

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

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

        [Fact(Skip = "Requires Redis instance - for manual integration testing")]
        public async Task RemoveAuthToken_ShouldDeleteTokenFromRedis()
        {
            // Arrange
            var cookies = new Dictionary<string, string>
            {
                { "auth", "token-to-delete" }
            };
            await _redisService.SaveAuthToken(TEST_USERNAME, cookies);
            
            // Verify token exists
            var tokenBeforeDelete = await _redisService.GetAuthToken(TEST_USERNAME);
            tokenBeforeDelete.Should().NotBeNull();

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

        [Fact(Skip = "Requires Redis instance - for manual integration testing")]
        public async Task GetAllAuthTokens_ShouldReturnAllStoredTokens()
        {
            // Arrange
            var user1 = "testuser1";
            var user2 = "testuser2";
            
            // Clean up
            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");
            
            // Cleanup
            await _redisService.RemoveAuthToken(user1);
            await _redisService.RemoveAuthToken(user2);
        }
    }
}