Core components for Campus apps smoke tests

[lukeskywalker22]

Core components for smoke tests

Test Client Fixture:
A reusable pytest fixture that initializes the Flask app in TESTING=True mode and provides a test_client for making isolated HTTP requests without running a live server.

App Initialization Test:
Verifies that the Flask application module imports successfully and the app object exists and is properly initialized (i.e. can create a test client and routing map).

Route Presence Test:
Checks that critical application routes are registered in the Flask app’s URL map, ensuring essential endpoints exist. Uses subset validation so the test only verifies required routes are present without enforcing a complete or rigid route list.

Sample AI prompt for smoke test generation (adjust according to needs)

Create a pytest-based smoke test suite for a Flask application.

Purpose of Smoke Tests

Smoke tests should:

Run fast and be executed before every commit (CI gate)
Only verify basic application sanity
Ensure the application can start and key routes respond without crashing
Avoid deep logic validation or edge-case testing
Avoid external dependencies (no network calls, file I/O, or database access)
Project Testing Structure

Tests should follow this organization:

tests/
  smoke/
  unit/
  contract/
  integration/

Smoke tests must live under tests/smoke/.

Use pytest test discovery (pytest CLI via Poetry).

Requirements for This Smoke Test Suite
Use pytest
Use a client fixture that:
Imports the Flask app using getDebugApp from main.py
Sets app.config["TESTING"] = True
Uses app.test_client() as a context manager
Returns a test client instance for use in tests
Smoke Test Coverage Expectations

Include only minimal sanity checks such as:

The application starts successfully without import/runtime errors
Core routes respond successfully (e.g. HTTP 200 or expected redirect)
Response objects are valid and not crashing (basic contract of “app is alive”)

At minimum, validate:

Root endpoint / responds and behaves as expected at a high level (e.g. redirect or reachable)
Main public page /menu loads successfully and returns HTML content
Assertions Guidelines
Keep assertions minimal and stability-focused
Do not test business logic or edge cases

These tests should act as a CI smoke gate:
If they fail, the application is fundamentally broken (cannot start, routes not wired, or major regressions).

Helpful additional context to provide:

- The Flask app import path
- List of routes to test for presence

Sample tests (adjust according to own app structure)

import pytest
import importlib
import subprocess

# ----------------------------
# Fixture: safely load module
# ----------------------------
@pytest.fixture(scope="session")
def main_module():
    """
    Import the main module once and reuse across tests.
    Fails early if app cannot be imported at all.
    """
    try:
        return importlib.import_module("main")
    except ImportError as e:
        pytest.fail(f"Failed to import main module: {e}")


# ----------------------------
# Smoke Test: app exists
# ----------------------------
def test_app_exists(main_module):
    """
    Smoke test: ensure Flask app object exists and is initialized.
    """
    assert hasattr(main_module, "app"), "Flask app instance not found in main.py"

    app = main_module.app
    assert app is not None, "Flask app is None"

# ----------------------------
# Contract-level smoke check: routes exist
# ----------------------------
def test_basic_routes_exist(main_module):
    """
    Ensures critical routes are registered without requiring exact route completeness.
    This avoids brittle full-route assertions.
    """
    app = main_module.app
    routes = {rule.rule for rule in app.url_map.iter_rules()}

    required_routes = {
        "/",
        "/menu",
        "/timetable",
        "/upload",
    }

    for route in required_routes:
        assert route in routes

# ----------------------------
# Environment validation (CI safety)
# ----------------------------
def test_poetry_lock_up_to_date():
    """
    Ensures dependency lock file is consistent.
    """
    result = subprocess.run(
        ["poetry", "lock", "--check"],
        capture_output=True,
        text=True
    )

    assert result.returncode == 0, (
        "poetry.lock is out of date. Run `poetry lock` to fix."
    )

[ngjunsiang]

Use follow_redirects=False to test the raw response status
Check status codes: 200 (success), 302 (redirect), 401 (unauthorized)
Validate response data: HTML content, redirect locations

These are contract tests actually; checking that the app, when given certain input, returns certain output.

Smoke tests are:

• checking that the app doesn't crash when being created because of ImportError
• checking that the app actually has routes (blueprints are correctly registered/inited)
• checking that poetry lockfile is updated

[lukeskywalker22]

Updated to check these attributes for smoke tests

[ngjunsiang]

And I think the AI prompt need not specify which tests to add, rather should clarify the intent and purpose of tests.

Smoke tests: should be fast (run before every commit), only do basic sanity checks without "digging into detail"
Unit tests: test a single function/class without invoking other modules that depend on it; self-contained tests that do not make network calls, read/write files, etc
Contract tests: test that routes, resources, endpoints, etc return a correct data format, raise the correct error, return current response status code, etc when given a acertain input
integration tests: test that multiple modules work together correctly; flask client requests successfully trigger view functions and result in database queries. May involve file IO, database activity, network requests. Expected to be slow but not too slow; typically only run during PR to check for inter-module breakage

Also state expected standards, e.g.:

• tests should be organized in subdirectories by test type (/smoke, /unit, /contract, /integration)
• use test autodiscovery (e.g. run with poetry run python -m unittest or )poetry run python -m pytest depending on which test framework is used)

[lukeskywalker22]

Updated

[ngjunsiang]

@sparsetable for devops could you also look into setting up git hooks ? Some that I'm thinking of:

• pre-commit: run ruff autoformatter to ensure consistent code format
• pre-push: run smoke tests as a basic sanity layer, run ruff checker for static checking issues