Certainly! Based on the extensive transcript you provided, I’ll continue building a comprehensive guide that covers Maven Execution, Automating Test Runs with Batch/Shell Scripts, and Git & GitHub Integration. This guide will help you seamlessly execute your automation tests both within and outside of Eclipse, manage your code using Git, and integrate with GitHub for version control.

Table of Contents

1. Executing Maven Tests in Eclipse

Before delving into executing Maven tests outside of Eclipse, it’s crucial to understand how to run them within the IDE. This ensures that your project is correctly set up and that your tests execute as expected.

Steps to Execute Maven Tests in Eclipse:

  1. Open Your Project:
    • Launch Eclipse and open your Maven-based automation project.
  2. Locate the pom.xml File:
    • In the Project Explorer, navigate to the root directory of your project and open the pom.xml file.
  3. Run as Maven Test:
    • Right-click on the pom.xml file.
    • Navigate to Run As > Maven Test.
    • (Replace with actual screenshot)
  4. Monitor Execution:
    • The Console view will display the test execution logs.
    • Upon completion, review the TestNG reports to verify pass/fail statuses.
  5. View Reports:
    • Navigate to the reports directory in your project to access detailed test reports (e.g., ExtentReports).

Note: Ensure that all necessary dependencies and plugins are correctly configured in your pom.xml to avoid execution issues.

2. Executing Maven Tests via Command Prompt

Executing Maven tests outside of Eclipse allows for greater flexibility, especially when integrating with Continuous Integration (CI) tools like Jenkins. This section covers installing Maven, configuring environment variables, and running Maven commands via the command prompt.

2.1. Installing Maven on Your Operating System

For Windows:

  1. Download Maven:
  2. Extract the Archive:
    • Right-click the downloaded zip file and select Extract All....
    • Choose a directory (e.g., C:\Program Files\Apache\Maven\apache-maven-3.8.6) to extract the contents.

For Mac/Linux:

  1. Download Maven:
  2. Extract the Archive:
      • Open Terminal.
      • Navigate to the download directory:
    cd ~/Downloads
      • Extract the tar.gz file:
    tar -xvzf apache-maven-3.8.6-bin.tar.gz
      • Move the extracted folder to /opt or any preferred directory:
    sudo mv apache-maven-3.8.6 /opt/maven

2.2. Configuring Maven Environment Variables

For Windows:

  1. Set MAVEN_HOME:
    • Right-click This PC > Properties > Advanced system settings.
    • Click on Environment Variables.
    • Under System variables, click New.....
    • Enter the following:
      • Variable name: MAVEN_HOME
      • Variable value: C:\Program Files\Apache\Maven\apache-maven-3.8.6
  2. Update PATH:
    • In the System variables section, find and select the Path variable, then click Edit.
    • Click New and add %MAVEN_HOME%\bin.
    • Click OK to save changes.

For Mac/Linux:

  1. Set MAVEN_HOME and Update PATH:
      • Open Terminal.
      • Edit the .bash_profile, .bashrc, or .zshrc file using a text editor:
    nano ~/.bash_profile
      • Add the following lines:
    export MAVEN_HOME=/opt/maven
export PATH=$MAVEN_HOME/bin:$PATH
      • Save and exit (e.g., Ctrl + X, then Y, and Enter).
      • Apply the changes:
    source ~/.bash_profile

2.3. Verifying Maven Installation

  1. Open Command Prompt/Terminal:
    • Windows: Press Win + R, type cmd, and press Enter.
    • Mac/Linux: Open Terminal.
  2. Check Maven Version: 
    mvn -version
  3. Expected Output:
Apache Maven 3.8.6 (cecedd343002696d0abb50b32b541b8a6ba2883f)
Maven home: C:\Program Files\Apache\Maven\apache-maven-3.8.6
Java version: 17.0.1, vendor: Oracle Corporation, runtime: C:\Program Files\Java\jdk-17.0.1
Default locale: en_US, platform encoding: Cp1252
OS name: "windows 10", version: "10.0", arch: "amd64", family: "windows"

Note: The Java version should be 11 or higher (e.g., Java 17).

3. Automating Test Execution with Scripts

Automating test executions using scripts like Batch (.bat) files on Windows or Shell (.sh) scripts on Mac/Linux streamlines the testing process, eliminating the need for manual command entries each time tests need to be run.

3.1. Creating a Batch File (run.bat) on Windows

  1. Navigate to Project Directory:
    • Open File Explorer and go to your project’s root directory where the pom.xml file is located.
  2. Create run.bat:
    • Right-click inside the directory > New > Text Document.
    • Rename the file to run.bat (ensure the extension changes from .txt to .bat).
  3. Edit run.bat:
    • Right-click run.bat > Edit (or open with Notepad).
    • Add the following commands:
    @echo off
