An Exploration of TDD Part 3 - Discovering that EF7 Doesn't Like Arrays

With my generic Get() method working as it should, it's now time to bake something that can retrieve a single location by its Id. My test for this looks as follows:

	[TestMethod]
	public void Get_returns_correct_details_for_a_stored_location()
	{
	// Create some locations
	Location l1 = new Location(4);
	Location l2 = new Location(2);
	Location l3 = new Location(7);
	// Set some random exits between locations
	l2.SetExitToLocation(0, l1.Id);
	l2.SetExitToLocation(2, l3.Id);
	// Set up the database context
	using (QuesterContext dbcontext = new QuesterContext())
	{
	// Clear the Locations table
	dbcontext.RemoveRange(dbcontext.Locations);
	// Add the locations I prepared earlier
	dbcontext.Locations.Add(l1);
	dbcontext.Locations.Add(l2);
	dbcontext.Locations.Add(l3);
	// Save my changes to the locations table
	dbcontext.SaveChanges();
	}
	// Now test that Get() retrieves entries from the database correctly
	LocationRepository locationRepository = new LocationRepository();
	Location retrievedLocation = locationRepository.Get(l2.Id);
	// Check that we have the correct number of locations
	Assert.AreEqual(l2.Id, retrievedLocation.Id);
	Assert.AreEqual(l1.Id, retrievedLocation.ExitInDirection(0));
	Assert.AreEqual(l3.Id, retrievedLocation.ExitInDirection(2));
	}

view raw LocationRepository Get test for single Location hosted with ❤ by GitHub

...and my initial implementation for the Get(int id) method simply throws an exception, which makes the test go red.

	public Location Get(int id)
	{
	throw new NotImplementedException();
	}

view raw LocationRepository Get by Id Initial hosted with ❤ by GitHub

After my first red, I implement the Get(int id) method:

	public Location Get(int id)
	{
	Location result = null;
	using(QuesterContext context = new QuesterContext())
	{
	result = (from e in context.Locations
	where e.Id == id
	select e).FirstOrDefault();
	}
	return result;
	}

view raw LocationRepository Get by Id #1 hosted with ❤ by GitHub

Running the test with the new implementation gives me - another red. The test fails on my attempt to retrieve the correct exit in direction 0. So what's going on here?

Stepping through the test in the debugger reveals the following: locations l1 through l3 are all set up with correct Ids and exits. My retrievedLocation, however, has the correct Id, but all exits are set to the default of -1.

Looking at the actual database file, I see that the schema only has a column for the Id - but nothing for the exits. This is not actually all that surprising, when you think about it. I, for one, can't think of a good way to store an array in a database - and I guess the programmers behind Entity Framework couldn't either, so I consider myself in good company here. As a result, the array that holds the information about exits in my Location class simply gets ignored.

I can see two ways around the problem: I can create individual integer fields for each allowable direction. This strikes me as a horrendous solution; it violates several OOD principles. If I ever needed more than, say, four directions, I would have to modify my Locations class to do so, which violates the open/closed principle. Furthermore, the number of directions really shouldn't be defined in the Location class - it belongs in a class that deals with navigation, according to the single responsibility principle.

With the current solution, using an array, I could have worked around it by injecting the number of possible directions into the constructor. With individual integer fields, e.g. int NorthExit, int SouthExit etc. that would be impossible, so I'm not going to go there.

Instead I'm going to use a new class that deals specifically with this problem:

	public class Exit
	{
	public Exit(int directionId, int destinationLocationId)
	{
	DirectionId = directionId;
	DestinationLocationId = destinationLocationId;
	}
	public int ExitId { get; set; }
	public int DirectionId { get; set; }
	public int DestinationLocationId { get; set; }
	}

view raw Exit Class hosted with ❤ by GitHub

