Setting Up Jenkins for Selenium Automated Tests with Python

Prerequisites

Step-by-Step Guide

1. Install Selenium and WebDriver

pip install selenium

2. Configure Jenkins

3. Set Up Git Repository

4. Add Build Step

For Linux/macOS:

# Navigate to the directory containing your tests
cd /path/to/your/tests

# Run your tests
python -m unittest discover -s ./tests

For Windows:

:: Navigate to the directory containing your tests
cd /path/to/your/tests

:: Run your tests
python -m unittest discover -s ./tests

5. Schedule Build Triggers

6. Save and Build

Setting Up GitLab CI for Selenium Automated Tests with Python

Prerequisites

1. Install Selenium and WebDriver

pip install selenium

2. Create .gitlab-ci.yml in your project root

image: python:latest

before_script:
  - pip install selenium

stages:
  - test

test_job:
  stage: test
  script:
    - cd /path/to/your/tests
    - python -m unittest discover -s ./tests

3. Commit and Push

git add .gitlab-ci.yml
git commit -m "Add GitLab CI configuration for Selenium tests"
git push origin main

4. Run Pipeline

Conclusion

You now have practical setups for running Selenium automated tests with both Jenkins and GitLab CI using Python.

Installing Selenium and WebDriver

1. Install Selenium

In your terminal or command prompt, run:

pip install selenium

2. Download WebDriver

For Chrome:

3. Setting Up Python Code

Create a Python script test_script.py:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time

# Path to WebDriver executable
driver_path = '/path/to/chromedriver'

# Initialize WebDriver
driver = webdriver.Chrome(executable_path=driver_path)

# Open a website
driver.get('https://www.example.com')

# Perform actions
search_box = driver.find_element(By.NAME, 'q')
search_box.send_keys('Selenium')
search_box.send_keys(Keys.RETURN)

# Wait for results
time.sleep(5)

# Close the browser
driver.quit()

4. Integrating with CI Tools (Short Overview)

Jenkins

GitLab CI

stages:
  - test

test_job:
  stage: test
  script:
    - pip install selenium
    - python test_script.py

Now you have the implementation ready for practical use, focusing on Selenium and WebDriver installations, with a generic guide for CI tool integration.

Practical Implementation of Selenium Test Scripts in Python

Sample Selenium Test Script

Directory Structure

Assume the project structure:

/my_project
  /tests
    test_sample.py
  /drivers
    chromedriver (or appropriate WebDriver)
  requirements.txt

File: requirements.txt

selenium==3.141.0
pytest==6.2.4

File: tests/test_sample.py

import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys

# Fixture to initialize and close the WebDriver
@pytest.fixture
def setup_driver():
    driver = webdriver.Chrome(executable_path='../drivers/chromedriver')
    yield driver
    driver.quit()

# Test function
def test_google_search(setup_driver):
    driver = setup_driver
    driver.get("https://www.google.com")

    search_box = driver.find_element(By.NAME, "q")
    search_box.send_keys("Selenium Python")
    search_box.send_keys(Keys.RETURN)

    assert "Selenium Python" in driver.title

CI Integration

Jenkins: Jenkinsfile

pipeline {
    agent any

    stages {
        stage('Install Dependencies') {
            steps {
                sh 'pip install -r requirements.txt'
            }
        }

        stage('Run Tests') {
            steps {
                sh 'pytest tests/'
            }
        }
    }

    post {
        always {
            junit 'tests/test-results.xml'
        }
    }
}

GitLab CI: .gitlab-ci.yml

image: python:3.8

services:
  - selenium/standalone-chrome

variables:
  DISPLAY_SIZE: 1920x1080

before_script:
  - pip install -r requirements.txt

stages:
  - test

test:
  script:
    - pytest tests/ --junit-xml=tests/test-results.xml
artifacts:
  when: always
  reports:
    junit: tests/test-results.xml

Use the above configurations to integrate and execute your Selenium tests with Jenkins or GitLab CI.

Configuring Jenkins Pipeline for Selenium Automated Tests in Python

Jenkinsfile

Create a Jenkinsfile in the root of your repository:

