Automation Testing in CI/CD Pipelines: Types and Stages

Get a rundown of the stages involved in testing as well as best practices and tools to integrate it within your CI/CD pipeline.

In this article, we will address integrating tests in a continuous integration/continuous delivery platform.

Let’s start with the basics first.

What Is Automation Testing?

Software testing refers to the execution of tests according to a set of test cases and comparing the results of actual and predicted outcomes. Several steps and testing techniques are followed in the process. Testing is essential to ensuring the quality of the product. This process is typically done manually by a team of testers. However, in automation testing, the process is automated using software tools and technology. Here, rather than resorting to a manual effort, scripts are created and test cases are run automatically. Automation testing eradicates many problems such as human error, coverage area, etc. It also saves time and enhances the ease of conducting tests with increased efficiency and effectiveness.

Automation Testing in CI/CD Pipelines

Automation testing is a core part of CI/CD pipelines because tests that run fast can provide early feedback to the developer. A problem or a bug that is identified early has the possibility to be rectified early. Therefore, the released product will be more accurate and bug-free. This enhances the overall quality of the product, which garners customer satisfaction. To put it succinctly, the advantages of automation testing in the CI/CD pipeline are as follows:

  • Aligns with the CI/CD idea of “build fast, fail fast”
  • Reduces manual effort, which saves time and the possibility of error.
  • Test results are more accurate with the increased number of test cases and can and cover a wider area.
  • Get immediate feedback on any problem
  • Multiple test results can be generated and compared to ensure quality and consistency

Types of Automation Testing Used in CI/CD Pipelines

  • Unit testing: It is a low-level test undertaken after a module has been coded and reviewed. Test cases are designed to test individual components. The purpose is to make sure each component works the way it is supposed to under any circumstance.
  • Integration testing: Integration refers to testing the interaction of components within the application. This testing is carried out after all the modules have been unit-tested. The primary objective is to test the module interfaces and check that there are no errors in parameter passing when one module invokes the functionality of another module.
  • System testing: Tests are designed to validate a fully developed system and make sure it adheres to the requirement specification document. Typically, at this stage, software is ready for use by potential users. These kinds of system tests are called alpha (carried out by a team of developers within the organization), beta (performed by a selected group of users/customers), or acceptance testing (performed by users/customers to determine acceptance of delivery of the system).

What Are Continuous Integration and Continuous Delivery?

In simple terms, continuous integration allows development teams to integrate their code into a shared repository. This helps maintain code quality and identify potential issues with the local version of the code at an early stage.

Continuous delivery is often called “Continuous Deployment” as well. Everything that is continuously merged by the development team is continuously deployed to the live environment.

Since most developers work in parallel, continuously integrating their code into one repository would mean that the master branch is continuously updated with new features. To ensure that there is no compromise in the code quality with so many changes happening rapidly, testing must happen at the same pace.

It should be no surprise that manual testing in this environment would not be the best approach to achieve this. Automated testing is the key to successful testing in a CI/CD pipeline.

9 Continuous Delivery Stages

  1. Develop: The developer builds the code according to the project requirements or the feature requests.
  2. Writing tests: Once the code is written, tests need to be written. At this point, these tests are usually unit tests written by the developers.
  3. Local Testing: This is then locally tested to check whether all the tests pass and to ensure the code does not break. Often, a percentage is set as the pass rate that the tests running need to meet.
  4. Rebase and Resolve conflict: In an actual development scenario, there will be multiple people merging their code. Developers need to make sure that their branch is updated at all times. Updating the branch with the latest merged code is called “rebasing.” Once it’s rebased, there will likely be some conflicts that need to be resolved. After that, the tests are run again against the rebased code.
  5. Commit: Once the tests have passed, the code is then ready to be committed with all the changes.
  6. Build: The source code developed is then combined to build a deployment artifact that can be run on an instance, like the server if the environment is on-premises. This code is now ready to be deployed to different testing environments.
  7. UAT: The code is then deployed to a test server where testers start to test the feature. These tests can be automated as well as manual.
  8. Merge: If the commit that’s under testing is approved by the testers, this is then merged into the master branch.
  9. Production deployment: Once the code is merged, it is then deployed to production.