That means some major changes in my Location class, of course. Instead of an array of integers, I now have a List of Exits. And, in case you're wondering why I have made that a private property instead of a private field - that's because Entity Framework needs a property to do its magic.

	public class Location
	{
	private List<Exit> _Exits { get; set; }
	public int LocationId { get; set; }
	public Location(int id) : this()
	{
	// Store the id of the location
	LocationId = id;
	}
	public Location()
	{
	// Initialise the exits
	_Exits = new List<Exit>();
	}
	/// <summary>
	/// Gets the location to which a given exit leads, if applicable
	/// </summary>
	/// <param name="direction">Direction of the exit</param>
	/// <returns>The location the exit leads to or -1 if there is no location in the specified direction</returns>
	public int ExitInDirection(int direction)
	{
	int result = -1;
	Exit exitInDirection = (from e in _Exits
	where e.DirectionId == direction
	select e).FirstOrDefault();
	// If an exit in the specified direction exists, return that
	if (exitInDirection != null)
	result = exitInDirection.DestinationLocationId;
	return result;
	}
	/// <summary>
	/// Connects an exit to the Id of the location it leads to
	/// </summary>
	/// <param name="direction">Direction of the exit</param>
	/// <param name="destinationLocationId">Id of the location the exit should lead to</param>
	public void SetExitToLocation(int direction, int destinationLocationId)
	{
	_Exits.Add(new Exit(direction, destinationLocationId));
	}
	}

view raw Location Class With List of Exits hosted with ❤ by GitHub

Running my tests after these changes gives me several reds, of course, where I was testing things like invalid indices. With a list, the following tests that deal with array initialisation or an index that's out of bounds are no longer required:

• Location_is_constructed_with_all_exits_set_to_no_exit()
• Location_returns_no_exit_if_direction_is_negative()
• Location_returns_no_exit_if_direction_is_greater_than_available_directions()
• CreateOneWayExitToLocation_throws_exception_if_direction_is_negative()
• CreateOneWayExitToLocation_throws_exception_if_direction_is_greater_than_available_directions()

I do need to add one test instead, however, to check that if an exit doesn't exist in a specific direction, my ExitInDirection() method still returns -1.

	[TestMethod]
	public void Location_returns_minus_one_if_no_exit_in_that_direction()
	{
	Location location = new Location(1);
	Assert.AreEqual(-1, location.ExitInDirection(-1));
	}

view raw Test Invalid Exit Direction hosted with ❤ by GitHub

One necessary test, however, remains stubbornly red: The one I created at the beginning of this article. But now it's red for a different reason. If I examine the database after creating my locations, I can see that I now have a table for my exits, and that this table is populated correctly when I save the changes to my context. The problem is that when I retrieve a location from my context, it doesn't automatically retrieve the exits as well (even though it automatically stores them when I store the location)

Getting around this is a little bit tricky in EF7, so I'll leave that until the next post. CodeProject

An Exploration of TDD Part 2 - A Data Repository for the Location Class

Now that I've got my data context class set up, I need a repository for at least basic CRUD operations for my Location class. In order to test this, I create  a new test project. In the UnitTestApp.xaml.cs file I add the following code to the constructor:

	using (var db = new QuesterContext())
	{
	db.Database.Migrate();
	}

view raw Migration hosted with ❤ by GitHub

This is to apply any pending migrations before running any of the tests.

Next, the beginning of my LocationRepository class:

	public class LocationRepository
	{
	public IEnumerable<Location> Get()
	{
	return null;
	}
	}

view raw LocationRepository Get Initial hosted with ❤ by GitHub

This simply returns null to give me my first red test.

In my first test, I'll try to read from an empty table, so I have to clear all entries from it first. After all, I can't be sure that this test won't run after one that adds something to my Locations table.

	[TestMethod]
	public void Get_returns_an_empty_set_if_table_contains_no_entries()
	{
	using (QuesterContext dbcontext = new QuesterContext())
	{
	// Clear the Locations table
	dbcontext.RemoveRange(dbcontext.Locations);
	dbcontext.SaveChanges();
	}
	// Now test that Get() returns an empty set
	LocationRepository locationRepository = new LocationRepository();
	var locations = locationRepository.Get().ToList();
	Assert.AreEqual(0, locations.Count);
	}