cd /d "%~dp0"
mvn clean test
pause

    Explanation:

    • @echo off: Hides command execution in the console for cleaner output.
    • cd /d "%~dp0": Changes the directory to the location of the batch file.
    • mvn clean test: Executes Maven commands to clean previous builds and run tests.
    • pause: Keeps the command prompt open after execution to view results.
  4. Save and Close:
    • Save the changes and close the editor.
  5. Execute run.bat:
    • Double-click run.bat to execute the Maven tests.
    • A command prompt window will open, run the specified Maven commands, and pause for you to review the output.

3.2. Creating a Shell Script (run.sh) on Mac/Linux

  1. Navigate to Project Directory:
      • Open Terminal and navigate to your project’s root directory where the pom.xml file is located:
    cd /path/to/your/project
  2. Create run.sh:
      • Use a text editor like nano to create the script:
    nano run.sh
  3. Edit run.sh:
    • Add the following commands:
    #!/bin/bash
cd "$(dirname "$0")"
mvn clean test

    Explanation:

    • #!/bin/bash: Specifies the script should be run in the Bash shell.
    • cd "$(dirname "$0")": Changes the directory to the script’s location.
    • mvn clean test: Executes Maven commands to clean previous builds and run tests.
  4. Save and Close:
    • Press Ctrl + X, then Y, and Enter to save and exit.
  5. Make Script Executable:
      • Run the following command to make the script executable:
    chmod +x run.sh
  6. Execute run.sh:
      • Run the script using:
    ./run.sh
    • The script will execute the Maven commands, running your tests and displaying the output in the terminal.
    • Note: Unlike Windows, Mac/Linux shells don’t require a pause command, as the terminal remains open unless explicitly closed.

4. Introduction to Git and GitHub

Version control is essential for managing changes to your codebase, collaborating with team members, and maintaining a history of your project’s evolution. Git is a distributed version control system, and GitHub is a cloud-based platform for hosting Git repositories.

4.1. Installing Git

For Windows:

  1. Download Git:
  2. Run the Installer:
    • Locate the downloaded Git-2.xx.x-64-bit.exe file and double-click to run it.
  3. Follow Installation Steps:
    • Select Destination Location: Choose the installation directory (default is recommended).
    • Select Components: Leave defaults unless specific changes are needed.
    • Choosing the Editor: Select your preferred text editor (e.g., Vim, Notepad++).
    • Adjusting PATH Environment: Choose “Git from the command line and also from 3rd-party software.”
    • Choosing HTTPS Transport Backend: Select “Use the OpenSSL library.”
    • Configuring Line Ending Conversions: Choose “Checkout Windows-style, commit Unix-style line endings.”
    • Configuring Terminal Emulator: Use “Use Windows’ default console window.”
    • Configuring Extra Options: Leave defaults unless specific needs arise.
  4. Complete Installation:
    • Click Install and wait for the process to complete.
    • Click Finish to exit the installer.

For Mac:

  1. Install via Homebrew (Recommended):
      • If Homebrew is not installed, install it using:
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
      • Install Git:
    brew install git
  2. Alternative: Download Installer:

For Linux:

  1. Using Package Manager:
    • Debian/Ubuntu: 
      sudo apt update
sudo apt install git
    • Fedora: 
      sudo dnf install git
    • Arch Linux: 
      sudo pacman -S git
  2. Verify Installation:
      • Run the following command:
    git --version
    • Expected Output:
git version 2.34.1

4.2. Setting Up Git Configuration

Configuring your Git environment ensures that your commits are correctly attributed to you.

  1. Open Git Command Prompt/Terminal:
    • Windows: Right-click inside your project directory and select Git Bash.
    • Mac/Linux: Open Terminal.
  2. Set Username: 
    git config --global user.name "Your Name"
  3. Set Email: 
    git config --global user.email "your.email@example.com"
  4. Verify Configuration: 
    git config --list

    Expected Output:

    user.name=Your Name
user.email=your.email@example.com

    Note: Replace “Your Name” and “your.email@example.com” with your actual name and email address.

4.3. Basic Git Workflow

Understanding the basic Git workflow is essential for effective version control.

  1. Initialize Git Repository: 
    git init

    Explanation: Creates a new Git repository in the current directory.

  2. Check Repository Status: 
    git status

    Explanation: Displays the status of changes as untracked, modified, or staged.

  3. Add Files to Staging Area:
    • Add All Files: 
      git add .
    • Add Specific File: 
      git add path/to/file
  4. Commit Changes: 
    git commit -m "Your commit message"

    Explanation: Records the staged changes with a descriptive message.

  5. Add Remote Repository: 
    git remote add origin https://github.com/username/repository.git

    Explanation: Links your local repository to a remote GitHub repository.

  6. Push Changes to Remote: 
    git push origin master

    Explanation: Uploads local commits to the remote repository’s master branch.

  7. Pull Changes from Remote: 
    git pull origin master

    Explanation: Fetches and merges changes from the remote master branch to your local repository.

  8. Cloning a Repository: 
    git clone https://github.com/username/repository.git

    Explanation: Creates a local copy of a remote repository.

