XRLib/Assets/Scripts/Simulator/HttpManager.cs

using Cysharp.Threading.Tasks;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UVC.Data;
using UVC.Data.Core;
using UVC.Data.Http;
using UVC.Tests;

public class HttpManager : MonoBehaviour
{
    private HttpDataFetcher? pipeLine;
    [SetUp]
    public void Setup()
    {
        pipeLine = new HttpDataFetcher();
        pipeLine.UseMockup = false; // MockHttpRequester 사용 설정
                                   // 테스트를 위한 DataRepository 초기화
        ClearDataRepository();
    }

    private void ClearDataRepository()
    {
        var repositoryType = typeof(DataRepository);
        var instanceField = repositoryType.GetField("instance",
            BindingFlags.NonPublic | BindingFlags.Static);

        if (instanceField != null)
        {
            // Lazy<DataRepository> 필드 값을 가져옴
            var lazyInstance = instanceField.GetValue(null);

            // Lazy<T>의 Value 속성을 통해 인스턴스 접근
            var instance = lazyInstance.GetType().GetProperty("Value").GetValue(lazyInstance);

            // dataObjects 딕셔너리 필드 가져오기
            var dataObjectsField = repositoryType.GetField("dataObjects",
                BindingFlags.NonPublic | BindingFlags.Instance);

            // 딕셔너리 접근하여 Clear 메서드 호출
            var dataObjects = dataObjectsField.GetValue(instance) as Dictionary<string, IDataObject>;
            dataObjects.Clear();
        }
    }

    private void Start()
    {
        Setup();
        test();
    }

    private async void test()
    {
        await RunTestAsync(nameof(Test_Excute_WithValidData_ValidatorPasses), Test_Excute_WithValidData_ValidatorPasses);
    }

    private void RunTest(string testName, Action testAction)
    {
        try
        {
            Debug.Log($"테스트 시작: {testName}");
            testAction();
            Debug.Log($"테스트 성공: {testName}");
        }
        catch (Exception ex)
        {
            Debug.LogError($"테스트 실패: {testName}\n{ex.Message}\n{ex.StackTrace}");
        }
    }

    private async UniTask RunTestAsync(string testName, Func<UniTask> testAction)
    {
        try
        {
            Debug.Log($"테스트 시작: {testName}");
            await testAction();
            Debug.Log($"테스트 성공: {testName}");
        }
        catch (Exception ex)
        {
            Debug.LogError($"테스트 실패: {testName}\n{ex.Message}\n{ex.StackTrace}");
        }
    }

    public void HttpResponseMask_Apply_SuccessfulResponse_ReturnsSuccessWithData()
    {
        // Arrange
        var responseMask = new HttpResponseMask(); // 기본값 사용 (successKey="message", successValue="success", dataKey="data")
        var jsonResponse = @"{""message"": ""success"", ""data"": {""key"":""value""}}";
        var expectedData = @"{""key"":""value""}";

        // Act
        var result = responseMask.Apply(jsonResponse);

        // Assert
        Assert.IsTrue(result.IsSuccess, "결과가 성공이어야 합니다.");
        Assert.AreEqual(expectedData, result.Data, "추출된 데이터가 예상과 다릅니다.");
        Assert.IsNull(result.Message, "성공 시 메시지는 null이어야 합니다.");
    }

    public void Add_NewInfo()
    {
        // Arrange
        var info1 = new HttpRequestConfig("http://220.90.135.42:3030/simulation/projects/1","get");

        // Act
        pipeLine.Add("project", info1);

        // Assert - Dictionary에 추가되었는지 확인 (reflection 사용)
        var infoList = GetInfoListField();
        Assert.IsTrue(infoList.ContainsKey("test"));
        Assert.AreEqual(info1, infoList["test"]);
    }

    public async UniTask Test_Excute_WithValidData_ValidatorPasses()
    {
        var dataMask = new DataMask
        {
            ["id"] = 0,
            ["userId"] = 0,
            ["name"] = "심각도",
            //["description"] = "상태"
        };

        // Arrange
        bool handlerCalled = false;
        IDataObject? receivedData = null;
        string testUrl = "http://220.90.135.42:3030/simulation/projects/1";
        //var mockResponse = @"{""status"": 200}";
        //MockHttpRequester.SetResponse(testUrl, mockResponse);

        var dataMapper = new DataMapper(dataMask);

        // "status" 필드가 "active"인 경우에만 유효하도록 설정
        var validator = new DataValidator();
        validator.AddValidator("id", value =>
        {
            return value is int s && s == 1;
        });

        var info = new HttpRequestConfig(testUrl,"get")
            .SetDataMapper(dataMapper)
            //.SetValidator(validator)
            .SetResponseMask(new HttpResponseMask("status","200","data"))
            .SetSuccessHandler(data =>
            {
                handlerCalled = true;
                receivedData = data;
                Debug.Log($"test{receivedData}");
            })
            .SetFailHandler((message) =>
            {
                Debug.LogError("Fail message: " + message);
            });

        pipeLine.Add("validatorPassTest", info);

        try
        {
            // Act
            await pipeLine.Excute("validatorPassTest");

            Assert.IsTrue(handlerCalled, "유효성 검사를 통과했으므로 핸들러가 호출되어야 합니다.");
            Assert.IsNotNull(receivedData, "데이터가 핸들러로 전달되어야 합니다.");
        }
        finally
        {
            await pipeLine.RemoveAsync("validatorPassTest");
            MockHttpRequester.ClearResponses(testUrl);
        }
    }

    private Dictionary<string, HttpRequestConfig> GetInfoListField()
    {
        var fieldInfo = typeof(HttpDataFetcher).GetField("configList",
            BindingFlags.NonPublic | BindingFlags.Instance);

        return (Dictionary<string, HttpRequestConfig>)fieldInfo.GetValue(pipeLine);
    }
}