A:common 文件测试

test/Common.Test/JsonHelperTests.cs

@@ -0,0 +1,510 @@
+using Common.Utils;
+using System.Net;
+
+namespace Common.Test;
+
+/// <summary>
+/// JsonHelper 测试
+/// 展示 JSON 序列化和反序列化功能
+/// </summary>
+[TestClass]
+public class JsonHelperTests
+{
+    #region 基础序列化测试
+
+    /// <summary>
+    /// 测试：序列化简单对象
+    /// </summary>
+    [TestMethod]
+    public void ToJson_SimpleObject_SerializesCorrectly()
+    {
+        // Arrange
+        var person = new Person
+        {
+            Name = "John Doe",
+            Age = 30,
+            Email = "john@example.com"
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(person);
+
+        // Assert
+        Assert.IsTrue(json.Contains("\"name\": \"John Doe\""));  // camelCase
+        Assert.IsTrue(json.Contains("\"age\": 30"));
+        Assert.IsTrue(json.Contains("\"email\": \"john@example.com\""));
+    }
+
+    /// <summary>
+    /// 测试：序列化使用 camelCase 命名策略
+    /// </summary>
+    [TestMethod]
+    public void ToJson_UsesCamelCase()
+    {
+        // Arrange
+        var config = new AppConfig
+        {
+            AppName = "MyApp",
+            MaxConnections = 100
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(config);
+
+        // Assert: 属性名应该是 camelCase
+        Assert.IsTrue(json.Contains("\"appName\""));
+        Assert.IsTrue(json.Contains("\"maxConnections\""));
+        Assert.IsFalse(json.Contains("\"AppName\""));  // 不应该是 PascalCase
+    }
+
+    /// <summary>
+    /// 测试：序列化带格式化（缩进）
+    /// </summary>
+    [TestMethod]
+    public void ToJson_WritesIndented()
+    {
+        // Arrange
+        var person = new Person { Name = "Jane", Age = 25 };
+
+        // Act
+        var json = JsonHelper.ToJson(person);
+
+        // Assert: 应该包含换行符（表示有缩进）
+        Assert.IsTrue(json.Contains("\n") || json.Contains("\r\n"));
+    }
+
+    #endregion
+
+    #region 基础反序列化测试
+
+    /// <summary>
+    /// 测试：反序列化简单对象
+    /// </summary>
+    [TestMethod]
+    public void FromJson_ValidJson_DeserializesCorrectly()
+    {
+        // Arrange
+        var json = """
+        {
+            "name": "Alice",
+            "age": 28,
+            "email": "alice@example.com"
+        }
+        """;
+
+        // Act
+        var person = JsonHelper.FromJson<Person>(json);
+
+        // Assert
+        Assert.IsNotNull(person);
+        Assert.AreEqual("Alice", person.Name);
+        Assert.AreEqual(28, person.Age);
+        Assert.AreEqual("alice@example.com", person.Email);
+    }
+
+    /// <summary>
+    /// 测试：反序列化 camelCase JSON
+    /// </summary>
+    [TestMethod]
+    public void FromJson_CamelCaseJson_DeserializesCorrectly()
+    {
+        // Arrange: JSON 使用 camelCase
+        var json = """
+        {
+            "appName": "TestApp",
+            "maxConnections": 50
+        }
+        """;
+
+        // Act
+        var config = JsonHelper.FromJson<AppConfig>(json);
+
+        // Assert
+        Assert.IsNotNull(config);
+        Assert.AreEqual("TestApp", config.AppName);
+        Assert.AreEqual(50, config.MaxConnections);
+    }
+
+    #endregion
+
+    #region 特殊类型处理测试
+
+    /// <summary>
+    /// 测试：序列化和反序列化枚举（使用字符串）
+    /// </summary>
+    [TestMethod]
+    public void ToJson_Enum_SerializesAsString()
+    {
+        // Arrange
+        var data = new DataWithEnum
+        {
+            Status = Status.Active,
+            Priority = Priority.High
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(data);
+
+        // Assert: 枚举应该序列化为字符串（camelCase）
+        Assert.IsTrue(json.Contains("\"active\""));
+        Assert.IsTrue(json.Contains("\"high\""));
+        Assert.IsFalse(json.Contains("0"));  // 不应该是数字
+        Assert.IsFalse(json.Contains("1"));
+    }
+
+    /// <summary>
+    /// 测试：反序列化枚举字符串
+    /// </summary>
+    [TestMethod]
+    public void FromJson_EnumString_DeserializesCorrectly()
+    {
+        // Arrange
+        var json = """
+        {
+            "status": "active",
+            "priority": "low"
+        }
+        """;
+
+        // Act
+        var data = JsonHelper.FromJson<DataWithEnum>(json);
+
+        // Assert
+        Assert.IsNotNull(data);
+        Assert.AreEqual(Status.Active, data.Status);
+        Assert.AreEqual(Priority.Low, data.Priority);
+    }
+
+    /// <summary>
+    /// 测试：序列化 IPAddress
+    /// </summary>
+    [TestMethod]
+    public void ToJson_IPAddress_SerializesCorrectly()
+    {
+        // Arrange
+        var networkInfo = new NetworkInfo
+        {
+            ServerIp = IPAddress.Parse("192.168.1.1"),
+            ClientIp = IPAddress.Parse("10.0.0.5")
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(networkInfo);
+
+        // Assert
+        Assert.IsTrue(json.Contains("\"192.168.1.1\""));
+        Assert.IsTrue(json.Contains("\"10.0.0.5\""));
+    }
+
+    /// <summary>
+    /// 测试：反序列化 IPAddress
+    /// </summary>
+    [TestMethod]
+    public void FromJson_IPAddress_DeserializesCorrectly()
+    {
+        // Arrange
+        var json = """
+        {
+            "serverIp": "192.168.1.1",
+            "clientIp": "10.0.0.5"
+        }
+        """;
+
+        // Act
+        var networkInfo = JsonHelper.FromJson<NetworkInfo>(json);
+
+        // Assert
+        Assert.IsNotNull(networkInfo);
+        Assert.AreEqual(IPAddress.Parse("192.168.1.1"), networkInfo.ServerIp);
+        Assert.AreEqual(IPAddress.Parse("10.0.0.5"), networkInfo.ClientIp);
+    }
+
+    /// <summary>
+    /// 测试：IPv6 地址序列化和反序列化
+    /// </summary>
+    [TestMethod]
+    public void ToJson_IPv6Address_SerializesCorrectly()
+    {
+        // Arrange
+        var networkInfo = new NetworkInfo
+        {
+            ServerIp = IPAddress.Parse("2001:0db8:85a3:0000:0000:8a2e:0370:7334"),
+            ClientIp = IPAddress.IPv6Loopback
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(networkInfo);
+        var deserialized = JsonHelper.FromJson<NetworkInfo>(json);
+
+        // Assert
+        Assert.IsNotNull(deserialized);
+        Assert.AreEqual(networkInfo.ServerIp, deserialized.ServerIp);
+        Assert.AreEqual(IPAddress.IPv6Loopback, deserialized.ClientIp);
+    }
+
+    #endregion
+
+    #region 复杂对象测试
+
+    /// <summary>
+    /// 测试：序列化嵌套对象
+    /// </summary>
+    [TestMethod]
+    public void ToJson_NestedObject_SerializesCorrectly()
+    {
+        // Arrange
+        var order = new Order
+        {
+            OrderId = "ORD-001",
+            Customer = new Person
+            {
+                Name = "Bob",
+                Age = 35,
+                Email = "bob@example.com"
+            },
+            Items = new List<OrderItem>
+            {
+                new() { ProductName = "Laptop", Price = 999.99, Quantity = 1 },
+                new() { ProductName = "Mouse", Price = 29.99, Quantity = 2 }
+            }
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(order);
+        var deserialized = JsonHelper.FromJson<Order>(json);
+
+        // Assert
+        Assert.IsNotNull(deserialized);
+        Assert.AreEqual("ORD-001", deserialized.OrderId);
+        Assert.AreEqual("Bob", deserialized.Customer?.Name);
+        Assert.AreEqual(2, deserialized.Items?.Count);
+        Assert.AreEqual("Laptop", deserialized.Items?[0].ProductName);
+        Assert.AreEqual(999.99, deserialized.Items?[0].Price);
+    }
+
+    /// <summary>
+    /// 测试：序列化集合
+    /// </summary>
+    [TestMethod]
+    public void ToJson_Collection_SerializesCorrectly()
+    {
+        // Arrange
+        var people = new List<Person>
+        {
+            new() { Name = "Alice", Age = 30 },
+            new() { Name = "Bob", Age = 35 },
+            new() { Name = "Charlie", Age = 28 }
+        };
+
+        // Act
+        var json = JsonHelper.ToJson(people);
+        var deserialized = JsonHelper.FromJson<List<Person>>(json);
+
+        // Assert
+        Assert.IsNotNull(deserialized);
+        Assert.AreEqual(3, deserialized.Count);
+        Assert.AreEqual("Alice", deserialized[0].Name);
+        Assert.AreEqual("Bob", deserialized[1].Name);
+    }
+
+    #endregion
+
+    #region 实际应用场景测试
+
+    /// <summary>
+    /// 场景测试：配置文件序列化
+    /// 演示如何使用 JsonHelper 读写配置文件
+    /// </summary>
+    [TestMethod]
+    public void Scenario_SaveAndLoadConfiguration()
+    {
+        // Arrange: 创建配置对象
+        var originalConfig = new AppConfig
+        {
+            AppName = "MyApplication",
+            MaxConnections = 100,
+            Settings = new Dictionary<string, string>
+            {
+                ["Theme"] = "Dark",
+                ["Language"] = "en-US"
+            }
+        };
+
+        // Act: 序列化配置
+        var json = JsonHelper.ToJson(originalConfig);
+
+        // 模拟保存到文件后再读取
+        var loadedConfig = JsonHelper.FromJson<AppConfig>(json);
+
+        // Assert: 验证配置正确加载
+        Assert.IsNotNull(loadedConfig);
+        Assert.AreEqual(originalConfig.AppName, loadedConfig.AppName);
+        Assert.AreEqual(originalConfig.MaxConnections, loadedConfig.MaxConnections);
+        Assert.AreEqual("Dark", loadedConfig.Settings?["Theme"]);
+        Assert.AreEqual("en-US", loadedConfig.Settings?["Language"]);
+    }
+
+    /// <summary>
+    /// 场景测试：API 请求和响应
+    /// 演示如何序列化 API 数据
+    /// </summary>
+    [TestMethod]
+    public void Scenario_ApiRequestResponse()
+    {
+        // Arrange: 创建 API 请求
+        var request = new ApiRequest
+        {
+            Endpoint = "/api/users",
+            Method = "POST",
+            Headers = new Dictionary<string, string>
+            {
+                ["Content-Type"] = "application/json",
+                ["Authorization"] = "Bearer token123"
+            },
+            Body = new Person
+            {
+                Name = "New User",
+                Age = 25,
+                Email = "newuser@example.com"
+            }
+        };
+
+        // Act: 序列化请求
+        var requestJson = JsonHelper.ToJson(request);
+
+        // 模拟 API 调用后收到响应
+        var responseJson = """
+        {
+            "success": true,
+            "data": {
+                "name": "New User",
+                "age": 25,
+                "email": "newuser@example.com"
+            },
+            "message": "User created successfully"
+        }
+        """;
+
+        var response = JsonHelper.FromJson<ApiResponse<Person>>(responseJson);
+
+        // Assert
+        Assert.IsNotNull(response);
+        Assert.IsTrue(response.Success);
+        Assert.AreEqual("User created successfully", response.Message);
+        Assert.IsNotNull(response.Data);
+        Assert.AreEqual("New User", response.Data.Name);
+    }
+
+    /// <summary>
+    /// 场景测试：网络配置持久化
+    /// 演示如何序列化包含 IPAddress 的复杂对象
+    /// </summary>
+    [TestMethod]
+    public void Scenario_NetworkConfigurationPersistence()
+    {
+        // Arrange: 创建网络配置
+        var networkConfig = new NetworkConfig
+        {
+            ServerIp = IPAddress.Parse("192.168.1.100"),
+            DnsServers = new List<IPAddress>
+            {
+                IPAddress.Parse("8.8.8.8"),
+                IPAddress.Parse("8.8.4.4")
+            },
+            Gateway = IPAddress.Parse("192.168.1.1")
+        };
+
+        // Act: 序列化并反序列化
+        var json = JsonHelper.ToJson(networkConfig);
+        var loaded = JsonHelper.FromJson<NetworkConfig>(json);
+
+        // Assert
+        Assert.IsNotNull(loaded);
+        Assert.AreEqual(networkConfig.ServerIp, loaded.ServerIp);
+        Assert.AreEqual(2, loaded.DnsServers?.Count);
+        Assert.AreEqual(IPAddress.Parse("8.8.8.8"), loaded.DnsServers?[0]);
+        Assert.AreEqual(networkConfig.Gateway, loaded.Gateway);
+    }
+
+    #endregion
+
+    #region 测试辅助类型
+
+    private class Person
+    {
+        public string Name { get; set; } = "";
+        public int Age { get; set; }
+        public string? Email { get; set; }
+    }
+
+    private class AppConfig
+    {
+        public string AppName { get; set; } = "";
+        public int MaxConnections { get; set; }
+        public Dictionary<string, string>? Settings { get; set; }
+    }
+
+    private enum Status
+    {
+        Inactive = 0,
+        Active = 1,
+        Suspended = 2
+    }
+
+    private enum Priority
+    {
+        Low = 0,
+        Medium = 1,
+        High = 2
+    }
+
+    private class DataWithEnum
+    {
+        public Status Status { get; set; }
+        public Priority Priority { get; set; }
+    }
+
+    private class NetworkInfo
+    {
+        public IPAddress? ServerIp { get; set; }
+        public IPAddress? ClientIp { get; set; }
+    }
+
+    private class Order
+    {
+        public string OrderId { get; set; } = "";
+        public Person? Customer { get; set; }
+        public List<OrderItem>? Items { get; set; }
+    }
+
+    private class OrderItem
+    {
+        public string ProductName { get; set; } = "";
+        public double Price { get; set; }
+        public int Quantity { get; set; }
+    }
+
+    private class ApiRequest
+    {
+        public string Endpoint { get; set; } = "";
+        public string Method { get; set; } = "";
+        public Dictionary<string, string>? Headers { get; set; }
+        public object? Body { get; set; }
+    }
+
+    private class ApiResponse<T>
+    {
+        public bool Success { get; set; }
+        public T? Data { get; set; }
+        public string Message { get; set; } = "";
+    }
+
+    private class NetworkConfig
+    {
+        public IPAddress? ServerIp { get; set; }
+        public List<IPAddress>? DnsServers { get; set; }
+        public IPAddress? Gateway { get; set; }
+    }
+
+    #endregion
+}