kunshan-bzfm-mes-backend/DOAN.Tests/MES/Product/ProWorkorderEndToEndTests.cs

using DOAN.Model.MES.base_;
using DOAN.Model.MES.base_.Dto;
using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;
using DOAN.Service.MES.product;
using DOAN.Service.MES.product.IService;
using Infrastructure.Pagination;
using Moq;
using Xunit;

namespace DOAN.Tests.MES.Product
{
    /// <summary>
    /// 工单服务端到端测试
    /// </summary>
    public class ProWorkorderEndToEndTests
    {
        private readonly ProWorkorderService _workorderService;
        private readonly Mock<IProWorkorderCoreService> _mockCoreService;
        private readonly Mock<IProWorkorderQueryService> _mockQueryService;
        private readonly Mock<IProWorkorderImportService> _mockImportService;
        private readonly Mock<IProWorkorderExportService> _mockExportService;
        private readonly Mock<IProWorkorderUtilityService> _mockUtilityService;
        private readonly Mock<IProWorkorderReferenceService> _mockReferenceService;

        public ProWorkorderEndToEndTests()
        {
            // 创建所有子Service的模拟对象
            _mockCoreService = new Mock<IProWorkorderCoreService>();
            _mockQueryService = new Mock<IProWorkorderQueryService>();
            _mockImportService = new Mock<IProWorkorderImportService>();
            _mockExportService = new Mock<IProWorkorderExportService>();
            _mockUtilityService = new Mock<IProWorkorderUtilityService>();
            _mockReferenceService = new Mock<IProWorkorderReferenceService>();

            // 初始化主Service
            _workorderService = new ProWorkorderService(
                _mockCoreService.Object,
                _mockQueryService.Object,
                _mockImportService.Object,
                _mockExportService.Object,
                _mockUtilityService.Object,
                _mockReferenceService.Object
            );
        }

        /// <summary>
        /// 测试完整的工单创建和查询流程
        /// </summary>
        [Fact]
        public void WorkorderCreationAndQueryFlow_ShouldWorkCorrectly()
        {
            // Arrange - 准备添加工单的测试数据
            var workorder = new ProWorkorder
            {
                Id = "WO123",
                productionName = "端到端测试产品",
                productionCode = "E2E001",
                PlanNum = 50
            };

            // 模拟添加工单的返回结果
            _mockCoreService.Setup(x => x.AddProWorkorder(It.IsAny<ProWorkorder>()))
                .Returns(workorder);

            // 模拟获取工单详情的返回结果
            _mockQueryService.Setup(x => x.GetInfo(workorder.Id))
                .Returns(workorder);

            // 模拟查询工单列表的返回结果
            var queryDto = new ProWorkorderQueryDto
            {
                productionCode = "E2E001"
            };

            var expectedListResult = new PagedInfo<ProWorkorderDto3>
            {
                Total = 1,
                Result = new List<ProWorkorderDto3>
                {
                    new ProWorkorderDto3
                    {
                        Id = workorder.Id,
                        productionName = workorder.productionName,
                        productionCode = workorder.productionCode,
                        PlanNum = workorder.PlanNum
                    }
                }
            };

            _mockQueryService.Setup(x => x.GetList(queryDto))
                .Returns(expectedListResult);

            // Act 1 - 添加工单
            var addedWorkorder = _workorderService.AddProWorkorder(workorder);

            // Assert 1 - 验证添加工单的结果
            Assert.NotNull(addedWorkorder);
            Assert.Equal(workorder.Id, addedWorkorder.Id);
            Assert.Equal(workorder.productionName, addedWorkorder.productionName);
            _mockCoreService.Verify(x => x.AddProWorkorder(workorder), Times.Once);

            // Act 2 - 查询工单详情
            var retrievedWorkorder = _workorderService.GetInfo(workorder.Id);

            // Assert 2 - 验证查询工单详情的结果
            Assert.NotNull(retrievedWorkorder);
            Assert.Equal(workorder.Id, retrievedWorkorder.Id);
            Assert.Equal(workorder.productionName, retrievedWorkorder.productionName);
            _mockQueryService.Verify(x => x.GetInfo(workorder.Id), Times.Once);

            // Act 3 - 查询工单列表
            var workorderList = _workorderService.GetList(queryDto);

            // Assert 3 - 验证查询工单列表的结果
            Assert.NotNull(workorderList);
            Assert.Equal(expectedListResult.Total, workorderList.Total);
            Assert.Single(workorderList.Result);
            Assert.Equal(workorder.Id, workorderList.Result[0].Id);
            _mockQueryService.Verify(x => x.GetList(queryDto), Times.Once);
        }

        /// <summary>
        /// 测试工单服务的API兼容性
        /// </summary>
        [Fact]
        public void ApiCompatibility_ShouldMaintainSameInterface()
        {
            // 验证所有原始方法都能通过新的服务架构访问
            // 这确保了上游模块无需修改即可正常工作

            // 测试查询方法
            var queryDto = new ProWorkorderQueryDto();
            _mockQueryService.Setup(x => x.GetList(queryDto))
                .Returns(new PagedInfo<ProWorkorderDto3>());
            var listResult = _workorderService.GetList(queryDto);
            Assert.NotNull(listResult);

            // 测试添加工单方法
            var workorder = new ProWorkorder();
            _mockCoreService.Setup(x => x.AddProWorkorder(workorder))
                .Returns(workorder);
            var addResult = _workorderService.AddProWorkorder(workorder);
            Assert.NotNull(addResult);

            // 测试修改工单方法
            _mockCoreService.Setup(x => x.UpdateProWorkorder(workorder))
                .Returns(1);
            var updateResult = _workorderService.UpdateProWorkorder(workorder);
            Assert.Equal(1, updateResult);

            // 测试获取引用数据方法
            var materialQueryDto = new BaseMaterialListQueryDto5();
            _mockReferenceService.Setup(x => x.GetMaterialInfo(materialQueryDto))
                .Returns(new List<BaseMaterialList>());
            var materialResult = _workorderService.GetMaterialInfo(materialQueryDto);
            Assert.NotNull(materialResult);
        }

        /// <summary>
        /// 测试工单服务的异常处理
        /// </summary>
        [Fact]
        public void ExceptionHandling_ShouldBeConsistent()
        {
            // 模拟核心服务抛出异常
            var workorder = new ProWorkorder();
            _mockCoreService.Setup(x => x.AddProWorkorder(workorder))
                .Throws(new Exception("模拟添加失败"));

            // 验证异常能够正确传递
            Assert.Throws<Exception>(() => _workorderService.AddProWorkorder(workorder));
        }
    }
}