How I Learned to Love Loosely Coupled Test Data

"Play fast and loose with faith? So jest with heaven,
Make such unconstant children of ourselves"
-- Shakespeare, King John
Act III, Scene I, Lines 242-243

For C# development, I love to use AutoFac!  I find that AutoFac allows me to change the design of my code without having to worry about decencies.  The last thing I want to have to do while refactoring my design is fix a bunch of broken unit tests.  Typically if find that I have to support hard coded test setup for the system under test, when I change the signature of the constructor I'll also need to change all the test setups related to the class (this is often the case in code in which I was not the original author).  This can become very annoying, since the test cases often do not really care about the setup of the system under test.

If you are using a decency injection framework like AutoFac you really need to pair the loose coupling of your production code decencies with loose coupling of the setup of your system under test.  Loose coupling of the setup of your system under test is exactly what a test fixture is for.

Personally I love AutoFixture for C# development!  AutoFixture does all the hard work of creating a test fixture for you, all you have to do is walk up to it and ask it for what you want.

If you are using AutoFac or some other IoC framework in your system under test, more likely than not, you are using a mocking framework like Moq or Rhino Mocks.  Well, AutoFixture has you covered by allowing you to use an auto mocking plugin for Moq, Rhino Mocks, or whatever.  By using auto mocking along with AutoFixture you are able to create a system under test with all the decencies already mocked out.

With AutoFixture creating the system under test for you, you can freely change the signature of your constructor for your system under test without the need to change any of the setup for the test cases!

Say we have the following:

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Reflection;
	using System.Text;
	using System.Threading.Tasks;
	using Autofac;
	namespace AutoFixture
	{
	public static class DependencyResolver
	{
	public static IContainer Resolver()
	{
	var builder = new ContainerBuilder();
	builder
	.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
	.AsImplementedInterfaces();
	return builder.Build();
	}
	}
	public class Program
	{
	public static void Main(string[] args)
	{
	var resolver = DependencyResolver.Resolver();
	var system = resolver.Resolve<ISystem>();
	system.Do();
	}
	}
	public interface ISystem
	{
	void Do();
	bool Status();
	}
	public class System : ISystem
	{
	/*private readonly ILog _logger;*/
	private readonly IMessager _messager;
	private readonly IProcessor _processor;
	public System(/*ILog logger,*/ IMessager messager, IProcessor processor)
	{
	/*_logger = logger;*/
	_messager = messager;
	_processor = processor;
	}
	public void Do()
	{
	}
	public bool Status()
	{
	var messages = _messager.Pull();
	var value = _processor.Calculate(messages);
	/*_logger.Info(value.ToString());*/
	return value > 0;
	}
	}
	public interface IMessager
	{
	IList<int> Pull();
	}
	public interface ILog
	{
	void Info(string message);
	}
	public interface IProcessor
	{
	int Calculate(IList<int> messages);
	}
	}

