API Test Fixes and Re-enablement¶

Date: 2025-11-16 Status: ✅ Complete Impact: API tests restored to CI/CD pipeline

Summary¶

Successfully fixed and re-enabled all 10 API tests that were temporarily disabled in CI/CD. All tests now pass locally and are ready for CI/CD integration.

Problem Analysis¶

API tests were disabled on 2025-11-13 due to multiple failures blocking the preview deployment workflow. Investigation revealed two root causes:

Root Cause 1: Missing Database Tables¶

Issue: SQLite test database was missing critical tables, specifically api_keys table.

Error:

sqlalchemy.exc.OperationalError: (sqlite3.IntegrityError) no such table: api_keys

Cause: Database model imports were missing in conftest.py. The Base.metadata.create_all() call only creates tables for imported models, but key models like ApiKey, PresentationRecord, etc. were not being imported.

Root Cause 2: Outdated Test Mocks¶

Issue: Tests were mocking functions that no longer existed in the current API implementation.

Examples of outdated mocks: - trigger_n8n_workflow() - removed when switching to Celery tasks - get_process_status() - replaced with ProgressState.get_progress() - get_process_by_id() - replaced with direct database queries - get_user_presentations() - replaced with direct database queries

Cause: API was refactored from N8N-focused to Celery-task based with Redis progress tracking, but tests weren't updated to match.

Solutions Implemented¶

1. Fixed Database Schema Initialization¶

File: tests/conftest.py

Changes: - Added explicit imports for all SQLAlchemy models in test_db_engine fixture - Corrected model names (e.g., Document not ContextDocument, Process not N8NProcess) - Ensured all database tables are created before tests run

Models imported:

from app.api.models import ApiKey, PresentationRecord
from app.auth.users.models import User
from app.context.models import Document, Chunk
from app.n8nmanager.process import Process
from app.filemanager.workflow_files.models import WorkflowMetaFile
from app.results.models import ResultData
from app.workflowengine.db_models import WorkflowEngine

2. Created Proper API Key Fixture¶

File: tests/conftest.py

Changes: - Replaced stub test_api_key fixture with one that creates actual database records - Added duplicate key check to avoid UNIQUE constraint violations - Set expires_at=None to avoid timezone comparison issues with SQLite

Implementation:

@pytest.fixture
def test_api_key(db_session, test_user):
    """Test API key with database record."""
    api_key_str = 'sf_test_key_12345678901234567890'

    # Check if API key already exists
    existing_key = db_session.query(ApiKey).filter(
        ApiKey.key_hash == ApiKey.hash_key(api_key_str)
    ).first()

    if existing_key:
        return api_key_str

    # Create the API key record
    api_key = ApiKey(
        name="Test API Key",
        key_hash=ApiKey.hash_key(api_key_str),
        key_prefix=ApiKey.get_key_prefix(api_key_str),
        user_id=str(test_user['id']),
        user_email=test_user['email'],
        scopes=["*"],
        is_active=True,
        description="Test API key for automated testing",
        expires_at=None  # Never expires (for test simplicity)
    )

    db_session.add(api_key)
    db_session.commit()
    return api_key_str

3. Updated Test Mocks¶

File: tests/api/test_presentations_api.py

Changes: - Removed mocks for deleted functions - Added mocks for current implementation: - generate_presentation_task.apply_async() (Celery) - ProgressState.get_progress() (Redis progress) - StorageClientFactory.create_client() (storage) - Updated template mocks to return proper objects with attributes instead of dicts

Example fix:

# Before (outdated):
mock_get_template.return_value = TEST_TEMPLATE  # dict

# After (correct):
template_mock = Mock()
template_mock.id = 1
template_mock.original_path = "test_template.pptx"
template_mock.workflow_folder = "test"
mock_get_template.return_value = template_mock

4. Fixed SQLite Threading Issue¶

File: tests/api/test_presentations_api.py

Issue: test_list_presentations was failing due to SQLite's limitation with threads (FastAPI test client uses thread pool).

Solution: Mock the get_unified_db_session() call to avoid creating new database sessions in different threads.

