XRLib/Assets/Scripts/UVC/Tests/Data/DataMapperTests.cs

using Newtonsoft.Json.Linq;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using UnityEngine;
using UVC.Data;

namespace UVC.Tests.Data
{
    /// <summary>
    /// DataMapper 클래스의 테스트를 위한 테스트 클래스입니다.
    /// </summary>
    [TestFixture]
    public class DataMapperTests
    {
        /// <summary>
        /// 모든 테스트 메서드를 실행하는 메서드입니다.
        /// </summary>
        /// <remarks>
        /// 이 메서드는 클래스의 모든 테스트 메서드를 순차적으로 호출하고 
        /// 각 테스트의 성공 또는 실패 여부를 로그로 출력합니다.
        /// </remarks>
        public void TestAll()
        {
            Debug.Log("===== DataMapper 테스트 시작 =====");

            RunTest(nameof(Map_StringProperty_MapsCorrectly), Map_StringProperty_MapsCorrectly);
            RunTest(nameof(Map_IntProperty_MapsCorrectly), Map_IntProperty_MapsCorrectly);
            RunTest(nameof(Map_DoubleProperty_MapsCorrectly), Map_DoubleProperty_MapsCorrectly);
            RunTest(nameof(Map_BoolProperty_MapsCorrectly), Map_BoolProperty_MapsCorrectly);
            RunTest(nameof(Map_DateTimeProperty_MapsCorrectly), Map_DateTimeProperty_MapsCorrectly);
            RunTest(nameof(Map_DataMapProperty_MapsCorrectly), Map_DataMapProperty_MapsCorrectly);
            RunTest(nameof(Map_DataMapWithUnmappedValue_ReturnsOriginal), Map_DataMapWithUnmappedValue_ReturnsOriginal);
            RunTest(nameof(Map_EnumProperty_MapsCorrectly), Map_EnumProperty_MapsCorrectly);
            RunTest(nameof(Map_AdditionalProperty_AddsToResult), Map_AdditionalProperty_AddsToResult);
            RunTest(nameof(Map_InvalidDateTimeString_ReturnsNull), Map_InvalidDateTimeString_ReturnsNull);
            RunTest(nameof(Map_ComplexObject_MapsAllProperties), Map_ComplexObject_MapsAllProperties);
            RunTest(nameof(Map_NestedObject_MapsCorrectly), Map_NestedObject_MapsCorrectly);
            RunTest(nameof(Map_ArrayMapping_MapsCorrectly), Map_ArrayMapping_MapsCorrectly);
            RunTest(nameof(Map_EmptyMaskArray_CopiesSourceArray), Map_EmptyMaskArray_CopiesSourceArray);
            RunTest(nameof(Map_ComplexNestedStructure_MapsCorrectly), Map_ComplexNestedStructure_MapsCorrectly);
            RunTest(nameof(Map_MixedArrayTypes_HandlesCorrectly), Map_MixedArrayTypes_HandlesCorrectly);
            RunTest(nameof(Map_WithNamesForReplace_ShouldRenameProperties), Map_WithNamesForReplace_ShouldRenameProperties);

            Debug.Log("===== DataMapper 테스트 완료 =====");
        }

