Code Refactoring for Automated Tests

by Nataliia Vasylyna | June 26, 2015 10:00 am

Note: the article was updated in September 2020.

The term ‘Refactoring’ stands for the process of code cleanup and redesign aimed to improve its internal structure without altering the functionality. Refactoring reduces code complexity, cuts off redundancies, and cuts down on unnecessary loops. All the manipulations are performed on a code already deployed and used in production.
Despite the popular misconception, refactoring is not only for software developers. Test code refactoring involves changes in test code that increase its maintainability without adding or removing test cases.

Benefits of Refactoring in Testing

Refactoring is a valuable practice in testing. Why? It naturally makes everything better.

• Simple test cases are better because they are easier to maintain, execute, and run simultaneously with other test cases.
• Test automation gets better if based on a refactored code because it reduces the maintenance effort and allows more reuse in the codebase.
• The productivity of new QA engineers increases and becomes better because they do not spend time rewriting the code they inherited.

Refactoring test code differs from refactoring production code in a particular set of bad smells involved and, therefore, it requires test-specific refactorings.

Why You Should Refactor

There are several reasons behind the need for a particular module or piece of code to get refactored, including code smells, technical debt, and implementation of agile methodology.

• Code smells indicate severe problems existing in the code, such as the presence of redundant or identical code, overcomplicated code design, lazy classes, abundance of loops, etc.

N.B. There are numerous code smells that are specific to test code. The list includes undesirable duplications, test methods in production code, assertions in a test method that have no explanation, resource interference, use of external resources, test code that makes optimistic assumptions about the existence or state of external resources, etc.

• Technical debts refer to additional rework required but postponed due to the limited time and resources available. Especially relevant to legacy systems that tend to acquire significant technical debt that in turn brings about difficulties in maintaining the application.
• Agile software development involves working in small increments evaluating and adjusting the results gradually. Therefore, a clean and well-structured code ensures that the team will not have to extend the existing code with each iteration.

Possible Test Code Refactorings

The golden rule of test code refactoring states that tests should work as intended afterward. Other principles involve simplifying tests if possible, detecting and removing code smells, as well as applying suitable refactoring methods.

There are five test code refactorings test automation[1] engineers can implement right away:

1. Incorporating the required external resource in the test code to remove the dependency between a test method and the resource.
2. Ensuring that the test that relies on external resources uses them explicitly, allocates them before testing, and releases when done/failed.
3. Using unique identifiers for all allocated resources.
4. Minimizing fixtures to make tests less sensitive to changes.
5. Adding explanations for failed assertions.

Conclusion

Test code refactoring is an important technique that involves restructuring an existing body of code to make it cleaner and, therefore, allows increasing the productivity of test automation engineers. It also may reveal missing test cases and even helps in improving the production code by indicating the presence of code smells.

Related Posts:

• Warning Signs: How to Identify Inefficient Test Automation in Your Project[2]
• 6 Steps To Automate Your Testing Process[3]
• Test Automation Myths: Where the Truth Ends and the Myth Begins?[4]

Source URL: https://blog.qatestlab.com/2015/06/26/automated-tests-refactoring/

---