Question

I’m trying to get my head round Unit Testing and there’s one more piece of the jigsaw I need to find.

What I’m trying to do is write tests for the following code. In this case, I’ve got a really simple Front Controller (written in PHP).

class frontController
{
   public function routeRequest($oRequest)
   {
      $sClassname = $oRequest->getController();
      $sMethod = $oRequest->getAction();

      $oController = new $sClassname();

      $oResponse = $oController->{$sMethod}($oRequest);

      return $oResponse;
   }

}

The problem I have is because the code creates new objects. I can easily mock the request object so that I can tightly control what it will actually do within my test case. I’m not sure the best way to actually replace the controller with a test double.

This article from IBM suggests having a factory method for creating my controller and then overriding this with a specific class used for testing:

class frontController
{
   public function routeRequest($oRequest)
   {
      $sMethod = $oRequest->getAction();

      $oController = $this->createController($oRequest);
      $oResponse = $oController->{$sMethod}($oRequest);

      return $oResponse;
   }

   protected function createController($oRequest)
   {
      $sClassname = $oRequest->getController();
      return new $sClassname();
   }

}

and then for testing perhaps something like this:

class testFrontController extends frontController
{
   public function setMockController($oMockController)
   {
      $this->oMc = $oMockController;
   }

   protected function createController($oRequest)
   {
      return $this->oMockController;
   }
}

(note this isn’t quite what the article says, but I’m thinking it would be most useful to me if it did this)

Another solution could be to have another class that creates the controller. This would then be a dependent class of the frontController. This way I can replace the factory/creation class during testing with a test double. Something like this:

class frontController
{
   public function routeRequest($oRequest, $oControllerFactory)
   {
      $sMethod = $oRequest->getAction();

      $oController = $oControllerFactory->create($oRequest);
      $oResponse = $oController->{$sMethod}($oRequest);

      return $oResponse;
   }
}

class controllerFactory
{
   public function create($oRequest)
   {
      $sClassname = $oRequest->getController();
      return new $sClassname();
   }
}

I guess the dependency injection could be taken care of in the front controller constructor or via a setter instead of a parameter to the actual “route” method.

I think I prefer option 2.

Is either of these two methods the right way of going about testing this kind of thing?

(perhaps “good way” would be better word here!)

Any thoughts or suggestions on option 1 vs option 2 appreciated or indeed any alternatives. Remember – the key thing is about how to test an object that itself creates other objects as part of its execution.

Thanks!

Answer 1

I generally find factories to be a good thing to use for this scenario. In addition to the swappability aspect, it means that additional parameters, data, or dependencies required by the object being created can be stored by the factory, and so the object which actually requests the new object doesn’t have to know anything about them…