Creating End-to-End Web Test Automation Project from Scratch — Part 6

Welcome to the 6th part of the blog post series called “Creating an End-to-End Web Test Automation Project from Scratch.” It was a long series, I know. But we are in the final round! So please, just bear with me! 🐻

So far, we have covered many topics, from the creation of a project to integrating it with CI/CD pipeline. If you need to review the previous chapters, you can find the articles at the links below.

• Let’s Create and Configure Our Web Test Automation Project!

• Let’s Write Our Test Scenarios!

• Bonus: Recording Failed Scenario Runs in Ruby

• Let’s Configure Our Web Test Automation Project for Remote Browsers and Parallel Execution

• Let’s Dockerize Our Web Test Automation Project

• Bonus: Recording Scenario Runs on Docker with Selenium Video!

• Let’s Integrate Our Dockerized Web Test Automation Project with CI/CD Pipeline!

• Auto-Scaling and Kubernetes Integration with KEDA

Auto-Scaling and Kubernetes Integration with KEDA

You will make a magic touch, which will enable you to auto-scale your Selenium Grid with the help of KEDA, Kubernetes Event-driven Autoscaling. KEDA will help you scale your nodes not according to CPU or RAM usage but according to the queue size of our tests to be run! Now, if you are ready, let's get down to it!

Minikube Installation

First you are going to install minikube to create a kubernetes instance in your local machine.

Let’s install minikube with brew:

brew install minikube

If you do not want to use brew or if you have another OS, you can go to the official minikube site and install it by choosing our OS and CPU Architecture type.

Now let’s start minikube:

minikube start --vm-driver=docker 

Here, the –vm-driver is the driver type of which a minikube can be deployed. For MacOS, Docker is recommended. See the full list of drivers for minikube.

After successfully starting your minikube, browse your dashboard with:

minikube dashboard

It will automatically open the dashboard on your default browser:

Now since you have your kubernetes up and running, let’s add your Selenium Grid and your Nodes to your Cluster!

Grid And Node Yaml

For your Grid and Node configurations, you will use example yaml files for these in the official Kubernetes GitHub repository. Let’s navigate to this repository. You need to download these three yaml files:

- selenium-hub-deployment.yaml => To deploy selenium hub.

- selenium-hub-svc.yaml => A service for nodes to connect to the hub.

- selenium-node-chrome-deployment.yaml => To deploy Chrome node.

In selenium-node-chrome-deployment.yaml, let’s change replica count to `1`.

Note: If you have a computer which has Apple Silicon with Arm64 Architecture, you need to make these small changes in the following files as well:

In selenium-hub-deployment.yaml file, change the container image to `seleniarm/hub`.

In selenium-node-chrome-deployment.yaml file, change the container image to `seleniarm/node-chromium`.

Now let’s connect them to your k8s cluster.

kubectl create -f selenium-hub-deployment.yaml

kubectl create -f selenium-hub-svc.yaml

3. Node Deployment:

kubectl create -f selenium-node-chrome-deployment.yaml

Now let’s check if your deployments are successful with the command below.

kubectl get deploy  

If your deployments were successful, you should see something like below.

Now let’s check your service with:

kubectl get services

You can see your service as well:

Now let’s find out the url of your grid with the command below:

minikube service selenium-hub --url

Your grid is on one of these ports below. Usually the first one:

After entering correct port, you should see something like this:

Next, you will configure KEDA.

KEDA Yaml Configuration

From the KEDA releases page, download the latest KEDA version. At the moment of writing this blogpost, the latest version is 2.10.1.

And you need to create a scaled-object for your Chrome node. Let’s create a file named scaled-object-chrome.yaml and populate it with the code below:

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: selenium-chrome-scaledobject
  namespace: default
  labels:
    deploymentName: selenium-node-chrome
spec:
  minReplicaCount: 0
  maxReplicaCount: 4
  scaleTargetRef:
    name: selenium-node-chrome
  pollingInterval: 1  
  triggers:
    - type: selenium-grid
      metadata:
        url: 'http://selenium-hub.default:4444/graphql'
        browserName: 'chrome'

In here:

- minReplicaCount is the number of replicas when there are not any tests in the queue.

- maxReplicaCount is the max number of replicas when the activation threshold is reached. In this instance, this means that you won’t have more than 4 Chrome nodes no matter how many tests are in queue.

Now let’s integrate them into your Cluster.

kubectl apply -f keda-2.10.1.yaml

After that, let’s apply your scaled-object. Since your Chrome deployment in the default namespace, you will apply your scaled-object to there too.

kubectl apply -f ./scaled-object-chrome.yaml --namespace=default

Now give it a few moments and check your Selenium Grid again:

No nodes!? Why? Because you configured your minReplicaCount as 0. So when there aren’t any tests in the queue, KEDA scales down your nodes to zero. Now I call this resource management!

Okay, let’s change the remote_url variable in the test automation project to our current Selenium Grid Port, which is 64824 in this instance, and run 8 tests in parallel with the `parallel_cucumber -n 8` command. And let’s see what happens.

Now that’s it! You have a grid that is auto-scaled with the help of Kubernetes and KEDA!

This is the end of a long journey. Thanks for bearing with me with this eight-chapter-long blogpost series. 

Before closing up, let’s summarise what you have accomplished so far:

✅You created a test automation project using Ruby - Capybara - Cucumber and Installed all dependencies.

✅You learned how to write CSS selectors.

✅You wrote test scenarios to be used on your test automation project. 

✅You recorded failed test scenarios as video files in Ruby.

✅You used remote connections to run your tests in different machines.

✅You used Selenium Grid and ran your tests in parallel.

✅You dockerized your test automation project so that it can be run in any environment.

✅You recorded failed test runs in a Docker container using Selenium Video image.

✅You integrated CI/CD pipeline to your project by using Jenkins.

✅You configured auto-scaling for your project by using KEDA.

Hope to see you in upcoming sprints!