Building Your First AI-Powered Test Case Generator

# Simple architecture
User Input (Feature Description)
  ↓
Prompt Template (Your QA expertise)
  ↓
OpenAI API (GPT-4)
  ↓
Test Cases (Your format)
  ↓
Output (CSV, JSON, or direct to test tool)

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install openai python-dotenv

# Create .env file
echo "OPENAI_API_KEY=your_key_here" > .env

from string import Template

# Your QA expertise goes here
PROMPT_TEMPLATE = Template("""
You are a senior QA engineer. Generate comprehensive test cases for the following feature.

Feature Name: $feature_name
Description: $description
User Story: $user_story

Requirements:
$requirements

Generate test cases in this exact format:

Test Case ID | Title | Preconditions | Steps | Expected Result | Priority | Type

Include:
- Positive test cases (happy path)
- Negative test cases (error handling)
- Edge cases and boundary conditions
- Security considerations
- Performance edge cases

Use Given-When-Then format for steps.
Priority: Critical, High, Medium, Low
Type: Functional, Security, Performance, Usability

Generate 15-20 test cases covering all scenarios.
""")

import os
from openai import OpenAI
from dotenv import load_dotenv
from prompt_template import PROMPT_TEMPLATE

load_dotenv()

class TestCaseGenerator:
  def __init__(self):
      self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

  def generate(self, feature_name, description, user_story, requirements):
      """Generate test cases for a feature"""

      # Fill in the prompt template
      prompt = PROMPT_TEMPLATE.substitute(
          feature_name=feature_name,
          description=description,
          user_story=user_story,
          requirements=requirements
      )

      # Call OpenAI API
      response = self.client.chat.completions.create(
          model="gpt-4",  # or "gpt-4-turbo" for faster/cheaper
          messages=[
              {
                  "role": "system",
                  "content": "You are an expert QA engineer specializing in test case design."
              },
              {
                  "role": "user",
                  "content": prompt
              }
          ],
          temperature=0.7,  # Balance creativity and consistency
          max_tokens=2000
      )

      return response.choices[0].message.content

  def save_to_csv(self, test_cases, filename):
      """Save generated test cases to CSV"""
      with open(filename, 'w') as f:
          f.write(test_cases)
      print(f"Test cases saved to {filename}")

# Usage
if __name__ == "__main__":
  generator = TestCaseGenerator()

  test_cases = generator.generate(
      feature_name="User Login",
      description="Email/password authentication with remember me option",
      user_story="As a user, I want to log in with my email and password so I can access my account",
      requirements="""
      - Email and password fields required
      - "Remember me" checkbox (optional)
      - Forgot password link
      - Account lockout after 5 failed attempts
      - Session timeout after 30 minutes of inactivity
      """
  )

  generator.save_to_csv(test_cases, "login_test_cases.csv")
  print(test_cases)

# Add this to your generator class
class TestCaseGenerator:
  def __init__(self, domain_context=None):
      self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
      self.domain_context = domain_context or self.default_domain_context()

  def default_domain_context(self):
      """Your domain expertise"""
      return """
      Domain: E-commerce web application

      Standard Security Checks:
      - SQL injection attempts
      - XSS attacks
      - CSRF protection
      - Session hijacking

      Common Edge Cases:
      - Unicode characters in inputs
      - Very long strings (>1000 chars)
      - Special characters in email
      - Concurrent user sessions

      Compliance Requirements:
      - GDPR data handling
      - PCI DSS for payment data
      - WCAG 2.1 AA accessibility

      Performance Baselines:
      - Page load: <2 seconds
      - API response: <500ms
      - Support 1000 concurrent users
      """

  def generate(self, feature_name, description, user_story, requirements):
      # Prepend domain context to every prompt
      full_prompt = f"{self.domain_context}\n\n{PROMPT_TEMPLATE.substitute(...)}"
      # ... rest of the method

import json
from test_case_generator import TestCaseGenerator

def batch_generate(features_file):
  """Generate test cases for multiple features from JSON"""

  generator = TestCaseGenerator()

  # Load features from JSON
  with open(features_file, 'r') as f:
      features = json.load(f)

  results = {}

  for feature in features:
      print(f"Generating test cases for: {feature['name']}...")

      test_cases = generator.generate(
          feature_name=feature['name'],
          description=feature['description'],
          user_story=feature['user_story'],
          requirements=feature['requirements']
      )

      results[feature['name']] = test_cases

      # Save individual files
      filename = f"test_cases_{feature['name'].lower().replace(' ', '_')}.csv"
      generator.save_to_csv(test_cases, filename)

  return results

# Usage: python batch_processor.py features.json
if __name__ == "__main__":
  import sys
  batch_generate(sys.argv[1])

[
{
  "name": "User Login",
  "description": "Email/password authentication",
  "user_story": "As a user, I want to log in...",
  "requirements": "- Email required\n- Password required..."
},
{
  "name": "Product Search",
  "description": "Search products by keyword",
  "user_story": "As a user, I want to search...",
  "requirements": "- Search bar\n- Filters..."
}
]

from jira import JIRA

class JiraIntegration:
  def __init__(self, server, email, api_token):
      self.jira = JIRA(server=server, basic_auth=(email, api_token))

  def create_test_case(self, project_key, test_case):
      """Create a test case in Jira"""
      issue_dict = {
          'project': {'key': project_key},
          'summary': test_case['title'],
          'description': self.format_test_case(test_case),
          'issuetype': {'name': 'Test'},
      }

      new_issue = self.jira.create_issue(fields=issue_dict)
      return new_issue.key

  def format_test_case(self, test_case):
      """Format test case for Jira"""
      return f"""
      *Preconditions:*
      {test_case['preconditions']}

      *Steps:*
      {test_case['steps']}

      *Expected Result:*
      {test_case['expected_result']}

      *Priority:* {test_case['priority']}
      *Type:* {test_case['type']}
      """

# Usage
jira = JiraIntegration(
  server="https://your-domain.atlassian.net",
  email="your-email@example.com",
  api_token="your_api_token"
)

jira.create_test_case("PROJ", test_case)

Bad: "Generate test cases"
Good: "Generate test cases in this EXACT format: [format]
Do not add any extra text before or after the table."

# Add example test cases to your prompt
EXAMPLE_TEST_CASE = """
Example of a good test case:
TC-001 | Login with valid credentials | User has account | GIVEN user on login page WHEN enters valid email and password THEN redirected to dashboard | Success | Critical | Functional
"""

"Also consider these edge cases:
- Very long inputs (>1000 characters)
- Special characters: <>"'&
- Concurrent requests
- Network timeouts
- Database failures"