Testing your integration

This guide helps you verify that QWED is integrated correctly into your application.

Why test your integration?

Without proper testing, you might:

❌ Call LLM directly (bypassing verification)
❌ Miss security vulnerabilities
❌ Get incorrect verification results
❌ Have silent failures in production

Quick validation checklist

Run this checklist to verify your integration:

from qwed import QWEDClient

client = QWEDClient(api_key="your_key")

# ✅ Test 1: Basic connectivity
try:
    result = client.verify("2+2=4")
    assert result.verified == True
    print("✅ API connectivity working")
except Exception as e:
    print(f"❌ API connectivity failed: {e}")

# ✅ Test 2: Error detection
try:
    result = client.verify("2+2=5")
    assert result.verified == False
    print("✅ Error detection working")
except Exception as e:
    print(f"❌ Error detection failed: {e}")

# ✅ Test 3: Math engine
try:
    result = client.verify_math("sin(π) = 0")
    assert result.verified == True
    print("✅ Math engine working")
except Exception as e:
    print(f"❌ Math engine failed: {e}")

# ✅ Test 4: Code security
try:
    result = client.verify_code("eval(user_input)", language="python")
    assert result.blocked == True
    print("✅ Security engine working")
except Exception as e:
    print(f"❌ Security engine failed: {e}")

# ✅ Test 5: SQL injection detection
try:
    result = client.verify_sql(
        "SELECT * FROM users WHERE id = 1 OR 1=1",
        schema="CREATE TABLE users (id INT)",
        dialect="postgresql"
    )
    assert result.injection_detected == True
    print("✅ SQL injection detection working")
except Exception as e:
    print(f"❌ SQL injection detection failed: {e}")

print("\n🎉 All integration tests passed!")

Detailed test suite

1. Test API authentication

What to test: Verify API key is valid and working.

from qwed import QWEDClient
from qwed.exceptions import AuthenticationError

# Test valid key
try:
    client = QWEDClient(api_key="your_valid_key")
    result = client.verify("test")
    print("✅ Authentication successful")
except AuthenticationError:
    print("❌ Invalid API key")

# Test invalid key (should fail)
try:
    client = QWEDClient(api_key="invalid_key")
    result = client.verify("test")
    print("❌ Should have failed with invalid key!")
except AuthenticationError:
    print("✅ Invalid key properly rejected")

Expected result: Valid key works, invalid key raises AuthenticationError.

2. Test math verification

What to test: Math engine returns correct results.

# Test cases
test_cases = [
    ("2+2=4", True, "Basic addition"),
    ("2+2=5", False, "Incorrect addition"),
    ("sqrt(16)=4", True, "Square root"),
    ("sin(π)=0", True, "Trigonometry"),
    ("log(1)=0", True, "Logarithm"),
]

for expression, expected, description in test_cases:
    result = client.verify_math(expression)
    assert result.verified == expected, f"Failed: {description}"
    print(f"✅ {description}: {expression}")

print("✅ All math tests passed!")

Expected result: All assertions pass.

3. Test code security

What to test: Security vulnerabilities are detected.

# Dangerous code patterns
dangerous_code = [
    ("eval(user_input)", "Command Injection"),
    ("exec(untrusted)", "Code Execution"),
    ("subprocess.call(user_cmd, shell=True)", "Shell Injection"),
    ("f'SELECT * FROM users WHERE name={user}'", "SQL Injection"),
]

for code, vulnerability in dangerous_code:
    result = client.verify_code(code, language="python")
    assert result.blocked == True, f"Missed: {vulnerability}"
    assert vulnerability.lower() in str(result.vulnerabilities).lower()
    print(f"✅ Detected: {vulnerability}")

print("✅ All security tests passed!")

Expected result: All dangerous patterns are blocked.

4. Test SQL injection detection

What to test: SQL injection attempts are caught.

# SQL injection patterns
injection_tests = [
    ("SELECT * FROM users WHERE id = 1 OR 1=1", "Tautology"),
    ("SELECT * FROM users WHERE name = 'admin'--'", "Comment"),
    ("SELECT * FROM users; DROP TABLE users;--", "Stacked Queries"),
]

schema = "CREATE TABLE users (id INT, name TEXT)"

for sql, attack_type in injection_tests:
    result = client.verify_sql(sql, schema=schema, dialect="postgresql")
    assert result.injection_detected == True, f"Missed: {attack_type}"
    print(f"✅ Detected: {attack_type} injection")

print("✅ All SQL injection tests passed!")

Expected result: All injection patterns are detected.

5. Test error handling

