使用接口对后台线程进行单元测试

Question

我创建了一个类SenderClass，它将从其构造函数启动并运行一个后台工作程序。 方法RunWorker() 运行是一个while(true) 循环，它将从队列中弹出元素，通过方法SendMessage() 发送它们，并休眠一小段时间以允许将新元素添加到队列中。

问题出在这里：如何测试从队列中发送元素的方法，而不会将其暴露给使用该类的人？

实施：

public class SenderClass : ISenderClass
{
    private Queue<int> _myQueue = new Queue<int>();
    private Thread _worker;

    public SenderClass()
    {
        //Create a background worker
        _worker = new Thread(RunWorker) {IsBackground = true};
        _worker.Start();
    }

    private void RunWorker() //This is the background worker's method
    {
        while (true) //Keep it running
        {
            lock (_myQueue) //No fiddling from other threads
            {
                while (_myQueue.Count != 0) //Pop elements if found
                    SendMessage(_myQueue.Dequeue()); //Send the element
            }
            Thread.Sleep(50); //Allow new elements to be inserted
        }
    }

    private void SendMessage(int element)
    {
        //This is what we want to test
    }

    public void AddToQueue(int element)
    {
        Task.Run(() => //Async method will return at ones, not slowing the caller
        {
            lock (_myQueue) //Lock queue to insert into it
            {
                _myQueue.Enqueue(element);
            }
        });
    }
}

想要的接口：

public interface ISenderClass
{
    void AddToQueue(int element);
}

测试所需的接口：

public interface ISenderClass
{
    void SendMessage(int element);
    void AddToQueue(int element);
}

有一个非常简单的解决方案，说由于Single Responsability Principle，我创建了不正确的类，而我的类的目的不是发送消息，而是实际运行发送消息的内容。

我应该拥有的是另一个类TransmittingClass，它通过自己的接口公开了方法SendMessage(int)。 这样我就可以测试那个类，SenderClass 应该只是通过那个接口调用方法。

但是对于当前的实现，我还有哪些其他选择？

我可以让我想测试的所有私有方法（全部）都有一个[assembly:InternalsVisibleTo("MyTests")]，但是是否存在第三个选项？

Answer 1

发送消息逻辑应在具有单独接口的单独类中实现。此类应将新类作为依赖项。您可以单独测试新类。

public interface IMessageQueue
{
    void AddToQueue(int element);
}

public interface IMessageSender
{
    void SendMessage(object message);
}

public class SenderClass : IMessageQueue
{
    private readonly IMessageSender _sender;
    public SenderClass(IMessageSender sender)
    {
        _sender = sender;
    }
    public void AddToQueue(int element)
    {
        /*...*/
    }

    private void SendMessage()
    {
        _sender.SendMessage(new object());
    }
}

public class DummyMessageSender : IMessageSender
{
    //you can use this in your test harness to check for the messages sent
    public Queue<object> Messages { get; private set; }

    public DummyMessageSender()
    {
        Messages = new Queue<object>();
    }
    public void SendMessage(object message)
    {
        Messages.Enqueue(message);
        //obviously you'll need to do some locking here too
    }
}

编辑

为了解决您的评论，这里是使用Action<int> 的实现。这允许您在测试类中定义消息发送操作以模拟 SendMessage 方法，而无需担心创建另一个类。 （就个人而言，我仍然更喜欢明确定义类/接口）。

public class SenderClass : ISenderClass
    {
        private Queue<int> _myQueue = new Queue<int>();
        private Thread _worker;
        private readonly Action<int> _senderAction;

        public SenderClass()
        {
            _worker = new Thread(RunWorker) { IsBackground = true };
            _worker.Start();
            _senderAction = DefaultMessageSendingAction;
        }

        public SenderClass(Action<int> senderAction)
        {
            //Create a background worker
            _worker = new Thread(RunWorker) { IsBackground = true };
            _worker.Start();
            _senderAction = senderAction;
        }

        private void RunWorker() //This is the background worker's method
        {
            while (true) //Keep it running
            {
                lock (_myQueue) //No fiddling from other threads
                {
                    while (_myQueue.Count != 0) //Pop elements if found
                        SendMessage(_myQueue.Dequeue()); //Send the element
                }
                Thread.Sleep(50); //Allow new elements to be inserted
            }
        }

        private void SendMessage(int element)
        {
            _senderAction(element);
        }

        private void DefaultMessageSendingAction(int item)
        {
            /* whatever happens during sending */
        }

        public void AddToQueue(int element)
        {
            Task.Run(() => //Async method will return at ones, not slowing the caller
            {
                lock (_myQueue) //Lock queue to insert into it
                {
                    _myQueue.Enqueue(element);
                }
            });
        }
    }

    public class TestClass
{
    private SenderClass _sender;
    private Queue<int> _messages;

    [TestInitialize]
    public void SetUp()
    {
        _messages = new Queue<int>();
        _sender = new SenderClass(DummyMessageSendingAction);
    }

    private void DummyMessageSendingAction(int item)
    {
        _messages.Enqueue(item);
    }

    [TestMethod]
    public void TestMethod1()
    {
        //This isn't a great test, but I think you get the idea
        int message = 42;
        _sender.AddToQueue(message);
        Thread.Sleep(100);
        CollectionAssert.Contains(_messages, 42);            
    }
}

Answer 2

看起来SenderClass 根本不应该执行任何发送。它应该简单地维护队列。通过执行发送的构造函数注入Action<int>。这样您就可以将SendMessage 移动到其他地方，然后随心所欲地调用它。

另外一个好处是，您对SendMessage 的测试不会因为队列管理而杂乱无章。

看到您的编辑，您似乎不喜欢这种方法，而且您似乎也不喜欢 InternalsVisibleTo 方法。您可以通过单独的接口公开SendMessage 并显式实现该接口。这样SendMessage 仍然可以通过该接口调用，但默认情况下，如果没有一些强制转换，它就无法访问。它也不会出现在智能感知自动完成列表中。