The above process needs to be done with every build coded by the developers.

Where Does Automation Testing Fall in This CI/CD Pipeline?

Automated testing ideally happens once the build stage has been completed and the code can be deployed. Unit tests, UI tests, and integration tests can all be run at this stage. These tests help in ensuring that the code meets a standard of quality.

This phase can last from a few minutes to a couple of hours depending on how the automation is architected.

Tests can be run in parallel to execute them more quickly. If a code fails during the test phase, the build can be rejected without further investing in any manual testing time.

Tools Used for CI/CD

  • Jenkins: Jenkins is an open-source tool that is used for continuous integration. It’s free to use and jobs can be configured both by the interface as well as scripts.
  • Travis CI: This tool is free of cost for open-source projects, hosted by GitHub.
  • Gitlab: Gitlab is a version control tool that has its own cloud-based CI methodology. It is supported on multiple platforms which have both free and paid versions.
  • Bamboo: Bamboo is a CI tool by Jira. If your organization uses Jira, then it would be beneficial to check this tool out. It supports automated merging on approval of tickets as well.

Best Practices for CI/CD Pipeline to Make the Best Out of Test Automation

  • Incremental changes: It is always advisable to follow a feature-by-feature approach. If the feature is really big, it is good to break it down into smaller and quicker-to-test features. This is important in terms of automation because if there is an issue, it is easier to figure out the root cause. If your commit is too big, isolating the cause of an issue would be a tough task.
  • Identify what can be automated: It is very common for teams to dive fast and say, “Let’s automate everything,” but this is a common mistake. We must know the purpose of automation and identify the test cases that should be automated.
  • Parallel Tests: Tests should be run in parallel to make testing more efficient and timely. It can greatly reduce the time taken to run tests and thus give the results much faster. But it’s not sufficient to just execute these tests in parallel; it is also important to scale the server size where the tests are running in order to actually make them faster.


Automating tests is an important part of the successful deployment of projects while maintaining a standard of quality. Ensuring tests are run at every stage gives good transparency on the quality of the code. Bugs can be discovered at an early stage, and any delays that might be caused by them can be addressed promptly. Having a CI/CD pipeline with integrated tests helps in speeding up the testing and deployment process.

This article was written by: Joyce Prabhakaran

What is DevOps?

This article is a beginner’s guide to DevOps. Know more about DevOps practices, the role of DevOps in engineering teams, and their benefits.

DevOps is a mix of Development and Operations that combines people from a distributed stack and tools used to create efficient applications with the development process to enable faster delivery of quality products.

By bringing together the people, tools, and processes, DevOps enables rapid development and delivery with a scope of incremental features added to the product.

DevOps toolchain

How Does DevOps Work?

The DevOps model combines the Development teams and Operations teams to bridge the gap between the ‘siloed’ processes. Sometimes people across these processes work in a combined team to develop and deliver faster to achieve business goals. Simply put, a single team consisting of developers having skills in coding, deploying (using various tools and applications), and maintaining the application working together over the development life cycle to deploy a product faster. Incremental features are added to the application to keep it up to date with the latest trends for customer satisfaction.

What is the Role of DevOps?

DevOps enables a combination of major parts of application creation, namely development, quality, deployment, and security, into one single process using various DevOps tools to enable faster delivery of applications.

The Benefits of DevOps in Your Engineering Team


Due to a multitude of skills in the same process working together, product delivery is faster. It is easier to add updates and features to stay up to date with market standards and maintain quality and customer satisfaction.

Rapid Delivery

Due to increased delivery speed, faster releases of new features are possible. Hence fixing bugs, adding/updating features, and adding to products based on market needs and customer feedback is now possible, enabling applications to deliver effectively in competitive markets.


Due to faster delivery, DevOps practices like continuous integration and continuous delivery allow software reliability, i.e., new features ensuring quality is rapidly added to the application while users continue to get a smooth and quality experience.


Due to rapid delivery and reliability, add to your application to make it scalable as per business need without compromising the user experience.

Improved Collaboration

