Muthukumarank/testgenius-ai

🧪 TestGenius AI

AI Test Case Generation Agent for QA Teams

Multi-Agent Iterative Refinement • Behavior Coverage Mapping • Mutation-Guided Testing

Not just another GPT wrapper. A 5-agent pipeline that generates, validates, and iteratively improves tests using mutation testing feedback — inspired by MuTAP (ISSTA 2023).

---

🎯 Problem

"Writing comprehensive test cases manually is time-consuming and often misses edge cases."

QA teams spend 40-60% of their time writing tests. They miss edge cases, security vulnerabilities, and integration failures. Existing AI tools (Copilot, basic GPT wrappers) do single-shot generation with no validation — producing tests that look good but don't catch real bugs.

TestGenius AI is different. It doesn't just generate — it analyzes, generates, validates, refines iteratively, and maps behavior coverage.

---

🧠 Research-Grade Architecture (The Key Differentiator)

Inspired by: MuTAP (arxiv:2308.16557, ISSTA 2023) + HITS (ASE 2024) + Code Agents (arxiv:2406.12952)

┌──────────────────────────────────────────────────────────────────────┐
│              TESTGENIUS MULTI-AGENT PIPELINE                          │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│  INPUT (code/requirements/API spec)                                  │
│         │                                                             │
│         ▼                                                             │
│  ┌─────────────────────────────────────────────┐                     │
│  │ AGENT 1: ANALYZER                            │                     │
│  │ • AST-based complexity scoring               │                     │
│  │ • Behavior extraction (testable behaviors)   │                     │
│  │ • Coverage gap detection                     │                     │
│  │ • Function prioritization (complex = more tests) │                │
│  └──────────────────────┬──────────────────────┘                     │
│                          ▼                                            │
│  ┌─────────────────────────────────────────────┐                     │
│  │ AGENT 2: GENERATOR                           │                     │
│  │ • Context-rich structured prompt             │                     │
│  │ • Behavior-guided generation (tests PER behavior) │               │
│  │ • Framework-specific (pytest/Jest/Cypress)   │                     │
│  └──────────────────────┬──────────────────────┘                     │
│                          ▼                                            │
│  ┌─────────────────────────────────────────────┐                     │
│  │ AGENT 3: VALIDATOR                           │                     │
│  │ • Quality scoring (5 dimensions, A-D grade)  │                     │
│  │ • Assertion density check                    │                     │
│  │ • Edge case coverage measurement             │                     │
│  │ • Identifies WHAT'S WEAK in the tests        │                     │
│  └──────────────────────┬──────────────────────┘                     │
│                          ▼                                            │
│  ┌─────────────────────────────────────────────┐                     │
│  │ AGENT 4: REFINER (MuTAP-inspired loop)       │   ← ITERATES       │
│  │ • Identifies surviving mutations             │      until           │
│  │ • Re-prompts LLM with mutation feedback      │      quality ≥ B    │
│  │ • Strengthens weak tests automatically       │                     │
│  │ • Adds tests that KILL surviving mutants     │                     │
│  └──────────────────────┬──────────────────────┘                     │
│                          ▼                                            │
│  ┌─────────────────────────────────────────────┐                     │
│  │ AGENT 5: COVERAGE MAPPER                     │                     │
│  │ • Maps tests → behaviors (which ARE tested)  │                     │
│  │ • Shows UNTESTED behaviors (red flags)       │                     │
│  │ • Coverage % by category (happy/edge/error/security) │            │
│  └─────────────────────────────────────────────┘                     │
│                                                                       │
│  OUTPUT: Tests + Quality Grade + Behavior Coverage Map                │
│          + Refinement History + Untested Behavior Warnings            │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

Why this beats every other hackathon submission:

• Single-shot generators (Copilot, GPT wrappers): Generate once, no validation → produce tests that miss bugs
• TestGenius: Generate → Score → Identify weaknesses → Re-generate stronger tests → Verify coverage

---

✨ 8 Novelty Features

