After talking about testing inner behavior inside a method, it is time to make some observations about the code and answer a lot of *why* questions. I must give credit to Shani, one of a great bunch of people I worked with during my service and a very good friend of mine. He asked me some hard questions that bother every TDD newbie or a TDD wannabee as myself (raise your hand if you’re one of them.. higher!). Now I’ll take my shot and reply in detail.

Question 1: Is it worth spending time on tests for simple methods ?

I’ve talked about “code little, think and code little” and why we need it in my last post “TDD in the eyes of a simpleminded: Part 1 – The NameResolver”. One of the great comments I received was “You spent more time on the tests than on the (simple)method itself. Isn’t it time consuming? You’ve just talked about focus on deadlines in your preface..”. From my experience, the easy, 5 minutes, methods are the one you spend most the time thinking about(relatively). You keep saying to yourself “this is so easy… such a shame” and spend a full hour thinking about a various of problems that can happen and various solution to handle them: ” Maybe I’ll use array? no… maybe List<int>? no… Oh! Yes! I’ll use an interface! I’ll call it IMyCollection and make a nice method in it named “AISolveProblem(params object[] anyThing)” “. This all process take place before you even write your first line of code! It’s a 5 minutes, even-a-lame-monkey-can-do-it method. You don’t want to look stupid and leave “open holes” right? So you waste a great deal of time over-thinking the irrelevant. Classic.

Sure, TDD can be costly (depends on a few variables), but it makes you code along the challenges(tests) and always challenge you to come up with the simplest solution. minimum effort. It prevents you from thinking too much upfront; You don’t have to think too much about avoiding potential bugs, just write test cases and make them green. Don’t have red tests ? Your code is ready for production. Again, I’m not going to address the big questions like “when, how and how much?” at the moment and I’m not saying that you should TDD the entire application. I’m just stating a point here. Keep your head open for a new way of coding. That’s the best I can request from you and that is what I’m doing now, during the learning process with Roy.

Question 2: Changing the class because of our tests, is that a good thing ?

I think that if the time comes and you need to change the way your class looks or behaves just because your tests become hard to write, you should lay back and smile. That means that the process of TDD just helped you design your code better. If the test was too hard to write, you must be doing some uncomfortable API (usability warning) or maybe you’ve put too much knowledge in one place and created a GOD(do-it-all) method\class. Having 5+ dependencies in one class should make you stop and rethink about the way you work right? testing actually makes you write the API before you actually write the implementation itself. If the early API sketching is too hard, just think about the poor programmer which will have to work with your API, about yourself (if it’s hard to test it must be hard to write) and even better – the miserable programmer which will have to take over your code and maintain it later on.

Question 3: Injecting concrete implementation can lead to incorrect usages! Why do we need it?

Let me start by relaxing you – injecting concrete implementation of an interface *can* lead to serious bugs and malfunctions in your application. Let me repeat it. By providing the programmer the ability to “inject” his implementation for the class dependencies he can cause the application to die. It might even cost you your job.

Relaxed?

No? But you should be! I’ve just demonstrated the worst case scenario and if we’ll think about it together, the world is not over and you and I still got our jobs. Programmers can make mistakes while using any API. Damn it, I’ve asked my boss for hiring machines but he keeps bringing people who actually use their head. You see, I don’t trust the “next guy” no more than you do, but I realize that I can take care of the low-level (in Hebrew: BARZELIM) API and still provide the high-level API which will help the idiot(brighter than me) next guy a simple method for any complex scenario. We need an option to inject our dependencies as we don’t want to couple our classes together.

We want the option to replace one concrete implementation with another (fake one, for example). This doesn’t prevent me from developing some nice & simple API that will wrap the all thing up and inject the dependencies I want.

Question 4: Writing tests can lead to bugs in those tests? should I write tests for my test?

Sure you do! you have to test your tests, and then test those tests and than test the latter one just until you will run out of RAM, space on your HD or energy.

Writing code can lead to additional bugs to your system just as living can cause death(No research shows it does by the way). We can minimize the chance of bugs in our tests by following some simple rules:

1. The test should be obvious by it’s name (I follows Roy’s tip: MethodName_State_ExpectedResult).
   
2. A test should check one method only.
   
3. A test should Assert only once.
   
4. Writing new tests should be easy and take no more than a few lines (few != 50).