view raw Program.cs hosted with ❤ by GitHub

	using System;
	using System.Collections.Generic;
	using Microsoft.VisualStudio.TestTools.UnitTesting;
	using Moq;
	using Ploeh.AutoFixture;
	using Ploeh.AutoFixture.AutoMoq;
	using Ploeh.AutoFixture.Kernel;
	namespace AutoFixture.Tests
	{
	// these will continue to work after the constructor's signature is changed
	[TestClass]
	public class SystemTestsWithAutoFixture
	{
	private Fixture _fixture;
	[TestInitialize]
	public void BeforeEach()
	{
	_fixture = new Fixture();
	_fixture
	.Customize(new AutoMoqCustomization());
	}
	[TestMethod]
	public void GivenProcessorReturnsLessThanZero_StatusMustReturnFalse()
	{
	_fixture.Customizations.Add(
	new RandomNumericSequenceGenerator(-1000, -1));
	var processor = _fixture.Freeze<Mock<IProcessor>>();
	processor
	.Setup(s => s.Calculate(It.IsAny<IList<int>>()))
	.Returns(_fixture.Create<int>());
	var sut = _fixture.Create<System>();
	Assert.IsFalse(sut.Status());
	}
	[TestMethod]
	public void GivenProcessorReturnsGreaterThanZero_StatusMustReturnTrue()
	{
	_fixture.Customizations.Add(
	new RandomNumericSequenceGenerator(1, 1000));
	var processor = _fixture.Freeze<Mock<IProcessor>>();
	processor
	.Setup(s => s.Calculate(It.IsAny<IList<int>>()))
	.Returns(_fixture.Create<int>());
	var sut = _fixture.Create<System>();
	Assert.IsTrue(sut.Status());
	}
	}
	// these will stop working once the constructor's signature is changed
	[TestClass]
	public class ProgramTestsWithoutAutoFixture
	{
	private Mock<IMessager> _mockMessager;
	private Mock<IProcessor> _mockProcessor;
	private System _sut;
	[TestInitialize]
	public void BeforeEach()
	{
	_mockMessager = new Mock<IMessager>();
	_mockProcessor = new Mock<IProcessor>();
	_sut = new System(
	_mockMessager.Object,
	_mockProcessor.Object);
	}
	[TestMethod]
	public void GivenProcessorReturnsLessThanZero_StatusMustReturnFalse()
	{
	_mockProcessor
	.Setup(s => s.Calculate(It.IsAny<IList<int>>()))
	.Returns(-5);
	Assert.IsFalse(_sut.Status());
	}
	[TestMethod]
	public void GivenProcessorReturnsGreaterThanZero_StatusMustReturnTrue()
	{
	_mockProcessor
	.Setup(s => s.Calculate(It.IsAny<IList<int>>()))
	.Returns(5);
	Assert.IsTrue(_sut.Status());
	}
	}
	}

view raw ProgramTests.cs hosted with ❤ by GitHub

The above is a fairly common example of C# application that I work with.

We see that we are testing using two different test classes, one using AutoFixture and one not.  If we uncomment out the ILog decency in the System class we would break the test setup in the test class ProgramTestsWithoutAutoFixture, but the test class SystemTestsWithAutoFixture would continue to work!  For such a simple example this might not matter, but with larger code bases this can become an issue.

By using AutoFixture with Moq we are pairing the same loosely coupling of the creation of our system under test with the loosely coupling we get for our decencies in our production code using AutoFac.  Truly one can say, AutoFac iff AutoFixture with Moq.

Unquote, App.config, and You

"What curious eye doth quote deformities?"
-- Shakespeare, Romeo and Juliet
Act I, Scene IV, Line 31

I've started using Unquote for my assertions with F# xUnit tests.  I find that its step-by-step failure messages really help in figuring out what is going on.

One thing that really throw me when I first used it was the System.MissingMethodException exception that Unquote was throwing at runtime.  Luckily I was able to find this StackOverflow answer.  It seems that you need to do a binding redirect for FSharp.Core, so you'll need to set up an App.config file in your test project like this example of the Coin Changer kata (using MapFold).

	<?xml version="1.0" encoding="utf-8" ?>
	<configuration>
	<runtime>
	<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
	<dependentAssembly>
	<assemblyIdentity name="FSharp.Core"
	publicKeyToken="b03f5f7f11d50a3a"
	culture="neutral"/>
	<bindingRedirect oldVersion="4.3.1.0"
	newVersion="4.4.0.0"/>
	</dependentAssembly>
	</assemblyBinding>
	</runtime>
	</configuration>

view raw App.config hosted with ❤ by GitHub

	namespace CoinChanger
	module Changer =
	let change coins amount =
	coins
	|> List.mapFold
	(fun amount coin -> List.replicate <| amount / coin <| coin, amount % coin)
	amount
	|> fst
	|> List.reduce (@)

