6 Ways to Improve Software Testing through Planning, Work Environment, Automated Testing, and Reporting

A lot of research has been done to identify the root causes of software startups failures. One of the main reasons for such failures turned out to be poor quality assurance during the software development process. The chief purpose of executing stringent quality assurance test on software is to prevent the release of poor quality products to the end customers. Small mistakes that slip through may lead to large financial losses.

A good example of QA’s importance is Flud, a social news reader application for iPad, iPhone, Android, and Windows Phone. Flud was known as the “first true social news reader.” But the startup failed because of poor QA services. The main priority of the Flud team was the development process and its focus was on code creation almost to the exclusion of all else. When the product was finally released, it was bug-infested and load with mismatches.No matter that everything was fixed, the bad reputation and awful user experience prevented its success. And, Flud was discontinued.

The way to provide high-quality software is to implement effective QA management that provides tools and methodologies for building bug-free products. Software quality management is an umbrella term covering three core aspects: quality assurance, quality control, and testing.

Software quality assurance (SQA) is the part of quality management that includes a planned set of organizational actions. The purpose of these actions is to improve the software development process, introducing standards of quality for preventing errors and bugs in the product.

Software quality control (SQC) is the part of quality management that includes a set of activities focused on fulfilling quality requirements. QC is about product-oriented activities that certify software products for their quality before release. The process of software quality control is governed by software quality assurance.

Testing is the basic activity aimed at detecting and solving technical issues in the software source code and assessing the overall product usability, performance, security, and compatibility. It isn’t only the main part of quality assurance; it is also an integral part of the software development process.

Agile software development cycle

This article will discuss the best practices for improving software testing and for increasing the quality of your software products.

1. Plan the testing and QA processes

Test processes should be well planned, defined, and documented. Good documentation is the tool that builds efficient communication within the software team. So, effective planning entails the creation of the quality and test plans for a project.

Quality management plan

A quality management plan is a document that defines an acceptable level of product quality and describes how the project will achieve this level. It isn’t a mandatory document, but it will help you schedule all the tasks needed to make sure that the project meets your customer’s needs and expectations. The main goal of this plan is to support project managers. Accordingly, it should include the software’s quality requirements and describe how they should be assessed.

Key components of the quality management plan:

• Quality objectives
• Key project deliverables and processes to be reviewed for satisfactory quality level
• Quality standards
• Quality control and assurance activities
• Quality roles and responsibilities
• Quality tools
• Plan for reporting quality control and assurance problems

Test Plan

A test plan is a document that describes what to test, when to test, how to test, and who will do the tests. It also describes the testing scope and activities. The test plan includes the objectives of the tests to be run and helps control the risks. It’s a good practice to have a test plan written by an experienced person like a QA lead or manager. The test plan must be a guidebook for the testing process and it should cover:

• The scope of testing
• Test objectives
• Budget limitations
• Deadlines
• Test execution schedule
• Risks identifications

A good test plan should include the schedule for all necessary testing activities in order to control your team testing time. It also should define the roles of every team member so that everyone is clear about what is required of them. There’s no universal way of creating a test plan because it depends on the processes, standards, and test management tools implemented in the company. According to the IEEE standard 829, a test plan document should contain the following information:

