TypeMock tutorial #02. Object creation.

In this new part of the TypeMock series I am going to show you how to deal with objects and classes in general, how you can create them and what are (honestly aren’t) the limit of TypeMock on dealing with objects.

First of all I have just drawn down a little domain that I have added to the demo application. I am planning to upload this demo the next week on Codeplex.com so that every geek reading this blog can just go there and download the source code.

The Demo domain

The domain is a very simple one, we have an abstract base class called Person, then we have two concrete classes, an Employee and a Customer that right now do not have any differences (we will see in the next tutorials why we have two different concrete classes) and then we have a value object Address that is composed only if we provide to it a parent Person object in the constructor. The Person entity exposes a read-only IEnumerable collection of Addresses, so in order to add or remove an address we must use the provided methods AddAddress and RemoveAddress.

The following picture shows the corresponding class diagram of this small domain.

These are the most important piece of code that you may be interested in:

Read-only collection Addresses

privateIList<Address> addresses = newList<Address>();

publicIEnumerable<Address> Addresses

{

get { returnthis.addresses; }

}

publicvoid AddAddress(Address address)

{

if (this.addresses.Contains(address))

{

thrownewInvalidOperationException(“The address is already in the collection.”);

}

this.addresses.Add(address);

}

publicvoid RemoveAddress(Address address)

{

if (!this.addresses.Contains(address))

{

thrownewInvalidOperationException(“The address is not in the collection.”);

}

this.addresses.Add(address);

}

and

Constructor of an Address obj

public Address(Person person)

{

Person = person;

}

publicPerson Person { get; privateset; }

As you can see we have few things that need to be tested but in order to do that we have to create new instances of these objects in order to run our tests, which is pretty verbose and boring …

Create the test project

The first step is to create a new Visual Studio 2010 Visual C# class library project and call it TypeMockDemo.Fixture and add the following references to it:

The references are pointing to:

my TDD framework nUnit (you can work with any TDD framework but I personally found nUnit to be the best out there …)

TypeMock assemblies, installed in the GAC of your machine

The TypeMockDemo project (the one we have the domain entities in)

Now we can start to create the first class fixture and verify that we can create a new Person, a new Employee and a new Customer. But hold on a second! How can we mock an abstract and two sealed class with a mocking framework? We simply can’t if we are not using TypeMock …

Create new abstract and Sealed

[Test]

[Category(“Domain.Isolated”)]

publicvoid AssertThatCanCreateANewPerson()

{

Person person = Isolate.Fake.Instance<Person>();

Assert.That(person, Is.Not.Null);

}

[Test]

[Category(“Domain.Isolated”)]

publicvoid AssertThatCanCreateANewEmployee()

{

Person person = Isolate.Fake.Instance<Employee>();

Assert.That(person, Is.Not.Null);

}

[Test]

[Category(“Domain.Isolated”)]

publicvoid AssertThatCanCreateANewCustomer()

{

Person person = Isolate.Fake.Instance<Customer>();

Assert.That(person, Is.Not.Null);

}

Looking at the code we have introduced the new method Isolate.Fake.Instance<T> that is coming from TypeMock. With this method we can simply inform TypeMock that we want it will create for us a Proxy of the object we want to mock and it will return a derived class of the tested one, even if we are mocking a sealed class.

If the class is sealed TypeMock will create a new instance of the original object while if the object is abstract, TypeMock will create a proxy version of that object. Same thing will be done for all the child properties, complex or not …

That’s simply wow, we just used two lines of code to create a mockup and test it.

Now let’s move forward and let’s verify that we will not be able to add the same address twice and to remove the same address twice from a Person object.

Working with Instances or Proxy?

First of all we start to create this simple test but the result is not the one we expect …

nUnit bombs saying that at line 8 the expected result is supposed to be 1 but in reality is 0. Why? This happens because TypeMock has created a full mockup proxy of the person object so also the methods AddAddress and RemoveAddress are mocks and they do not point to the real code we have implemented …

If we change the way TypeMock is creating the object Person, we can now say to it:

“Dear TypeMock, I want that you create an instance of my object and that you call its constructor so that I can test the code I have implemented in this abstract class …”

Et voila’, the test will pass! Same thing for the remove address and so on …

Now, the last test we may require is that we want to be sure that when we create a new address, the constructor is properly injecting the parent Person object so that we can keep a back-forward reference from the parent object and the collection of children.

We run the test and kabum! It fails again. This time it fails on the address side because the Person instance TypeMock is injecting is not the same it returned to use in the previous line of code. So what can we do now?

We can manually create an Address and inject the parent Person but it sucks … or we can do this:

We simply inject the person value we want to use (the one created by TypeMock) because this is what it is going to happen with live code. What we care here is to be sure that inside the Address class constructor, the Person parameter is passed to the read-only property Person of the Address class, nothing more, nothing less!

Conclusion

As you can see, TypeMock is pretty cool and it allows you to control the way we can create and fake objects. Even if we use proxies we can still ask to TypeMock to create a real mock that reflect our code so that we can still test the business logic included in our objects without the need of creating complex objects manually.

In the next tutorial we will see how to customize the methods and other behaviors of an object and I will also publish the first part of the quiz that will allow you to win almost 1,000 USD value of TypeMock license!

Disclaimer

All content provided on this blog is for informational purposes only. The owner of this blog makes no representations as to the accuracy or completeness of any information on this site or found by following any link on this site.

Advise for SpammersThis blog is manually moderated, please stop to post scam, spam and other annoying comments as they will never get approved, thank you.

Support MeDid you enjoy the content of this blog, then just click the banner below, it will give me back some money which I will use to keep running this blog.