1. What is API Testing?

• API (Application Programming Interface):
  A set of rules that allows different software applications to communicate with each other.
• API Testing:
  Checking if APIs work as expected. Unlike UI testing, API testing focuses on the logic, functionality, reliability, and performance of the API endpoints.

Key points:

• No GUI needed.
• Faster and more stable than UI testing.
• Validates responses, status codes, headers, and data integrity.

2. Why Use Postman for API Testing?

Postman is a popular tool for testing APIs because it allows you to:

• Send HTTP requests (GET, POST, PUT, DELETE, PATCH).
• Receive and validate responses.
• Automate tests with scripting.
• Organize tests into collections and environments.
• Generate documentation automatically.

3. Types of API Tests in Postman

1. Functional Testing – Verify API performs its function correctly.
   • Example: Check if /login returns a valid token.
2. Integration Testing – Test interaction between multiple APIs or services.
   • Example: /create-user and /get-user endpoints working together.
3. Regression Testing – Ensure API changes do not break existing functionality.
4. Load/Performance Testing – Check API performance under high traffic (Postman uses Runner + Newman for this).
5. Security Testing – Verify authentication, authorization, and data encryption.

4. HTTP Methods Commonly Tested

5. Postman Interface Basics

1. Request Tab: Send requests and see responses.
2. Collections: Group related API requests.
3. Environments: Set variables for different environments (dev, staging, production).
4. Tests Tab: Write scripts to validate API responses.
5. Pre-request Scripts: Run code before sending request (e.g., generate tokens).

6. Steps to Test an API in Postman

Step 1: Create a Request

• Choose HTTP method (GET/POST/PUT/DELETE).
• Enter API endpoint URL.
• Add headers (e.g., Content-Type: application/json).
• Add body data (for POST/PUT/PATCH requests).

Step 2: Send Request

• Click Send.
• View the response: status code, headers, body, and response time.

Step 3: Validate Response

• Check HTTP status codes:
  • 200 OK – Success
  • 201 Created – Resource created
  • 400 Bad Request – Client error
  • 401 Unauthorized – Invalid authentication
  • 404 Not Found – Resource missing
  • 500 Internal Server Error – Server error
• Validate response body (JSON/XML).

Step 4: Write Tests in Postman

Postman allows JavaScript-based tests. Example:

// Status code check
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// Response time check
pm.test("Response time is less than 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

// Response body check
pm.test("Response has userId", function () {
    var jsonData = pm.response.json();
    pm.expect(jsonData.userId).to.eql(1);
});

Step 5: Use Variables & Environments

• Store base URL, tokens, or dynamic values as variables.
• Use {{variableName}} in requests for easier maintenance.

Step 6: Organize Requests in Collections

• Group similar requests.
• Run multiple tests using Collection Runner.
• Automate with Newman CLI to run collections from terminal or CI/CD.

7. Postman Automation Features

1. Collection Runner – Run multiple requests sequentially.
2. Tests & Scripts – Write assertions for responses.
3. Pre-request Scripts – Generate dynamic values like timestamps, tokens.
4. Monitors – Schedule API tests to run periodically.
5. Newman – CLI tool for running Postman collections in pipelines (CI/CD).

8. Best Practices for API Testing in Postman

1. Validate status codes, headers, and response body.
2. Test with valid and invalid inputs.
3. Use environments and variables to avoid hardcoding.
4. Organize requests in collections.
5. Include pre-request scripts for dynamic data like tokens.
6. Automate tests with Collection Runner/Newman.
7. Test for performance and security where possible.

9. Summary

• API testing ensures endpoints work correctly without relying on UI.
• Postman is a widely used tool for sending requests, validating responses, and automating tests.
• Key steps: Create request → Send → Validate → Automate → Organize.
• Postman supports functional, integration, regression, and performance testing.

Automation Testing (Selenium) — Detailed Breakdown

1. Introduction to Automation Testing

• What is automation testing?
• Difference between manual and automation testing
• Benefits: speed, reliability, reusability, CI/CD integration
• When to automate & when not to

2. Overview of Selenium

• What is Selenium?
• Selenium Suite Components:
  • Selenium WebDriver
  • Selenium IDE
  • Selenium Grid
• Advantages & limitations of Selenium

3. Selenium WebDriver Basics

• WebDriver architecture
• Launching browsers (Chrome, Firefox, Edge, Safari)
• Locating elements:
  • ID, Name, ClassName, TagName, LinkText, PartialLinkText, CSS Selector, XPath
• Types of waits:
  • Implicit Wait
  • Explicit Wait
  • Fluent Wait

4. Web Elements & User Interactions

• Click, sendKeys, clear
• Handling dropdowns (Select class)
• Handling checkboxes & radio buttons
• Actions class:
  • Mouse hover
  • Drag and drop
  • Right-click, double-click
• Keyboard actions

5. Working with Web Page Components

• Alerts (accept, dismiss, prompt)
• Frames & iFrames
• Windows & Tabs handling
• File upload & download
• Handling dynamic elements

6. Selenium with Java / Python

• Writing your first Selenium script
• Project setup using Maven / PIP
• Creating reusable functions
• Exception handling
• Logging with Log4j

7. TestNG / PyTest Framework

• TestNG basics:
  • @Test, @BeforeMethod, @AfterMethod
  • Groups, Priority, Dependency
• Assertions
• Test suite XML
• Reporting
• PyTest (for Python):
  • Fixtures, markers, plugins

8. Page Object Model (POM)

• What is POM?
• Benefits of POM
• PageFactory & @FindBy
• Implementing modular, scalable framework

9. Data-Driven Testing

• Reading data from:
  • Excel
  • CSV
  • JSON
  • Database
• Apache POI for Excel
• Parameterization in TestNG

10. Behavior-Driven Testing (BDD)

• Introduction to Cucumber
• Gherkin language — Given/When/Then
• Creating feature files
• Step definitions
• Runner classes

11. Selenium Grid

• What is Selenium Grid?
• Node & Hub architecture
• Running tests in parallel
• Cross-browser testing

12. CI/CD Integration

• Running Selenium with:
  • Jenkins
  • GitHub Actions
  • GitLab CI
• Automated job scheduling

13. Reporting Tools

• Extent Reports
• Allure Reports
• TestNG default reports

14. Advanced Selenium Concepts

• Handling Shadow DOM
• Working with WebDriverManager
• Headless browser automation
• Capturing screenshots & logs
• Smart waits & synchronization strategies

15. Common Interview Questions

• Framework design questions
• XPath vs CSS selector
• StaleElementReferenceException solutions
• Page load strategy
• Test flakiness handling

I

🧪 Manual Testing – Overview

Manual Testing is a software testing process where test cases are executed manually without using automation tools.
The tester plays the role of an end-user and verifies the application to ensure it works as expected.

Manual testing helps identify:

• Functional issues
• UI problems
• User experience bugs
• Logical errors
• Performance glitches (basic)

🎯 Why Manual Testing is Important?

Because:

• It helps catch bugs early
• It ensures the application meets user requirements
• Some tests cannot be automated (UI, usability)
• It provides human insight into usability and user experience

🔑 1. Software Testing Basics

What is Testing?

Testing is the process of evaluating software to detect differences between expected and actual behavior.

Goal of Testing

• Improve product quality
• Ensure reliability
• Verify functionality
• Prevent defects

🧩 2. Types of Manual Testing

1️⃣ Functional Testing

Tests the features and actions of software.

• Smoke Testing
• Sanity Testing
• Integration Testing
• System Testing
• Regression Testing
• User Acceptance Testing (UAT)

2️⃣ Non-Functional Testing

Checks performance, usability, reliability.

• Usability Testing
• Performance (basic manual checks)
• Compatibility Testing
• Accessibility Testing

3️⃣ White Box vs. Black Box Testing

Black Box Testing

• Tester does not know internal code
• Focus on input/output
• Example: Login verification

White Box Testing

• Tester knows internal code
• Validates logic, loops, conditions

Grey Box Testing

• Partial internal knowledge

📝 3. Test Artifacts in Manual Testing

These are documents created during the testing process:

• Test Plan – Testing strategy
• Test Scenario – High-level testing idea
• Test Case – Step-by-step test steps
• Test Data – Values to test with
• Test Report – Summary of testing results
• Bug Report – Defect description for developers

🔍 4. Test Case Structure

A typical test case includes:

• Test Case ID
• Test Title
• Pre-conditions
• Test Steps
• Expected Result
• Actual Result
• Status (Pass/Fail)

🐞 5. Bug Life Cycle (Defect Life Cycle)

1. New
2. Assigned
3. Open
4. Fixed
5. Retested
6. Closed
7. Reopened (if still failing)

🛠 6. Key Techniques in Manual Testing

• Equivalence Partitioning
• Boundary Value Analysis (BVA)
• Error Guessing
• Exploratory Testing
• Ad Hoc Testing

⚙️ 7. Manual Testing vs Automation Testing

💼 8. Skills Required for Manual Testing

• Understanding SDLC & STLC
• Writing test cases
• Bug reporting
• Logical thinking
• Communication skills
• Basic SQL
• Basic knowledge of UI/UX

🔄 9. Where Manual Testing is Used Today?

Even with automation, manual testing is essential in:

• Mobile apps
• Web applications
• Gaming testing
• Usability testing
• Exploratory testing
• Initial development stages

🏁 10. Roles Related to Manual Testing

• QA Tester
• Test Engineer
• QA Analyst
• UAT Tester
• Functional Tester