view raw Changer.fs hosted with ❤ by GitHub

	namespace CoinChangerTests
	module ChangerTests =
	open Xunit
	open Swensen.Unquote
	open CoinChanger.Changer
	[<Theory>]
	[<InlineData(0)>]
	[<InlineData(1)>]
	[<InlineData(99)>]
	let ``given pennies it must return coins equal to amount given`` amount =
	let pennies = [1]
	test <@
	change pennies amount |> List.length = amount
	@>
	[<Theory>]
	[<InlineData(0, 10)>]
	[<InlineData(1, 5)>]
	[<InlineData(42, 25)>]
	[<InlineData(99, 20)>]
	let ``given number of coins and value it must return number of coins`` number value =
	let coins = [value]
	test <@
	change coins <| number * value |> List.length = number
	@>
	[<Theory>]
	[<InlineData(1)>]
	[<InlineData(10)>]
	[<InlineData(99)>]
	let ``given coin values it must return coins of that value`` value =
	let coins = [value]
	let amount = 99
	test <@
	let unique = change coins amount |> List.distinct
	unique |> List.length = 1
	&&
	unique |> List.head = value
	@>
	[<Fact>]
	let ``given full register and 1 of each coin it must return 1 of each coin`` () =
	let register = [25; 10; 5; 1]
	let amount = List.sum register
	test <@
	change register amount |> List.distinct = register
	@>
	[<Theory>]
	[<InlineData(0)>]
	[<InlineData(1)>]
	[<InlineData(42)>]
	[<InlineData(99)>]
	let ``given full register it must return coins summing to amount`` amount =
	let register = [25; 10; 5; 1]
	test <@
	change register amount |> List.sum = amount
	@>

view raw ChangerTests.fs hosted with ❤ by GitHub

Happy coding.

Behold the Power of Mutation!

"And – ere a man hath power to say ‘ Behold!’ –"
-- Shakespeare, A Midsummer Night's Dream
Act I, Scene I, Line 147

One of the things I found very interesting in the Pluralsight class "Exploring C# 6 with Jon Skeet" was that the new interpolated strings works with expressions.  Since C# is a mutable language we can easily abuse this!

	> $"I Love C# {((Func<int>)(() => { int x = 6; return x; }))()}!"
	"I Love C# 6!"
	> ((Func<int>)(() => { int x = 6; return x; }))()
	6
	> var six = 6;
	> six
	6
	> $"I Love C# {((Func<int>)(() => { return six; }))()}!"
	"I Love C# 6!"
	> $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!"
	"I Love C# 7!"
	> var wat = $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!"
	. ;
	> wat
	"I Love C# 8!"
	> wat
	"I Love C# 8!"
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; return six; }))()}!")
	. ;
	> wat()
	"I Love C# 9!"
	> wat()
	"I Love C# 10!"
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; System.Console.WriteLine(six); return six; }))()}!");
	> wat()
	11
	"I Love C# 11!"
	> var message = "They actual used it! HAHAHA! WAT!";
	> var wat = (Func<string>)(() => $"I Love C# {((Func<int>)(() => { six++; System.Console.WriteLine(message); return six; }))()}!");
	> wat()
	They actual used it! HAHAHA! WAT!
	"I Love C# 12!"
	> wat()
	They actual used it! HAHAHA! WAT!
	"I Love C# 13!"
	>

view raw repl.txt hosted with ❤ by GitHub

In the above C# REPL we see that we can we can have all kinds of fun as long as we have an expression in our interpolated string.

Example:

var intValue = 0;
var stringValue = $"{((Func)(() => { intValue++; return intValue; }))()}"

As long as the expression has a ToString value it will work.  Note, stringValue will only increment intValue once and after that it will always give the same result, but it is fun nonetheless.

Remember, never under estimate the power to abuse mutable languages!

Item and Slice F#

"Slice, I say. Pauca, pauca. Slice! That's my humour."
-- Shakespeare, The Merry Wives of Windsor
Act I, Scene I, Line 125

