feat: 单元测试

HttpClientStudy.UnitTest/GlobalUsings.cs

@@ -1,4 +1,15 @@
+global using System;
+global using System.Collections.Generic;
+global using System.Linq;
+global using System.Text;
+global using System.Threading.Tasks;
+
 global using Xunit;
+global using Xunit.Sdk;
+global using Xunit.Abstractions;
+global using Xunit.Extensions;
+global using Xunit.Internal;
+global using Xunit.Serialization;
 
 global using HttpClientStudy.Model;
 global using HttpClientStudy.Core;

HttpClientStudy.UnitTest/WebApp/BaseResultTest.cs

@@ -1,12 +1,4 @@
-using System;
+namespace HttpClientStudy.UnitTest.WebApp
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-using Xunit.Abstractions;
-
-namespace HttpClientStudy.UnitTest.WebApp
 {
     public class BaseResultTest
     {
@@ -23,7 +15,7 @@ namespace HttpClientStudy.UnitTest.WebApp
             var result = new BaseResult() { Code = 1, Message = "成功", Data = null };
 
             Assert.NotNull(result);
-            Assert.Equal(1, result.Code);
+            Assert.True(1 == result.Code);
             Assert.Equal("成功", result.Message);
             Assert.Null(result.Data);
         }
@@ -91,11 +83,11 @@ namespace HttpClientStudy.UnitTest.WebApp
             
 
             var result3 = BaseResultUtil.Default(new { Name="匿名类"});
-            Assert.NotNull(result);
+            Assert.NotNull(result3);
             Assert.IsType(result3.Data!.GetType(),result3.Data);
             Assert.Equal("匿名类",result3.Data!.Name);
-            Assert.Equal(0, result2.Code);
+            Assert.Equal(0, result3.Code);
-            Assert.Equal("", result2.Message);
+            Assert.Equal("", result3.Message);
         }
 
         [Fact]
@@ -104,23 +96,23 @@ namespace HttpClientStudy.UnitTest.WebApp
             var result = BaseResultUtil.Success<string>();
             Assert.NotNull(result);
             Assert.Null(result.Data);
-            Assert.Equal(0, result.Code);
+            Assert.Equal(1, result.Code);
-            Assert.Equal("", result.Message);
+            Assert.Equal("成功", result.Message);
 
             var result2 = BaseResultUtil.Success<int>();
             Assert.NotNull(result2);
             Assert.IsType<int>(result2.Data);
             Assert.Equal(0, result2.Data);
-            Assert.Equal(0, result2.Code);
+            Assert.Equal(1, result2.Code);
-            Assert.Equal("", result2.Message);
+            Assert.Equal("成功", result2.Message);
 
 
             var result3 = BaseResultUtil.Success(new { Name = "匿名类" },1,"成功");
-            Assert.NotNull(result);
+            Assert.NotNull(result3);
             Assert.IsType(result3.Data!.GetType(), result3.Data);
             Assert.Equal("匿名类", result3.Data!.Name);
-            Assert.Equal(0, result2.Code);
+            Assert.Equal(1, result3.Code);
-            Assert.Equal("", result2.Message);
+            Assert.Equal("成功", result3.Message);
         }
 
         [Fact]

HttpClientStudy.WebApp/BaseResult.cs

