Techniques to refactor and test legacy code

1. TDD 101
3. Testing Legacy code

2. Testing Legacy code

3. Legacy is
code without tests
Michael Feathers

4. Refactor without tests

5. Why refactor
without tests
Reflect knowledge about the system
Put the system in a testable state

6. How to refactor
without tests
Perform safe refactors
Use tools provided by IDE
Proceed step by step

7. Leave the camp better
than you found it
The Camp Rule

8. Rename Rename things to reflect your current
knowledge of the system
Give meaning to them
$message
$confirmationMessage
public function processFile($file)
public function extractInvoiceIdsFromFile($file)

9. Extract
constants
Give meaning to magic values
if ($items >= 3)
if ($items >= self::MINIMUN_ITEMS_TO_SHOW)

10. Extract variables Simplify complex expressions slicing
them into parts
Give meaning to them
$amount = $price - ($price * $pct / 100);
$discount = $price * $discountPercent / 100;
$amount = $price - $discount;

11. Extract method Isolate dependencies while not ready to
inject them
Give meaning to them
$date = new DateTime();
$date = $this->getCurrentDate();
public function getCurrentDate()
{
return new DateTime();
}

12. Extract method Simplify complex operations slicing them
into parts based on abstraction level
Give meaning to them
public function doSomething()
{
// more than 30 lines of code…
}
public function doSomething()
{
$this->prepareThings();
$this->getData();
$this->processData;
return $result;
}

13. Extract interface Abstract behaviors so you can
replace/exchange implementations
Give meaning to them
class SomeService
{
public function doSomething(): Class
{
}
}
interface Service
{
public function doSomething(): Class;
}
class SomeService implements Service
class BetterService implements Service

14. Are you getting the point?

15. Refactor is about
knowledge and meaning

16. Testing legacy code

17. We need
characterization
tests
Describe the behavior of a system/unit
from the outside
Have a base line

18. Characterization
tests
Get the output of a unit of software
Use that to create a test

19. Characterization
tests
Hypothesis about the behavior
of a unit of code
Make a test to prove it

20. Fighting dependencies

21. The first step on the way to
victory is to recognize the enemy
Corrie Ten Boom

22. Dependencies Identify injectable dependencies
Isolate them (extract method)
Extract them (extract class, extract
interface)

23. Injectables Don’t need runtime knowledge at
construction time
Can have dependencies on another
injectables
You can use the same instance

24. Newables Need runtime knowledge to be created
Don’t have injectable dependencies
You need different instances

25. Hidden
dependencies
Those “new” inside the code
Use extract method to isolate them
Override method to test
Isolate, Inject

26. Global state
dependencies
Dependency on things out of our system
• Ramdomness (uuid)
• DateTime
• File System…
Isolate, Extract, Inject

27. Takeaways
Legacy is code without tests
Refactor to
• reflect (evolving) knowledge about the
system
• put system in a testable state
Describe behavior with tests
Fight hidden and global dependencies

28. Hands on…

29. 1. Make this thing run again

30. 2. Put in testable state

31. 3. Describe behavior with tests

32. 4. Fix the @todo, test protected