DEV Community

Debesh Acharya
Debesh Acharya

Posted on

From Manual API Testing to AI-Powered Automation: My Journey with Keploy Chrome Extension

#testing #automation #keploy #github

How I went from 31 Jest tests to 51 total tests using AI, and what I learned about the future of API testing

🚀 The Challenge: Testing a Recipe Optimizer API

As a developer who contributes to open-source projects like Keploy and has experience with Jest testing for Node.js projects, I recently built a Smart Recipe Optimizer API with sophisticated multi-factor scoring algorithms. The testing journey that followed opened my eyes to the evolution of API testing.

My Starting Point:

  • ✅ 31 Jest tests (unit, integration, API)
  • ✅ 72.58% code coverage
  • ✅ Complex optimization algorithms tested manually
  • ✅ Professional CI/CD pipeline with GitHub Actions

But I wanted to explore how AI could enhance this already solid foundation.

📊 The Traditional Approach: Jest Testing Excellence

What I Built Manually

My Recipe Optimizer API includes sophisticated business logic:

// Example: Multi-factor optimization scoring
const calculateRecipeScore = (recipe, userPreferences, availableIngredients) => {
  const ingredientScore = calculateIngredientMatch(recipe.ingredients, availableIngredients) * 0.40;
  const dietaryScore = checkDietaryCompliance(recipe.dietaryTags, userPreferences.dietaryRestrictions) * 0.25;
  const nutritionalScore = calculateNutritionalAlignment(recipe.nutrition, userPreferences.nutritionalGoals) * 0.20;
  const costScore = evaluateCostEfficiency(recipe.estimatedCost, userPreferences.budgetConstraints) * 0.15;

  return Math.round(ingredientScore + dietaryScore + nutritionalScore + costScore);
};
Enter fullscreen mode Exit fullscreen mode

The Manual Testing Reality

Writing comprehensive tests for this required:

describe('Recipe Optimization Algorithm', () => {
  test('should calculate correct optimization score with all factors', () => {
    const recipe = {
      ingredients: [
        { name: 'flour', amount: 2, unit: 'cups', isOptional: false },
        { name: 'milk', amount: 1, unit: 'cups', isOptional: false }
      ],
      dietaryTags: ['vegetarian'],
      nutrition: { calories: 400, protein: 10 },
      estimatedCost: 3.0
    };

    const userPreferences = {
      dietaryRestrictions: ['vegetarian'],
      nutritionalGoals: { targetCalories: 400 },
      budgetConstraints: { maxCostPerServing: 5.0 }
    };

    const score = calculateRecipeScore(recipe, userPreferences, ['flour', 'milk']);
    expect(score).toBeGreaterThan(80);
  });
});
Enter fullscreen mode Exit fullscreen mode

The Challenges I Faced:

  • ⏰ Time-intensive: Writing 31 comprehensive tests took hours
  • 🔄 Maintenance overhead: Updating tests when algorithms changed
  • 🎯 Limited scenarios: Hard to think of every edge case
  • 📊 Static test data: Mock data didn't reflect real-world complexity

🤖 Enter AI-Powered Testing with Keploy

The Transformation

When I integrated Keploy's AI testing platform, everything changed:

Results:

  • ✅ 20 AI-generated tests passed (100% success rate)
  • ✅ Zero manual test writing required
  • ✅ Realistic test data generated automatically
  • ✅ Edge cases discovered that I hadn't considered

What AI Testing Discovered

The AI found scenarios I never thought to test:

  1. Complex ingredient combinations with optional ingredients
  2. Boundary conditions for nutritional goals
  3. Realistic user preference patterns from actual usage data
  4. Performance edge cases with large recipe datasets

🔍 Real-World API Discovery with Chrome Extension

Testing GitHub APIs

Using Keploy's Chrome Extension on GitHub (where I collaborate on pull requests and manage repositories) revealed fascinating patterns:

APIs Captured:

GET /repos/Debesh-Acharya/Recipe_Optimizer
GET /repos/Debesh-Acharya/Recipe_Optimizer/actions/runs
GET /repos/Debesh-Acharya/Recipe_Optimizer/commits
POST /repos/Debesh-Acharya/Recipe_Optimizer/actions/runs/{id}/rerun
Enter fullscreen mode Exit fullscreen mode

Key Insights:

  • Authentication patterns: Bearer tokens with specific scopes
  • Pagination strategies: Cursor-based pagination for large datasets
  • Error handling: Graceful degradation when APIs are rate-limited
  • Caching headers: Intelligent use of ETags and cache control

