October 25, 2008

Using events to improve testability and reduce temporal coupling.

Temporal coupling in code is usually not very obvious but can cause maintainability nightmares. Code is coupled not by direct dependencies but by depending on the state that left behind by another piece of code. Temporal coupling is not something that should be avoided but it should be expressed explicitly. Someone editing your code should be able to see clearly where dependencies lie.

Functional languages solve this problem by not having side effects. Ordering of functions is very clear if you follow the returned values. In OO languages like C# you don't always have this luxury. Side effects can make things difficult for us. In this post I want to show a different approach to solving this problem[more]

In higher level components, for example the presenter in an MVP UI architecture you often find code like this (warning, contrived example with non-production pseudo code ahead):

   1: public void LoadFile( string path )
   2: {
   3:     fileLoadService.FillModelFromFile( path, model );
   4:     if( model.Verify() )
   5:     {
   6:         view.ShowFileNameInTitle( inputFile.Name );
   7:         view.ShowLines( inputFile.Lines );
   8:     }
   9: }

Effectively you’re just sequencing calls here. The only reason for the existence of LoadFile is to make sure that all the functions that actually do anything are called in the right order. When I started writing tests for code like this I started feeling a bit uneasy:

   1: [Fact]
   2: public void ShouldCallModelVerifyAfterFillModel() { //blah.. }
   4: [Fact]
   5: public void ShouldShowFileNameViewWhenVerified() { //blah.. }
   7: [Fact] 
   8: public void ShouldShowLinesInViewWhenVerified() { //blah.. }

I won’t bore you with the details of the tests. Let’s just say that there’s a lot of mockery and some rhino’s. If you’re used to NUnit think [Test] instead of [Fact]. The point I want to bring across here is that I am forced to test the order in which the functions are called. This means I’m testing implementation details. This isn’t optimal. I don’t know if this is an official test-smell but it should be.

But as is ofthen the case it’s not the tests that should be fixed, it’s the code. Tests smells often point out code smells. Actually I don’t care if model.Verify() is called after fileLoadService.FillModelFromFile(). I only care that the model is verified when it changes to a possible unverified state. I don’t care if the filename and lines are shown in the view when it’s verified, I only care that they are updated every time the model changes to a verified state. So the dependencies I care about are kept hidden while I’m testing them indirectly by testing the order of the calls.

Eventually this will get more of a mess. If the presenter grows more of these implicit dependencies will show up and start conflicting with each other. Sequences like this will show up in more functions. They will be similar but different and hard to maintain.

Events to the rescue!

What we want here is to be notified by the model when it needs to be verified and when it changes so that the display needs to be refreshed. I’d write more code for you but I think this is best illustrated with a sequence diagram.

Here is the original situation where the presenter does all the work:


And here is how we can make this better, the model fires events and the presenter reacts. Coupling between expectations on the state of the model and the reaction by the presenter are made explicit here.


This will cause me to write tests like these:

   1: [Fact]
   2: public void ShouldVerifyOnModelVerifyRequired() { //blah... }
   4: [Fact]
   5: public void ShouldDisplayTitleWhenModelChangesVerified() { //blah... }

I don’t know about you but I find this a lot clearer. The tests reflect requirements instead of implementation. The logic in the presenter is also partitioned better and is easier to reuse.

No comments:

Post a Comment