如何仅使用存根类对C＃中的if-else语句进行单元测试？

Question

I want to test whether the if-else statements are executed, The "if" block returns the item from the dictionary/cache and returns the output, while "else" block adds the input inside the cache and returns an output

An interface of IModifyBehavior with a method Apply

I was able to implement it properly using moq, but now what I want to try is unit test just using a stubclass (no framework), I also want to implement it without using fakes.

I have this classes:

namespace Decorator
{
    using System;

    /// <summary>
    /// Reverse Behavior
    /// </summary>
    public class ReverseBehavior : IModifyBehavior
    {
        /// <summary>
        /// Applies the specified value.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>result</returns>
        public string Apply(string value)
        {
            var result = string.Empty;
            if (value != null)
            {
                char[] letters = value.ToCharArray();
                Array.Reverse(letters);
                result = new string(letters); 
            }

            return result; 
        }
    }
}




using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    /// <summary>
    /// Caching Decorator
    /// </summary>
    public class CachingDecorator : IModifyBehavior
    {

        /// <summary>
        /// The behavior
        /// </summary>
        private IModifyBehavior behavior;


        public CachingDecorator(IModifyBehavior behavior)
        {
            if (behavior == null)
            {
                throw new ArgumentNullException("behavior");
            }

            this.behavior = behavior;
        }



        private static Dictionary<string, string> cache = new Dictionary<string, string>();

        /// <summary>
        /// Applies the specified value.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>
        /// value
        /// </returns>
        public string Apply(string value)
        {
            ////Key = original value, Value = Reversed
            var result = string.Empty;

            //cache.Add("randel", "lednar");
            if(cache.ContainsKey(value))
            {
                result = cache[value];
            }
            else
            {
                result = this.behavior.Apply(value);// = "reversed";
                ////Note:Add(key,value)
                cache.Add(value, result); 
            }
            return result;
        }
    }
}

Here's my current code for the test, the codes were able to passed the test, but I'm not sure if my implementation was correct:

[TestClass]
    public class CachingDecoratorTest
    {
        private IModifyBehavior behavior;

        [TestInitialize]
        public void Setup()
        {
            this.behavior = new CachingDecorator(new ReverseBehavior());
        }

        [TestCleanup]
        public void Teardown()
        {
            this.behavior = null;
        }

        [TestMethod]
        public void Apply_Cached_ReturnsReversedCachedValue()
        {
            string actual = "randel";           
            ////store it inside the cache
            string cached = this.behavior.Apply(actual);

            ////call the function again, to test the else block statement
            ////Implement DRY principle next time
            string expected = this.behavior.Apply(actual);
            Assert.IsTrue(cached.Equals(expected));

        }

        [TestMethod]
        public void Apply_NotCached_ReturnsReversed()
        {
            string actual = "randel";
            string expected = "lednar";
            Assert.AreEqual(expected, this.behavior.Apply(actual));
        }


    }

Sir/Ma'am your answers would be of great help. Thank you++

Answer 1

I would think that you would want a unit test that really exercises the contract of the class without worrying about the internals too much. You could, for example, do something via reflection, or expose some new method, that allows your test to ask the cache what it's doing, but your test shouldn't care about that anyway. If I look at the caching decorator, the contract you have implied is something like :

Once apply has been called with argument x and returning value v , any subsequent call to apply with argument x will also return v .

So as you already have, a test that calls the method twice with x can show that we get v back both times. But we can't tell that this is because the caching decorator is doing what we want, or if it's because the underlying reversal modifier is just following the contract.

So what if we had an underlying modifier that didn't play by those rules?

Suppose, using a mock, you set up an implementation of IModifyBehavior that returned the number of times it had been invoked? Now we've got a different behavior - if I call apply on this implementation 3 times with the same argument x , I will get back 3 different answers (which can be verified with a unit test). If I then wrap that mock in your CachingDecorator, I can see that the CachingDecorator is hanging onto the first invocation that it saw, and abiding by the original contract. This 'proves' to me that the internals of CachingDecorator are following the contract instead of just passing along the invocation to some other object that happens to also follow the contract.

Answer 2

My first question is why are you opposed to using a mocking framework?

But working under that, why not just roll your own mock see Rolling your own mock objects , this solves your problem without using external libs.