Kanishk Gupta

Posted on Jun 27

From Manual Grind to AI Power: My Journey with Keploy API Testing

#webdev #backend #testing #keploy

The Beginning of My Testing Journey

When I first started building my Video Games API project, testing was a necessary evil. I'd spend hours crafting test cases, mocking database calls, setting up test environments, and debugging flaky tests. Like most developers, I knew testing was crucial, but it was also time-consuming and sometimes tedious.

My Video Games API project had grown to include dozens of endpoints - everything from basic CRUD operations to specialized endpoints for retrieving game screenshots, system requirements, and DLC information. Writing comprehensive tests for each endpoint, each edge case, and each potential failure mode was becoming overwhelming.

The Manual Testing Pain Points

Let me walk you through what my typical testing workflow looked like:

Write a new API endpoint in my Express router
Create a test file with Jest
Set up mock data and database connections
Write tests for successful cases
Write more tests for failure cases
Write even more tests for edge cases
Run the tests, fix bugs, repeat

For each endpoint, this could take hours. And when requirements changed? Rinse and repeat. My tests directory was growing faster than my actual codebase!

Enter Keploy: Testing with AI

Everything changed when I discovered Keploy. At first, I was skeptical - could an AI-driven tool really understand the complexity of my API and generate meaningful tests? The answer was a resounding yes.

With Keploy, my workflow transformed:

Write a new API endpoint
Make a few manual API calls to test basic functionality
Let Keploy observe the traffic and automatically generate test cases
Review the generated tests and make minor adjustments if needed

What used to take hours now took minutes. The first time I saw my test coverage jump from patchy to comprehensive in a single afternoon, I was genuinely amazed.

The Challenges: Not All Smooth Sailing

While the end results were amazing, I want to be honest about the challenges I faced. My journey with Keploy wasn't without its frustrations:

CLI Issues with Request Logging: One of the biggest headaches was getting the Keploy CLI to properly log API requests. Despite sending numerous requests through both WSL and PowerShell, the CLI wasn't capturing the traffic as expected. This was particularly frustrating because, without capturing the requests, Keploy couldn't generate test cases.

VS Code Extension Problems: I also tried the VS Code extension for Keploy, hoping it would simplify the process. Unfortunately, it had issues with recording and saving test reports. The extension would sometimes fail to record API calls or wouldn't save the test reports properly, which meant starting over multiple times.
Documentation Gaps: While the documentation was generally good, there were some gaps when it came to troubleshooting these specific issues. I spent at least three hours going around in circles trying different commands and configurations.

The solution finally came when I abandoned the local CLI approach and went directly to the Keploy website (https://keploy.io/). Using their web interface to generate and run test cases proved much more reliable and intuitive than the CLI or VS Code extension approaches.

Integrating Keploy into My Project

After overcoming these initial hurdles, getting Keploy integrated into my CI/CD workflow was surprisingly straightforward. I added it to my GitHub Actions workflow with just a few lines:

- name: Run Keploy Test Suite
  run: |
    # Start your application in the background
    npm start &
    # Wait for application to start
    sleep 10
    # Run Keploy tests
    export KEPLOY_API_KEY=${{ secrets.KEPLOY_API_KEY }}
    keploy test-suite --app=94cad786-1403-4d02-8860-f1c334ada9ee --base-path http://localhost:5000/api/games --cloud
    # Kill the background process
    kill $!

Once properly configured, the magic happened. Keploy didn't just test the happy paths - it found edge cases I hadn't even considered. It validated response structures against my OpenAPI schema and ensured consistent behavior across different API calls.

Real Results: From 0 to 100% in Minutes

The results were immediate and impressive. Before Keploy, my test coverage hovered around 70% - respectable, but with clear gaps. After implementing Keploy, my coverage shot up to over 95% within a day.

More importantly, the quality of testing improved. Keploy caught subtle issues that my manual tests had missed:

Inconsistent error response formats
Edge cases with pagination parameters
Potential race conditions in concurrent requests
Schema validation issues I hadn't anticipated

The test report showed dozens of passing tests that I never had to write manually.

Beyond Coverage: Better Development Experience

The benefits extended far beyond just test coverage percentages. With Keploy handling the testing burden, I could:

Focus on features instead of tests: I spent more time building new endpoints and less time writing test cases.
Ship with confidence: Every PR now had comprehensive test coverage automatically.
Catch regressions early: If I accidentally broke an existing endpoint, Keploy would catch it immediately.
Better document my API: The tests themselves became a form of living documentation for how my API behaves.

The Developer Experience Transformation

The most meaningful change wasn't technical - it was psychological. Testing went from being a chore I'd sometimes postpone to an effortless part of my workflow.

Before Keploy, I'd often think: "I should write tests for this, but I'll do it later..." (and "later" sometimes never came).

After Keploy: "Let me run the API and let Keploy generate tests while I work on the next feature."

Looking Forward: The Future of API Testing

This experience has fundamentally changed how I think about testing. I'm excited about several aspects of this AI-driven testing approach:

Testing becomes proactive, not reactive: Tests are generated as you build, not as an afterthought.
Tests evolve with your API: As your API changes, your tests automatically adapt.
Focus shifts to quality, not quantity: Instead of worrying about writing enough tests, you can focus on making your API better.

Conclusion: A New Testing Paradigm

If you're still writing all your API tests manually in 2025, it's time to reconsider your approach. Tools like Keploy represent a fundamental shift in how we think about testing - from a manual burden to an automated, AI-driven process that improves both code quality and developer happiness.

Despite the initial setup challenges, the payoff was absolutely worth it. My advice to anyone starting with Keploy would be to go straight to their web interface rather than struggling with the CLI or extension if you encounter similar issues. The three hours I spent troubleshooting ended up saving me days of manual test writing.

My Video Games API project is better for it, and my sanity as a developer is intact. That's a win-win in my book.

Want to see this in action? Check out my Video Games API repository and see how I've implemented Keploy alongside traditional Jest tests. The README includes comprehensive documentation of how everything fits together.

Have you tried AI-driven testing tools? I'd love to hear about your experiences in the comments!

DEV Community