Strategies to test legacy code - PART 1
Often developers have to deal with code base without test, which might lead to discomfort in maintaining the code base. In one hand there is the business that needs a new feature or a bug fix ready for the users to use, and in the other hand there is the developer without a guide to make sure that the change in the code doesn’t make any side effect.
To refactor is the ability to change the code, without affecting it’s behavior . If the code is changed and it’s behavior change, it is not refactoring, it is changing code without confidence.
The following content aims to define strategies to refactor existing code without tests. Taking into account two basic rules, also named in :
- Don’t change existing code without a test first ( states: “Never write a new functionality without a failing test”)
- Boy Scout Rule - improving the code you need to touch 
The acceptance testing is, compared to the unit test slower to run and depends on the integration of many components, it is the test that simulates a user interacting with the application.
Often the acceptance testing (UI Tests) is used with a web driver, to open a browser and start to reproduce the events that an user would have done . The pyramid of test  though, gave it a label of being slow and that depends on integration to be possible to test.
There are at least two reasons for acceptance test be considered slow, the first, is the need to use a web drive, which creates a real browser environment to execute the test. The second is related to the first, which requires for each test to reset the browser instance, and not only that, you also might need a database running, a cache server and a third party service.
For that reason, the recommended approach is to have a few acceptance tests as possible and even exclude external dependencies from the way if the scenario allows to.
The unit test is the test that tests the smallest part in the code, often referred as a function, or a method. It depends on the definition, I personally prefer the “unit” as being defined as the behavior, as explained in this talk by Mario Cervera.
The unit tests is the test written by the developer along the production code, and trying at best to follow the pyramid of tests . In the pyramid, the unit test is the type of test that should have the higher amount in the suite (composing the pyramid base).
Unit test are fast to run and gives fast feedback to the developer while writing the program. The opposite of acceptance testing.
Defining a strategy
The first strategy to approach testing in legacy systems is to start by writing acceptance testing via web driver. The focus here is to stablish the minimum feedback possible to allow further improvements.
The flow is to get confidence in as many scenarios as possible, in a way that is possible to refactor the code with confidence. In PHP for instance, is possible to use codeception, would be recommended to follow the TDD methodology even with acceptance test, in short the flow is as follows:
- Write acceptance test
- Refactor the code to be possible to add unit test
- Execute the acceptance test
The pro is to have a few testes which gives the developer confidence in refactoring, covering as many scenarios as possible, on the other hand acceptance tests are slow to execute. Even a small change would take a few seconds/minutes to execute the suite.
Be mindful that this strategy is a first approach, trying to follow the “make the change easy, then make the easy change” by Kent Beck.
for each desired change, make the change easy (warning: this may be hard), then make the easy change— Kent Beck 🌻 (@KentBeck) September 25, 2012
Which Martin Fowler also used as a metaphor on an example of preparatory refactoring . If I were to depict some flow to describe this suggested approach, I would follow the same as TDD, but with different kind of tests in each step:
Iterating over the strategy
Having acceptance test in place is a start to start improving the test strategy. As mentioned before acceptance test is slow to execute, in addition to that, we should have a few as possible in the test suite.
The acceptance test in the scenario gives the developer more confidence to start refactoring (this is the feedback possible with “minimum” effort), where the goal to achieve is to increase the unit test based on the acceptance test suite. Take this step as a means to an end.
For each acceptance test is recommended to start to substitute the acceptance test with the unit test, bit by bit, doing refactoring along the way, in the end, the approach would be something like the following:
- Identify which classes are touched by the acceptance test
- Pick one class and start refactoring with the unit test
- If the class does’t have a unit test, create a class for it
- If the class already have a unit test class, start to write the test
- Repeat step 2 until all acceptance tests is converted into unit test
The last part is to remove specific cases in the acceptance testing suite, and keep only the general ones, which covers the most basic flow.
It is possible to keep with all the acceptance test suite in place as well, just the execution approach would change from a developer point of view.
Once the unit test suite is good enough to have confidence, the developer at each change would execute the suite to have feedback on the change. Whereas in the acceptance suite would be executed only once when the refactor is done.
The next steps for such strategy would be to iterate on the acceptance tests that are valuable and double-check if they can be replaced by contract test, this kind of test is specifically valuable to validate third party integration
- M. Fowler, Improving the Design of Existing Code(2nd Edition). Addison-Wesley Professional, 2018.
- S. Mancuso, “Working with legacy code,” 2011 [Online]. Available at: https://www.codurance.com/publications/2011/07/03/working-with-legacy-code. [Accessed: 22-Mar-2021]
- S. Freeman and N. Pryce, Growing object-oriented software, guided by tests. Pearson Education, 2009.
- R. C. Martin, Clean code: a handbook of agile software craftsmanship. Pearson Education, 2009.
- seleniumHQ, “Selenium WebDriver,” 2018 [Online]. Available at: https://www.seleniumhq.org/projects/webdriver. [Accessed: 06-Feb-2019]
- H. Vocke, “The Practical Test Pyramid,” 2018 [Online]. Available at: https://martinfowler.com/articles/practical-test-pyramid.html. [Accessed: 06-Feb-2019]
- M. Cohn, SUCCEEDING WITH AGILE (1st edition). Addison-Wesley Professional, 2009.
- M. Fowler, “An example of preparatory refactoring,” 2021 [Online]. Available at: https://martinfowler.com/articles/preparatory-refactoring-example.html. [Accessed: 05-Jan-2015]
Edit 27, 2019 - PHPMad talk
Edit 18, 2021 - Contract test
Added reference to contract test in the section Iterating over the strategy.
Table of contents
- Acceptance testing
- Unit test
- Defining a strategy
- Iterating over the strategy
- Edit 27, 2019 - PHPMad talk
- Edit 18, 2021 - Contract test