Using Containers for Automation Testing

All managers think containers are what they want, but very few teams know what to do with them. The containerization of your resources will change the way your company thinks about testing when executed thoughtfully.


The days of holding x different computing environments with y different configurations are over. Imagine, instead, for just as long as you need it, spinning up only the code you need, on the sort of system it needs. Your teams will reduce cycle time significantly while also improving overall product quality.


This technology has become a key element of digital business transformation ever since Docker started popularizing containers about five and a half years ago. Containers have become an increasingly common option due to characteristics such as portability, highly efficient sharing of device resources, and wide support. In reality, a Forrester study found 66 percent of organizations that had implemented containers experienced accelerated developer productivity in March 2017, while a modest to a substantial increase in application deployment speed was achieved by 75 percent of enterprises.

What Is A Container?


In its simplest form, a container is a collection of code, configuration, and runtime dependencies, all packed on a virtual machine together with an execution engine, as shown below:



The Docker platform currently has most container requirements (although there are several different container orchestration engines, of which Docker Swarm is only one).


It's as easy to construct a container as to run a source control build to generate an executable, bundle that with a specified system image, and tell Docker to start. As a guest operating system on the server, Docker then spins the container, with the required program running and ready for use.


FROM linuximage:version1 as base


FROM code-build:dev AS build

WORDIR /code/src/MyApp

RUN dotnet build MyApp.csproj -c Release -o /app FROM build AS publish
RUN dotnet publish MyApp.csproj -C Release -o /app FROM base AS final
WORKDIR /app COPY -from=publish /app .
ENTRYPOINT ["dotnet", "MyApp.dll"]

In order to make a complete application, engineers may determine that several services must be composed together along those lines. They can string together as many resources as possible using many Docker files — each from either a construct or from a trusted published source.


Using Docker Compose, engineers can build any kind of environment that might be necessary, locally, on-demand, and with exactly the same version and dependencies of the OS as they would have in production.



image: code-build:dev
dockerfile: Dockerfile myapp:
image: myapp:dev
condition: service_started
dockerfile: src/MyApp/
image: "


Using The Containers In The Test Environments


As has encountered for every software tester, research environments are a mixed blessing. They allow end-to-end tests, on the one hand, that would otherwise have to be performed in development.


Testing teams will ship code that has not been checked across functional boundaries to users without a test environment and hope for the best. A well-configured and preserved test setting, one that closely mimics output and includes up-to-date code implementations, will provide testers with a secure and stable way to verify a scenario before it gets into a customer's hands.


Problematically, however, research environments are promoting an increasingly obsolete mode of development: long integration cycles, an untrustworthy primary source trunk, and late-stage testing.


Just the opposite is achieved by the most efficient, best-performing engineering teams. They need to be able to trust the code might go into production at any time in the main trunk. They also turn left to consistency, with most testing going on before a code even changes lands. They seldom have time to "integrate" changes in days or weeks and test them in a QA setting.


The highest-performing teams realize the sooner a bug is detected in the development phase, the cheaper it is to fix — and they want to help other developers quickly find bugs.


Also, test environments tend to be difficult to manage, often have mixed or special configurations, and in either operating system or dependency versions rarely resemble their production counterparts. Updating a test environment is normally at the very bottom of a priority list for a QA or Operations team.


Benefits Of Container


You get a well-maintained test environment for containers, without the detrimental consequences for the production phase of a team. Test engineers can spin exactly the utilities and dependencies that will be required in production on their own development machine but with their own code deployed at the top.


They can evaluate this code entirely, not only at the level of the device but also at the level of integration. They can also conduct specialty tests on the code – such as visual validation of the user interface or security scans – and feel assured that what they are testing is the same as what will be implemented in production.


Also, with a colleague or dedicated tester, an engineer can share access to the facilities, which can then have a second set of eyes on the shift before giving signoff.


Orchestration: Automating Container Process


Orchestration refers to software systems and services that automate and orchestrate key IT and business processes to help IT staff simplify and streamline operations management. Orchestration can free IT from the responsibility of handling a range of mission-critical but often complex tasks and processes by Automating Testing the configuration, management, and interoperability of various computer systems, applications, and services.




Kubernetes is a portable, extensible, open-source platform to manage containerized workloads and services which facilitates both declarative configuration and automation. It has a broad ecosystem which is rapidly increasing. There is ample availability of Kubernetes services, support, and software. 


The word Kubernetes has its roots in Greek, meaning helmsman or pilot. In 2014 Google open-sourced the project Kubernetes. Kubernetes blends Google's experience of operating production workloads on a scale for more than 15 years with best-of-breed group ideas and practices.


Kubernetes automates the containers, in essence, handling the load between them by spreading it strategically. While working, Kubernetes manages to spread the load to other containers if a container is down due to heavy loads.


The key feature of Kubernetes is to simplify the use of containers in App deployments. Implementation begins by specifying the nodes that Kubernetes can control your containers within, identified as physical or virtual machines, such as AWS, MS, or Google cloud hosts. There are pods, beyond nodes, that are the containers and clusters that Kubernetes orchestrates for you. In reality, containers are simulators holding the OS and running an instance of the software and can thus simultaneously asynchronized as many apps as the system can physically accommodate.


Since we recognize that development, testing, and deployment are interconnected, it is necessary to be prepared to accept that in testing as well. Let us explore the advantages of using Kubernetes containers and clusters in automation research:


  • Quick- The selenium containers can be deployed as and when needed. 


  • After the test finishes, Short-Lived- Selenium containers are lost. 



It may seem like a daunting challenge to containerize established services, but the advantages saved in time from no longer managing countless test environments or debugging problems in development far outweigh the initial investment. The sooner you can find bugs in the development cycle and the further left you can drive the testing of software, the more changes you can see in the quality of the code, but for all your engineers as well in the quality of life. It helps in creating a world where a tester will work in a precisely similar environment as a developer, and where a shrug and a dismissal of "works on my computer" are not regularly met with a bug report.


Containers and Kubernetes help in testing a large number of test cases and where there is a lot of testing required. These are really useful tools in the agile methodology where there is a need of loads of testing.  


Soft Tech follows best practices to ensure the quality of the code during quality assurance phase. Each project is exposed to vigorous automated testing. Please feel free to Contact us for your project idea.

Facebook Linkedin