view raw LocationRepository Get test for empty table hosted with ❤ by GitHub

Running the test gives me a red result, as I expected, so now I add the functionality I want to my Get() method:

	public class LocationRepository
	{
	public IEnumerable<Location> Get()
	{
	IEnumerable<Location> result = null;
	using (QuesterContext context = new QuesterContext())
	{
	result = from e in context.Locations
	select e;
	}
	return result;
	}
	}

view raw LocationRepository Get #1 hosted with ❤ by GitHub

I run my test again and... Gadzooks! It's still red! Looking at the test results, I see the following message: "System.ObjectDisposedException: Cannot access a disposed object."

Well, that's because I forgot that my LINQ query actually uses lazy evaluation, and by the time I get around to trying to use my result (in my test), my database context has already disposed of. So I do a quick fix on my Get() method to force the evaluation of my query while it's still in scope:

	public class LocationRepository
	{
	public IEnumerable<Location> Get()
	{
	IEnumerable<Location> result = null;
	using (QuesterContext context = new QuesterContext())
	{
	result = (from e in context.Locations
	select e).ToList();
	}
	return result;
	}
	}

view raw LocationRepository Get #2 hosted with ❤ by GitHub

...and running this give me the first green test for my repository class. So there it is - the test did its job to point out my temporary lapse of memory. Good test. Have a biscuit.

Now let's see how we fare with a table that's not empty:

	[TestMethod]
	public void Get_returns_all_stored_locations()
	{
	// Create some locations
	Location l1 = new Location(4);
	Location l2 = new Location(2);
	Location l3 = new Location(7);
	// Set up the database context
	using (QuesterContext dbcontext = new QuesterContext())
	{
	// Clear the Locations table
	dbcontext.RemoveRange(dbcontext.Locations);
	// Add the locations I prepared earlier
	dbcontext.Locations.Add(l1);
	dbcontext.Locations.Add(l2);
	dbcontext.Locations.Add(l3);
	// Save my changes to the locations table
	dbcontext.SaveChanges();
	}
	// Now test that Get() retrieves entries from the database correctly
	LocationRepository locationRepository = new LocationRepository();
	var locations = locationRepository.Get().ToList();
	// Check that we have the correct number of locations
	Assert.AreEqual(3, locations.Count);
	}

view raw LocationRepository Get test for table with entries hosted with ❤ by GitHub

This test returns green straight away. I have no idea how I could make it red. I guess I should have created it at the same time as the first test, since it tests the same method. Ah, well, live and learn...

P.S. Remember: this is NOT a tutorial on how to write good code. This is an exploration of how useful TDD is in weeding out mistakes, bad code and possibly bad architecture. So I'm throwing everything at it, including the kitchen sink.

P.P.S. You may be able to see where this is going. I'm currently looking at the code I will be using over the next few posts, and I'm not certain if the wetness trickling down my face is tears or if my eyes are bleeding.

P.P.P.S But hey - "For Science!" CodeProject

An Slight Detour From TDD in Favour of Entity Framework 7

Now that I've created a class for my locations, I need a way to store them. Unfortunately Microsoft, for reasons I have yet to fathom, decided that the best way to store data for MS Store applications would be as XML or JSON text files.

Looking at my fledgling project I can already see that there's a good chance that I'll need objects that will contain other objects, all of which need to be referenced to each other - in short, a classic database scenario. And while other platforms have embraced the lovely lightweight database framework that is SQLite... Microsoft hasn't. Quite.

Looking at Nuget I can see more SQLite .NET wrappers than I can shake a stick at, which makes it very hard to decide which one to go with that will be around for the long term. However, there's another possibility. Remember that I said 'Quite' at the end of the previous paragraph? That's because Microsoft is going to offer SQLite support as part of Entity Framework 7 - but that is currently only available as a pre-release. Still, it seems like the best bet for now, and since I'm curious about it anyway, I'll take that route.

To get started, I'll be perusing the (sparse) EF7 documentation at ef.readthedocs.org/en/latest/index.html, but I'll do a quick recap here, for your enjoyment. I'm working with an Universal Windows project, so I

