In this module, we would go through a deep dive of understanding what is SCM, why you need it, and want is the internal working of GIT SCM. We then will move into understanding commits, branching, tags, and working with the remote repository. Throughout the course, we would be using Gitlab as the Remote Repository.

•  Introduction to SCM

•  Working with linux Command (Basix)

•  Installing Git on local Machine

•  Git Basic Commands

•  Git Branches

•  Merging Branches using Rebasing and Merge

•  Handling Merge Conflicts

•  Working with Remote Repositories

•  Assignment Create Git Branch Model

In this module we will start by the Project KT. Understanding what needs to tested, how to write test cases and strategy for testing the application. This is the real time knowledge that will be useful to you to test and automate web applications.We will then move into the world of APIs and understand the reason to test APIs and how to test APIs.

•  Project KT

•  Understanding Web Application Component

•  Different Types of API

•  Components of API Request

•  HTTP verbs

•  Working with Variables in Postman

•  Writing Tests in Postman using Chai.js

•  Data Driven Testing in Postman

•  Executing Postman Collection using newman and generating the report

•  Creating a Continous Testing Plan using Git Postman and Jenkins

 Introduction to Python

• Introduction to programming paradigms
• Python’s history and popularity
• Installing Python and setting up an IDE (e.g., Visual Studio Code, PyCharm)
• Running Python programs and using the interactive shell
• Understanding Python’s philosophy (PEP 8)
• Basic syntax and indentation rules

 Python Basics

• Variables: naming conventions, assignment
• Data types: int, float, str, bool
• Type conversion and casting
• Strings: operations, methods, formatting
• Numeric operations: arithmetic, precedence
• Boolean logic: and, or, not

 Control Flow

• Conditional statements: if, elif, else
• Comparison operators: ==, !=, <, >, <=, >=
• Logical operators: and, or, not
• Nested conditionals and complex conditions
• Loops: while loop, for loop
• Using the range() function for iteration
• Loop control: break, continue, pass

: Data Structures

• Lists: creation, indexing, slicing, modifying
• List methods: append, insert, remove, pop, sort
• Tuples: creation, indexing, immutability
• Sets: creation, adding, removing, set operations
• Dictionaries: creation, accessing, adding, updating, deleting
• List comprehensions and generator expressions

 Functions and Modules

• Functions: definition, parameters, return values
• Scope: local, global, nonlocal
• Lambda functions: syntax, use cases
• Modules: creating and using custom modules
• Importing modules and using functions from modules
• Exploring Python’s standard library
• Packages and managing dependencies using pip

 File Handling and Exception Handling

• Reading and writing text files
• Handling file paths and directories
• Working with different file formats: CSV, JSON
• Exception handling: try, except, else, finally
• Handling multiple exceptions and raising exceptions
• Custom exceptions and error messages

 Object-Oriented Programming (OOP)

• Introduction to OOP concepts
• Classes and objects: attributes, methods
• Constructors: init() method
• Inheritance: base class, derived class, method overriding
• Encapsulation: public, private, protected
• Polymorphism: method overloading, method overriding
• Abstract classes and interfaces

 Design Patterns in Python

• Creational Patterns: Singleton, Factory, Abstract Factory, Builder
• Structural Patterns: Adapter, Decorator, Proxy, Composite
• Behavioral Patterns: Observer, Strategy, Command, Template Method
• Implementing each design pattern in Python

 Advanced Concepts

• Decorators: creating and using decorators
• Generator functions and the yield keyword
• Iterators and iterables
• Context managers and the with statement
• List comprehensions, dictionary comprehensions, set comprehensions
• Using map(), filter(), and reduce() functions

Introduction to Behavior-Driven Development (BDD) and Behave

• Understanding the principles of BDD and its benefits
• Introduction to the Behave library for BDD in Python
• Setting up the development environment: installing Python and Behave

Gherkin Syntax and Feature Files