5. Managing Repositories with GitHub

GitHub serves as a central platform for hosting Git repositories, facilitating collaboration, version control, and integration with CI/CD tools like Jenkins.

5.1. Creating a GitHub Account

  1. Visit GitHub:
  2. Sign Up:
    • Click on Sign up.
    • Enter your username, email address, and password.
    • Follow the on-screen instructions to complete the account setup.
  3. Verify Email:
    • GitHub will send a verification email.
    • Click the verification link in your email to activate your account.

5.2. Creating a Remote Repository on GitHub

  1. Log In to GitHub:
    • Navigate to github.com and log in with your credentials.
  2. Create New Repository:
    • Click on the + icon in the top-right corner and select New repository.
    • (Replace with actual screenshot)
  3. Repository Details:
    • Repository Name: Enter a name (e.g., automation-framework).
    • Description: (Optional) Provide a brief description.
    • Visibility: Choose Public (recommended for Jenkins integration) or Private.
    • Initialize Repository: Do not check Initialize this repository with a README (since you’ll be pushing an existing repository).
  4. Create Repository:
    • Click Create repository.
  5. Note Remote URL:
    • GitHub will display the remote repository URL. Copy it for later use.

5.3. Linking Local Repository to GitHub

Assuming you’ve already initialized a Git repository locally and committed your changes:

  1. Add Remote Origin: 
    git remote add origin https://github.com/username/automation-framework.git

    Explanation: Replace username and automation-framework with your GitHub username and repository name.

  2. Push Local Commits: 
    git push -u origin master

    Explanation: The -u flag sets origin as the default remote for the master branch.

  3. Authenticate:
    • First Push: GitHub may prompt for authentication. Use your GitHub credentials or a Personal Access Token (PAT) if prompted.
    • Note: For enhanced security, it’s recommended to use PATs instead of passwords.

5.4. Pushing and Pulling Code

Pushing Changes:

  1. Stage Changes: 
    git add .

    Explanation: Adds all modified and new files to the staging area.

  2. Commit Changes: 
    git commit -m "Add new test case for search functionality"
  3. Push to Remote: 
    git push origin master

Pulling Changes:

  1. Fetch and Merge Remote Changes: 
    git pull origin master

    Explanation: Retrieves updates from the remote master branch and merges them into your local branch.

Cloning an Existing Repository:

  1. Clone Repository: 
    git clone https://github.com/username/automation-framework.git

    Explanation: Creates a local copy of the specified remote repository.

6. Best Practices

  1. Commit Often:
    • Make frequent commits with clear, descriptive messages to track changes effectively.
  2. Use Branches for Features:
    • Develop new features or fixes in separate branches to isolate changes and facilitate collaboration.
  3. Pull Before Pushing:
    • Always pull the latest changes from the remote repository before pushing your commits to minimize merge conflicts.
  4. Write Clear Commit Messages:
    • Use concise and informative commit messages to describe the purpose of each change.
  5. Avoid Large Commits:
    • Break down changes into manageable commits to enhance readability and traceability.
  6. Protect the master Branch:
    • Implement branch protection rules to prevent direct pushes and ensure code reviews before merging.
  7. Regularly Backup Your Work:
    • Ensure that your local repositories are regularly pushed to remote repositories to prevent data loss.
  8. Leverage .gitignore:
    • Use a .gitignore file to exclude files and directories that shouldn’t be tracked (e.g., target/, .idea/, *.log).
    • Sample .gitignore:
    # Maven
target/

# Eclipse
.classpath
.project
.settings/

# IntelliJ IDEA
.idea/

# Logs
*.log
  9. Stay Consistent:
    • Follow consistent naming conventions and project structures to enhance maintainability.
  10. Use Pull Requests for Code Reviews:
    • Encourage team collaboration by using pull requests to review and discuss changes before merging.

7. Conclusion

This guide has walked you through executing Maven tests within Eclipse and via the command prompt, automating test executions with scripts, and managing your codebase using Git and GitHub. By following these steps, you can establish a robust automation framework that supports both local development and integration with CI tools like Jenkins.

Next Steps:

  1. Setting Up Jenkins:
    • In the upcoming sessions, we’ll explore how to install Jenkins, integrate it with your GitHub repository, and configure it to automatically run your automation tests upon code pushes.
  2. Advanced Git Features:
    • Dive deeper into branching strategies, merge conflict resolution, and collaboration workflows to enhance your version control practices.
  3. Enhancing Automation Framework:
    • Incorporate additional tools and libraries (e.g., Cucumber for BDD, Allure for reporting) to enrich your automation framework’s capabilities.

Happy Testing and Version Controlling! 🚀


Last Post


Next Post