• Add the following application specific runtime directive to my Default.rd.xml file (found under the project properties): <Type Name="System.Collections.ArrayList" Dynamic="Required All" />. The documentation says that this will become unnecessary at a later point, but for now, in it goes.
• Install the NuGet packages for EntityFramework.SQLite and EntityFramework.Commands. both are pre-release, so make sure you use the -pre option or tick the box that allows you to search pre-release packages.

With the preliminaries out of the way I use EF7 to create my database context class:

	public class QuesterContext : DbContext
	{
	public DbSet<Location> Locations { get; set; }
	protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
	{
	optionsBuilder.UseSqlite(@"Filename=Quester.db");
	}
	}

view raw WorldContext hosted with ❤ by GitHub

I build my solution and use migrations to create my database by running Add-Migration LocationMigration in the package manager console to create my initial database. This actually required a bit of guesswork because my Location class is in a class library rather than my main app project, but after adding a reference to the library to my main app, the command worked fine.

Now, I can't see much to test in my  class itself, but I do want to test that I can do at least basic CRUD operations with my new data context. I don't think those tests can be classified as unit tests, but hey, they're going to be useful, so I'm gonna add them and worry about the semantics another time.

Coming up: Testing CRUD operations CodeProject

An Exploration of TDD Part 1

I've been squinting at TDD as a development concept for a while now. I'm coming from a background where all you did was testing after the fact (if you were lucky and had a patient boss), and I remember the pain of extending or changing code in such an environment. So TDD looked like a great concept to me, and now I've decided to put it to the test.

My plan is as follows: I'm going to create a project with only the vaguest of notions as to where it may be going, and see just how useful TDD is going to be in helping me create maintainable code. As an added obstacle I have to say that I don't know much about TDD other than the principle of red-green-refactor.

So this exercise should be interesting.

Here's the concept of the software I'm going to create: A piece of software that creates a world that a player can walk through and do stuff. How's that for a fuzzy brief?

If I'm going to have a world that a player can navigate, it stands to reason that I need locations, and that my locations have to connect to other locations. And in order for a player to get to other locations, each location needs exits, which shouldn't point anywhere before they've been assigned. I'll also need to be able to get and set the location that an exit leads to, and each location should have a unique ID, which can be assigned to an exit in another location.

Here are the tests I've come up with:

	[TestMethod]
	public void Location_is_constructed_with_correct_Id()
	{
	Location location = new Location(1);
	Assert.AreEqual(1, location.Id);
	}
	[TestMethod]
	public void Location_is_constructed_with_all_exits_set_to_no_exit()
	{
	Location location = new Location(1);
	Assert.AreEqual(-1, location.ExitInDirection(0));
	Assert.AreEqual(-1, location.ExitInDirection(1));
	Assert.AreEqual(-1, location.ExitInDirection(2));
	Assert.AreEqual(-1, location.ExitInDirection(3));
	}

view raw Location Constructor Tests hosted with ❤ by GitHub

I'm not entirely sure about the second test because, strictly speaking, it tests two things at the same time (the constructor and the ExitInDirection method), but I don't want my method of storing exits to be public, so until I figure out how to access private variables in a unit test, this'll have to do.

I implement the constructor and ExitInDirection method to return hard-coded values other than the expected test results in order to get my first reds, then flesh them out as follows, which gives me green tests:

	private static int _numberOfDirections = 4;
	private int[] _exits;
	public int Id { set; get; }
	public Location(int id)
	{
	// Store the id of the location
	Id = id;
	// Initialise the exits
	_exits = new int[_numberOfDirections];
	for (int i = 0; i < _numberOfDirections; i++)
	{
	_exits[i] = -1;
	}
	}
	public int ExitInDirection(int direction)
	{
	// Return the id of the location stored in the exits array in the specified direction
	return _exits[direction];
	}

view raw First Green hosted with ❤ by GitHub

