Software testing refactoring tutorials and videos

Code Refactoring and Its Role in the Software QA Process

Software Testing Magazine — Mon, 10 Jul 2023 13:43:17 +0000

Code refactoring is the process of restructuring existing code without changing its behavior. Its goal is to improve the design, structure or implementation of the software, while keeping its functionality. This article discusses how refactoring is integrated in software quality assurance (QA). Author: Nataliia Syvynska, TestMatick, https://testmatick.com/ Code refactoring is a special process that consists of editing and analyzing previously created code without changing its current function. This process aims to improve the overall efficiency of the code so that it is easy to use, contains as few edits as possible, and is easy to take apart. Main Techniques and Rules for Performing Refactoring There are several popular and effective methods for performing code refactoring: Red-Green-Refactoring; Refactoring by abstraction; Method of composition; Simplifying method; Preparatory code refactoring. Let’s analyze each type in more detail. Red-Green-Refactor This is a very popular technique that is in particular demand among software testing companies that follows an Agile approach for software development. Its basic steps are: Define what needs to be done; Ensure the smooth execution of basic testing; Implement improvements (if necessary). Refactoring by abstraction This is ideal for a very high-volume refactoring process. With it, you can overcome the excessive amount of code by removing duplicate subclasses and collapsing the hierarchy. This type of refactoring contains several execution methods, namely: Pull-Up/Push-Down: “splits” one class into two, one of which will be tied to the superclass, and the second to the subclass. Pull-Up: collects part of the code in a superclass and deals with code duplication. Push Down: The method allows you to move [...]

The post Code Refactoring and Its Role in the Software QA Process first appeared on Software Testing Magazine.

Testing Legacy Code: Safe Refactoring

Software Testing Magazine — Mon, 16 Nov 2020 10:36:23 +0000

The paradox: I cannot test this code because it is legacy. I need to refractor the code to make it testable. How can I manage that, without breaking existing functionality? I will need to write some tests, but… argh! This presentation explains how to safely refactor and test ‘untestable’ code – without breaking any existing functionality. Video producer: https://www.phpconference.co.uk/

The post Testing Legacy Code: Safe Refactoring first appeared on Software Testing Magazine.

Advanced Software Testing & Refactoring Techniques

Software Testing Magazine — Tue, 24 Mar 2020 15:25:25 +0000

When you inherit difficult code it can take weeks to become productive. Having the right tools for software testing and refactoring job and knowing how to use them makes a huge difference. Emily Bache explains this in a series of three posts that deal with approvals and mutation testing; the Lift-Up Conditional refactoring technique; replacing conditional with polymorphism. The first video presents the concepts of Approval Testing, Coverage and Mutation Testing. Approval testing can get you test coverage quickly without having to understand the code. The second video discusses the “Lift-Up Conditional” refactoring technique. It is a manipulation of a long complex conditional statement that will let you group together all the statements related to one particular conditional. The third video presents a classic refactoring technique named “Replace Conditional with Polymorphism”. The basic idea is that you create subclasses to encapsulate the logic concerned with each logical case. Find more about this series on https://www.praqma.com/stories/advanced-testing-refactoring-techniques/ https://www.praqma.com/stories/advanced-testing-refactoring-techniques-2/ https://www.praqma.com/stories/advanced-testing-refactoring-techniques-3/

The post Advanced Software Testing & Refactoring Techniques first appeared on Software Testing Magazine.

Refactoring for Testability

Software Testing Magazine — Tue, 18 Sep 2018 14:18:01 +0000

There are a lot of examples on the web on how to introduce good agile testing and architectural patterns when you are starting a new software development project. In reality, even on newer projects, you are more often working in a less than ideal state. Schedules are tight, customers want more features, but at some point your productivity will fall apart if you do not make good software architecture and software testing a priority. How do you get out of this state? This talk presents common issues and agile, realistic solutions within the context of real world examples. https://www.youtube.com/watch?v=lVNb39ysmy0 Video producer: http://seleniumconf.co.uk/

The post Refactoring for Testability first appeared on Software Testing Magazine.

Testable Frontend JavaScript Anti-patterns

Software Testing Magazine — Tue, 03 Jun 2014 18:34:43 +0000

Software testing starts when you write the code that will be tested. In these two articles, Shane Tomlinson discusses some anti-patterns that will make your JavaScript frontend code difficult to test. He explains how to detect these anti-patterns in your code and then shows how to refactor your JavaScript to be easier to read, to reuse and to test. The first article presents a basic JavaScript sample application that contains several common anti-patterns and their solutions. Some of these anti-patterns are inline Javascript, Javascript code that is embedded in an HTML file. This code is impossible to include in an external unit test harness. Another anti-pattern are poorly constructed DOM event handlers where the event handler logic is mixed with form submission logic. This results in an inflexible mixture of concerns. This article addresses each of the problems outlined in the sample code so that the front end code becomes easier to test. The second article refactors the sample JavaScript code so that it becomes easier to read, to reuse and to test. After the refactoring, testing begins: a test harness is created, an XHR mock is developed and finally, a full unit test suite is added. Each of the anti-pattern discussed in the first article is refactored with detailed explanations. The conclusion of the article is that “Writing testable code is often a challenge, but the basics are easy once you are used to it. Before writing a single line of code, start with the question “how am I [...]

The post Testable Frontend JavaScript Anti-patterns first appeared on Software Testing Magazine.

The Negative Side of Mocking Tools

Software Testing Magazine — Thu, 04 Oct 2012 10:38:38 +0000

In this article, Brett Schuchert discusses how modern mocking tools affects positively our ability to work with legacy code and the possible negative implications of using mocking tools. These tools allow us to perform unit testing without actually changing the underlying code. He starts with a discussion about the challenges of unit testing and how mocking tools help to solve them; at least on the surface. He argues however that performing some refactoring on some code structures could make them more testable using more traditional unit testing tools. The fact is that using powerful mocking tools like JMockIt could cover sometimes questionable design in code. His conclusion is not that you shouldn’t use mocking tools, but rather than using them sparingly during new development could lead to writing new code with more discipline. This article provides thinking content with many code examples and it should be considered by all developers using mocking tools, especially in a Java context.

The post The Negative Side of Mocking Tools first appeared on Software Testing Magazine.

Transformation Priority Premise for TDD

Software Testing Magazine — Thu, 25 Aug 2011 17:14:21 +0000

This just might be the thing that brings a mathematical rigor to Test Driven Development (TDD). If nothing else, it will certainly help programmers choose which tests to write next, and how best to make them pass. Transformations are like refactorings in that they are simple incremental changes to code. They are unlike refactorings in that they change the behavior of code. In this video, Robert “Uncle” Martin presents a set of transformations sufficient to create any application. It also suggests that when they are applied in a certain order developers can avoid many of the common problems with TDD such as painting yourself into a corner, or taking steps that are too large. It also suggests that the ordering helps developers to find better algorithms. http://ndc2011.macsimum.no/mp4/Day1%20Wednesday/Track5%201740-1840.mp4

The post Transformation Priority Premise for TDD first appeared on Software Testing Magazine.

Unit Test and Refactor Legacy PHP Code

Software Testing Magazine — Tue, 26 Jul 2011 13:07:23 +0000

This article proposes strategies to refactor problematic PHP code, making it easier to test it with unit testing tools, while reducing dependencies that improves your code base.

The post Unit Test and Refactor Legacy PHP Code first appeared on Software Testing Magazine.