• Test plan identifier
• Introduction
• References (list of related documents)
• Test items (the product and its versions)
• Features to be tested
• Features not to be tested
• Item pass or fail criteria
• Test approach (testing levels, types, techniques)
• Suspension criteria
• Deliverables (Test Plan, the document itself, Test Cases, Test Scripts, Defect/Enhancement Logs, Test Reports
• Test environment (hardware, software, tools)
• Estimates
• Schedule
• Staffing and training needs
• Responsibilities
• Risks
• Assumptions and Dependencies
• Approvals

Here are some key guidelines for making the test plan more effective:

Make your test plan brief. Avoid repetition or irrelevance. It should contain only the relevant information.

Be specific. Include all details, e.g. editions and versions of the programs, to make the document searchable

Update a test plan. It’s a live document that must be frequently updated on an on-demand basis.

Share a test plan with your stakeholders. It will give them information about your testing processes. The quality of your test plan will represent the quality of the testing your team will to perform.

Test cases

Preparation of effective test cases is an integral part of software testing improvements. According to the definition, given by ISTQB (International Software Testing Qualifications Board, the worldwide leader in the certification of competences in software testing) “a test case is a document which consists of a set of conditions or actions which are performed on the software application in order to verify the expected functionality of the feature”. It’s one of the key instruments used by testers. The standard test case includes the following information:

• The test case ID
• Test case description
• Prerequisites
• Test steps
• Test data
• Expected result
• Actual result
• Status
• Created by
• Date of creation
• Executed by
• Date of execution

Below you can see the example of a standard test case.

Example of standard test case

Source: ISTQB certification

Use the following practices to write effective test cases :

Identify testable requirements. Identify the scope and purpose of testing before starting the test process.

Customer requirement. The specialist who writes the test case must have a good understanding of the features and user requirements. Each test case should be written keeping the client’s requirements in mind.

Write on time. The best time to write test cases is the early requirement analysis and design phases. That way QA specialists can understand whether all requirements are testable or not.

Simple and сlear. Test cases should be simple and easy to understand. Every test case should include only the necessary and relevant steps. No matter how many times and by whom it will be used, a test case must have a single expected result rather than multiple expected results.

Unique test cases. Each test case must have a unique name. This will help classify, track, and review test cases at later stages.

Test cases should be maintainable. If requirements change, a tester must be able to maintain a test case.

2. Employ test-oriented software development management

Implementation of test-oriented management approaches is a good way to improve the quality of software. One of the ways to achieve this is using extreme programming (EX) — a software development methodology that aims to produce higher quality software with the ability to adapt to changing requirements. Let’s take a closer look at the following extreme programming practices:

• Test-driven development
• Pair programming

Test-driven development

Test-driven development (TDD) is a software development process in which tests are written before any implementation of code. TDD has a test-first approach based on repetition of a very short development cycle. According to it, each new feature begins with writing a test. The developer writes an automated test case before he/she writes enough production code to fulfill that test. This test case will initially fail. The next step will be to write the code focusing on functionality to get that test passed. After these steps are completed, a developer refactors the code to pass all the tests.

Test-Driven Development lifecycle

The following are the benefits of using the TDD approach:

High quality. The quality of TDD-based products is usually much higher than that achieved with other methods.

Optimization of development costs. The cost of debugging at later stages is minimized as tests are run from the beginning of the design cycle.

Simplification of code. Engineers invest more effort in aligning code requirements to particular tests.

Positive effects on productivity. The TDD approach provides quick feedback on introducing a bug and fixing it. A developer notices a bug as soon as the test fails and then fixes it to pass the test again.

Executable documentation. Use-cases are written as tests and other developers can view the tests as examples of how the code is supposed to work.

Pair programming

Pair programming is also an extreme programming technique. This development approach requires two engineers working in tandem at a single computer. One of them writes a code while the other watches and makes suggestions through the process. These roles can be swapped at any time. Two developers working at a single computer will produce software with a significantly higher quality. The increased code quality can reduce the debugging and refactoring cost of the project in the long run.

The benefits of pair programming:

High code quality. Fewer mistakes and bugs are introduced into the code as problems are caught before or during the code writing.

Better knowledge sharing among team members. You will have more people who know how the product works. In this case, if one of the pair leaves the company, there will be someone remaining who is experienced with the code.

Clear code. You will receive shorter and much clearer code.

Two heads are better than one. If some problems crop up along the way, two people can solve them faster than one.

3. Ensure suitable work environment for QA team

Involve the dedicated QA team from the beginning to start testing early

Testing should be done by a dedicated team. In this case, you will be assured that testing is done professionally. Making quality improvements must be part of the team members goals. Testers must be involved in the software design process from the start. It helps ensure that they will be able to solve any problems that arise before the cost of resolving an issue starts growing exponentially.

Respect your testers

If you want to achieve high-level quality goals, you need to build trusting relationships between a QA team and developers with respect for each other. Also, it would be better to search for people with coding skills. Obviously, engineers will respect such testers more. They will also be able to code some of their own testing tools. Such an approach provides for better communication between both sides, testers, and developers. A QA lead has to recognize the progress of the team and individual achievements of its members at team meetings. It will encourage other specialists to do better work in the future.

Give business training to your QA team

Provide the necessary pieces of training for your QA specialists to expand their knowledge. You can organize training sessions and other team building exercises to improve the work of the entire team. A QA team lead should organize brainstorming sessions to create the floods of collective creativity in the team. It will help invent new techniques for solving existing problem.

Importance of communication

Collocate your testers and developers to improve communication efficiency. Face-to-face communication will help avoid misunderstandings. Good communication within the team allows people to compare results and share effective solutions to problems encountered during tests. You also need a good team leader who will be able to effectively share feedback and ideas with testers. QA managers should encourage team members to speak about existing problems and other issues with the team that could impact productivity and efficiency.

It’s also important to give your testers a chance to talk about things privately, separately from group meetings. QA leaders should be flexible and open to new strategies to best serve their teams.

4. Optimize the use of automated tests

If you really want to improve the quality of your software, then automated testing is definitely worth taking into consideration. According to the World Quality Report 2017–2018 by Capgemini, Sogeti, and Micro Focus, two of three key trends are increasing test automation and widespread adoption of the Agile methodologies. It’s really a wise recommendation to deploy automated testing throughout the QA process. Automated testing means using automation tools to run the tests.

While automated testing can be employed within traditional Agile workflows, it can also be a part of a broader practice called continuous integration.

Continuous integration and continuous delivery

Continuous delivery is considered an evolutionary development of the Agile principles. This method means that you can release changes to your customers quickly in a sustainable way. CD allows the commitment of new pieces of code when they are ready without short release iterations. Generally, you automatically deploy every change that passes the tests. This is achieved by a high level of testing and deployment automation.

Continuous integration describes how the continuous delivery method is implemented at the software engineering level. It’s a development practice that requires engineers to integrate the changes into a product several times a day. Each code piece runs the “integration tests” at every code change to detect errors and bugs quickly, and locate them more easily. A good practice is to combine the CI with the automated testing to make your code dependable. Bamboo, Hudson, and Cruise Control are open source tools that allow for introduction of continuous integration in your environment.

Read our article about continuous delivery and continuous integration to learn more.

Key benefits of using automated tests with continuous delivery:

Save time. Automated tests run after each commit and send feedback with results to developers.

High quality of created software. As the regression errors are captured early by the automated tests, fewer bugs get shipped to production.

Code consistency. It is achieved by avoiding the chance of human error when performing tests.

Reducing the test costs. Your CI server can run hundreds of tests in a matter of seconds.

Your QA team will spend less time on testing. As a result, they will be able to focus on improving quality.

Testing capabilities. Automated testing tools provide testing of web applications on various browsers simultaneously.

Improved test coverage. Automated testing can easily test code with more than a thousand lines. Providing such testing coverage without automation is difficult at best.

Higher ROI. Manual testing includes the costs of man hours and the work effort of testers and QA managers. With automated testing tools and continuous delivery, testers are able to test faster, more easily and efficiently producing nearly bug-free software. It’s important to understand that ROI is not immediate and it requires long-term planning.

There is a wide variety of automation testing tools. They can be both open-source and commercial. Selenium, Katalon Studio, Unified Functional Testing, Test Complete, Watir are the most popular ones worth checking first.

5. Employ code quality measurements

Quality objectives should be measurable, documented, reviewed, and tracked. There’s no single right way to measure code quality. The best advice is to choose metrics which are simple and effective for your workflow.

The CISQ Software Quality Model defines four important aspects of software quality: reliability, performance efficiency, security, maintainability, and rate of delivery. Additionally, the model can be expanded to include the assessment of testability and product usability.

Let’s look at each of the main five aspects of software quality and explore how they can be measured:

Reliability. This indicator defines how long the system can run without failure. The purpose of checking reliability is to reduce application downtime.

You can measure reliability by counting the number of bugs found in production, or by reliability testing, specifically, load testing, that checks how the software functions under high loads. It could also be regression testing which verifies the number of new defects when software undergoes changes.

Performance efficiency means the responsiveness of a system to execute any action within a given time interval. Performance efficiency can be measured using the following metrics:

• Stress testing provides the understanding of the upper limit of the capacity of the system.
• Soak testing checks how long the system can handle a certain load and when performance starts to degrade.
• Application performance monitoring is the detailed metrics of performance from the user’s perspective provided by a special software.

Security is the capability of a system to protect information against the risk of software breaches and to prevent the loss of information. You can count the number of vulnerabilities by scanning the software application. The number of found vulnerabilities is a positive or negative measure of security.

• Deployment of security updates is the percentage of users that have actually installed a patch or security update.
• Time to resolution is the amount of time needed to fix a vulnerability.

Maintainability is the ability of the system to modify software, adapt it for other purposes, transfer it from one development team to another, or meet new business requirements with a degree of ease. A very simple metric of code maintainability is to check the number of lines of code in a feature or even the entire application. Software with more lines of code is harder to maintain. You can also use the software complexity metrics to measure how complex software is. More complex code is less maintainable.

The rate of delivery. It’s also important to measure the rate of software delivery. The number of software releases is the main metric of how frequently new software is delivered to users. Consider reading our piece on main Agile development metrics to broaden your view on this topic.

6. Report bugs effectively

A good bug report will help make software testing more efficient by clearly identifying the problem and in this manner navigating engineers towards solving it. A badly written report can lead to serious misunderstanding.

Here are the guidelines for an effective bug report:

Communication basis. A bug report must be a cornerstone and an efficient form of communication between a QA specialist and developer.

Provide solutions if possible. The document must include not only the bugs scenarios but also provide solutions for them, i.e. describing the needed behavior of a feature

Clarity. A bug report must be clear enough to help developers understand the failure, including information about what QAs see, and a statement what they expect to see. It should detail what went wrong. Clarity also entails addressing only one problem per task.

Screenshots. Include a screenshot of the examples of a failure highlighting a defect. This simplifies the work of an engineer who fixes the issue.

Relevant information. Always verify whether or not the bug can be reproduced to avoid non-reproducible bugs.

The latest automated testing tools have built-in integration with bug-tracking systems. They can automatically report the bugs and track their status. There are also separate bug reporting tools like JIRA or Mantis.

Conclusion

If you want your company to be competitive and achieve a winning position in the IT industry market, you must produce very high-quality products. Improving the quality of software products will have the biggest overall impact on your business and its financial performance. When managing your work processes don’t save on testing, as the cost of mistakes may prove to be too high. Consequently, your quality strategy should cover all key aspects: effective planning, test-oriented quality management approach, and a dedicated QA team.

Liked the story? Clap for us so more people can find it! 👏
Originally published at AltexSoft’s blog: “6 Ways to Improve Software Testing through Planning, Work Environment, Automated Testing, and Reporting”