I don't think I want to keep the number of possible exits to be hard-coded in the Location class, but that's for later. For now I can't see any other tests that I could apply to the constructor, but the ExitInDirection method is another thing. I need to test that against a direction that's outside of the bounds of my array of exits.

	[TestMethod]
	public void Location_returns_no_exit_if_direction_is_negative()
	{
	Location location = new Location(1);
	Assert.AreEqual(-1, location.ExitInDirection(-1));
	}
	[TestMethod]
	public void Location_returns_no_exit_if_direction_is_greater_than_available_directions()
	{
	Location location = new Location(1);
	Assert.AreEqual(-1, location.ExitInDirection(4));
	}

view raw ExitInDirection Tests hosted with ❤ by GitHub

With the current code, both those tests are red as they throw an out of bounds exception, so now I refactor to account for invalid directions:

	public int ExitInDirection(int direction)
	{
	// If the direction exceeds the bounds of the exits array, return -1
	if (direction >= _numberOfDirections || direction < 0)
	return -1;
	// Return the id of the location stored in the exits array in the specified direction
	return _exits[direction];
	}

view raw ExitInDirection Refactored hosted with ❤ by GitHub

And with that amendment, all my tests are now green. Looking good so far.

Another thing I need is a method to determine where each exit direction leads to. But so far I can't set the location for an exit, so that's my next goal.

First I'll create a method to link a location to an exit, which initially does nothing at all:

	public void SetExitToLocation(int direction, int destinationLocationId)
	{
	}

view raw SetExitToLocation Red hosted with ❤ by GitHub

And some tests to check whether an exit links to the correct location after it's been created:

	[TestMethod]
	public void CreateExitToLocation_stores_id_of_target_location_in_correct_direction()
	{
	Location location = new Location(1);
	Location destination1 = new Location(1);
	Location destination2 = new Location(2);
	Location destination3 = new Location(3);
	location.SetExitToLocation(1, destination1.Id);
	location.SetExitToLocation(2, destination2.Id);
	location.SetExitToLocation(3, destination3.Id);
	Assert.AreEqual(-1, location.ExitInDirection(0));
	Assert.AreEqual(1, location.ExitInDirection(1));
	Assert.AreEqual(2, location.ExitInDirection(2));
	Assert.AreEqual(3, location.ExitInDirection(3));
	}

view raw Test CreateExitLocation hosted with ❤ by GitHub

Running this against the blank method gives me my initial red, so now I'm good to flesh out my SetExitToLocation method:

	public void SetExitToLocation(int direction, int destinationLocationId)
	{
	_exits[direction] = destinationLocationId;
	}

view raw SetExitToLocation Initial hosted with ❤ by GitHub

At this point I have to ask myself again what should happen if the direction is outside of the bounds of the array. Right now I get an index out of bounds exception, which isn't all that bad, but I figure that an argument out of range exception would make more sense. So I add two more tests for that:

	[TestMethod]
	public void CreateOneWayExitToLocation_throws_exception_if_direction_is_negative()
	{
	Location location = new Location(1);
	Assert.ThrowsException<ArgumentOutOfRangeException>(() => location.SetExitToLocation(-1, 1));
	}
	[TestMethod]
	public void CreateOneWayExitToLocation_throws_exception_if_direction_is_greater_than_available_directions()
	{
	Location location = new Location(1);
	Assert.ThrowsException<ArgumentOutOfRangeException>(() => location.SetExitToLocation(10, 1));
	}

view raw Test CreateExitLocationIndex Out Of Bounds hosted with ❤ by GitHub

This gives me another red test until I amend my SetExitToLocation method to

	public void SetExitToLocation(int direction, int destinationLocationId)
	{
	// If the direction exceeds the bounds of the exits array, throw an exception
	if (direction >= _numberOfDirections || direction < 0)
	throw new ArgumentOutOfRangeException("direction", "Value exceeds the limit of the array");
	else
	_exits[direction] = destinationLocationId;
	}

view raw SetExitToLocation Green hosted with ❤ by GitHub

And that has my whole range of tests green again, and completes my first draft for my location class.

P.S. Since I'm new to TDD, any constructive comments as to what could be improved in my process are very welcome. CodeProject