The idea of continuous testing has been brewing as a new paradigm for complementing DevOps, continuous integration and continuous deployment CI/CD. While CI/CD promise faster software, the enterprise risks its brand reputation and financial impacts if this speed does not come with better software quality. Implementing processes around continuous testing can help maintain quality at a much faster pace. Here are 12 resolutions enterprises can adopt in 2018 for making continuous testing work, some even with Service Virtualization.
Assess what continuous testing means for your organization
Continuous testing involves more than just adopting new tools or buzz words. Its a paradigm shift that involves all the different teams involved in creating new business value through software. Its easy to get stuck on finding software defects faster. But the real value lies in getting everyone to open their eyes to defects in stories, specifications, development, delivery, experience, and profitability. This could start with simple conversations at the coffee station, a slack channel, or more formal general meetings. It may also involve looking at dependencies in software development workflows, many of which can be reduced using tools like service virtualization that reduce wait times for pre-configured testing environments.
Inventory test automation gaps
Continuous testing is only practical to the extent that the testing part is automated. And some kinds of exploratory testing require a kind of creativity that is difficult to automate. A good starting point for a continuous testing journey lies in assessing how applications are tested, and how much of this process involves manual configuration or implementation. Frequent testing tasks, like integration testing, are good candidates for adopting better tools to automate more of these processes. For example, the use of service virtualization can help reduce the constraints to doing integration testing across new services.
Improve the lines of communication
Good communication is one of the biggest challenges with reliably and efficiently finding and remediating software defects. It’s human nature to look for someone to blame when a problem emerges, which creates a focus on hiding problems rather than revealing them. Its important to focus on how to fix bugs or the bad processes that caused them, rather than blaming people. Service virtualization can help by providing an objective way to streamline communications about the state of services as they are implemented across teams.
Prioritize quality over speed
Its easy for many organizations to become fixated on releasing software faster to keep up with nimble competitors. But as the recent State of DevOps report emphasized, this only causes many organizations to fail faster. Continuous testing requires a shift towards finding defects faster. Its important to focus on building better software first, and then using various test automation tools to accelerate this process. Once this in place, it becomes easier to build better software faster. With Service virtualization you can have both quality with speed. It can help improve quality earlier in the software development lifecycle in a way that improves development pace saving time as well. https://puppet.com/resources/whitepaper/state-of-devops-report
Hidden dependencies create bottlenecks to adopting continuous testing, and there are a lot of them. These can include testing environments, availability of services, specialized personnel, data configurations, and the availability of new services. In many cases, tools like service virtualization can help reduce these and many other dependencies, so that more of the software testing lifecycle can be automated.
Manage test environments
The 2017/2018 World quality report notes that about half of all companies don’t have a solution to manage their test environments. The lack of test environments wastes time and resources and results in more software defects. You should investigate how your testing environment is managed today, with an eye towards building a cohesive architecture for managing all components of the testing process in a unified way. This could involve developing an architecture for managing test environments across tools, or adopting a unified environment across the software development lifecycle. Tools like service virtualization could help improve the configuration and deployment of these tests with greater agility. For a more in depth look at the World Quality Report. https://www.capgemini.com/service/world-quality-report-2017-18/
Test your tests
Test automation only works when tests are stable. If tests break, then developers and QA teams must build manual kludges to work around these defects, or customize tests. Test defects need to be logged and fixed just like regular software bugs. Service virtualization can replace dedicated hardware and automate service configurations required for a specific test. This makes it easier to test the tests more quickly and thoroughly.
Decouple your systems
According to the recent State of DevOps Report, decoupled architectures were one of the biggest contributors to an enterprises ability to create new value faster. Part of this seems to be related to decoupled systems and another part to decoupling of communications in organizations. Decoupled systems mean that organizations can incrementally add value faster in order to do new business experiments. But this introduces challenges with testing out how the new code for delivering value works with the other components in the architecture. Fortunately, tools like service virtualization can make it easier to identify these problems earlier in development when they are easier to fix.
For a peek at the report. https://puppet.com/resources/whitepaper/state-of-devops-report
Architect for testing
Testing and automation need to be priorities in delivering quality faster. This requires design, architecture, processes to make it work. A good starting point is to craft an architecture for testing, just like many enterprises craft and architecture for deployment. It is important for this architecture to include considerations about how the testing process is managed across different roles in the software development chain. Service virtualization and help to bridge many of these gaps. Different people in the organization can leverage a library of standardized services and configuration setting required for specific types of tests. This helps keep everyone on the same page whether they are debugging code or doing integration testing.
Integration as a forethought
Just because new code passes unit tests, does not mean it will integrate well with other software components. A good practice is to ensure that cade is always ready to be integrated. One way of doing this is to run integration tests during development and on a pull request basis. This ensures that once it is integrated, it is ready to be delivered to customers. Service virtualization creates virtual services representing live services application code is likely to be integrated with. These services are easier to spin up and can be configured for integration tests, which reduces the risk that integration with a live service will fail.
Its easier to build quality software when it’s the entire teams responsibility rather than having separate teams involved in development, testing, and release. This requires making automation a priority so that developers can increase the amount of time writing new code rather than looking for problems. This approach can help avoid long back and forth cycle times between QA and development, and allow developers to fix problems when the project is fresh in their minds. Service virtualization can help automate many aspects of this “earlier” testing.
Shrink the feedback loop
DevOps is all about improving the feedback between new business ideas and application delivery. When code sits in testing for long periods, the feedback loop can drag on and makes it more difficult to adjust the implementation of a new business model. Service virtualization allows developers to test new code using simulated services, rather than having to wait for dependent systems to become available. They can also reduce the amount of time required to configure a service for a particular test. This means that new code can go into production faster, which also speeds the feedback regarding the impact that new apps have on business.
Just like in life, you can’t expect to do everything all at once. So, don’t expect to implement continuous testing all at once either. It involves more of a journey and requires buy-in from all stakeholders in the software development process. Tools like service virtualization can help reduce the dependencies that creep into software development. However, it is important for developers and testers to explore how this can aid their own efforts in continuous boosting software quality.