Understand Stub, Mock and Fake in Unit Testing

Still, if you are confused by them then here is another shot for clarification.

Yes, a stub cannot fail your unit test because you know what you are implementing and why you are implementing it. But a mock is just an object that mimics the real object. If our business logic in code is wrong then the unit test will fail even if we pass a correct mock object.

Now, I think you are very nearly clear about stub and mock. Let's understand fake now.

What is Fake?

As we know, the dictionary meaning of fake is, not real. Yes, it's the same in terms of unit testing. It's a general meaning, it might point to a stub or a mock or dummy or something that is not real.

So, fake is a generic term, that can point to anything.

Let's implement a stub in action

As we are a .NET developer, we will use C# as the programming language, but the concept is the same for all programming languages.

Have a look at the following example.

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

namespace ConsoleApp
{
    public interface IExtensionNanager
    {
        Boolean CheckExtension(string FileName);
    }

    public class ExtensionManager : IExtensionNanager
    {
        public bool CheckExtension(string FileName)
        {
            // Some complex business logic might go here. May be DB operation or file system handling
            return false;
        }
    }

    // Stub implementation to bypass actual Extension manager class.
    public class StubExtensionManager : IExtensionNanager
    {
        public bool CheckExtension(string FileName)
        {
            return true;
        }
    }

    public class FileChecker
    {
        IExtensionNanager objmanager = null;
        
        // Default constructor
        public FileChecker()
        {
            objmanager = new ExtensionManager();
        }

        // Parameterized constructor
        public FileChecker(IExtensionNanager tmpManager)
        {
            objmanager = tmpManager;
        }

        public Boolean CheckFile(String FileName)
        {
            return objmanager.CheckExtension(FileName);
        }
    }
}

The code is very simple to understand. We have implemented a simple FileChecker operation. The actual FileExtension manager class is not implemented fully and so we have implemented a stub version of the class. We are seeing that the CheckExtension function will always return true, as we defined explicitly.

Here is our code for the unit test.

using System;
using System.Web.Mvc;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using MVCApplication.Controllers;
using Moq;
using ConsoleApp.Company;
using ConsoleApp;

namespace TestMVC
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            // Act
            StubExtensionManager stub = new StubExtensionManager();
            FileChecker checker = new FileChecker(stub);

            // Action
            bool IsTrueFile = checker.CheckFile("myFile.whatever");

            // Assert
            Assert.AreEqual(true, IsTrueFile);
        }
    }
}

And the test will always pass because we have used the function that is defined within the stub class and it will make the unit test true always.

Ok, so once again to clarify the fundamental idea, a stub is used to always pass the unit test because we know what we are implementing and why. Our intention is to get the unit test.

Implement Mock in Example

Fine, we will now implement a mock. As I said, there are many mocking frameworks in the market, and though we will use none of them, we will implement a simple handwritten mocking.

Another key point about mock is, we can use a mock object to check unit testing. I mean within assert, but we cannot with stub. Have a look at the following code.

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

namespace ConsoleApp
{
    public interface IServiceProvider
    {
        void extensionService(string fileName);
    }

    // Mock extenison service provider
    public class MockExtensionService : IServiceProvider
    {
        public string ErrorMessage = null;
        public void extensionService(string fileName)
        {
            if (fileName.Split('.')[1] != "myType")
            {
                ErrorMessage = "Wrong Type";
            }
        }
    }

    // Actual incomplete ExtensionManager functionality
    public class ExtensionManager : IServiceProvider
    {
        public void extensionService(string fileName)
        {
            throw new NotImplementedException();
        }
    }

    public class ExtensionAnalyzer
    {
        public IServiceProvider provider = null;
        public ExtensionAnalyzer(IServiceProvider tmpProvider)
        {
            provider = tmpProvider;
        }

        public void ExtensionCheck(string fileName)
        {
            provider.extensionService(fileName);
        }
    }
}

The implementation is very simple, we have just implemented a Mock class that will mimic the actual functionality. Here is the unit test for this code.

using System;
using System.Web.Mvc;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using MVCApplication.Controllers;
using Moq;
using ConsoleApp.Company;
using ConsoleApp;

namespace TestMVC
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            // Act
            MockExtensionService mockobject = new MockExtensionService();
            // Inject mock object now
            ExtensionAnalyzer analyzer = new ExtensionAnalyzer(mockobject);
            // Action
            analyzer.ExtensionCheck("somefile.someextension");

            // Assert
            Assert.AreEqual(mockobject.ErrorMessage, "Wrong Type");
        }
    }
}

And we are seeing that the test has passed because the file extension is different than the expected one.

Conclusion

In this article, we have learned the concept of Stub and Mock in terms of unit testing. I hope this article helps you to understand them better. We need to pick the right one depending on the situation. A stub will help you when you want to replace the actual functionality, mock will help when you want to mimic the actual data.