As the developers and operations teams share responsibilities to achieve faster delivery, collaboration improves. Teams can add and improvise based on shared responsibilities, reducing the wait time between handovers and dependencies.


DevOps provides a range of security and compliance testing/managing tools so that you can improvise your application without sacrificing security.

The Benefits of DevOps in Your Engineering Team

Terms of software have changed from supporting a business’s online presence to becoming a key aspect of the business. In such a market, an application must stay up to date with the latest demand and dynamically adapt to trends to promote the business and achieve customer satisfaction.

The DevOps model allows the flexibility to deploy a business-ready application faster and add or update the application based on customer needs. By closing the gap between various parts of the application development process, DevOps enables fast deployment of high-performance, rapidly enhancing, and secure applications.

Adapting DevOps with the right tools and the right mindset is important to implement and utilize the DevOps model successfully.


DevOps Practices

DevOps is an evolving model that adapts to organizational needs based on varying strategies. The agile mindset supports DevOps and an iterative development model. A few DevOps models are Agile, Scrum, Kanban, etc.

Continuous Integration

Changes are continuously made to the code base, and new code is added based on new requirements, customer feedback, etc. Builds and tests are automatically run to ensure the changes are per required standards and adhere to previous functionality. Continuous integration provides all developers access to the code base, with new changes regularly rolled out, allowing easy refactoring wherever needed.

Continuous Delivery

As the code base is updated, builds and checks are performed to check it’s working. The code is then moved to a pre-production environment and tested until it is ready for production. Therefore, a production-ready code is always present with the team, with new updates added frequently.


Microservices architecture breaks down a single application into small services that interact with each other over a secure network. Each service independently runs its process while communicating with other microservices to complete a larger task. As each microservice can be deployed independently, updates can be rolled out faster, and bugs can be pinpointed and fixed quickly.

Infrastructure as Code (IaC)

Infrastructure as a Code allows users to manage and implement the infrastructure in the form of scripts or code that can be managed just like any other code change. Version control, frequent updates, and reverts are a few features of an IaC practice. Terraform is an example of an IaC tool that is used to manage the entire infrastructure lifecycle of an application.

Being an easily scalable infrastructure can be managed as per requirements.

Monitoring and Logging

As the applications are used 24/7 throughout the globe, actively monitoring the application for user activities, discrepancies in functionality and unexpected errors, etc., have become more important. By Logging and Monitoring, teams can set up alerts for specific errors, manage infrastructure and software working, and pinpoint bugs and errors faster.

Communication and Collaboration

DevOps culture encourages communication and collaboration by bringing together people from different workflows of Development and Operations. Communicating requirements and challenges amongst teams and effectively collaborating to resolve and deploy them is part of the DevOps team model. Proper tools for communication amongst teams are needed to achieve this goal.

DevOps from Integration to Deployment

DevOps Toolchain

A toolchain is a set of tools used in the programming world to achieve business goals. DevOps also uses such programming tools to collaborate and coordinate between developers and operations engineers. Using them, teams can program, test and deploy applications faster. These tools have various purposes, from communication and versioning to automated pipelines for quality checks and deployments.


Planning is the first step of any project. Determining the business plan and requirements and then breaking them down for the development teams to take up is a part of the planning process.

A few tools used for planning include – Git, Jira, etc.


After planning, this is a part of the execution phase where the actual development of software is implemented based on the design.

Tools used for coding include – GitHub, GitLab, Atlassian, Bitbucket, etc.


Unlike before, where developers had to run builds and checks on code manually, the automated builds are configured and run in this phase. Checks, like code quality, can also be added to the build along with simultaneous deployment.

Tools used in this stage include – Docker, Jenkins, Gradle, Maven, etc.


Testing is an integral part of the development process. In this phase, the code is tested manually or through automation.

Tools involved in this phase include – JUnit, Selenium, TestNG, Soap, etc.


This phase includes the deployment of software by automated releases to production. Deployment builds are scheduled, coordinated, and then run to complete this process.

Tools used in this phase include – Jenkins, Kubernetes, Docker, etc.


The managing of software during production comes under this phase.

