Gamma Project: Modern Test Automation with Python + Selenium
For a long time, I was using Solarwinds for E2E test automation. At first, it did the job, but over time some issues became impossible to ignore:
- Conditional scenarios constantly caused problems.
- Its performance was far below my expectations.
- I couldn’t customize it or add the features I wanted.
At some point, I realized: Instead of struggling with existing tools, it would make more sense to build something tailored to my needs.
That’s how Gamma was born: a fast and flexible test automation tool I can use both in my own projects and future client work.
Why I Needed a Tool Like This
Tools like Solarwinds may look powerful, but they’re usually “one-size-fits-all” solutions. What I needed was something much simpler but far more flexible:
- A system that runs fast without slowing down tests.
- A structure where I can add my own rules when needed.
- A single interface to manage tests without getting lost in complex logs/reports.
None of the existing tools satisfied me at that level.
The Heart of Gamma: The GUI
When I started developing Gamma, my first goal was this: Test processes should be understandable even for someone who doesn’t know how to code.
That’s why I invested most of my effort into the GUI.
- Dark theme makes it easy on the eyes.
- From one screen, you can start tests, view logs, and track results.
- Real-time log tracking, automatic screenshots, and console log collection during failures dramatically reduce debugging time.
In short, answering “are my tests working?” takes just a few clicks.
Multi-Project Structure: One Tool, Multiple Scenarios
I didn’t just build Gamma for my own project. I wanted to use it for future client work as well. That’s why I added multi-project support.
For each project, you get:
- Separate configuration
- Separate test files
- Separate credential management
This way, I can use the same tool across different domains.
Selenium + Chrome DevTools Protocol
Selenium is already a classic, but on its own, it’s not always enough. That’s why I integrated Chrome DevTools Protocol (CDP) into Gamma.
Advantages include:
- Monitoring network requests and performance metrics.
- Capturing screenshots and console logs even in headless mode.
- Enabling deeper debugging capabilities.
Artifact Management: Tracing the Failure
When a test fails, figuring out why often takes time. In Gamma, this process is automated:
- Screenshot → capture of the screen at the moment of failure
- Console log → JS errors and warnings
- Network summary → failed requests
- Page analysis → state of the page at that moment
Each run also generates timestamped folders (logs/20241201-143022-checkout). This makes it super easy to compare past runs or identify when a bug first appeared.
The Biggest Advantage: Speed and Control
What satisfies me the most about Gamma:
- Much faster compared to Solarwinds.
- Most importantly, I have full control.
If something is missing, I just build it. I don’t need to wait for someone’s roadmap or a release cycle to get the features I want.
What’s Next?
Gamma is still in its first version, but I already have many improvements in mind:
- Drag-and-drop Test Builder → create tests directly from the GUI
- Scheduler → run tests at scheduled times
- Parallel Execution → run multiple tests simultaneously
- CI/CD Integration → GitHub Actions support
- HTML Report Generation → shareable detailed reports
Conclusion
Sometimes it’s easier to just settle with existing tools. But building something tailored to your own needs is far more rewarding.
For me, Gamma is not just a testing tool; it’s proof that a side project can actually solve a real problem.
🔗 Curious about the project? Check out the GitHub repo:
👉 Gamma - E2E Testing Tool