        /// <summary>
        /// 단일 테스트 메서드를 실행하고 결과를 로그로 출력합니다.
        /// </summary>
        /// <param name="testName">테스트 메서드 이름</param>
        /// <param name="testAction">실행할 테스트 메서드</param>
        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}");
            }
        }

        /// <summary>
        /// 문자열 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_StringProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["Name"] = "홍길동";
            mask.ObjectIdKey = "Name"; // Id로 사용할 키 설정

            var source = JObject.Parse(@"{ ""Name"": ""김철수"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Name"));
            Assert.AreEqual("김철수", result.GetString("Name"));
            Assert.AreEqual("김철수", result.Id);
        }

        /// <summary>
        /// 정수 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_IntProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["Age"] = 25;
            mask.ObjectIdKey = "Age"; // Id로 사용할 키 설정

            var source = JObject.Parse(@"{ ""Age"": 30 }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Age"));
            Assert.AreEqual(30, result.GetInt("Age"));
            Assert.AreEqual("30", result.Id);
        }

        /// <summary>
        /// 부동소수점 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DoubleProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["Height"] = 175.5;
            mask.ObjectIdKey = "Height"; // Id로 사용할 키 설정

            var source = JObject.Parse(@"{ ""Height"": 180.5 }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Height"));
            Assert.AreEqual(180.5, result.GetDouble("Height"));
            Assert.AreEqual("180.5", result.Id);
        }

        /// <summary>
        /// Boolean 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_BoolProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["IsActive"] = false;

            var source = JObject.Parse(@"{ ""IsActive"": true }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("IsActive"));
            Assert.IsTrue(result.GetBool("IsActive"));
            Assert.AreEqual("True", result.Id);// Id는 Boolean 값의 문자열 표현으로 설정됨(첫글자 대문자)
        }

        /// <summary>
        /// DateTime 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DateTimeProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["BirthDate"] = JToken.FromObject(DateTime.Now);

            var expectedDate = new DateTime(1990, 1, 1);
            var source = JObject.Parse(@"{ ""BirthDate"": ""1990-01-01T00:00:00.000"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("BirthDate"));
            Assert.AreEqual(expectedDate, result.GetDateTime("BirthDate"));
        }

        /// <summary>
        /// DataMap 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_DataMapProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            var valueMapper = new DataMap();
            valueMapper["ON"] = "활성화";
            valueMapper["OFF"] = "비활성화";
            mask["Status"] = JToken.FromObject(valueMapper);

            var source = JObject.Parse(@"{ ""Status"": ""ON"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual("활성화", result.GetString("Status"));
        }

        /// <summary>
        /// DataMap에 매핑되지 않는 값 처리 테스트
        /// </summary>
        [Test]
        public void Map_DataMapWithUnmappedValue_ReturnsOriginal()
        {
            // Arrange
            var mask = new DataMask();
            var valueMapper = new DataMap();
            valueMapper["ON"] = "활성화";
            valueMapper["OFF"] = "비활성화";
            mask["Status"] = JToken.FromObject(valueMapper);

            var source = JObject.Parse(@"{ ""Status"": ""UNKNOWN"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual("UNKNOWN", result.GetString("Status"));
        }

        /// <summary>
        /// 열거형 타입 매핑 테스트
        /// </summary>
        [Test]
        public void Map_EnumProperty_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask();
            mask["Status"] = JToken.FromObject(UserStatus.Inactive);

            var source = JObject.Parse(@"{ ""Status"": ""Active"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Status"));
            Assert.AreEqual(UserStatus.Active, result.GetEnum<UserStatus>("Status"));
        }

        /// <summary>
        /// 타겟에 없는 추가 속성 매핑 테스트
        /// </summary>
        [Test]
        public void Map_AdditionalProperty_AddsToResult()
        {
            // Arrange
            var mask = new DataMask();
            mask["Name"] = "홍길동";

            var source = JObject.Parse(@"{ ""Name"": ""김철수"", ""Email"": ""kim@example.com"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsFalse(result.ContainsKey("Email"));
            Assert.AreEqual(null, result.GetString("Email"));
        }

        /// <summary>
        /// 유효하지 않은 DateTime 문자열 매핑 테스트
        /// </summary>
        [Test]
        public void Map_InvalidDateTimeString_ReturnsNull()
        {
            // Arrange
            var mask = new DataMask();
            mask["BirthDate"] = JToken.FromObject(DateTime.Now);

            var source = JObject.Parse(@"{ ""BirthDate"": ""InvalidDateTime"" }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("BirthDate"));
            Assert.IsNull(result["BirthDate"]);
        }

        /// <summary>
        /// 복합 객체 매핑 테스트
        /// </summary>
        [Test]
        public void Map_ComplexObject_MapsAllProperties()
        {
            // Arrange
            var mask = new DataMask();
            mask["Id"] = 1;
            mask["Name"] = "홍길동";
            mask["IsActive"] = false;
            mask["JoinDate"] = JToken.FromObject(DateTime.Now);
            mask["Height"] = 175.5;
            mask["Status"] = JToken.FromObject(UserStatus.Inactive);

            string json = @"{
                ""Id"": 100,
                ""Name"": ""김철수"",
                ""IsActive"": true,
                ""JoinDate"": ""2023-01-01T00:00:00"",
                ""Height"": 180.0,
                ""Status"": ""Active"",
                ""Email"": ""kim@example.com""
            }";

            var source = JObject.Parse(json);
            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.AreEqual(6, result.Count);
            Assert.AreEqual(100, result.GetInt("Id"));
            Assert.AreEqual("김철수", result.GetString("Name"));
            Assert.IsTrue(result.GetBool("IsActive"));
            Assert.AreEqual(new DateTime(2023, 1, 1), result.GetDateTime("JoinDate"));
            Assert.AreEqual(180.0, result.GetDouble("Height"));
            Assert.AreEqual(UserStatus.Active, result.GetEnum<UserStatus>("Status"));
            Assert.AreEqual(null, result.GetString("Email"));
        }

        /// <summary>
        /// 중첩된 객체 매핑 테스트
        /// </summary>
        [Test]
        public void Map_NestedObject_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask
            {
                ["User"] = new DataMask
                {
                    ["Name"] = "홍길동",
                    ["Address"] = new DataMask
                    {
                        ["City"] = "서울",
                        ["ZipCode"] = "12345"
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""User"": {
                    ""Name"": ""김철수"",
                    ""Address"": {
                        ""City"": ""부산"",
                        ""ZipCode"": ""67890"",
                        ""Country"": ""대한민국""
                    }
                }
            }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("User"));

            var user = result.GetDataObject("User");
            Assert.IsNotNull(user);
            Assert.AreEqual("김철수", user.GetString("Name"));

            var address = user.GetDataObject("Address");
            Assert.IsNotNull(address);
            Assert.AreEqual("부산", address.GetString("City"));
            Assert.AreEqual("67890", address.GetString("ZipCode"));
            Assert.AreEqual(null, address.GetString("Country"));
        }

        /// <summary>
        /// 배열 매핑 테스트
        /// </summary>
        [Test]
        public void Map_ArrayMapping_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask
            {
                ["Contacts"] = new JArray
                {
                    new DataMask
                    {
                        ["Type"] = "mobile",
                        ["Number"] = "010-0000-0000"
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""Contacts"": [
                    { ""Type"": ""mobile"", ""Number"": ""010-1234-5678"" },
                    { ""Type"": ""home"", ""Number"": ""02-123-4567"", ""Extension"": ""123"" }
                ]
            }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Contacts"));
            var contacts = result.GetDataArray("Contacts");
            Assert.IsNotNull(contacts);
            Assert.AreEqual(2, contacts.Count);

            var contact1 = contacts[0];
            Assert.IsNotNull(contact1);
            Assert.AreEqual("mobile", contact1.GetString("Type"));
            Assert.AreEqual("010-1234-5678", contact1.GetString("Number"));

            var contact2 = contacts[1];
            Assert.IsNotNull(contact2);
            Assert.AreEqual("home", contact2.GetString("Type"));
            Assert.AreEqual("02-123-4567", contact2.GetString("Number"));
            Assert.AreEqual(null, contact2.GetString("Extension"));
        }

        /// <summary>
        /// 빈 가이드 배열 테스트
        /// </summary>
        [Test]
        public void Map_EmptyMaskArray_CopiesSourceArray()
        {
            // Arrange
            var mask = new DataMask
            {
                ["Tags"] = new JArray()
            };

            var source = JObject.Parse(@"{
                ""Tags"": [""개발"", ""테스트"", ""배포""]
            }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("Tags"));
            var tags = result.GetDataArray("Tags");
            Assert.IsNotNull(tags);
            Assert.AreEqual(3, tags.Count);

            // DataArray의 항목들을 검증
            for (int i = 0; i < tags.Count; i++)
            {
                var item = tags[i];
                Assert.IsNotNull(item);
                // DataObject는 "value" 키에 실제 값을 저장
                Assert.AreEqual(((JArray)source["Tags"])[i].ToString(), item.GetString("value"));
            }
        }

        /// <summary>
        /// 복잡한 중첩 구조 매핑 테스트
        /// </summary>
        [Test]
        public void Map_ComplexNestedStructure_MapsCorrectly()
        {
            // Arrange
            var mask = new DataMask
            {
                ["Company"] = new DataMask
                {
                    ["Name"] = "회사명",
                    ["Founded"] = JToken.FromObject(DateTime.Now),
                    ["Departments"] = new JArray
                    {
                        new DataMask
                        {
                            ["Name"] = "부서명",
                            ["Employees"] = new JArray
                            {
                                new DataMask
                                {
                                    ["Name"] = "직원명",
                                    ["Age"] = 30,
                                    ["Status"] = JToken.FromObject(UserStatus.Active)
                                }
                            }
                        }
                    }
                }
            };

            var source = JObject.Parse(@"{
                ""Company"": {
                    ""Name"": ""XYZ 주식회사"",
                    ""Founded"": ""2000-01-01T00:00:00"",
                    ""Departments"": [
                        {
                            ""Name"": ""개발부"",
                            ""Employees"": [
                                { ""Name"": ""김개발"", ""Age"": 35, ""Status"": ""Active"" },
                                { ""Name"": ""이테스트"", ""Age"": 28, ""Status"": ""Inactive"" }
                            ]
                        },
                        {
                            ""Name"": ""마케팅부"",
                            ""Employees"": [
                                { ""Name"": ""박마케팅"", ""Age"": 32, ""Status"": ""Active"" }
                            ],
                            ""Budget"": 500000
                        }
                    ],
                    ""Address"": ""서울시 강남구""
                }
            }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            var company = result.GetDataObject("Company");
            Assert.IsNotNull(company);
            Assert.AreEqual("XYZ 주식회사", company.GetString("Name"));
            Assert.AreEqual(new DateTime(2000, 1, 1), company.GetDateTime("Founded"));
            Assert.AreEqual(null, company.GetString("Address"));

            var departments = company.GetDataArray("Departments");
            Assert.IsNotNull(departments);
            Assert.AreEqual(2, departments.Count);

            var devDept = departments[0];
            Assert.AreEqual("개발부", devDept.GetString("Name"));
            var devEmployees = devDept.GetDataArray("Employees");
            Assert.AreEqual(2, devEmployees.Count);
            Assert.AreEqual("김개발", devEmployees[0].GetString("Name"));
            Assert.AreEqual(35, devEmployees[0].GetInt("Age"));
            Assert.AreEqual(UserStatus.Active, devEmployees[0].GetEnum<UserStatus>("Status"));
            Assert.AreEqual("이테스트", devEmployees[1].GetString("Name"));
            Assert.AreEqual(UserStatus.Inactive, devEmployees[1].GetEnum<UserStatus>("Status"));

            var marketingDept = departments[1];
            Assert.AreEqual("마케팅부", marketingDept.GetString("Name"));
            Assert.AreEqual(0, marketingDept.GetInt("Budget"));
            var marketingEmployees = marketingDept.GetDataArray("Employees");
            Assert.AreEqual(1, marketingEmployees.Count);
            Assert.AreEqual("박마케팅", marketingEmployees[0].GetString("Name"));
        }

        /// <summary>
        /// 다양한 형식의 배열 테스트
        /// </summary>
        [Test]
        public void Map_MixedArrayTypes_HandlesCorrectly()
        {
            // Arrange
            var mask = new DataMask
            {
                ["MixedArray"] = new JArray
                {
                    "문자열",
                    123,
                    true,
                    new DataMask { ["Key"] = "Value" },
                    new JArray{1, 1}
                }
            };

            var source = JObject.Parse(@"{
                ""MixedArray"": [
                    ""테스트"",
                    456,
                    false,
                    { ""Key"": ""NewValue"", ""Extra"": ""ExtraValue"" },
                    [1, 2, 3],
                    { ""items"": [1, 2, 3] }
                ]
            }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            Assert.IsTrue(result.ContainsKey("MixedArray"));
            var mixedArray = result.GetDataArray("MixedArray");
            Assert.IsNotNull(mixedArray);
            Assert.AreEqual(5, mixedArray.Count);

            // 문자열 항목 검증
            Assert.AreEqual("테스트", mixedArray[0].GetString("value"));
            // 숫자 항목 검증
            Assert.AreEqual(456, mixedArray[1].GetInt("value"));
            // 불리언 항목 검증
            Assert.AreEqual(false, mixedArray[2].GetBool("value"));

            // 객체 항목 검증
            var objInArray = mixedArray[3];
            Assert.IsNotNull(objInArray);
            Assert.AreEqual("NewValue", objInArray.GetString("Key"));

            // 중첩 배열 항목 검증
            var nestedItem = mixedArray[4];
            Assert.IsNotNull(nestedItem);
            // DataMapper는 중첩 배열을 "items" 키를 가진 DataObject로 포장합니다
            var nestedArray = nestedItem.GetDataArray("items");
            Assert.IsNotNull(nestedArray);
            Assert.AreEqual(2, nestedArray.Count);
            Assert.AreEqual(1, nestedArray[0].GetInt("value"));
            Assert.AreEqual(2, nestedArray[1].GetInt("value"));
        }


        /// <summary>
        /// NamesForReplace 속성이 제대로 구현되었을 때 예상되는 동작을 테스트합니다.
        /// </summary>
        [Test]
        public void Map_WithNamesForReplace_ShouldRenameProperties()
        {
            // Arrange
            var mask = new DataMask();
            mask["OldName"] = "홍길동";
            mask["Age"] = 25;
            mask.NamesForReplace = new Dictionary<string, string> {
                { "OldName", "NewName" }
            };

            var source = JObject.Parse(@"{ ""OldName"": ""김철수"", ""Age"": 30 }");

            var mapper = new DataMapper(mask);

            // Act
            var result = mapper.Mapping(source);

            // Assert
            // NamesForReplace가 제대로 구현되면 이 테스트는 통과해야 함
            Assert.IsTrue(result.ContainsKey("NewName"));
            Assert.AreEqual("김철수", result.GetString("NewName"));
            Assert.IsFalse(result.ContainsKey("OldName"));
            Assert.IsTrue(result.ContainsKey("Age"));
            Assert.AreEqual(30, result.GetInt("Age"));
        }
    }

    /// <summary>
    /// 테스트에 사용할 샘플 열거형
    /// </summary>
    public enum UserStatus
    {
        Active,
        Inactive,
        Suspended
    }
}