#	Feature	Research Basis	What It Does
1	🔄 Iterative Refinement	MuTAP (ISSTA'23)	Tests improve across iterations using mutation feedback
2	📊 Behavior Coverage	Qodo/CodiumAI concept	Maps WHICH behaviors are tested vs untested
3	🧬 Mutation-Guided Testing	MuTAP + EvoSuite	Identifies test gaps where mutations would survive
4	🧠 Code Complexity Analysis	McCabe (1976)	AST-based cyclomatic complexity → prioritizes testing
5	🔍 Coverage Gap Detection	Static analysis	Finds untested error paths, branches, external calls
6	📈 Test Quality Scoring	Test smell research	Grades tests A-D on 5 dimensions
7	🔐 API Security Scanner	OWASP Top 10	Detects injection points, missing auth, path traversal
8	🤖 Multi-Agent Architecture	Code Agents (arxiv:2406.12952)	5 specialized agents, not one monolithic prompt

---

🚀 Quick Start

# Backend
cd backend
pip install -r requirements.txt
cp .env.example .env   # Set LLM_BASE_URL, LLM_API_KEY, LLM_MODEL
uvicorn app.main:app --reload --port 8000

# Frontend  
cd frontend
npm install && npm run dev
# → http://localhost:5173

Docker (Full Stack)

cp backend/.env.example backend/.env  # Set your LLM API key
docker-compose up -d
# → Backend: http://localhost:8000/docs
# → Frontend: http://localhost:3000

Custom LLM (.env)

# Works with ANY OpenAI-compatible API:
LLM_BASE_URL=https://api.groq.com/openai/v1
LLM_API_KEY=gsk_your_key
LLM_MODEL=llama-3.3-70b-versatile

Supports: Groq, Featherless, OpenAI, Together, DeepSeek, OpenRouter, Mistral, Ollama, LM Studio

---

📡 API Endpoints

Method	Endpoint	Description
POST	/api/v1/generate/from-requirements	Generate from product requirements
POST	/api/v1/generate/from-api-spec	Generate from OpenAPI/Swagger
POST	/api/v1/generate/from-code	Generate unit tests from source code
POST	/api/v1/generate/from-flow	Generate E2E tests from user flow
POST	/api/v1/generate/unified	All inputs → full test suite
POST	/api/v1/generate/multi-agent	🧠 Multi-agent iterative pipeline
POST	/api/v1/generate/multi-agent/stream	Streaming SSE pipeline
POST	/api/v1/analyze/behaviors	Extract testable behaviors
POST	/api/v1/analyze/complexity	AST complexity analysis
POST	/api/v1/analyze/security	OWASP API security scan
POST	/api/v1/analyze/mutations	Identify mutation points
POST	/api/v1/analyze/mutations/execute	🧬 Run real mutation testing
POST	/api/v1/analyze/quality	Score test quality (A-D)
POST	/api/v1/analyze/gaps	Coverage gap detection
GET	/api/v1/usage	Token usage & cost tracking
GET	/api/v1/frameworks	Supported frameworks
GET	/api/v1/provider	Current LLM provider info
GET	/health	System health + capabilities

---

📊 Multi-Agent Response (Example)

{
  "run_id": "MAS-a7f3b2c9",
  "pipeline": "multi-agent-iterative-v2",
  "quality": {
    "overall": 82,
    "grade": "A",
    "scores": {"assertions": 8, "edge_cases": 7, "error_handling": 9, "isolation": 8, "docs": 6}
  },
  "syntax_validation": {"valid": true, "test_count": 18, "has_assertions": true},
  "behavior_coverage": {
    "total_behaviors": 18,
    "covered": 15,
    "uncovered": 3,
    "coverage_pct": 83.3
  },
  "mutation_testing": {
    "total_mutants": 12,
    "killed": 9,
    "survived": 3,
    "mutation_score": 75.0
  },
  "iterations_performed": 2,
  "processing_time_ms": 4200
}

---

📁 Project Structure

testgenius-ai/
├── backend/
│   ├── app/
│   │   ├── main.py
│   │   ├── api/
│   │   │   ├── generate.py              # Standard generation endpoints
│   │   │   ├── multi_agent_routes.py     # 🧠 Multi-agent + analysis endpoints
│   │   │   └── frameworks.py
│   │   └── services/
│   │       ├── llm_provider.py           # Universal LLM (any provider)
│   │       ├── test_generator.py         # Core generation logic
│   │       ├── prompt_builder.py         # Structured prompts
│   │       ├── multi_agent_engine.py     # 🧠 5-agent iterative pipeline
│   │       └── novelty_features.py       # Complexity, mutations, security
│   ├── tests/                            # Pytest test suite
│   ├── Dockerfile
│   ├── requirements.txt
│   └── .env.example
├── frontend/
│   ├── src/
│   │   ├── App.tsx                       # Router + Error Boundary
│   │   └── pages/
│   │       ├── LandingPage.tsx           # Hero + features
│   │       ├── GeneratePage.tsx          # Multi-tab input + output
│   │       ├── AnalyzePage.tsx           # Deep code analysis
│   │       └── HistoryPage.tsx           # Previous generations
│   ├── Dockerfile
│   └── package.json
├── docker-compose.yml
└── README.md

---

🏆 Why This Wins the Hackathon

What Judges Look For	What We Deliver
Creativity	Multi-agent iterative refinement (no other team has this)
Technical depth	AST parsing, real mutation execution, OWASP scanning, behavior mapping
AI integration	Not "call GPT and return" — 5-agent pipeline with feedback loops
Real-world usability	Paste code → get production-ready tests in 3 seconds
Research backing	Cites MuTAP (ISSTA'23), HITS (ASE'24), Code Agents (2406.12952)
Production quality	FastAPI + Docker + Pydantic + universal LLM + pytest suite

What Makes This UNIQUE vs Every Other Submission:

"Other teams will call an LLM once and return whatever it outputs. We call it, VALIDATE the output, identify weaknesses using mutation analysis, then ITERATIVELY IMPROVE until quality reaches grade A — exactly like the MuTAP paper from ISSTA 2023. That's not a wrapper — that's a research-grade AI agent."

---

🧪 Running Tests

cd backend
pip install -r requirements.txt
pytest tests/ -v

---

📄 License

MIT

---

TestGenius AI — Not just generating tests. Generating BETTER tests, iteratively.

Research-grade quality. Production-ready deployment. Hackathon-winning novelty.