pipeline {
    agent any

    stages {
        stage('Checkout') {
            steps {
                // Checkout source code
                git 'https://your-repo-url.git'
            }
        }

        stage('Set Up Python Environment') {
            steps {
                // Set up Python environment
                sh 'python3 -m venv venv'
                sh '. venv/bin/activate'
                sh 'pip install -r requirements.txt'
            }
        }

        stage('Run Tests') {
            steps {
                // Run Selenium tests
                sh '. venv/bin/activate && pytest tests/'
            }
        }

        stage('Post Steps') {
            steps {
                // Clean up after testing
                sh 'deactivate'
            }
        }
    }

    post {
        always {
            // Store test results
            junit 'reports/*.xml'
        }
    }
}

Configuring GitLab CI Pipeline for Selenium Automated Tests in Python

.gitlab-ci.yml

Create a .gitlab-ci.yml file in the root of your repository:

stages:
  - test

variables:
  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"

cache:
  paths:
    - .cache/pip

test:
  stage: test
  image: python:3.8
  before_script:
    - python -m venv venv
    - source venv/bin/activate
    - pip install -r requirements.txt
  script:
    - pytest tests/
  artifacts:
    when: always
    reports:
      junit:
        - Report.xml

These configurations will allow you to run Selenium automated tests using Jenkins or GitLab CI pipelines effectively with Python.

Integrate Selenium Tests into CI Pipeline

Jenkins

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://your-repository-url.git'
            }
        }
        stage('Install Dependencies') {
            steps {
                sh 'pip install -r requirements.txt'
            }
        }
        stage('Run Selenium Tests') {
            steps {
                sh 'pytest path/to/your_selenium_tests'
            }
        }
    }
    post {
        always {
            junit 'path/to/selenium_test_results/*.xml'
        }
    }
}

GitLab CI

.gitlab-ci.yml

stages:
  - test

cache:
  paths:
    - .cache/pip

before_script:
  - pip install -r requirements.txt

selenium_tests:
  stage: test
  script:
    - pytest --junitxml=path/to/selenium_test_results.xml path/to/your_selenium_tests
  artifacts:
    reports:
      junit: path/to/selenium_test_results.xml
    paths:
      - path/to/selenium_test_results.xml

Assume the structure of your repository is:

??? Jenkinsfile
??? .gitlab-ci.yml
??? requirements.txt
??? path
    ??? to
        ??? your_selenium_tests
            ??? test_script.py

Execute and Monitor the CI Pipeline

1. Configure the Jenkins or GitLab CI Job to Execute Tests

Jenkins:

pipeline {
    agent any
    stages {
        stage('Checkout') {
            steps {
                git 'https://your-repo-url.git'
            }
        }
        stage('Install Dependencies') {
            steps {
                sh 'pip install -r requirements.txt'
            }
        }
        stage('Run Tests') {
            steps {
                sh 'pytest --junitxml=report.xml'
            }
        }
    }
    post {
        always {
            junit 'report.xml'
        }
    }
}

GitLab CI:

stages:
  - test

test_job:
  stage: test
  script:
    - pip install -r requirements.txt
    - pytest --junitxml=report.xml
  artifacts:
    reports:
      junit: report.xml

2. Trigger the Pipeline

Jenkins:

GitLab CI:

3. Monitor the Pipeline Execution

Jenkins:

GitLab CI:

4. Monitor and Maintain Test Health

Common Configurations:

Conclusion

These steps provide a practical outline to execute and monitor a CI pipeline with Jenkins or GitLab CI integrated with Selenium tests using Python. This implementation can be readily used to maintain and observe your CI/CD pipeline.

Part 7: Generate and Analyze Test Reports

Generate Test Reports

Selenium Test Script with Report Generation:

import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
import HtmlTestRunner