• Exploring the Gherkin syntax: Feature, Scenario, Given-When-Then
• Creating and structuring feature files with real-world examples
• Defining scenarios, steps, and placeholders in feature files

Installing and Running Behave

• Installing the Behave library using pip
• Running Behave tests using the behave command
• Customizing test execution using command-line options

 Step Definitions and Implementation

• Understanding step definitions and their role in BDD
• Creating step definition files for feature steps
• Mapping Gherkin steps to Python functions using decorators

 Passing Data Between Steps

• Sharing data between step definitions using context
• Using step argument transformations for data conversion
• Handling dynamic values and variables in scenarios

Using Hooks

• Understanding hooks and their execution order
• Implementing before_scenario and after_scenario hooks
• Using hooks for setup and teardown operations

 Scenario Outlines and Parametrized Testing

• Working with scenario outlines to run the same scenario with different data
• Using data tables in scenario outlines for parametrized testing

 Tags and Test Organization

• Using tags to categorize and filter scenarios
• Running specific scenarios using tag expressions
• Organizing tests using tags for different test suites

 Background and Given Steps

• Understanding the Background section in feature files
• Using Given steps to set up common preconditions
• Enhancing scenario readability and maintainability

Advanced Topics

• Customizing Behave configuration using behave.ini and command-line options
• Using environment variables to parameterize Behave runs
• Writing custom step decorators and step argument transformations

Integrating with Test Frameworks (Optional)

• Integrating Behave with other testing frameworks (e.g., unittest, pytest)
• Combining BDD-style tests with traditional unit tests

Reporting and Test Documentation

• Generating human-readable test reports using different formatters
• Creating test documentation from Gherkin feature files
• Interpreting test results and identifying failures

This module will focus on the Selenium WebDriver that will be helping in the UI Test Automation for our web application

•  Learn Locating Elements

•  Interacting With Elements

•  Interacting With Dynamic Elements

•  Managing Page Drivers

•  Working with Windows/Popup and Frames

•  Working with FileUploads

•  Working with DatePicker

•  Working with JavaScripts

•  Working with Actions

•  Working with Tables

•  Syncronization in Selenium Webdriver

•  Remote Browser Testing with BrowserStack and Selenium Grid

•  Creating Browser Utility

In this module will learn how appium will help us in the (Android) mobile test automation. Appium is an open source test automation framework for use with native, hybrid and mobile web apps.

•  Appium Architecture

•  Setting up the Local Machine for Appium

•  Working with Appium Inspecture

•  Working with Gestures in Appium

•  Working Page Object Design Pattern in Appium

•  Taking Screenshots in Appium

•  Continous Integration with Jenkins

Introduction to Jenkins

• Introduction to CI/CD and its benefits
• Overview of Jenkins: History and purpose

Advanced Jenkins Concepts

• Installation and setup of Jenkins
• Navigating the Jenkins dashboard
• Creating and managing Jenkins jobs

CI/CD and Deployment Automation

• Configuring deployment pipelines with Jenkins
• Using tools like Docker for containerization in the deployment process
• Managing configuration and environment variables in Jenkins
• Security best practices for Jenkins: Authentication, authorization, and access control

Introduction to Docker and Containerization

• Understanding the need for containerization
• Overview of Docker: History and purpose
• Core concepts: images, containers, and registries
• Installation and setup of Docker on different platforms
• Basic Docker commands and CLI usage

Docker Images and Containers

• Creating Docker images: Dockerfile and layers
• Building custom images for different applications
• Managing containers: creation, starting, stopping, and removal
• Data persistence and volumes in Docker

 Docker Compose and Multi-Container Applications

• Introduction to Docker Compose for managing multi-container applications
• Defining services and containers using YAML
• Networking between containers in Docker Compose
• Scaling services and containers
• Running multi-container applications with a single command

 Docker and DevOps Workflow

• Integrating Docker into development workflow
• Version control for Docker-related files (Dockerfile, docker-compose.yml)
• Continuous integration with Docker: Building and testing images