Tools supporting this phase are – Ansible, Powershell, Puppet, etc.


As the application remains deployed, it is important to monitor the application to catch any errors or bugs that may occur at this phase. Any bug or problem can be isolated quickly using various monitoring tools.

Tools used in this phase include – Grafana, Splunk, Datalog, Wireshark, etc.

List of DevOps Tools

Various tools are used to achieve the DevOps goal of bringing development and operations together. While the tools do not define DevOps, they help greatly in automating processes which is another DevOps goal. 

With the help of the right tools, a team can easily coordinate and collaborate to reduce the gap between requirement generation and deployment.

What is the Shift Left Principle for DevOps?

During any normal development cycle, changes are made to different modules, which are later clubbed together and tested to implement complex business goals. In this process, integration testing gets performed at a later stage, where issues may get detected as the software comes together. Bugs, errors, and other cross-platform dependency issues get detected at a much later stage, where the process to resolve them is then rushed to achieve set deadlines.

The ‘Shift Left‘ principle in DevOps refers to shifting the testing, mainly integration testing, into the earlier stages of development and adding to the tests as requirements get implemented.

This requires a cultural change in thinking of business where code is the main priority. Many organizations are now using this approach to detect issues at earlier stages, saving a lot of time and maintenance at later stages.

Test-driven development in Agile focuses on testing and writing the test cases based on the requirements and then adding code to support. Similarly, the Shift Left principle focuses on integration testing in the earlier phases of the development lifecycle to achieve a combined goal.

‘The Shift Left Principle and DevOps’ go into more detail on the reasoning, history, and proper implementation of the Shift Left principle.

Agile Project Management

What is DevSecOps?

The DevOps model enables teams to work together and deliver at a faster speed while overcoming the shortcomings of Agile.

Security is something any application should not compromise on. Developers implement changes by keeping the security of the application in mind. Secure infrastructure, communication between services, and possible data leaks in code security are each important parts of the development, testing, and deployment process.

DevSecOps is a term that adds security to development and operations. As security is made a part of the development process from the beginning of the process, secure and reliable applications can be developed faster. New changes can be added as per business needs and customer feedback.

DevSecOps aims to integrate security in every phase of the development lifecycle. Hence instead of security as just being a parameter to take care of, applications are built in a way where security is considered right from the planning stage. This results in secure applications from the very beginning instead of adding security later and making modifications to completed code as per requirements and found vulnerabilities.

What Are the Differences Between DevOps and SRE?

SRE or Site Reliability Engineering focuses on automation or completing tasks generally done by the operations team via developers or Ops engineers who use a set of tools or software to automate tasks. This brings together most of the operations performed, eliminating the need for a separately managed part of a project hence bringing together the modules under software development.

While SRE focuses on automating operations, DevOps focuses on bringing the development and operations teams together. Both teams have a clarity of requirements and changes made by the other team hence bridging the gap between different processes and time required to coordinate the information and sync the release cycles.

DevOps and SRE have a common goal of eliminating the traditional methods of separation and bringing together dependent processes into one single process. However, there is a difference in how DevOps and SRE go about achieving this goal.

DevOps Glossary

Agile. A software development methodology based on a repetitive cycle of planning, development, testing, and deployment.

Automation. Configuring a process/task to run itself rather than manual execution.

Deployment. In the development paradigm, deployment refers to planning, developing/configuring, testing, and then getting a change running in the specific environment for users to use.

Integration. Integration refers to bringing together various modules to function as a single system.

Releases. Releases are periodic updates or the latest versions made available to the end users.

Refactoring. Changing or updating already existing functionality or code to make improvements or add new updates while maintaining the same behavior.

Siloed. Isolated or separated from other counterparts.

Versioning. Versioning is assigning unique names/numbers to different versions of the same product.


DevOps has gained a lot of popularity in recent years. With Agile organizations switching to the cloud for all their needs, DevOps has gained more attention as it is a means to achieve faster deployment. Security has also been the main concern for organizations adopting DevOps, leading to the term DevSecOps.

Note This article is written by Anand R Mehta and Srikarthick Vijaykumar