Testing Dev.to APIs

Testing on Dev.to (where I'm publishing this post!) showed:

APIs Captured:

GET /api/articles/me/published
GET /api/articles/{id}
POST /api/articles
PUT /api/articles/{id}
Enter fullscreen mode Exit fullscreen mode

Discoveries:

  • Content delivery optimization: Lazy loading for article lists
  • Real-time features: WebSocket connections for notifications
  • Search functionality: Debounced search with intelligent ranking
  • User interaction tracking: Analytics APIs for engagement metrics

🎯 The Combined Approach: Best of Both Worlds

My Final Testing Architecture

Instead of choosing between traditional and AI testing, I combined them:

# GitHub Actions CI/CD Pipeline
name: Comprehensive API Testing

jobs:
  traditional-testing:
    - name: Run Jest Test Suite
      run: npm run test:coverage
      # Result: 31/31 tests passed (72.58% coverage)

  ai-testing:
    - name: Validate OpenAPI Schema
      run: validate-api ./docs/openapi.yaml
      # Result: {"valid": true}

    - name: Run Keploy AI Tests
      run: keploy test
      # Result: 20/20 tests passed (100% success)
Enter fullscreen mode Exit fullscreen mode

The Results:

  • 📊 51 total tests across both platforms
  • ✅ Zero failures in production deployment
  • 🎯 Comprehensive coverage of both logic and integration
  • 🚀 Professional-grade testing that scales

💡 What Excites Me About AI Testing

1. Intelligent Edge Case Discovery

AI found scenarios like:

// AI discovered this edge case I missed
{
  availableIngredients: [],
  dietaryRestrictions: ['vegan', 'gluten-free', 'nut-free'],
  nutritionalGoals: { targetCalories: -100 } // Invalid input
}
Enter fullscreen mode Exit fullscreen mode

2. Realistic Test Data Generation

Instead of static mocks:

// Manual approach
const mockRecipe = { title: "Test Recipe", servings: 4 };

// AI-generated approach
const aiGeneratedRecipe = {
  title: "Spicy Thai Basil Chicken with Jasmine Rice",
  servings: 4,
  ingredients: [/* 12 realistic ingredients with proper amounts */],
  nutrition: {/* Calculated nutritional data */},
  estimatedCost: 8.75 // Based on real ingredient costs
};
Enter fullscreen mode Exit fullscreen mode

3. Continuous Learning

The AI improves with each test run, learning from:

  • API response patterns in my application
  • User behavior data from real interactions
  • Performance characteristics under different loads
  • Error scenarios that occur in production

4. Developer Productivity

Time Comparison:

  • ⏰ Manual Jest tests: 4-6 hours for comprehensive coverage
  • 🚀 AI-generated tests: 10-15 minutes for equivalent coverage
  • 🔄 Maintenance: AI tests update automatically with API changes

🔮 The Future of API Testing

My Recommendations

  1. Don't replace traditional testing - Use both approaches
  2. Start with AI for rapid prototyping - Get coverage quickly
  3. Use manual tests for business logic - Critical algorithms need human insight
  4. Leverage AI for integration testing - Perfect for complex API interactions
  5. Combine in CI/CD pipelines - Automated validation at every level

What's Next?

I'm excited about:

  • AI-powered performance testing - Load testing with realistic user patterns
  • Intelligent test maintenance - AI updating tests when APIs evolve
  • Cross-platform test generation - One schema, tests for multiple frameworks
  • Production monitoring integration - AI learning from real user behavior

🎯 Key Takeaways

  1. AI testing enhances, doesn't replace traditional testing
  2. Chrome extension reveals real-world patterns you can apply to your APIs
  3. Combined approach gives comprehensive coverage with minimal effort
  4. CI/CD integration makes everything automatic and reliable
  5. The future is collaborative - humans and AI working together

🔗 Try It Yourself

Want to experience this transformation? Here's how:

  1. Install Keploy Chrome Extension: GitHub Repository
  2. Test your favorite websites: Capture real API patterns
  3. Create OpenAPI schema: Document your APIs professionally
  4. Generate AI tests: Use Keploy platform for instant test coverage
  5. Integrate with CI/CD: Automate everything in your pipeline

My Repository: Recipe_Optimizer - See the complete implementation with both Jest and Keploy tests.

Top comments (0)