Pages

Monday, 26 March 2012

In part one I explain the main idea behind this approach and in part two I start this example. Please read parts one and two before reading this post

Although the main ideas of Extract, Inject, Kill is already expressed, it's good to finish the exercise just for completion's sake. Here is where we stopped:

Let's have a look at the VoucherPricingService, that now
is the only concrete class at the bottom of our hierarchy.

Note that it uses the VoucherService class to calculate
the voucher value.

Before anything, let's write some tests to
VoucherPricingService.java

Once thing to notice is that the User parameter is not
used for anything. So let's remove it.

Now it is time to user the Extract, Inject, Kill on the
VoucherPricingService. Let's Extract the content of the
VoucherPricingService.applyAdditionalDiscounts(double, String) method
and add it to a class called VoucherDiscountCalculation. Let's call
the method calculateVoucherDiscount(). Of course, let's do that
writing our tests first. They need to test exactly the same things
that are tested on
VoucherPricingService.applyAdditionalDiscounts(double, String). We
also take the opportunity to pass the VoucherService object into the
constructor of VoucherDiscountCalculation.

If you noticed, when doing the extraction, we took the
opportunity to give proper names to our new classes and methods and
also to pass their essential dependencies to the constructor instead
of using method injection.

Let's now change the code in the VoucherPricingService
to use the new VoucherDiscountCalculation and see if all the tests
still pass.

Cool. All the tests still pass, meaning that we have the
same behaviour, but now in the VoucherDiscountCalculation class, and
we are ready to move to the Inject stage.

Let's now injectVoucherDiscountCalculation into
PricingService, that is the top class in the hierarchy. As always, let's add a test that will test this new
collaboration.

And here is the changed PriningService.

Now it is time to kill the VoucherPricingService class
and kill the PricingService.applyAdditionalDiscounts(double total,
String voucher) template method, since it is not being used anymore.
We can also kill the VoucherPricingServiceTest class and fix the
PricingServiceTest removing the applyAdditionalDiscounts() method
from the testable class.

So now, of course, we don't have a concrete class in our
hierarchy anymore, since the VoucherPricingService was the only one.
We can now safely promote UserDiscountPricingService to concrete.

That is now how our object graph looks like:

Our hierarchy is another level short. The only thing we need to do now is to apply Extract, Inject, Kill once again, extracting the logic inside UserDiscountPricingService into another class (e.g. UserDiscountCalculation), injectUserDiscountCalculation into PricingService, finally killUserDiscountPricingService and the calculateDiscount(User user) template method. UserDiscountPricingService,

Since the approach was described before, there is no need to go step by step anymore. Let's have a look at the final result.

Here is the diagram representing where we started:

After the last Extract, Inject, Kill refactoring, this is what we've got:

The cool thing about the final model pictured above is that now we don't have any abstract classes anymore. All classes and methods are concrete and every single class is independently testable.

Tuesday, 6 March 2012

In part 1 of this post I explain the problems of using the template method in deep class hierarchies and how I went to solve it. Please read it before reading this post.

Here is a more concrete example in how to break deep hierarchies using the Extract, Inject, Kill approach. Imagine the following hierarchy.

Let's start with the
StandardPricingService. First, let's write some tests:

Note that I used a small trick here, extending the StandardPricingService class inside the test class so I could have access to the protected method. We should not use this trick in normal circumstances. Remember that if you feel the need to test protected or private methods, it is because your design is not quite right, that means, there is a domain concept missing in your design. In other words, there is a class crying to come out from the class you are trying to test.

Now, let's do the step one in our
Extract, Inject, Kill strategy. Extract the content of the
calculateProductPrice() method into another class called
StandardPriceCalculation. This can be done automatically using
IntelliJ or Eclipse. After a few minor adjusts, that's what we've
got.

And the StandardPriceService now looks
like this:

All your tests should still pass.

As we create a new class, let's add
some tests to it. They should be the same tests we had for the
StandardPricingService.

Great, one sibling done. Now let's do
the same thing for the BoxingDayPricingService.

Now let's extract the behaviour into
another class. Let's call it BoxingDayPricingCalculation.

The new BoxingDayPriceService is now

We now need to add the tests for the
new class.

Now both
StandardPricingService and BoxingDayPricingService have no
implementation of their own. The only thing they do is to delegate
the price calculation to StandardPriceCalculation and
BoxingDayPriceCalculation respective. Both price
calculation classes have the same public method, so now let's extract
a PriceCalculation interface and make them both implement it.

