🥋 Karate Framework API Automation

Modern API automation framework using Karate Framework 1.4.1 with Page Object Model (POM) pattern for testing automation exercise APIs. Features comprehensive test coverage, multiple execution strategies, and detailed HTML reporting.

🌟 Key Features

• ✅ Karate Framework 1.4.1 with GraalVM JavaScript engine support
• ✅ Page Object Model (POM) pattern for maintainable test structure
• ✅ Multiple Test Runners for different execution scenarios
• ✅ Tag-based Test Execution for targeted testing
• ✅ Comprehensive API Validation (status, structure, data types)
• ✅ Negative Testing for error scenario coverage
• ✅ Rich HTML Reports with detailed request/response logs
• ✅ JUnit 5 Integration for modern testing framework
• ✅ Environment Configuration support

📁 Project Structure

karateFramework-API-automation/
├── src/
│   └── test/
│       └── java/
│           ├── api/
│           │   ├── products/
│           │   │   └── ProductsApi.feature         # Products API test scenarios
│           │   ├── brands/
│           │   │   └── BrandsApi.feature           # Brands API test scenarios
│           │   ├── runners/
│           │   │   ├── ApiTestRunner.java          # All API tests runner
│           │   │   ├── SmokeTestRunner.java        # Smoke tests runner
│           │   │   ├── RegressionTestRunner.java   # Regression tests runner
│           │   │   └── SimpleKarateRunner.java     # Direct execution runner
│           │   ├── utils/
│           │   │   └── common-utils.js             # Utility functions
│           │   └── data/
│           │       └── README.md                   # Test data documentation
│           └── karate-config.js                    # Global configuration
├── target/
│   └── karate-reports/                             # Generated test reports
├── pom.xml                                         # Maven configuration
└── README.md                                       # This file

🌐 APIs Under Test

1. Products API

• Endpoint: https://automationexercise.com/api/productsList
• Method: GET
• Description: Retrieves complete products catalog with details
• Expected Response: 200 OK with JSON array of products
• Test Coverage: Success scenarios, data validation, negative testing

Sample Response:

{
  "responseCode": 200,
  "products": [
    {
      "id": 1,
      "name": "Blue Top",
      "price": "Rs. 500",
      "brand": "Polo",
      "category": {
        "usertype": {"usertype": "Women"},
        "category": "Tops"
      }
    }
  ]
}

2. Brands API

• Endpoint: https://automationexercise.com/api/brandsList
• Method: GET
• Description: Retrieves all available brands information
• Expected Response: 200 OK with JSON array of brands
• Test Coverage: Success scenarios, data validation, negative testing

Sample Response:

{
  "responseCode": 200,
  "brands": [
    {
      "id": 1,
      "brand": "Polo"
    }
  ]
}

🏷️ Test Categories & Tags

Tag	Purpose	Description
@smoke	Critical Tests	Essential scenarios for basic functionality
@regression	Full Coverage	Comprehensive test suite for all features
@negative	Error Testing	Invalid inputs and error scenario validation
@products	Products API	All test scenarios related to products endpoint
@brands	Brands API	All test scenarios related to brands endpoint

⚡ Quick Start

Prerequisites

• ☑️ Java 11+ - Required for Karate 1.4.1
• ☑️ Maven 3.6+ - Build and dependency management
• ☑️ IDE (IntelliJ IDEA, VS Code, Eclipse) - For development

Installation

1. Clone the repository

   git clone https://github.com/adityadwic/karateFramework-API-automation.git
   cd karateFramework-API-automation

2. Install dependencies

   mvn clean compile test-compile

3. Verify setup

   mvn test

🚀 Running Tests

Option 1: Maven Commands

Run All Tests

mvn test

Run Specific Test Runners

# Run smoke tests only (critical scenarios)
mvn test -Dtest=SmokeTestRunner

# Run regression tests only (full coverage)
mvn test -Dtest=RegressionTestRunner

# Run all API tests (comprehensive)
mvn test -Dtest=ApiTestRunner

Run by Tags (Karate Options)

# Run smoke tests
mvn test -Dkarate.options="--tags @smoke"

# Run regression tests
mvn test -Dkarate.options="--tags @regression"

# Run negative tests only
mvn test -Dkarate.options="--tags @negative"

# Run product tests only
mvn test -Dkarate.options="--tags @products"

# Run brand tests only
mvn test -Dkarate.options="--tags @brands"

# Exclude specific tags
mvn test -Dkarate.options="--tags ~@ignore"

Option 2: Direct Java Execution

Run tests directly using the SimpleKarateRunner:

# Compile first
mvn clean compile test-compile

# Run with Java (includes classpath dependencies)
mvn exec:java -Dexec.mainClass="api.runners.SimpleKarateRunner"

