C#如何使用中介体e CQRS模式测试CommandsHandler

在我开始学习一些课程之前，我从未在TDD工作过，但我不知道在现实生活中如何做到这一点

我有一个项目是MVC+DDD+域通知+CQRS+事件源+工作和存储库模式的统一，我想测试，但我不知道从哪里开始，甚至不知道如何模拟这些注入

这是我的控制器

public class DepartmentsController : BaseController
    {
        private readonly IDepartmentAppService _departmentAppService;


        public DepartmentsController(IDepartmentAppService departmentAppService,
            INotificationHandler<DomainNotification> notifications) : base(notifications)
        {
            _departmentAppService = departmentAppService;
        }

        public ActionResult Create(DepartmentViewModel departmentViewModel)
        {
            if (!ModelState.IsValid) return View(departmentViewModel);
            _departmentAppService.CreateDepartment(departmentViewModel);

            if (IsValidOperation())
            {
                this.AddToastMessage("Success", "Department Saved", ToastType.Success);
                return RedirectToAction("Index");
            }

            this.AddToastMessage("Error", GetNotifications().FirstOrDefault()?.Value, ToastType.Error);
            return View(departmentViewModel);
        }
    }

公共类部门控制器：BaseController
{
私人只读IDepartmentAppService(u departmentAppService)；
公共部门控制员（IDepartmentAppService部门AppService、，
INotificationHandler通知）：基本（通知）
{
_departmentAppService=departmentAppService；
}
公共操作结果创建（部门视图模型部门视图模型）
{
如果（！ModelState.IsValid）返回视图（departmentViewModel）；
_departmentAppService.CreateDepartment（departmentViewModel）；
if（IsValidOperation（））
{
this.AddToastMessage（“成功”，“部门已保存”，ToastType.Success）；
返回操作（“索引”）；
}
此.AddToastMessage（“错误”，GetNotifications（）.FirstOrDefault（）？.Value，ToastType.Error）；
返回视图（部门视图模型）；
}
}

还有我的服务层

 private readonly IMediatorHandler _bus;
    private readonly IDepartmentRepository _departmentRepository;
    private readonly IMapper _mapper;


    public DepartmentAppService(IMapper mapper,
        IDepartmentRepository departmentRepository,
        IMediatorHandler bus)
    {
        _departmentRepository = departmentRepository;
        _bus = bus;
        _mapper = mapper;
    }



     public void CreateDepartment(DepartmentViewModel departmentViewModel)
    {
        var registerCommand = _mapper.Map<RegisterDepartmentCommand>(departmentViewModel);
        _bus.SendCommand(registerCommand);
    }

专用只读IMediatorHandler\u总线；
私有只读IDepartmentRepository(部门存储库)；
专用只读IMapper\u映射器；
公共部门应用服务（IMapper mapper，
IDepartmentRepository部门存储库，
IMediatorHandler（总线）
{
_departmentRepository=departmentRepository；
_总线=总线；
_映射器=映射器；
}
公共部门（部门视图模型部门视图模型）
{
var registerCommand=\u mapper.Map（departmentViewModel）；
_总线发送命令（寄存器命令）；
}

我创建了这个简单的测试方法，但我真的不知道我期望的是什么，我不确定在这一点上我应该做什么，你们能帮我一下吗

[TestClass()]
public class DepartmentAppServiceTests
{

    private readonly Mock<IMediatorHandler> _mediatorHandlerMock;
    private readonly Mock<IDepartmentRepository> _departmentRepositoryMock;
    private readonly Mock<IMapper> _mapper;

    public DepartmentAppServiceTests()
    {
        _mediatorHandlerMock = new Mock<IMediatorHandler>();
        _departmentRepositoryMock = new Mock<IDepartmentRepository>();
        _mapper = new Mock<IMapper>();

    }

    [TestMethod()]
    public void CreateDepartmentTest()
    {
        //Arrange
        var fakeDepartment = GetFakeDeparment();
        var fakeDepartmentVm = new DepartmentViewModel();

        Mock<RegisterDepartmentCommand> expected = new Mock<RegisterDepartmentCommand>();
        expected.SetupGet(x => x.Id).Returns(new Guid());
        expected.SetupGet(x => x.Name).Returns("Department Test");

        _departmentRepositoryMock.Setup(x => x.GetById(It.IsAny<Guid>()))
            .Returns(fakeDepartment);

        _mediatorHandlerMock.Setup(x => x.SendCommand(It.IsAny<RegisterDepartmentCommand>()));

        //Act
        var departmentService = new DepartmentAppService(
            _mapper.Object,
            _departmentRepositoryMock.Object,
            _mediatorHandlerMock.Object);


        _mapper.Setup(m => m.Map<Department, DepartmentViewModel>(It.IsAny<Department>())).Returns(fakeDepartmentVm);

        departmentService.CreateDepartment(fakeDepartmentVm);

        //Assert
      //  !_notifications.HasNotifications();



    }

    private Department GetFakeDeparment()
    {
        return new Department()
        {
            Id = new Guid(),
            Name = "fakeName",

        };
    }
}

[TestClass（）]
公共类DepartmentAppServiceTests
{
私有只读Mock_mediatorHandlerMock；
私有只读Mock_departmentRepositoryMock；
私有只读模拟映射器；
公共部门AppServiceTests（）
{
_mediatorHandlerMock=新Mock（）；
_departmentRepositoryMock=新Mock（）；
_mapper=newmock（）；
}
[TestMethod（）]
public void CreateDepartmentTest（）
{
//安排
var fakeDepartment=getfakedepartment（）；
var fakeDepartmentVm=新部门视图模型（）；
预期模拟=新模拟（）；
应为.SetupGet（x=>x.Id）.Returns（new Guid（））；
expected.SetupGet（x=>x.Name）.Returns（“部门测试”）；
_departmentRepositoryMock.Setup（x=>x.GetById（It.IsAny（）））
.退货（伪造部门）；
_mediatorHandlerMock.Setup（x=>x.SendCommand（It.IsAny（））；
//表演
var departmentService=新DepartmentAppService(
_mapper.Object，
_departmentRepositoryMock.Object，
_对象）；
_Setup（m=>m.Map（It.IsAny（））.Returns（fakeDepartmentVm）；
创建部门（fakeDepartmentVm）；
//断言
//！\u通知。HasNotifications（）；
}
私人部门
{
返回新部门（）
{
Id=新Guid（），
Name=“fakeName”，
};
}
}

}