I've been working my way through Dave Fancher's excellent Book of F# and found an interesting example of indexing and slicing arrays in F#.  Since programming is a full contact sport, here is my take on indexing and slicing in F#.

	namespace OO
	type Words(sentence : string) =
	let words = sentence.Split ' '
	member x.Item(i) = words.[i]
	member x.GetSlice(s : int option, e : int option) =
	match s, e with
	| Some(s), Some(e) -> if e > words.Length then words.[s..] else words.[s..e]
	| Some(s), None -> words.[s..]
	| None, Some(e) -> if e > words.Length then words else words.[..e]
	| _ -> Array.empty<string>
	module Tests =
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData("quick brown fox")>]
	[<InlineData("1 2 3")>]
	[<InlineData("one two")>]
	let ``given a sentence it must be able to get the 2nd word`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[``2nd``] |> should equal <| sentence.Split(' ').[``2nd``]
	[<Theory>]
	[<InlineData("nope yep yep nope")>]
	[<InlineData("1 2 3")>]
	let ``given a sentence it must be able to get the 2nd and 3rd words`` (sentence : string) =
	let ``2nd`` = 1
	let ``3rd`` = 2
	Words(sentence).[``2nd``..``3rd``] |> should equal <| sentence.Split(' ').[``2nd``..``3rd``]
	[<Theory>]
	[<InlineData("nope yep yep yep")>]
	[<InlineData("1 2 3 4 5 6 7")>]
	[<InlineData("one two")>]
	let ``given a sentence it must be able to cutoff the 1st word`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[``2nd``..] |> should equal <| sentence.Split(' ').[``2nd``..]
	[<Theory>]
	[<InlineData("yep yep nope")>]
	[<InlineData("1 2 3 4 5 6 7")>]
	[<InlineData("one two three")>]
	let ``given a sentence it must be able to get the 1st and 2nd words`` (sentence : string) =
	let ``2nd`` = 1
	Words(sentence).[..``2nd``] |> should equal <| sentence.Split(' ').[..``2nd``]
	[<Theory>]
	[<InlineData("it is not size")>]
	[<InlineData("that matters")>]
	let ``given a sentence it must be able to slice if length is longer than number of words`` (sentence : string) =
	let longer = 100
	Words(sentence).[0..longer] |> should equal <| sentence.Split ' '
	Words(sentence).[..longer] |> should equal <| sentence.Split ' '
	[<Theory>]
	[<InlineData("a b c")>]
	[<InlineData("1 2 3 4 5 6 7 8")>]
	let ``given a sentence it must be able to slice if length is 1 beyond the end`` (sentence : string) =
	Words(sentence).[..sentence.Length] |> should equal <| sentence.Split ' '

view raw IndexExamples.fs hosted with ❤ by GitHub

We have a constructor for a type called Word which takes a string and separates it into words.

type Words(sentence : string)

We implement an index with the Item member.

member x.Item(i) = words.[i]

This allows us to access the words of the string given.

Words(sentence).[1]

We also implement an array slice with the GetSlice member.

member x.GetSlice(s : int option, e : int option)

This allows us to slice the array (substring it) of words in the string given.

Words(sentence).[1..2]

We can go one better than built in slice by allow for range in the slice to be bigger than the number of words.

let longer = 100
Words(sentence).[0..longer]

In order to allow for this we have to check to see if the end is greater than the number of words.

if e > words.Length then words.[s..] else words.[s..e]

and

if e > words.Length then words else words.[..e]

I hope I have shown that F# has some very nice support for objects.

FizzBuzz and the Roman Numeral Kata are the Same Thing!

"The same, sir."

-- Shakespeare, Coriolanus

Act IV, Scene III, Line 7

As Homer Simpson pointed out, "Coke and Pepsi are the same thing!"


Similarly I plan to show that the FizzBuzz and Roman Numeral katas are the same thing! 

First let's look at the rules of FizzBuzz.

f(x : int) : string

  if 3 | x and 5 | x then "FizzBuzz"
  if 3 | x then "Fizz"
  if 5 | x then "Buzz"
  default string x

*note, 3 | x reads 3 divides x, in other words x / 3 does not have a remainder

 In general we see that we have two (or three) rules and a default value, we are translating from the domain into the codomain following a set of rules, in other words we have a function.

	namespace FizzBuzz
	module FizzBuzz =
	let fizzbuzzer (n : int) =
	[(3, "Fizz");
	(5, "Buzz")]
	|> List.fold (fun m (x, s) -> m + if n % x = 0 then s else "") ""
	|> (fun s -> if s = "" then string n else s)

view raw FizzBuzz.fs hosted with ❤ by GitHub

	namespace FizzBuzz.Tests
	module FizzBuzzTests =
	open FizzBuzz.FizzBuzz
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Multiples of given value should contain expected`` (given : int) (expected : string) =
	fizzbuzzer given |> should haveSubstring expected

view raw FizzBuzzTests.fs hosted with ❤ by GitHub

How about the Roman Numeral kata?

f(x : int) : string

  fold

    roman-numerals : (int, string)

    lambda((x : int, m : string),

           (k : int, v : string)) : (int, string)

      while k | x then (x / k, concat m v)

    (x, default string) : (int, string)

