Examples - hypersolutions/hypermock GitHub Wiki

Mocking Examples

Below shows you how you can leverage HyperMock to handle a variety of scenarios. It uses an example controller and its service dependency.

Given the following controller and service:

public interface IAccountService
{
    bool HasAccounts { get; set; }
    void Credit(string account, int amount);
    bool CanDebit(string account, int amount);
    void Debit(string account, int amount);
    Task<string> DownloadStatementsAsync(string account);
}

public class AccountController
{
    private readonly IAccountService _accountService;

    public AccountController(IAccountService accountService)
    {
        _accountService = accountService;
    }

    public void Credit(AccountInfo info)
    {
        _accountService.Credit(info.Number, info.CreditAmount);
    }

    public void Debit(AccountInfo info)
    {
        if (_accountService.CanDebit(info.Number, info.DebitAmount))
            _accountService.Debit(info.Number, info.DebitAmount);
    }

    public bool HasAccounts()
    {
        return _accountService.HasAccounts;
    }

    public void Manage(bool hasAccounts)
    {
        _accountService.HasAccounts = hasAccounts;
    }

    public async Task<string> DownloadStatementsAsync(AccountInfo info)
    {
        return await _accountService.DownloadStatementsAsync(info.Number);
    }
}

public class AccountInfo
{
    public string Number { get; set; }
    public int CreditAmount { get; set; }
    public int DebitAmount { get; set; }
}

The following tests will run for either windows or universal apps - with one exception in that (at the time of writing) the way the exceptions are checked between VS windows and universal unit test frameworks differ. Below shows the windows version:

[TestClass]
public class AccountControllerTests
{
    private Mock<IAccountService> _mockService;
    private AccountController _controller;

    [TestInitialize]
    public void BeforeEachTest()
    {
        _mockService = Mock.Create<IAccountService>();
        _controller = new AccountController(_mockService.Object);
    }

    [TestMethod]
    public void CreditAddsToAccount()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = 100 };

        _controller.Credit(info);

        _mockService.Verify(s => s.Credit(info.Number, info.CreditAmount), Occurred.Once());
    }

    [TestMethod, ExpectedException(typeof(NotSupportedException))]
    public void CreditWithInvalidAmountThrowsException()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = -100 };
        _mockService.Setup(s => s.Credit(info.Number, Param.Is<int>(p => p < 1))).Throws(new NotSupportedException());

        _controller.Credit(info);
    }

    [TestMethod]
    public void CreditFailsWithUnknownAmount()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = 100 };

        _controller.Credit(info);

        _mockService.Verify(s => s.Credit(info.Number, 200), Occurred.Never());
    }

    [TestMethod]
    public void CreditWithAnyAmount()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = 100 };

        _controller.Credit(info);

        _mockService.Verify(s => s.Credit(info.Number, Param.IsAny<int>()), Occurred.Once());
    }

    [TestMethod]
    public void CreditWithAmountAboveMin()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = 2 };

        _controller.Credit(info);

        _mockService.Verify(s => s.Credit(info.Number, Param.Is<int>(p => p > 1)), Occurred.Once());
    }

    [TestMethod]
    public void CreditFailsWithAmountBelowMin()
    {
        var info = new AccountInfo { Number = "1234", CreditAmount = 1 };

        _controller.Credit(info);

        _mockService.Verify(s => s.Credit(info.Number, Param.Is<int>(p => p > 1)), Occurred.Never());
    }

    [TestMethod]
    public void DebitCorrectAccount()
    {
        var info1 = new AccountInfo { Number = "1234", DebitAmount = 100 };
        var info2 = new AccountInfo { Number = "4321", DebitAmount = 50 };
        _mockService.Setup(s => s.CanDebit(info1.Number, info1.DebitAmount)).Returns(false);
        _mockService.Setup(s => s.CanDebit(info2.Number, info2.DebitAmount)).Returns(true);

        _controller.Debit(info2);

        _mockService.Verify(s => s.Debit(info2.Number, info2.DebitAmount), Occurred.Once());
        _mockService.Verify(s => s.Debit(info1.Number, info1.DebitAmount), Occurred.Never());
    }

    [TestMethod]
    public void HasAccounts()
    {
        _mockService.SetupGet(s => s.HasAccounts).Returns(true);

        var result = _controller.HasAccounts();

        Assert.IsTrue(result);
    }

    [TestMethod]
    public void HasNoAccounts()
    {
        _mockService.SetupGet(s => s.HasAccounts).Returns(false);

        var result = _controller.HasAccounts();

        Assert.IsFalse(result);
    }

    [TestMethod]
    public void ManageDisablesAccount()
    {
        _controller.Manage(false);

        _mockService.VerifySet(s => s.HasAccounts, false, Occurred.Once());
    }

    [TestMethod, ExpectedException(typeof(NotSupportedException))]
    public void ManageDisablesAccountThrowsException()
    {
        _mockService.SetupSet(s => s.HasAccounts).SetValue(false).Throws<NotSupportedException>();

        _controller.Manage(false);
    }

    [TestMethod]
    public async Task DownloadStatementsAsync()
    {
        var info = new AccountInfo { Number = "1234" };

        _mockService.Setup(s => s.DownloadStatementsAsync("1234")).Returns(Task.Run(() => "Statement"));

        var statement = await _controller.DownloadStatementsAsync(info);

        Assert.AreEqual("Statement", statement);
    }
}
⚠️ **GitHub.com Fallback** ⚠️