Testing legacy code
2 likes52 views
This document discusses techniques for refactoring legacy code without tests. It recommends starting by performing safe refactors to reflect evolving knowledge of the system and put it in a testable state. Characterization tests are used to describe the existing behavior of units of code as a baseline. Dependencies need to be identified and isolated through extraction methods or interfaces to allow injection of fakes for testing. The overall goals are to fight hidden and global dependencies and leave the codebase in a better state than when refactoring began.
Testing legacy code
- 1. TDD 101 3. Testing Legacy code
- 3. Legacy is code without tests Michael Feathers
- 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
- 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
- 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