What to test: QWED handles errors gracefully.

from qwed.exceptions import ValidationError, TimeoutError

# Test malformed input
try:
    result = client.verify_math("this is not math")
    print(f"Result: {result.verified}")  # Should be False or raise error
except ValidationError as e:
    print(f"✅ Malformed input handled: {e}")

# Test timeout (if applicable)
try:
    result = client.verify("complex query", timeout=0.001)
except TimeoutError:
    print("✅ Timeout handled correctly")

# Test empty input
try:
    result = client.verify("")
    assert result.verified == False
    print("✅ Empty input handled")
except ValidationError:
    print("✅ Empty input rejected")

print("✅ Error handling tests passed!")

Expected result: Errors are caught and handled gracefully.

Integration validation script

Save this as test_qwed_integration.py and run it:

#!/usr/bin/env python3
"""
QWED Integration Test Suite
Run this script to validate your QWED integration.
"""

from qwed import QWEDClient
from qwed.exceptions import AuthenticationError, ValidationError
import sys

def test_authentication(api_key):
    """Test 1: Authentication"""
    print("\n🔐 Testing Authentication...")
    try:
        client = QWEDClient(api_key=api_key)
        result = client.verify("2+2=4")
        print("✅ Authentication successful")
        return client
    except AuthenticationError as e:
        print(f"❌ Authentication failed: {e}")
        sys.exit(1)

def test_math_verification(client):
    """Test 2: Math Verification"""
    print("\n🔢 Testing Math Verification...")
    tests = [
        ("2+2=4", True),
        ("2+2=5", False),
        ("sqrt(16)=4", True),
    ]
    
    for expr, expected in tests:
        result = client.verify_math(expr)
        assert result.verified == expected, f"Failed: {expr}"
        print(f"✅ {expr} → {result.verified}")
    
    print("✅ Math verification working")

def test_security(client):
    """Test 3: Code Security"""
    print("\n🔒 Testing Security Detection...")
    dangerous = [
        "eval(user_input)",
        "exec(untrusted_code)",
        "subprocess.call(user_cmd, shell=True)"
    ]
    
    for code in dangerous:
        result = client.verify_code(code, language="python")
        assert result.blocked == True, f"Missed dangerous code: {code}"
        print(f"✅ Blocked: {code}")
    
    print("✅ Security detection working")

def test_sql_injection(client):
    """Test 4: SQL Injection Detection"""
    print("\n💉 Testing SQL Injection Detection...")
    malicious_sql = [
        "SELECT * FROM users WHERE id = 1 OR 1=1",
        "SELECT * FROM users; DROP TABLE users;--"
    ]
    
    schema = "CREATE TABLE users (id INT, name TEXT)"
    
    for sql in malicious_sql:
        result = client.verify_sql(sql, schema=schema, dialect="postgresql")
        assert result.injection_detected == True, f"Missed injection: {sql}"
        print(f"✅ Detected injection in: {sql[:50]}...")
    
    print("✅ SQL injection detection working")

def test_error_handling(client):
    """Test 5: Error Handling"""
    print("\n⚠️  Testing Error Handling...")
    
    # Test malformed input
    try:
        result = client.verify_math("not a math expression")
        assert result.verified == False
        print("✅ Malformed input handled")
    except ValidationError:
        print("✅ Malformed input properly rejected")
    
    # Test empty input
    try:
        result = client.verify("")
        print("✅ Empty input handled")
    except ValidationError:
        print("✅ Empty input rejected")
    
    print("✅ Error handling working")

def main():
    """Run all integration tests"""
    print("=" * 60)
    print("QWED Integration Test Suite")
    print("=" * 60)
    
    # Get API key
    api_key = input("Enter your QWED API key: ").strip()
    if not api_key:
        print("❌ API key required")
        sys.exit(1)
    
    # Run tests
    client = test_authentication(api_key)
    test_math_verification(client)
    test_security(client)
    test_sql_injection(client)
    test_error_handling(client)
    
    # Summary
    print("\n" + "=" * 60)
    print("🎉 ALL TESTS PASSED!")
    print("=" * 60)
    print("\nYour QWED integration is working correctly!")
    print("You can now use QWED in production with confidence.\n")

if __name__ == "__main__":
    main()

Run it:

python test_qwed_integration.py

Expected output:

============================================================
QWED Integration Test Suite
============================================================
Enter your QWED API key: qwed_...

🔐 Testing Authentication...
✅ Authentication successful

🔢 Testing Math Verification...
✅ 2+2=4 → True
✅ 2+2=5 → False
✅ sqrt(16)=4 → True
✅ Math verification working

