多服务和测试设置

Question

类测试

为了清晰起见，一些隐藏的方法

namespace RiPS.Infrastructure.UA
{
    public class UAWorkflowManager
    {
        private readonly IContextIOAPI _api;
        private readonly IUAjoinedRepo _dbJoinedRepo;
        private readonly IRemindersSystem _remindersSystem;


        public UAWorkflowManager(IContextIOAPI contextIOAPI, IUAjoinedRepo uAjoinedRepo, IRemindersSystem remindersSystem)
        {

            _api = contextIOAPI;
            _dbJoinedRepo = uAjoinedRepo;
            _remindersSystem = remindersSystem;
        }


        public bool Assign(MongoUAJoinedWorkflow wf,string username, IUAWorkflowHub hub)
        {
                if (String.IsNullOrEmpty(wf.UA))
                {
                    hub.Error("Assignment Error", "Must have UA to assign");
                    return false;
                }
                if (wf.TaskReqs.Count < 1)
                {
                    hub.Error("Assignment Error", "Must have tasks");
                    return false;
                }
                foreach (var req in wf.TaskReqs)
                {
                    if (String.IsNullOrEmpty(req.Note))
                    {
                        hub.Error("Assignment Error", "All Tasks must have notes");
                        return false;
                    }

                    if (String.IsNullOrEmpty(req.Title))
                    {
                        hub.Error("Assignment Error", "All Tasks must have titles. Must be an error  ");
                        return false;
                    }
                }

                wf.Assigned = true;
                wf.AssignedBy = username;
                wf.AssignedDate = DateTime.UtcNow;

                var msg = GenerateMessage(wf);
                msg.Body = RenderViewToString(wf);
                var str = CreateStream(wf, hub);
                var fileName = str.Item1;
                var stream = str.Item2;
                AttachMessage(msg, stream, fileName);
                hub.Info("Assigning", "Sending Email");
                RetryUtility.RetryAction(() => SendMessage(msg));
                stream.Position = 0;
                hub.Info("Task", "adding");
                foreach (var taskReq in wf.TaskReqs)
                {
                   var r = _remindersSystem.AddReminder(new MongoReminder(wf.clientId, wf.policyId, wf.UA, "UAWF", taskReq.DueDate, taskReq.Title), stream, fileName);
                   wf.ReminderGuids.Add(r.Id);
                       stream.Position = 0;
                }
                _dbJoinedRepo.Save(wf);
                hub.Info("Task", "added");
                hub.Info("Assigning", "Moving Email To Assigned Folder");
                RetryUtility.RetryAction(() => MoveToFolder(wf.MessageId, "Assigned"));
                hub.Info("Assigning", "Saving Assignment to Database");
                wf.Error = "";

                hub.Update(wf);


                hub.Success("Assigned", wf.Subject);
                return true;
        }
    }
}   

测试类(nUnit & Moq)

namespace RiPSTests
{
    [TestFixture]
    public class UAWF
    {
        private Mock<IContextIOAPI> mock;
        private Mock<IUAjoinedRepo> repoMock;
        private Mock<IUAWorkflowHub> hubMock;
        private Mock<IRemindersSystem> reminderMock;
        private const string ConstSampleUA = "FAKEUA";
        private const string ConstSampleNote = "FAKENote";
        private const string ConstSampleTitle = "FAKETitle";
        [SetUp]
        public void setup()
        {
            mock = new Mock<IContextIOAPI>();
            repoMock = new Mock<IUAjoinedRepo>();
            hubMock = new Mock<IUAWorkflowHub>();
            reminderMock = new Mock<IRemindersSystem>();
        }
        [Test]
        public void CanSetup()
        {

            var man = new UAWorkflowManager(mock.Object, repoMock.Object, reminderMock.Object);
            Assert.NotNull(man);
        }

        [Test]
        public void FailMustHaveUA()
        {
            //Arrange 
            var man = new UAWorkflowManager(mock.Object, repoMock.Object, reminderMock.Object);
            var wf = new MongoUAJoinedWorkflow();

            //Act
            var res = man.Assign(wf, ConstSampleUA, hubMock.Object);

            //Assert
            Assert.IsFalse(res);
            hubMock.Verify(z => z.Error("Assignment Error", "Must have UA to assign"), Times.Exactly(1));
        }

        [Test]
        public void FailMustHaveTasks()
        {
            //Arrange 
            var man = new UAWorkflowManager(mock.Object, repoMock.Object, reminderMock.Object);
            var wf = new MongoUAJoinedWorkflow()
            {
                UA = ConstSampleUA
            };

            //Act
            var res = man.Assign(wf, ConstSampleUA, hubMock.Object);

            //Assert
            Assert.IsFalse(res);
            hubMock.Verify(z => z.Error("Assignment Error", "Must have tasks"), Times.Exactly(1));
        }


        [Test]
        public void FailTasksMustHaveNote()
        {
            //Arrange 
            var man = new UAWorkflowManager(mock.Object, repoMock.Object, reminderMock.Objects);
            var wf = new MongoUAJoinedWorkflow()
            {
                UA = ConstSampleUA,
                TaskReqs =  new List<TaskReq>()
                {
                    new TaskReq()
                    {
                        DueDate = DateTime.Today,
                        Title = ConstSampleTitle

                    }
                }

            };

            //Act
            var res = man.Assign(wf, ConstSampleUA, hubMock.Object);

            //Assert
            Assert.IsFalse(res);
            hubMock.Verify(z => z.Error("Assignment Error", "All Tasks must have notes"), Times.Exactly(1));
        }

    }
}

测试感觉非常冗长和易碎。写作测试第二(需要做一些大修，因为我不是一个强大的测试者，第一次无法测试)

Answer 1

您的第一个测试CanSetup永远不会失败；.NET构造函数永远不会返回null。

所有的测试都有相同的基本设置:创建一个“管理器”，创建一个“工作流”，调用All ()方法w/相同的参数。所有这些变化都是WF的构造方式。考虑：

1. 使管理器成为夹具的一部分(而不是局部变量)，并在安装过程中初始化它。在所有情况下，它的初始化似乎都是相同的。
2. 创建一个封装您遵循的模式的私有助手函数，并将变化的东西(比如WF，或WF的一些属性)公开为参数。当每个测试基本上都可以表示为模板的一种形式时，这是减少重复的一个不错的方法。
3. 个人偏好，但我喜欢在我的测试名称中下划线；这样可以更容易地阅读它们的长列表并发现差异。我还喜欢描述测试业务用例的相当冗长的名称：Cannot_assign_a_UA_without_tasks而不是FailMustHaveTasks。(我不知道我是否正确地推断了测试的目的，这正是我想要指出的；FailMustHaveTasks对我来说一点意义都没有)
4. 再:测试是脆弱的。如果您是针对错误消息进行断言，请避免执行相等断言。有人可以纠正语法错误并打破考试。相反，只需寻找一个或两个识别词。我不知道语法是w/ Moq，但是在RhinoMocks中，很容易说“断言这个方法是用包含单词‘Foo’的字符串参数调用的。”
5. 不然为什么你的测试很脆弱？有时候，脆弱的测试是由断言错误的人引起的；您真的关心调用特定的方法吗？还是你只是关心某个对象没有被修改？针对特定交互进行断言的测试可能比针对状态断言的测试更脆弱。