Option 3: IDE Execution

• IntelliJ IDEA: Right-click on any runner class → Run
• VS Code: Use Java Test Runner extension
• Eclipse: Right-click on runner → Run As → JUnit Test

📊 Test Results & Reporting

Console Output

Tests provide real-time feedback with emojis and color coding:

🚀 Running Karate API Tests...
✅ Smoke Tests Results:
Features Total: 2, Features Passed: 2, Features Failed: 0
Scenarios Total: 6, Scenarios Passed: 6, Scenarios Failed: 0
🎉 All tests passed! Karate Framework is working perfectly!

HTML Reports

After execution, detailed reports are generated in:

target/karate-reports/
├── karate-summary.html          # Main report dashboard
├── api.products.ProductsApi.html # Products API detailed report
├── api.brands.BrandsApi.html     # Brands API detailed report
└── *.karate-json.txt            # Raw JSON results

Open karate-summary.html in your browser for:

• 📈 Test execution statistics
• 🔍 Request/Response details
• ⏱️ Performance metrics
• 🐛 Failure analysis
• 📋 Step-by-step execution logs

⚙️ Configuration

Environment Configuration

Base URL and global settings are configured in karate-config.js:

function fn() {
  var config = {
    baseUrl: 'https://automationexercise.com/api',
    timeout: 30000,
    env: 'dev'
  };
  
  karate.log('Environment:', config.env);
  return config;
}

Maven Configuration

Key dependencies and versions in pom.xml:

<properties>
    <karate.version>1.4.1</karate.version>
    <junit.version>5.9.3</junit.version>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

🏗️ Project Architecture

Framework Design Principles

1. Page Object Model (POM)

   • Separates test logic from test data
   • Improves code reusability and maintainability
   • Organized feature files by API endpoints

2. Tag-Based Execution

   • Flexible test execution strategies
   • Easy integration with CI/CD pipelines
   • Selective test running capability

3. Multiple Test Runners

   • ApiTestRunner: Executes all API tests
   • SmokeTestRunner: Critical functionality only
   • RegressionTestRunner: Comprehensive test coverage
   • SimpleKarateRunner: Direct execution with detailed logging

Test Scenario Structure

Each feature file follows this pattern:

Feature: API Name Tests

Background:
  * url baseUrl

@smoke @api-name
Scenario: Positive test scenario
  Given path 'endpoint'
  When method GET
  Then status 200
  And match response.field == 'expected'

@negative @api-name  
Scenario: Negative test scenario
  Given path 'invalid-endpoint'
  When method GET
  Then status 404

🔧 Development Guide

Adding New Tests

1. Create Feature File

   src/test/java/api/new-endpoint/NewEndpoint.feature

2. Follow Naming Convention

   • Use descriptive scenario names
   • Add appropriate tags (@smoke, @regression, @negative)
   • Include API endpoint name in tags

3. Add to Test Runner

   @Karate.Test
   Karate testNewEndpoint() {
       return Karate.run("classpath:api/new-endpoint").tags("~@ignore");
   }

Best Practices

• ✅ Use meaningful scenario descriptions
• ✅ Add both positive and negative test cases
• ✅ Validate response structure and data types
• ✅ Include proper tags for categorization
• ✅ Follow consistent naming conventions
• ✅ Add comments for complex validations

🚨 Troubleshooting

Common Issues

Issue	Solution
Java version mismatch	Ensure Java 11+ is installed and JAVA_HOME is set
Maven build failures	Run mvn clean compile test-compile
Test discovery issues	Check JUnit 5 annotations and runner configuration
Karate script errors	Verify JavaScript syntax in feature files
Network timeouts	Increase timeout in karate-config.js

Debug Mode

Run tests with debug logging:

mvn test -Dkarate.options="--debug"

📈 CI/CD Integration

GitHub Actions Example

name: API Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          java-version: '11'
      - run: mvn test
      - uses: actions/upload-artifact@v3
        with:
          name: test-reports
          path: target/karate-reports/

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/new-api-tests)
3. Follow the existing POM structure and naming conventions
4. Add appropriate tags to new scenarios
5. Include both positive and negative test cases
6. Update README.md when adding new features
7. Commit changes (git commit -am 'Add new API tests')
8. Push to branch (git push origin feature/new-api-tests)
9. Create a Pull Request

Code Review Checklist

• Tests follow POM pattern
• Proper tags are applied
• Both positive and negative scenarios included
• Code is properly documented
• All tests pass locally

📄 License

This project is created for educational and testing purposes. No license restrictions apply.

🔗 Links

• Karate Framework Documentation
• Automation Exercise API
• GitHub Repository

---

Made with ❤️ using Karate Framework 1.4.1