I wrote “should” and not “must” as we should eat healthy food, it’s not a must (unless you eat burgers 24-7, in that case, you are a goner). You should come up with the rules that fit you and your team. You can enforce them to keep a follow a few rules just to create a standard you all(or just you, no one said we are living in a democracy) agree on.

I’ve attached the code I demonstrated so far to the original posts so you could play with the code a little and understand how it all connects (if code samples in my posts were not clear enough).

Requirements:

• Nunit 2.2.8
  
• TestDriven.Net (this is actually an extra, but give yourself a break and download this gold)
  
• Visual Studio .Net 2005

Code (inside the posts):

TDD in the eyes of a simpleminded: Part 1 – The NameResolver

TDD in the eyes of a simpleminded: Part 2 – Testing inner behavior

Have fun !

p.s: in every additional post I’ll publish about “TDD in the eyes of a simpleminded” I will upload the code.

code:

OrenTDDWorkShop_Part2.zip (44.06 KB)

If you haven’t read about the NameResolver at my previous post(TDD: Part1), now is the time as I’m going to take this class and use it later on in this post.

We are ready to take the next step and talk about “playing a doctor”. Imagine this picture: you are a doctor looking for a gun’s bullet in one of your patient’s stomach. He was shot a few moments ago. “One bullet to the chest” the nurse inform you. It’s all messy and you can’t find the bullet. You need to clear the blood, move the organs, going micro-level on the details so you don’t hit a vein on the way. Every mistake is a “welcome-better-place” for your patient and you don’t want this on your conscience do you ?

While developing applications, we are facing a world of “playing doctors”. We need to change inner behaviors in our code or others code. We want the application to live the surgery and we realize that the smallest change in a “core method” can make the application bleed all over the place without even noticing it. Every click on the keyboard raises our heart rate. But how can we check inner code inside a method? How can we get a micro-level look at the method’s internals, at the stomach of our tested object ?

This is what I’m going to address at this post. But before we see solutions, let’s talk about the client’s requirements so we’ll have something to play with.

Client’s requirements v1.0:

A class named HotelReservationService is required. In it, a method named ReserveRoomForTwo that receive the couple’s name in the format “[man] and [wife] [family name]”. The method will reserve the room and name the room under the family’s name. The method will return ReservationInformation object with the details (room, floor number & status).

• If the received couple’s name is empty (“”) – Throw an exception with “The couple name must be supplied”.
  
• If the hotel don’t have available rooms, the returned ReservationInformation should hold a status of “NoRoomAvailable”.
  
• if the everything goes well, the method should return a ReservationInformation filled with the floor number, room number, reservedFor (filled with the name of the family) and status of “RoomReserved”.

Simple solution, without TDD:

public class HotelReservationsService
{
   public ReservationInformation ReserveRoomForTwo(string coupleName)
   {
      // …. some checks …

      NameResolver resolver = new NameResolver();
      string familyName = resolver.GetFamilyName(coupleName);

      HotelRepository repository = new HotelRepository();
      return repository.ReserveRoom(2, familyName); // 2 = two people
   }
}

As you can notice, we have 2 dependencies here: NameResolver and HotelRepository. We need to test ReserveRoomForTwo but how can we do it ? the results of our tests for this method are coupled with the implementation of NameResolver and HotelRepository. If they have bugs in it, it will certainly affect our tests and therefore making them *unreliable*. What’s the point in writing tests if you doubt that a green(successful) result might actually be red(fail) under the surface due to an inner bug in one of the dependencies?

Keeping with my metaphor, the dependencies are the blood and organs laying around and making it harder for you to find the bullet, may it be a bug or a new feature. You need to clear(isolate) the area so things will be easier to see. You need a green light you can actually *trust*.

We’ll need to use Dependency Inversion Principle(DIP) to isolate our tested class from the actual implementation of its dependencies.

Our goal:

Inject dummy object instead of the dependencies and make them “act like” everything is good\bad according to our need. Will use DIP to make it happen.

We don’t want to test NameResolver nor HotelRepository. We assume that they are bugs-free. We need to test one and only one class at a time. Our goal is to test the interaction between our tested class to its dependencies.

Let’s use TDD to solve the client’s requirements:

Say hello to your new friend: geek, this is Stub; Stub, this is geek. Come on, don’t be shy, give him a hug, he will serve you well in time. Feel nice and fuzzy ? great, now let’s TDD this baby. Oh, and don’t worry, if you don’t understand the concept of “Stub” yet, everything will be clearer in a few moments. Just think about Stub as a dummy object.

