Gamlor's Blog

[SetUp]
public void Setup()
{
    var paperFormatsMock = new Mock<IPaperFormat>();
    paperFormatsMock.Setup(p => p.SupportedFormatCount).Returns(42);
    // More stuff about papers formats

    var printerQueue = new Mock<IPrintQueue>();
    printerQueue.Setup(p => p.PaperJam).Returns(false);
    // More stuff about the queue

    // Build up a mocked object graph
    var printerMock = new Mock<IPrinter>();
    printerMock.Setup(p => p.PaperFormats).Returns(paperFormatsMock.Object);
    printerMock.Setup(p => p.PrintQueue).Returns(printerQueue.Object);
}

• Whenever possible: Use the real implementation instead of a mock. I rarely mock my own interfaces, because I can use my real implementation. I only mock things that are too slow for fast tests or ifs part of a complex framework.

• Often I write a mock as plain code, which I can reuse in many tests. For example, I worked on some app that used git operations, provided by some framework. For that, I wrote a very basic mock implementation in straight code. I can reuse it in many tests, and everybody can understand it:

• Last, if writing a manual mock is too much effort, for example, due to a large API surface, then I fall back to mocking libraries. I keep the mocks in a central place for most tests, sharing the mock setup between tests. The goal is that the mock setup gets more realistic as different tests need more behavior of the mocked API:

[HttpGet]
public PurchaseSummary Get(string atTime)
{
    // Support a optional time query parameter to show reports of the past
    DateTime time;
    if (string.IsNullOrEmpty(atTime))
        time = DateTime.UtcNow;
    else
        time = DateTime.Parse(atTime);
    // Assume more complex code, like access checks, showing partial or full data depending on permissions etc
    return _summaries.SummarizeLastWeek(time);
}

// Testing edge cases is easy.
[Test]
public void WeekEndsAtTheEndOfYear()
{
    var endOfYear = DateTime.Parse("2020-12-31T23:00:00Z");
    /* Snip: insert test data at the end of the year */

    var endOfYearSummary = toTest.SummarizeLastWeek(endOfYear);
    /* Check that end of year calculation is correct */
}

public class Summaries{
    public PurchaseSummary SummarizeLastWeek(DateTime at)
    {
        // Assume more complex logic. Maybe it goes to different data sources, does more calculations etc
        var purchases = _purchases.LastWeeksPurchases(at);

        var total = purchases.Sum(e => e.Price);
        var count = purchases.Count();
        var priciest = purchases.OrderByDescending(p=>p.Price).FirstOrDefault();
        return new PurchaseSummary(total, count, priciest);
    }
}

public class Database
{
    public IList<Purchase> LastWeeksPurchases(DateTime at)
    {
        // Assume more complex queries, let's say joins with applied coupons, discounts at the time and god knows what
        return Database.InTransaction(conn => conn.Query<Purchase>(@"select * from purchases
        where dateTime < @at
        and (@at + INTERVAL '-7 day') < dateTime
        order by dateTime", new {at=at}).ToList());
    }
}

[Test]
public void DetectServiceFromUrl()
{
    var expectedDetection = new Dictionary<String, WellKnownEmailService>()
    {
        { "https://gmail.com", WellKnownEmailService.GMail },
        { "https://mail.google.com", WellKnownEmailService.GMail },
        { "https://hotmail.com", WellKnownEmailService.Microsoft },
        { "https://outlook.com", WellKnownEmailService.Microsoft },
        { "https://live.com", WellKnownEmailService.Microsoft },
        { "https://mail.company-x.com", WellKnownEmailService.OtherService },
    };

    foreach (var expected in expectedDetection)
    {
        var result = ParseUrls(expected.Key);

        Assert.AreEqual(expected.Value, result);
    }
}


[Test]
public void TitleAndBodyIsPresent()
{
    var expectedDetection = new List<IMailHandler>()
    {
        new GmailFormat(GmailHandler.Public),
        new GmailFormat(GmailHandler.Company),
        new OutlookFormat(),
        new MdnFormat()
    };

    foreach (var implementation in expectedDetection)
    {
        var formatted = implementation.FormatHtmlQuirks("Title", "Body of the Email");

        // No matter the html formatting flavor,
        // The title and the body have to be present
        Assert.IsTrue(formatted.Contains("Title"));
        Assert.IsTrue(formatted.Contains("Body of the Email"));
    }
}

[Test]
public void SerializeInts()
{
    var rnd = new Random();
    var baseCases = new[]
    {
        0,
        -1,
        1,
        int.MaxValue,
        int.MinValue
    };
    var randomExamples = Enumerable.Range(0, 10).Select(i => rnd.Next());

    var testExamples = baseCases.Concat(randomExamples);
    foreach (var original in testExamples)
    {
        var serialized = MyCleverSerialization.Serialize(original);

        var deserialized = MyCleverSerialization.Deserialize(serialized);

        Assert.AreEqual(original, deserialized);
    }
}