Recentemente ero TDDing un metodo di fabbrica. Il metodo consisteva nel creare un oggetto semplice o un oggetto avvolto in un decoratore. L'oggetto decorato potrebbe essere di uno dei tanti tipi che estendono StrategyClass.
Nel mio test volevo controllare, se la classe dell'oggetto restituito è come previsto. È semplice quando viene restituito il semplice oggetto os, ma cosa fare quando è racchiuso all'interno di un decoratore?
Codice in PHP, quindi potrei usare ext/Reflection per trovare una classe di oggetto spostato, ma mi sembrava che facesse da complemento alle cose, e in qualche modo le regole di nuovo del TDD.
Invece ho deciso di introdurre getClassName() che restituirebbe il nome della classe dell'oggetto quando chiamato da StrategyClass. Tuttavia, quando chiamato dal decoratore, restituisce il valore restituito con lo stesso metodo in oggetto decorato.
Un codice per renderlo più chiaro:
interface StrategyInterface {
public function getClassName();
}
abstract class StrategyClass implements StrategyInterface {
public function getClassName() {
return \get_class($this);
}
}
abstract class StrategyDecorator implements StrategyInterface {
private $decorated;
public function __construct(StrategyClass $decorated) {
$this->decorated = $decorated;
}
public function getClassName() {
return $this->decorated->getClassName();
}
}
E un test PHPUnit
/**
* @dataProvider providerForTestGetStrategy
* @param array $arguments
* @param string $expected
*/
public function testGetStrategy($arguments, $expected) {
$this->assertEquals(
__NAMESPACE__.'\'.$expected,
$this->object->getStrategy($arguments)->getClassName()
)
}
//below there's another test to check if proper decorator is being used
Il mio punto qui è: è corretto introdurre tali metodi, che non hanno altro scopo se non quello di facilitare i test unitari? In qualche modo non mi sembra giusto.