class TestExample(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.implicitly_wait(10)

    def test_title(self):
        self.driver.get("http://example.com")
        self.assertEqual("Example Domain", self.driver.title)

    def test_example_element(self):
        self.driver.get("http://example.com")
        element = self.driver.find_element(By.TAG_NAME, 'h1')
        self.assertEqual(element.text, "Example Domain")

    def tearDown(self):
        self.driver.quit()

if __name__ == "__main__":
    unittest.main(testRunner=HtmlTestRunner.HTMLTestRunner(output='reports'))

Analyze Test Reports

Jenkins/GitLab CI Configuration:

# .gitlab-ci.yml or Jenkins pipeline configuration
stages:
  - test

test:
  stage: test
  script:
    - python -m unittest discover -s tests -p '*_test.py'
  artifacts:
    paths:
      - reports
    when: always

Example Script for Jenkins Freestyle Project:

python -m unittest discover -s tests -p '*_test.py'

Practical Code for GitLab CI Integration:

Running Tests and Generating Reports

# Command line to execute tests and generate reports
python -m unittest discover -s tests -p '*_test.py'

Ensure HtmlTestRunner is installed:

pip install html-testRunner

Optimize and Maintain the CI System

Script to Optimize Jenkins CI System

pipeline {
    agent any

    environment {
        // Optimize resource allocation
        JAVA_OPTS = '-Xmx1g'
    }

    stages {
        stage('Clean Up Workspace') {
            steps {
                deleteDir()
            }
        }
        stage('Checkout Code') {
            steps {
                git 'https://github.com/your-repository.git'
            }
        }
        stage('Build and Test') {
            steps {
                // Use parallel stages to reduce build time
                parallel {
                    stage('Build') {
                        steps {
                            sh 'make build'
                        }
                    }
                    stage('Run Selenium Tests') {
                        steps {
                            sh 'python -m pytest tests/'
                        }
                    }
                }
            }
        }
        stage('Post Build Actions') {
            steps {
                // Archive build artifacts
                archiveArtifacts artifacts: '**/target/*.jar', allowEmptyArchive: true

                // Publish test results
                junit '**/target/test-*.xml'
            }
        }
        stage('Clean Up') {
            steps {
                // Efficient workspace cleanup to maintain disk space
                deleteDir()
            }
        }
    }

    post {
        always {
            // Notify team members about build status
            mail to: 'team@example.com',
                 subject: "Build ${currentBuild.fullDisplayName} completed",
                 body: "Check build logs at ${env.BUILD_URL}"
        }
    }
}

Script to Optimize GitLab CI System

stages:
  - cleanup
  - build
  - test
  - post

variables:
  JAVA_OPTS: "-Xmx1g"

cleanup_workspace:
  stage: cleanup
  script:
    - rm -rf *

build_job:
  stage: build
  script:
    - make build
  artifacts:
    paths:
      - target/*.jar

test_job:
  stage: test
  script:
    - python -m pytest tests/
  artifacts:
    reports:
      junit: target/test-*.xml

post_build_actions:
  stage: post
  script:
    - echo "Build completed"
  when: always
  after_script:
    # Notify team about the completion status
    - if [[ "$CI_JOB_STATUS" == "success" ]]; then echo "Build succeeded"; else echo "Build failed"; fi
    - # Use your preferred notification service here
    - curl -X POST -H 'Content-type: application/json' --data '{"text":"Build completed"}' https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
    - rm -rf *

default:
  before_script:
    - echo "Setting up the environment"
  after_script:
    - echo "Cleaning up"

CRON Script to Maintain Jenkins CI System

node {
    stage('Clean Up Old Builds') {
        steps {
            script {
                // Allow only the last 10 builds to be kept
                def job = Jenkins.instance.getItem('your-job-name')
                job.builds.findAll {
                    it.number < job.builds[-10].number
                }.each {
                    it.delete()
                }
            }
        }
    }

    stage('Clean Up Old Workspace') {
        steps {
            script {
                // Clean up old workspace data periodically
                def workspacePath = '/var/jenkins_home/workspace/your-job-name'
                sh "find ${workspacePath} -mtime +7 -exec rm -rf {} \;"
            }
        }
    }
}

Generic Optimization Tips (Pseudocode)

1. Allocate resources optimally:
   Adjust memory and CPU usage based on your server and job needs.

2. Use parallel stages where possible:
   Parallelize jobs to reduce the overall build time.

3. Clean up workspaces:
   Remove unnecessary files after jobs complete.

4. Limit the number of old builds to be kept:
   Retain only a specific number of recent builds to save space.

5. Monitor and analyze logs:
   Regularly check CI server logs for any issues or optimizations.

6. Automate notifications:
   Notify team members of job completion using email or instant messaging.

These implementation instructions can be directly applied to optimize and maintain your CI system in real practice.