Awesome. We are now ready for the Inject part of Extract, Inject, Kill approach. We just need to inject the desired behaviour into the parent (class that defines the template method). The
calculateProductPrice() is defined in the PricingService, the class
at the very top at the hierarchy. That's where we want to inject the
PriceCalculation implementation. Here is the new version:

Note that the template method calculateProductPrice() was removed from the PricingService, since its behaviour is now being injected instead of implemented by sub-classes.

As we are here,
let's write some tests for this last change, checking if the PricingService is invoking the PriceCalculation correctly.

Great. Now we are
ready for the last bit of the Extract, Inject, Kill refactoring.
Let's kill both StandardPricingService and
BoxingDayPricingService child classes.

The VoucherPricingService, now the deepest class in the hierarchy, can be promoted to concrete class. Let's have
another look at the hierarchy:

And that's it. Now it is just to repeat the same steps for VoucherPricingService and UserDiscountPricingService. Extract the implementation of their template methods into classes, inject them into PricingService, and kill the classes.

In doing so, every time you extract a class, try to give them proper names instead of calling them Service. Suggestions could be VoucherDiscountCalculation and PrimeUserDiscountCalculation.

There were a few un-safe steps in the re-factoring described above and I also struggled a little bit to describe exactly how I did it since I was playing quite a lot with the code. Suggestions and ideas are very welcome.

For more information about the original problem that triggered all this, please read part 1 of this blog post.In part 3 I finish the exercise, breaking the entire hierarchy. Please have a look at it for the final solution.

Years ago, before I caught the TDD bug,
I used to love the template method pattern. I really thought that it
was a great way to have an algorithm with polymorphic parts. The use
of inheritance was something that I had no issues with. But yes, that
was many years ago.

Over the years, I've been hurt by this
"design style". That's the sort of design created by
developers that do not TDD.

The situation

Very recently I was working on one part of our legacy code and found a six level deep hierarchy of classes.
There were quite a few template methods defined in more than one of
the classes. All classes were abstract with the exception of the
bottom classes, that just implemented one or two of the template
methods. There were just a single public method in the entire
hierarchy, right at the very top.

We had to make a change in one of the
classes at the bottom. One of the (protected) template method implementations had
to be changed.

The problem

How do you test it? Goes without saying
that there were zero tests for the hierarchy.

We know that we should never test
private or protected methods. A class should "always" be
tested from its public interface. We should always write tests that
express and test "what" the method does and not "how".
That's all well and good. However, in this case, the change needs to
be done in a protected method (template method implementation) that
is part of the implementation of a public method defined in a class
six level up in the hierarchy. To test this method, invoking the
public method of its grand grand grand grand parent we will need to
understand the entire hierarchy, mock all dependencies, create the
appropriate data, configure the mocks to have a well defined
behaviour so that we can get this piece of code invoked and then
tested.

Worse than that, imagine that this class at the bottom has siblings overriding the same template
method. When the siblings need to be changed, the effort to write tests for
them will be the same as it was for our original class. We will have
loads of duplications and will also need to understand all the code
inside all the classes in the hierarchy. The ice in the cake:
There are hundreds of lines to be understood in all parent classes.

Breaking the rules

Testing via the public method defined
at the very top of the hierarchy has proven not to be worth it. The
main reason is that, besides painful, we already knew that the whole
design was wrong. When we look at the classes in the hierarchy, they
didn't even follow the IS-A rule of inheritance. They inherit from
each other so some code could be re-used.

After some time I
thought: Screw the rules and this design. I'm gonna just directly test
the protected method and then start breaking the hierarchy.

The approach: Extract, Inject, Kill

The overall idea is:

1. Extract all the behaviour from the
template method into a class.

2. Inject the new class into the parent
class (where the template is defined), replacing the template method invocation with the invocation
of the method in the new class.

3. Kill the child class (the one that
had the template method implementation).

Repeat these steps until you get rid of
the entire hierarchy.

This was done writing the tests first, making the protected template method implementation public.

NOTES

1. This may not be so simple if we have
methods calling up the stack in the hierarchy.

2. If the class has siblings, we have
to extract all the behaviour from the siblings before we can inject
into the parent and kill the siblings.

This probably is too complicate to
visualise, so in part 2 of this post I'll be giving a more concrete example.