@@ -1,4 +1,6 @@
-namespace HttpClientStudy.WebApp
+using System.Linq.Expressions;
+
+namespace HttpClientStudy.WebApp
 {
     /// <summary>
     /// API 返回基类
@@ -41,77 +43,126 @@
     /// </summary>
     public static class BaseResultUtil
     {
+        /// <summary>
+        /// 创建 泛型返回基类
+        /// </summary>
         public static BaseResult<TData> Create<TData>(TData data, int code = 0, string message = "") 
         {
             return new BaseResult<TData>() { Data = data, Code = code, Message = message };
         }
 
+        /// <summary>
+        /// 创建 泛型成功返回基类
+        /// </summary>
         public static BaseResult<TData> Success<TData>() 
         {
             return Success<TData>(default, 1, "成功");
-            //return new BaseResult<TData>() { Data = default, Code = 1, Message = "成功" };
         }
 
-        public static BaseResult<TData> Success<TData>(TData data)
+        /// <summary>
+        /// 创建 泛型成功返回基类
+        /// </summary>
+        public static BaseResult<TData> Success<TData>(TData? data)
         {
-            return new BaseResult<TData>() { Data = data, Code = 1, Message = "成功" };
+            return Success(data, 1, "成功");
         }
 
-        public static BaseResult<TData> Success<TData>(TData data, string message) 
+        /// <summary>
+        /// 创建 泛型成功返回基类
+        /// </summary>
+        public static BaseResult<TData> Success<TData>(TData? data, string message) 
         {
-            return new BaseResult<TData>() { Data = data, Code = 1, Message = message };
+            return Success(data, 1, message);
         }
 
-        public static BaseResult<TData> Success<TData>(TData data, int code, string message) 
+        /// <summary>
+        /// 创建 泛型成功返回基类
+        /// </summary>
+        public static BaseResult<TData> Success<TData>(TData? data, int code, string message) 
         {
             return new BaseResult<TData>() { Data = data, Code = code, Message = message };
         }
 
+        /// <summary>
+        /// 创建 泛型错误返回基类
+        /// </summary>
         public static BaseResult<TData> Error<TData>() 
         {
-            return new BaseResult<TData>() { Data = default, Code = 0, Message = "错误" };
+            return Error<TData>(default, 0, "错误");
         }
 
-        public static BaseResult<TData> Error<TData>(TData data, string message = "错误") 
+        /// <summary>
+        /// 创建 泛型错误返回基类
+        /// </summary>
+        public static BaseResult<TData> Error<TData>(TData? data, string message = "错误") 
         {
-            return new BaseResult<TData>() { Data = data, Code = 0, Message = "错误" };
+            return Error(data, 0, message);
         }
 
-        public static BaseResult<TData> Error<TData>(TData data, int code = 0, string message = "错误") 
+        /// <summary>
+        /// 创建 泛型错误返回基类
+        /// </summary>
+        public static BaseResult<TData> Error<TData>(TData? data, int code = 0, string message = "错误") 
         {
-            return new BaseResult<TData>() { Data = data, Code = 0, Message = "错误" };
+            return Error(data, code, message);
         }
 
-        public static BaseResult<TData> Fail<TData>() where TData : class
+        /// <summary>
+        /// 创建 泛型失败返回基类
+        /// </summary>
+        public static BaseResult<TData> Fail<TData>()
         {
-            return new BaseResult<TData>() { Data = default, Code = 0, Message = "失败" };
+            return Fail<TData>(default, 0, "失败");
         }
 
-        public static BaseResult<TData> Fail<TData>(TData data, string message = "失败") 
+        /// <summary>
+        /// 创建 泛型失败返回基类
+        /// </summary>
+        public static BaseResult<TData> Fail<TData>(TData? data, string message = "失败") 
         {
-            return new BaseResult<TData>() { Data = data, Code = 0, Message = "失败" };
+            return Fail(data, 0, message);
         }
 
-        public static BaseResult<TData> Fail<TData>(TData data, int code = 0, string message = "失败") 
+        /// <summary>
+        /// 创建 泛型失败返回基类
+        /// </summary>
+        public static BaseResult<TData> Fail<TData>(TData? data, int code = 0, string message = "失败") 
         {
             return new BaseResult<TData>() { Data = data, Code = 0, Message = "失败" };
         }
 
+        /// <summary>
+        /// 创建 泛型异常返回基类
+        /// </summary>
         public static BaseResult<TData> Exception<TData>(Exception ex)
         {
-            return new BaseResult<TData>() { Data = default, Code = 0, Message = $"异常：{ex.Message}" };
+            return Exception<TData>(ex, default,0);
         }
 
-        public static BaseResult<TData> Exception<TData>(Exception ex, TData data) 
+        /// <summary>
+        /// 创建 泛型异常返回基类
+        /// </summary>
+        /// <typeparam name="TData"></typeparam>
+        /// <param name="ex"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public static BaseResult<TData> Exception<TData>(Exception ex, TData? data) 
         {
-            return new BaseResult<TData>() { Data = data, Code = 0, Message = $"异常：{ex.Message}" };
+            return Exception(ex, data, 0);
         }
 
-        public static BaseResult<TData> Exception<TData>(Exception ex, TData data, int code = 0) 
+        /// <summary>
+        /// 创建 泛型异常返回基类
+        /// </summary>
+
+        public static BaseResult<TData> Exception<TData>(Exception ex, TData? data, int code = 0) 
         {
             return new BaseResult<TData>() { Data = data, Code = code, Message = $"异常：{ex.Message}" };
         }
 
+        /// <summary>
+        /// 创建 泛型默认返回基类
+        /// </summary>
         public static BaseResult<TData> Default<TData>(TData? data = default)
         {
             return new BaseResult<TData>() { Code = 0, Message = "", Data = data };