Again we see a list of rules for translation.

	namespace RomanNumerals
	module RomanNumerals =
	let translate n =
	[(40, "XL");
	(10, "X"); (9, "IX");
	(5, "V"); (4, "IV");
	(1, "I")]
	|> List.fold
	(fun (x, m) (k, v) ->
	if x >= k then (x - (k * (x / k)), m + String.replicate (x / k) v)
	else (x, m))
	(n, "")
	|> snd

view raw RomanNumerals.fs hosted with ❤ by GitHub

	module RomanNumerals.Tests.Translate
	open RomanNumerals.RomanNumerals
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(3, "III")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	[<InlineData(6, "VI")>]
	[<InlineData(7, "VII")>]
	[<InlineData(8, "VIII")>]
	[<InlineData(9, "IX")>]
	[<InlineData(10, "X")>]
	[<InlineData(11, "XI")>]
	[<InlineData(29, "XXIX")>]
	[<InlineData(40, "XL")>]
	[<InlineData(49, "XLIX")>]
	let ``given 1 it must return I``
	(value : int, expected : string) =
	translate value |> should equal expected

view raw RomanNumeralsTests.fs hosted with ❤ by GitHub

The only real difference to FizzBuzz is the fold across the rules, but we've hinted at this in the FizzBuzz description above.  We stated that FizzBuzz has two (or three) rules, we can rewrite it using a fold with just the two rules using the fold to cover the "and" case.

	namespace Translate
	module Translate =
	let translate folding defaulting translations seed n =
	translations
	|> List.fold folding (n, seed)
	|> snd
	|> defaulting
	let fizzbuzzer (n : int) =
	[(3, "Fizz");
	(5, "Buzz")]
	|> List.fold
	(fun (n, r) (x, s) -> (n, r + if n % x = 0 then s else ""))
	(n, "")
	|> snd
	|> (fun s -> if s = "" then string n else s)
	let fizzbuzzer2 (n : int) =
	translate
	(fun (n, r) (x, s) -> (n, r + if n % x = 0 then s else ""))
	(fun s -> if s = "" then string n else s)
	[(3, "Fizz");
	(5, "Buzz")]
	""
	n
	let romanize (n : int) =
	[(5, "V");
	(4, "IV");
	(1, "I")]
	|> List.fold
	(fun (n, r) (x, s) ->
	(n % x, r + if n >= x then String.replicate (n / x) s else ""))
	(n, "")
	|> snd
	|> (fun s -> s)
	let romanize2 (n : int) =
	translate
	(fun (n, r) (x, s) ->
	(n % x, r + if n >= x then String.replicate (n / x) s else ""))
	(fun d -> d)
	[(5, "V");
	(4, "IV");
	(1, "I")]
	""
	n

view raw Translate.fs hosted with ❤ by GitHub

	namespace Translate.Tests
	module TranslateTests =
	open Translate.Translate
	open Xunit
	open FsUnit.Xunit
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Given value fizzbuzzer should contain expected`` (given : int) (expected : string) =
	fizzbuzzer given |> should haveSubstring expected
	[<Theory>]
	[<InlineData(3, "Fizz")>]
	[<InlineData(5, "Buzz")>]
	[<InlineData(15, "FizzBuzz")>]
	[<InlineData(2, "2")>]
	let ``Given value fizzbuzzer2 should contain expected`` (given : int) (expected : string) =
	fizzbuzzer2 given |> should haveSubstring expected
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	let ``Given value should romanize to expected`` (given : int) (expected : string) =
	romanize given |> should equal expected
	[<Theory>]
	[<InlineData(1, "I")>]
	[<InlineData(2, "II")>]
	[<InlineData(4, "IV")>]
	[<InlineData(5, "V")>]
	let ``Given value should romanize2 to expected`` (given : int) (expected : string) =
	romanize2 given |> should equal expected

view raw TranslateTests.fs hosted with ❤ by GitHub

We see the FizzBuzz and Roman Numeral as having the same shape which we use in the generalization in the "2 version".  Thus using the same function with a set of rules, a defaulting function, and a seed we create both the FizzBuzz and Roman Numeral kata from the same general function!