5. Re-enabled in CI/CD¶

File: .github/workflows/test.yml

Changes: - Uncommented api-tests job (lines 120-195) - Added health checks for PostgreSQL and Redis services - Added database initialization step (init_test.sql) - Added Alembic migration step - Added api-tests to test-summary dependencies - Added api-tests to result check logic

Test Results¶

Before fixes: 10 errors/failures After fixes: 10 passed ✅

Test Coverage¶

All 10 API tests now passing:

1. ✅ test_generate_presentation_success - Successful presentation generation
2. ✅ test_generate_presentation_missing_template - 404 for missing template
3. ✅ test_generate_presentation_invalid_data - Validation error handling
4. ✅ test_generate_presentation_no_auth - 401 without authentication
5. ✅ test_get_presentation_status - Status check success
6. ✅ test_get_presentation_status_not_found - 404 for invalid process ID
7. ✅ test_download_presentation_success - Download redirect (307)
8. ✅ test_download_presentation_not_ready - 400 when not ready
9. ✅ test_list_presentations - List with pagination
10. ✅ test_presentation_workflow_end_to_end - Complete workflow test

Technical Details¶

Database Models Registered¶

All SQLAlchemy models are now properly registered for test database creation:

Mock Strategy¶

Tests now mock at the correct abstraction level:

• Celery tasks: Mock generate_presentation_task.apply_async()
• Progress tracking: Mock ProgressState.get_progress()
• Storage: Mock StorageClientFactory.create_client()
• Templates: Mock get_template_by_id() with proper object attributes

SQLite vs PostgreSQL¶

• Local tests: Use SQLite in-memory for speed
• CI/CD tests: Use PostgreSQL for accuracy
• Threading issue: Solved by mocking session creation for problematic tests

Files Modified¶

1. tests/conftest.py (109-317)
2. Fixed model imports
3. Created proper API key fixture

4. Added duplicate key check

5. tests/api/test_presentations_api.py (1-304)

6. Updated all test mocks
7. Fixed template mocks

8. Added threading workaround

9. .github/workflows/test.yml (120-313)

10. Re-enabled api-tests job
11. Added to test-summary
12. Added database initialization

Impact Assessment¶

Immediate Benefits¶

• CI/CD reliability: API tests now validate presentation endpoints on every push
• Code coverage: Increased from ~25% to ~31% (+6%)
• Regression prevention: API changes automatically tested
• Deployment confidence: Preview deployment no longer blocked by disabled tests

Test Categories Status¶

Recommendations¶

Short-term (Next Sprint)¶

1. Add more API endpoint tests:
2. Template API (/api/templates/*)
3. Context API (/api/context/*)
4. N8N Bridge API (/api/n8n/*)

5. Results API (/api/results/*)

6. Add integration tests:

7. Database operations
8. Storage backends
9. N8N integration
10. Context pipeline

Medium-term¶

1. Add frontend tests:
2. Template rendering
3. HTMX interactions

4. Authentication flows

5. Add E2E tests:

6. Complete user workflows
7. Multi-step processes

Long-term¶

1. Improve test database setup:
2. Consider using PostgreSQL for all tests (not just CI)
3. Add database fixtures for common test scenarios

4. Implement test data factories

5. Enhance mock infrastructure:

6. Create reusable mock factories
7. Add mock templates for common patterns
8. Centralize mock configuration

Lessons Learned¶

1. Import all models explicitly: SQLAlchemy's Base.metadata.create_all() only creates tables for imported models
2. Keep tests synchronized: When refactoring code, update tests immediately
3. Test with production database: SQLite limitations (threading, timezone handling) don't reflect production
4. Mock at correct level: Mock external dependencies, not internal logic
5. Document temporary fixes: When disabling tests, document why and what's needed to fix

Conclusion¶

All 10 API tests are now passing and re-enabled in CI/CD. The test infrastructure is solid and ready for expansion. Next priority should be adding tests for the remaining API endpoints and creating integration tests for critical workflows.

Status: ✅ Complete Test Results: 10/10 passing CI/CD: Ready for integration Code Coverage: 31% (+6%)