We start with? Come on! I want to hear it from you! we’ll start with a Create method!

[TestFixture]
public class HotelReservationsServiceTests
{
   [Test]
   public void Create()
   {
      HotelReservationsService service = new HotelReservationsService();
      Assert.IsNotNull(service);
   }
}

As usual, in order to compile this method we’ll need to create an empty class:

public class HotelReservationsService
{
}

Let’s run the test – 1 passed, 0 failed. Good.

Let’s write our second test and look to our requirements:

[Test]
[ExpectedException(typeof(ArgumentException), “The couple name must be supplied”)]
public void ReserveRoomForTwo_EmptyCoupleName_ThrowEmptyCoupleNameException()
{
   HotelReservationsService service = new HotelReservationsService();
   ReservationInformation info = service.ReserveRoomForTwo(string.Empty);

   // We’ve got nothing to assert. We expect an exception to raise.
}

This will not compile as we don’t have ReserveRoomForTwo method nor ReservationInformation class. Let’s write them down:

public class ReservationInformation
{
   private int m_roomNumber;
   private int m_floorNumber;
   private string m_reservedFor;
   private string m_status;

   public ReservationInformation(string reservedFor, int floorNumber, int roomNumber, string status)
   {
      ReservedFor = reservedFor;
      FloorNumber = floorNumber;
      RoomNumber = roomNumber;
      Status = status;
   }

   public string ReservedFor
   {
      … get & set …
   }

   public int FloorNumber
   {
      … get & set …
   }

   public int RoomNumber
   {
      … get & set …
   }

   public string Status
   {
      … get & set …
   }
}

Now let’s add the ReserveRoomForTwo method to our HotelReservationsService:

public ReservationInformation ReserveRoomForTwo(string coupleName)
{
   throw new NotImplementedException(“”);
}

Compile. Run tests – 1 passed, 1 failed. Our test expect for ArgumentException with a specific message but we throw NotImplementedException. Let’s fix it.

public ReservationInformation ReserveRoomForTwo(string coupleName)
{
   throw new ArgumentException(“The couple name must be supplied”);
}

Run tests – 2 passed, 0 failed. Good.

Time for refactoring our tests as we create the HotelReservationsService in two methods. This time, instead of creating a “FactoryMethod” named GetNewHotelReservationsServer like we did in our NameResolver tests, let’s use the [Setup] attribute.

[TestFixture]
public class HotelReservationsServiceTests
{
   HotelReservationsService service;

   [SetUp]
   public void SetupTest()
   {
      service = new HotelReservationsService();
   }

   [Test]
   public void Create()
   {
      Assert.IsNotNull(service);
   }

   [Test]
   [ExpectedException(typeof(ArgumentException), “The couple name must be supplied”)]
   public void ReserveRoomForTwo_EmptyCoupleName_ThrowEmptyCoupleNameException()
   {
      ReservationInformation info = service.ReserveRoomForTwo(string.Empty);
      // We’ve got nothing to assert. We expect an exception to raise.
   }
}

Let’s continue to check our requirements: We want to represent a case where the provided couple’s name is good but the hotel is full.

[Test]
public void ReserveRoomForTwo_HotelIsFull_ReservationInformationWithStatusNoRoomAvailable()
{
   // We create a dummy repository and set the values we want it to return.
   FakeHotelRepository repository = new FakeHotelRepository();
   repository.StatusToReturn = “NoRoomAvailable”;
   service.SetRepository(repository); // Important! set the fake repository in the service.

   string goodCoupleName = “man and woman FamilyName”;
   ReservationInformation info = service.ReserveRoomForTwo(goodCoupleName);

   Assert.AreEqual(“NoRoomAvailable”, info.Status);
}

Run tests – 2 passed, 1 failed(our last one).

We get an exception here which is obvious (we hard-coded “throw new ArgumentException…”) instead of a status “NoRoomAvailable”. Notice that we are create a FakeHotelRepository and injecting it to our tested class. The purpose is to create a repository which will always return “NoRoomAvailable”. We want to test the *interaction* between our ReserveRoomForTwo method in our tested object to the repository. This can look bizarre but let’s remember that we want to test only our ReserveRoomForTwo method and not the repository class.

Let’s make our test green. minimum effort.