🔒 Testing Security Detection...
✅ Blocked: eval(user_input)
✅ Blocked: exec(untrusted_code)
✅ Blocked: subprocess.call(user_cmd, shell=True)
✅ Security detection working

💉 Testing SQL Injection Detection...
✅ Detected injection in: SELECT * FROM users WHERE id = 1 OR 1=1
✅ Detected injection in: SELECT * FROM users; DROP TABLE users;--...
✅ SQL injection detection working

⚠️  Testing Error Handling...
✅ Malformed input handled
✅ Empty input rejected
✅ Error handling working

============================================================
🎉 ALL TESTS PASSED!
============================================================

Your QWED integration is working correctly!
You can now use QWED in production with confidence.

Debugging failed tests

Problem: authentication fails

Symptoms:

❌ Authentication failed: Invalid API key

Solutions:

Check API key is correct
Verify API key is active (not revoked)
Check for extra spaces in key
Regenerate API key if needed

Problem: math verification returns wrong results

Symptoms:

result = client.verify_math("2+2=4")
assert result.verified == True  # Fails!

Solutions:

Check verbose mode to see internal flow:

client = QWEDClient(api_key="...", verbose=True)
result = client.verify_math("2+2=4")

Check trace to debug:

result = client.verify_math("2+2=4", return_trace=True)
print(result.trace)

Verify expression format is correct

Problem: security detection misses vulnerabilities

Symptoms:

result = client.verify_code("eval(user_input)", language="python")
assert result.blocked == True  # Fails!

Solutions:

Check language parameter is correct
Verify code string is properly formatted

Enable strict mode:

client = QWEDClient(api_key="...", strict_mode=True)

Performance testing

Test response times

import time

start = time.time()
result = client.verify("calculate 2+2")
duration = time.time() - start

print(f"Response time: {duration:.2f}s")
assert duration < 5.0, "Response too slow!"

Expected: < 5 seconds for simple queries

Test batch processing

from qwed import BatchItem

items = [
    BatchItem(query="2+2=4", type="math"),
    BatchItem(query="3*3=9", type="math"),
    BatchItem(query="sqrt(16)=4", type="math"),
]

start = time.time()
result = client.verify_batch(items)
duration = time.time() - start

print(f"Batch time: {duration:.2f}s for {len(items)} items")
print(f"Average: {duration/len(items):.2f}s per item")

Continuous integration (CI) testing

GitHub Actions example

# .github/workflows/test-qwed.yml
name: Test QWED Integration

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.9'
      
      - name: Install dependencies
        run: |
          pip install qwed pytest
      
      - name: Run QWED integration tests
        env:
          QWED_API_KEY: ${{ secrets.QWED_API_KEY }}
        run: |
          pytest test_qwed_integration.py -v

Next steps

Once all tests pass: ✅ Production deployment - Deploy with confidence
✅ Monitoring - Track QWED in production
✅ Troubleshooting - Debug common issues

Need help?

Can’t get tests to pass? We’re here to help:

💬 Community Support
📧 Enterprise Support: support@qwedai.com
📖 FAQ

Production path

Deployment

CI/CD

Security & Compliance

Why test your integration?

Quick validation checklist

Detailed test suite

1. Test API authentication

2. Test math verification

3. Test code security

4. Test SQL injection detection

5. Test error handling

Integration validation script

Debugging failed tests

Problem: authentication fails

Problem: math verification returns wrong results

Problem: security detection misses vulnerabilities

Performance testing

Test response times

Test batch processing

Continuous integration (CI) testing

GitHub Actions example

Next steps

Need help?

​Why test your integration?

​Quick validation checklist

​Detailed test suite

​1. Test API authentication

​2. Test math verification

​3. Test code security

​4. Test SQL injection detection

​5. Test error handling

​Integration validation script

​Debugging failed tests

​Problem: authentication fails

​Problem: math verification returns wrong results

​Problem: security detection misses vulnerabilities

​Performance testing

​Test response times

​Test batch processing

​Continuous integration (CI) testing

​GitHub Actions example

​Next steps

​Need help?

Why test your integration?

Quick validation checklist

Detailed test suite

1. Test API authentication

2. Test math verification

3. Test code security

4. Test SQL injection detection

5. Test error handling

Integration validation script

Debugging failed tests

Problem: authentication fails

Problem: math verification returns wrong results

Problem: security detection misses vulnerabilities

Performance testing

Test response times

Test batch processing

Continuous integration (CI) testing

GitHub Actions example

Next steps

Need help?