如何在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 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

The best way would be to use a mocking framework (like Moq, for instance) to create a fake IModifyBehaviour object.

The Apply_NotCached_ReturnsReversed test would then verify that the Apply method of the mock object was called to generate the result. The Apply_Cached_ReturnsReversedCachedValue test would check that the result was returned without calling the Apply method of the mock object.

As it is, you test for the cached case doesn't actually prove that the result came from the cache.

Answer 2

First of all I would actually test the two clases in isolation, as proper units. Below I wrote up how I would test these. For this I'm using NUnit, and Moq (available in Nuget) as a mocking framework. But you can just change the test attributes and use MSTest instead.

For the reverse behavior I'm covering both a regular apply and applying to a null text:

using System;
using System.Linq;
using Decorator;
using NUnit.Framework;

namespace StackOverflow.Tests.HowToTest
{
    [TestFixture]
    public class ReverseBehaviorTest
    {
        [Test]
        public void Apply()
        {
            const string someText = "someText";
            var target = new ReverseBehavior();
            var result = target.Apply(someText);
            Assert.AreEqual(someText.Reverse(), result);
        }
        [Test]
        public void Apply_WhenNull()
        {
            var target = new ReverseBehavior();
            var result = target.Apply(null);
            Assert.AreEqual(String.Empty, result);
        }
    }
}

And for the CachingDecorator, the constructor's exception throwing, applying with caching and without:

using System;
using Decorator;
using Moq;
using NUnit.Framework;

namespace StackOverflow.Tests.HowToTest
{
    [TestFixture]
    public class CachingDecoratorTest
    {
        [Test]
        public void Constructor()
        {
            Assert.Throws(typeof(ArgumentNullException), () => new CachingDecorator(null));
        }

        [Test]
        public void Apply_NotCached()
        {
            var internalBehaviorMock = new Mock<IModifyBehavior>();
            internalBehaviorMock.Setup(x => x.Apply(It.IsAny<string>())).Returns<string>(y => y);
            const string someText = "someText";
            var target = new CachingDecorator(internalBehaviorMock.Object);
            target.Apply(someText);
            internalBehaviorMock.Verify(x => x.Apply(It.IsAny<string>()), Times.Once());
        }

        [Test]
        public void Apply_Cached()
        {
            var internalBehaviorMock = new Mock<IModifyBehavior>();
            internalBehaviorMock.Setup(x => x.Apply(It.IsAny<string>())).Returns<string>(y => y);
            const string someOtherText = "someOtherText";
            var target = new CachingDecorator(internalBehaviorMock.Object);
            target.Apply(someOtherText);
            target.Apply(someOtherText);
            internalBehaviorMock.Verify(x => x.Apply(It.IsAny<string>()), Times.Once());
        }
    }
}

Answer 3

just try to set cache dictionary values in your testcase and check for count after calling Apply(string value) method.

` 
       public void Apply_Cached_ReturnsReversedCachedValue()
        {
            Dictionary<string, string> cacheDict = new Dictionary<string, string>() { { "sometext", "txetemos" } };

            string str = "sometext";

            int dictionaryCountBeforeApply = cacheDict.Count();

            //set value to static cache field using reflection, here dictionary count is 1
            Type type = typeof(CachingDecorator);
            FieldInfo cacheFieldInfo = type.GetField("cache", BindingFlags.NonPublic | BindingFlags.Static);
            cacheFieldInfo.SetValue(decorator, cacheDict);

            string result = decorator.Apply(str);

            int dictionaryCountAfterApply = cacheDict.Count();

            Assert.AreEqual(dictionaryCountAfterApply, dictionaryCountBeforeApply);
        }


        public void Apply_NotCached_ReturnsReversed()
        {
            Dictionary<string, string> cacheDict = new Dictionary<string, string>() { };
            string str = "sometext";

            int dictionaryCountBeforeApply = cacheDict.Count();

            //set value to static cache field using reflection, here dictionary count is 0
            Type type = typeof(CachingDecorator);
            FieldInfo cacheFieldInfo = type.GetField("cache", BindingFlags.NonPublic | BindingFlags.Static);
            cacheFieldInfo.SetValue(decorator, cacheDict);

            string result = decorator.Apply(str);

            int dictionaryCountAfterApply = cacheDict.Count();

            Assert.AreNotEqual(dictionaryCountAfterApply, dictionaryCountBeforeApply);
        }`