HTML attribute style tutorial ( inline styling vs css )

HTML lesson on style attribute . How to do inline styling in HTML
Difference between inline styling and css ( cascading style sheet )

A very basic introduction to style attributes in HTML

– How to write attribute in html
– HOw to write style attribute
– How to write multiple styles in a single line
– How to write inline styling
– When to use inline styling
what is the best way to use inline styling.
– css ve inline styling

Please like the video, subscribe for future tutorials and provide suggestions.

Techsith admin

Introduction to html tutorial for beginners

Welcome to techsith web development tutorials.

This is a very basic introduction to html language. You will lean following .
– What is HTML stand for ?
– What is a markup tag ?
– What is an HTML element ?
– Opening HTML tag
– Closing HTML tag
– HTML elements without content
– Nested HTML Tags
– basic HTML structure
– Tags : paragraph = p , break = br , html , header , title , body , footer

Checkout our next tutorial
– Writing your first html code.

Please like the video, subscibe for future tutorials and provide suggestions.

Techsith admin

javaScript tutorial basics fundamentals ( data types string numbers objects null undefined )

In this tutorial we learn javascript from the beginning. I will be using code playground such as to show you live code examples covering following topics

– Javascript how to define a variable
– Javascript how to define a string
– Javascript how to define a number
– Javascript how to define a object
– Javascript how to define a null
– – Javascript what is undefined?
– Javascript what is null?
– Javascript how to write hexadecimal, octal, floating point, double, Boolean ,
– – Javascript how to add properties to an object
– Javascript how to properties to an array

JS, Javascript, java script, java script tutorial , javascript tutorial, js tutorial, HTML5, techsith, learning javascript, javascript 101, javascript how to get started, Javascript introduction, javascript fundamentals,

css property display block inline none initial ( HTML5 css3)

CSS3 property Display

– What is CSS3 display property
– CSS display property values ( block, inline-block, inline, none, initial)
– CSS Display property Default value
– CSS User Agent Stylesheet

Css Display property, html display property, css display properti, css display property tutorial, css display property inline, inline-block, display:none, , css3 , html5, javaScript, html css display property, css display, css display, css display none, css display block,

css id vs class attributes, when to use id and when to use class, difference between id and class

css3 id vs class attributes,
when to use id and when to use class,
difference between id and class in css
css benefits of using class over id, css3 benefits of using id over class, html id vs class, css id vs class, html class vs id, css class vs id, The Difference Between ID and Class, id vs class tutorial, difference between id and class tutorial,The Difference Between class and id
HTML5, CSS3 and JavaScript Tutorials , lessons with examples.

id vs class more of a design related question and its a very important one. Overall you will be using more classes then ids.

id: think of element that is unique. there is only one id per element. your html validateor would throw and en error if you do use it which means you will not be reusing the same style anywhere else. all the main containers in your HTMLs you should use id because you are not going to repete them . That doesnt mean that you cant use class there. advantage of using is for is as your main namespace. for css this way you can segregate work so your css doesn’t messup. for example #leftContainer .button { color:red} which mean all the botton in the left containers are red.

class: you can used them freely. any common styles you can define as class. as you can have multiple classes for the same element. and mix and match of the classes will make your css small . for example you can create two divs with same color but diffrent font sizes.

Dont forget the attributes. actually id and class are attributes wich special meaning. and you can create your own custome attributes. like myattr. Platforms like angularjs uses them freely.

overall i thin its better to use classes then ids especially when you working in a team envirement where you are responsible for a partial html . using id can be riskier if someone else is using the same id in the other part of the html .

in css id has higher priority than class for example …..

CSS introduction ( Cascading Stylesheet ) + CSS3

Basic intro to CSS and CSS3 ( How to do inline styling in HTML
Difference between inline styling and css )

A very basic introduction to CSS in HTML

– How to write style attribute
– Difference between inline styling and CSS
– How to write CSS in a separate (.css) file and include it into your HTML header.
– Next tutorial covers CSS selectors.

Please like the video, subscribe for future tutorials and provide suggestions.

Techsith admin
Your Home to simple and intuitive HTML Tutorials