We need some sort of HotelRepository in order to know if the hotel is full. At the moment, we don’t need the NameResolver as we are looking for the status only. Let’s define an interface named IHotelRepository.

public interface IHotelRepository
{
   ReservationInformation ReserveRoom(int capacity, string familyName);
}

This time we need to build the “basics” so the minimum effort will be a little more than we use to, but that’s OK as we’ll do it only once. Let’s add this code to our HotelReservationsService class:

private IHotelRepository m_repository;

private IHotelRepository Repostiory
{
   get 
   { 
      if (m_repository == null)
         throw new ArgumentNullException(“Repostiory”, “Repository must be set before being used”);

      return m_repository; 
   }
   set { m_repository = value;}
   }
}

public void SetRepository(IHotelRepository repository)
{
   Repostiory = repository;
}

Now we can use the repository in our ReserveRoomForTwo method:

public ReservationInformation ReserveRoomForTwo(string coupleName)
{
   if (coupleName == string.Empty)
      throw new ArgumentException(“The couple name must be supplied”);
   else
   {
      ReservationInformation info = this.Repostiory.ReserveRoom(2, coupleName);
      return info; // just so we’ll remember that we return ReservationInformation.
   }
}

We call the repository and ask it to save a room for the received couple. All we left with is to create the FakeHotelRepository object:

This class will sit in the tests project and will be used for testing only. Notice that we can manipulate the data we want to return from this repository. Remember: we want to test the interaction between the classes. We assume that the repository in production was tested and will be able to “know” if the hotel is really full or not. We make a fake one so we can control the internal behavior. We are playing doctors: Assuming that the repository is OK, will our class still behave as we expect ?

We can play with the repository and look at the results we get. Will do the same with the NameResolver later on.

Run the tests – 3 passed, 0 failed. So far, requirements 1 and 2 are set.

What is Stub then ?

stub is an object that helps you test another object. You never ever Assert the stub itself.
You use it only as an helper while you’re looking to test another object.

In our example, the FakeHotelRepository is a classic stub. We use it to assert another object – ReservationInformation.

Let’s take a pause here as this post cover a lot of material and code. The next post will answer the third requirement and I’ll present additional solution for the problems we encounter here.

If you didn’t read the preface yet, I strongly recommend you to invest good 5 minutes for it now; I’ll wait…

Code:

OrenTDDWorkShop.zip (37.09 KB)

the NameResolver:

This class should have a method named GetFamilyName that gets a string as parameter and return the last name of a person.

The client defines these requirements:

• If the sent string is empty (“”), the method should return “None”.
  
• The string can contain only one word – in this case, return that word.
  
• The string can contain first name and last name separated by space between them. The method should return the last name (obviously).

Simple enough right ?

Let’s TDD this thing. We start with a “Create” test:

[TestFixture]
public class NameResolverTests
{
   [Test]
   public void Create()
   {
      NameResolver c = new NameResolver();
      Assert.IsNotNull(c);
   }
}

This code doesn’t compile as we don’t have NameResolver class yet. This test will check that we have an empty constructor for NameResolver and that we can actually initialize it. So let’s write the required code:

public class NameResolver
{

}

Run the test. It works. It’s time to test our GetFamilyName method. Let’s see if the first requirement works:

[Test]
public void GetFamilyName_EmptyString_ReturnTheWordNone()
{
   NameResolver c = new NameResolver();

   string actualResult = c.GetFamilyName(string.Empty);
   Assert.AreEqual(“None”, actualResult);
}

Notice the structure of the method:

MethodName_State_ExpectedResult

This will not compile as we don’t have the method GetFamilyName, so we’ll make the minimum effort to make it compile.

public class NameResolver
{
   public string GetFamilyName(string fullName)
   {
      throw new NotImplementedException(“”);
   }
}

Now it compiles. Nice. Let’s run the test. 1 passed, 1 failed(our last test).

Let’s refactor the method so it will pass, remember, minimum effort.

public string GetFamilyName(string fullName)
{
   return “None”;
}

I know, it doesn’t make sense at first. The trick here is “baby-steps”. You will add new code or refactor existing one only if you have a test that prove you *need* to do so. Our tests pass without problems so we don’t have to modify our GetFamilyName. It works as expected so far!

Before we are running along and writing another test that will fail let’s make some refactoring. We can do it with peace as we have tests to run after we change our code. In my tests you can see a line that repeat itself which is “NameResolver c = new NameResolver();”. We don’t like initializing new objects in the tests method as this initialization can get complex later on and we don’t want to change X test methods. Refactoring:

[Test]
public void Create()
{
   NameResolver c = GetNewNameResolver();
   Assert.IsNotNull(c);
}

[Test]
public void GetFamilyName_EmptyString_ReturnTheWordNone()
{
   NameResolver c = GetNewNameResolver();

   string actualResult = c.GetFamilyName(string.Empty);
   Assert.AreEqual(“None”, actualResult);
}

private NameResolver GetNewNameResolver()
{
   return new NameResolver();
}

Compile – Good. Run tests – Good. That was simple.

Let’s carry on and prove ourself that GetFamilyName is not good:

[Test]
public void GetFamilyName_OneWordOnly_ReturnThatWord()
{
   NameResolver c = GetNewNameResolver();

   string actualResult = c.GetFamilyName(“test”);
   Assert.AreEqual(“test”, actualResult);
}

Perfect, run the test – 2 passed, 1 failed (our last one)

This is quite obvious, we return None no matter what. Let’s fix it. remember, minimum effort.

public string GetFamilyName(string fullName)
{
   if (fullName == string.Empty)
      return “None”;

   return fullName;
}

Run tests – Good! Now that the tests were OK, we can refactor (we have the tests as our backup – to see that we didn’t introduce new bugs). You can see that the lines of GetFamlyName(“…”) and the Assert repeat itself. Let’s extract this into a private helper method and use it:

[TestFixture]
public class NameResolverTests
{
   [Test]
   public void Create()
   {
      NameResolver c = GetNewNameResolver();
      Assert.IsNotNull(c);
   }

   [Test]
   public void GetFamilyName_EmptyString_ReturnTheWordNone()
   {
      NameResolver c = GetNewNameResolver();
      VerifyGetFamilyName(c, string.Empty, “None”);
   }

   [Test]
   public void GetFamilyName_OneWordOnly_ReturnThatWord()
   {
      NameResolver c = GetNewNameResolver();
      VerifyGetFamilyName(c, “test”, “test”);
   }
   
   private void VerifyGetFamilyName(
      NameResolver nameResolver, 
      string fullNameToCheck, 
      string expectedResult)
   {
      string actualResult = nameResolver.GetFamilyName(fullNameToCheck);
      Assert.AreEqual(expectedResult, actualResult);
   }

   private NameResolver GetNewNameResolver()
   {
      return new NameResolver();
   }
}

VerifyGetFamilyName will help us to write smaller test. We want the option to write a new test with only a couple of lines. Adding new tests should be fun.

Let’s move on.

Now we don’t have bugs anymore right? we do ?
prove it!

Here you go:

[Test]
public void GetFamilyName_TwoWords_ReturnLastWord()
{
   NameResolver c = GetNewNameResolver();
   VerifyGetFamilyName(c, “one two”, “two”);
}

Run test – 3 passed, 1 failed (our last one).
It makes sense, we don’t check for space character yet so Let’s fix it with minimum effort (remember?).

public string GetFamilyName(string fullName)
{
   if (fullName == string.Empty)
      return “None”;
   else if (fullName.IndexOf(” “) == -1) // no spaces
      return fullName;
   else
   {
      string[] words = fullName.Split(‘ ‘);
      return words[1];
   }
}

Run tests – Good !

Hold on, you think you’re done but you’re not. The client adds another requirement (things change, you know):

• the string can contain 3 words – first name, middle name and last name; Separated by space, of course. Return the last name (obvious).

We have a bug! How do I know? Here you go:

[Test]
public void GetFamilyName_ThreeWords_ReturnLastWord()
{
   NameResolver c = GetNewNameResolver();
   VerifyGetFamilyName(c, “one two three”, “three”);
}

Run tests –  4 passed, 1 failed(our last one). Let’s fix the method so our last test will work. minimum effort.

public string GetFamilyName(string fullName)
{
   if (fullName == string.Empty)
      return “None”;
   else if (fullName.IndexOf(” “) == -1) // no spaces
      return fullName;
   else
   {
      string[] words = fullName.Split(‘ ‘);
      return words[2];
   }
}

Run tests – 4 passed, 1 failed (GetFamilyName_TwoWords_ReturnLastWord()). Oops! our last test passed but I screwed up our previous test (to two words scenario – “one two”). This is a great thing with TDD, you cover your ass with tests! Let’s refactor:

public string GetFamilyName(string fullName)
{
   if (fullName == string.Empty)
      return “None”;
   else if (fullName.IndexOf(” “) == -1) // no spaces
      return fullName;
   else
   {
      string[] words = fullName.Split(‘ ‘);
      return words[words.Length-1];
   }
}

Run tests – 5 passed, 0 failed! Good!

Conclusions:

We want to work with ~100% code coverage. That means that every piece of code in GetFamilyName method is accounted for. I don’t add new features to this method until I have a test that shows it is required. In addition, look at our GetFamilyName method, the code is so simple you want to cry with joy. Instead of thinking about all the possibilities to screw this method up at the beginning, write your “bugs” and see if the method can handle it. In addition, let’s say that the client request another feature (“I want to allow sending names in Hebrew and names in English. The GetFamilyName should be able to handle them both”. You can change whatever you need (but with minimum effort) and you’ve got the tests to see that everything is still ticking as expected. Refactoring is something you can do here with a smile on your face. You don’t have to be afraid changing the code. The well known sentence “But what if I’ll create 5 other bugs?!” is no longer valid. You’ve got the tests to tell you “You’re OK!”.

Good tests = peace of mind.

I sat down for about 15 minutes before I could even write this sentence.

You see, as human beings, we (usually) tend to think too much before we speak.
As programmers, we (usually) tend to think too much before we write our first line of code.
“But what if the programmer will send null?”
“What if the programmer will send string when I expect int? should I throw an exception?”
“Should I return int or maybe void will do?”
“Should I implement the feature in this class? maybe I should use some external object and implement it there?”
“Should I inherit from this class or encapsulate it?”

We tend to over-think stuff. That’s the way we are wired.

Tell me if you can relate to this monologue:
“ I’m putting a lot of effort in finding solutions to many problems before they appear. These effort makes me tired so a few “end-cases” still slips me by; This, of course, only makes me think more before I write my code. Little, not-more-than-1-day-max missions turn into “Projects”. The frustration when something breaks for unknown reason is sky-high as I spent 1-2 days just to think about how to avoid these bugs! I simply don’t have enough time. I’m working like hell but the day is just too short and I’ve got too many tasks to complete. “

I remember sitting with my last team leader, Pasha, in the office one evening(~3 years ago), after spending 12 hours in refactoring something that never actually worked; His words were: ” Oren, you fell in love with your code. You’re spending way too much time on things that… are not really important at the moment…. If you keep it up this way, you’ll never finish your task. “
I remember my response, his words were like a knife in my heart: ” Hey! I put my guts in this code, I’ve stayed the all week for more than 14 hours per day! I even sat at home during the weekend and worked on this task just to keep up with the deadline! you can’t tell me that this is not important! Someone can use this some day! And the design is so extendable! “Not really important…” (bad, bad, dirty thoughts) “.

He was right. I couldn’t make the deadline. It was a battle I couldn’t win; I had to much work and almost no time at this point.

I remember that day like it was a few hours ago. I couldn’t sleep the all night. I kept running scenarios in my head and analyzing his words. I thought about the way I worked until that point, about the times I managed to complete my tasks in time and those times I worked extra hours and still miss my deadlines. I could really see what he meant. I wasn’t able to think in small tasks. I connected every little piece of code with 1000 other usages “that could be used someday”. I thought that I could make it all work at once. I thought that I can prevent bugs from happening. The reality proved me otherwise.

I knew that I can get better, so I set my mind on “think less, do more”. I needed some basic rules to contain my need to over-think, so I use these simple rules to make my life easier:

• I refactor only when I see a tangible reason (2 places with the same code).
  
• I think in small “Contexts” (=tasks). No context should be bigger than 1-1.5 days of work.
  
• I’m trying to WIN *small* battles.
  
• I write some API usages, test that API with my programmers (to see if it’s comfortable enough) and only than starting to code it.
  
• I participate others when things get a little more complicated than they should be.
  
• I write my milestones on my white-board so I could look at them during the day.

This is the mantra behind TDD.
TDD is about letting things go. To Work in small tasks and most importantly:

Let the *code* prove you wrong, not your thoughts or fears.

I don’t have a bug until I can write a test that proves me otheriwse.
With this said, we can now start practicing TDD. Let’s write NameResolver class.

* As this post turned to be quite long, you can see the example here.

clarification: if it wasn’t obvious, the simpleminded is yours truly.