aboutsummaryrefslogtreecommitdiff
path: root/tests/test_cli.py
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--tests/test_cli.py650
1 files changed, 650 insertions, 0 deletions
diff --git a/tests/test_cli.py b/tests/test_cli.py
new file mode 100644
index 0000000..f6b7051
--- /dev/null
+++ b/tests/test_cli.py
@@ -0,0 +1,650 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import logging
+from collections.abc import Iterator
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+import sqlalchemy as sa
+from alembic.script import ScriptDirectory
+from flask import Flask
+from flask_migrate import upgrade as migrate_upgrade
+from sqlalchemy import inspect
+from sqlalchemy.exc import IntegrityError
+
+from webmentions_ssg import DATABASE, MIGRATE, create_app
+from webmentions_ssg.config import TestingConfig
+from webmentions_ssg.models import User
+
+
+def test_cli_groups_are_registered(app: Flask) -> None:
+ commands = app.cli.commands
+ assert {"users", "mail"}.issubset(commands)
+
+
+@pytest.fixture
+def database_app(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Iterator[Flask]:
+ monkeypatch.chdir(tmp_path)
+
+ class DatabaseTestingConfig(TestingConfig):
+ LOG_FILE = str(tmp_path / "database-cli.log")
+ SQLALCHEMY_DATABASE_URI = f"sqlite:///{tmp_path / 'database.sqlite'}"
+
+ app = create_app(DatabaseTestingConfig)
+ yield app
+
+ with app.app_context():
+ DATABASE.session.remove()
+ DATABASE.engine.dispose()
+
+
+def _script_directory() -> ScriptDirectory:
+ """Open the migration scripts configured for this application."""
+ return ScriptDirectory(str(MIGRATE.directory))
+
+
+def _head_revision(app: Flask) -> str:
+ with app.app_context():
+ revision = _script_directory().get_current_head()
+ assert revision is not None, "Expected a migration head"
+ return revision
+
+
+def _database_revision(app: Flask) -> str:
+ with app.app_context(), DATABASE.engine.connect() as connection:
+ return connection.execute(
+ sa.text("SELECT version_num FROM alembic_version")
+ ).scalar_one()
+
+
+def test_database_commands_are_registered_without_hiding_flask_migrate(
+ database_app: Flask,
+) -> None:
+ runner = database_app.test_cli_runner()
+
+ result = runner.invoke(args=["db", "--help"])
+ assert result.exit_code == 0, result.output
+ assert "create-db" in result.output
+ assert "upgrade" in result.output
+
+ result = runner.invoke(args=["migrate", "--help"])
+ assert result.exit_code == 0, result.output
+ assert "downgrade" in result.output
+ assert "revision" in result.output
+
+
+def test_create_db_builds_schema_and_records_latest_migration(
+ database_app: Flask,
+) -> None:
+ result = database_app.test_cli_runner().invoke(args=["db", "create-db"])
+
+ assert result.exit_code == 0, result.output
+ assert "Database created" in result.output
+ assert _database_revision(database_app) == _head_revision(database_app)
+
+ with database_app.app_context():
+ inspector = inspect(DATABASE.engine)
+ table_names = set(inspector.get_table_names())
+ columns = {
+ column["name"] for column in inspector.get_columns("sent_webmentions")
+ }
+ received_columns = {
+ column["name"] for column in inspector.get_columns("received_webmentions")
+ }
+ received_indexes = {
+ index["name"] for index in inspector.get_indexes("received_webmentions")
+ }
+ assert {"alembic_version", "users", "received_webmentions"} <= table_names
+ assert {"attempt_count", "next_retry_at"} <= columns
+ assert "recovery_attempts" in received_columns
+ assert "ix_received_webmentions_status_updated_at" in received_indexes
+
+
+def test_create_db_refuses_existing_database_without_modifying_it(
+ database_app: Flask,
+) -> None:
+ runner = database_app.test_cli_runner()
+ assert runner.invoke(args=["db", "create-db"]).exit_code == 0
+ revision_before = _database_revision(database_app)
+
+ result = runner.invoke(args=["db", "create-db"])
+
+ assert result.exit_code != 0
+ assert "already contains tables" in result.output
+ assert _database_revision(database_app) == revision_before
+
+
+def test_create_db_refuses_unversioned_existing_tables(database_app: Flask) -> None:
+ with database_app.app_context(), DATABASE.engine.begin() as connection:
+ connection.execute(sa.text("CREATE TABLE legacy_data (id INTEGER PRIMARY KEY)"))
+
+ result = database_app.test_cli_runner().invoke(args=["db", "create-db"])
+
+ assert result.exit_code != 0
+ assert "already contains tables" in result.output
+ with database_app.app_context():
+ assert "legacy_data" in inspect(DATABASE.engine).get_table_names()
+ assert "alembic_version" not in inspect(DATABASE.engine).get_table_names()
+
+
+def test_upgrade_requires_an_initialized_database(database_app: Flask) -> None:
+ result = database_app.test_cli_runner().invoke(args=["db", "upgrade"])
+
+ assert result.exit_code != 0
+ assert "flask db create-db" in result.output
+
+
+def test_upgrade_refuses_unversioned_existing_database(database_app: Flask) -> None:
+ with database_app.app_context(), DATABASE.engine.begin() as connection:
+ connection.execute(sa.text("CREATE TABLE legacy_data (id INTEGER PRIMARY KEY)"))
+
+ result = database_app.test_cli_runner().invoke(args=["db", "upgrade"])
+
+ assert result.exit_code != 0
+ assert "No Flask-Migrate revision table" in result.output
+ with database_app.app_context():
+ assert "legacy_data" in inspect(DATABASE.engine).get_table_names()
+
+
+def test_upgrade_applies_pending_migrations_and_preserves_data(
+ database_app: Flask,
+) -> None:
+ # Start with the first migration, as if this were an older deployment.
+ with database_app.app_context():
+ base_revision = _script_directory().get_base()
+ assert base_revision is not None
+ assert base_revision != _head_revision(database_app)
+ migrate_upgrade(revision=base_revision)
+
+ with DATABASE.engine.begin() as connection:
+ connection.execute(
+ sa.text(
+ "INSERT INTO users (username, password_hash) "
+ "VALUES (:username, :password_hash)"
+ ),
+ {"username": "existing-user", "password_hash": "existing-hash"},
+ )
+
+ result = database_app.test_cli_runner().invoke(args=["db", "upgrade"])
+
+ assert result.exit_code == 0, result.output
+ assert "Database upgraded" in result.output
+ assert _database_revision(database_app) == _head_revision(database_app)
+
+ with database_app.app_context(), DATABASE.engine.connect() as connection:
+ assert (
+ connection.execute(
+ sa.text("SELECT password_hash FROM users WHERE username = :username"),
+ {"username": "existing-user"},
+ ).scalar_one()
+ == "existing-hash"
+ )
+ assert "sent_webmentions" in inspect(connection).get_table_names()
+
+
+def test_upgrade_is_safe_to_run_when_already_current(database_app: Flask) -> None:
+ runner = database_app.test_cli_runner()
+ assert runner.invoke(args=["db", "create-db"]).exit_code == 0
+
+ result = runner.invoke(args=["db", "upgrade"])
+
+ assert result.exit_code == 0, result.output
+ assert _database_revision(database_app) == _head_revision(database_app)
+
+
+def test_create_db_does_not_report_success_when_migration_fails(
+ database_app: Flask, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ import webmentions_ssg.cli as database_cli
+
+ def fail_upgrade() -> None:
+ raise RuntimeError("simulated migration failure")
+
+ monkeypatch.setattr(database_cli, "migrate_upgrade", fail_upgrade)
+
+ result = database_app.test_cli_runner().invoke(args=["db", "create-db"])
+
+ assert result.exit_code != 0
+ assert isinstance(result.exception, RuntimeError)
+ assert "Database created" not in result.output
+
+
+def test_create_db_preserves_logging(
+ database_app: Flask, caplog: pytest.LogCaptureFixture
+) -> None:
+ with caplog.at_level(logging.WARNING):
+ result = database_app.test_cli_runner().invoke(args=["db", "create-db"])
+
+ assert result.exit_code == 0, result.output
+
+ database_app.logger.warning("Logging still works after migration")
+
+ assert "Logging still works after migration" in caplog.text
+
+
+def test_upgrade_backfills_portable_digest_for_existing_received_rows(
+ database_app: Flask,
+) -> None:
+ """Upgrade a pre-fingerprint SQLite database without losing historical rows."""
+ from webmentions_ssg.models import received_url_digest
+
+ with database_app.app_context():
+ migrate_upgrade(revision="c0272f25ce17")
+ with DATABASE.engine.begin() as connection:
+ connection.execute(
+ sa.text(
+ "INSERT INTO received_webmentions "
+ "(uuid, source, target, status, updated_at) "
+ "VALUES (:uuid, :source, :target, :status, :updated_at)"
+ ),
+ {
+ "uuid": "0" * 31 + "1",
+ "source": "https://source.example/old",
+ "target": "https://dennisfink.me/target",
+ "status": "verified",
+ "updated_at": "2026-01-01 00:00:00",
+ },
+ )
+ migrate_upgrade()
+ with DATABASE.engine.connect() as connection:
+ result = connection.execute(
+ sa.text(
+ "SELECT source, target, status, url_digest "
+ "FROM received_webmentions"
+ )
+ ).one()
+ assert result.status == "verified"
+ recovery_attempts = connection.execute(
+ sa.text("SELECT recovery_attempts FROM received_webmentions")
+ ).scalar_one()
+ assert recovery_attempts == 0
+ assert result.url_digest == received_url_digest(
+ result.source, result.target
+ )
+ constraints = inspect(connection).get_unique_constraints(
+ "received_webmentions"
+ )
+ assert any(
+ constraint["column_names"] == ["url_digest"]
+ for constraint in constraints
+ )
+
+
+def test_mail_cli_sends_to_configured_notification_email(app: Flask) -> None:
+ app.config.update(
+ NOTIFICATION_EMAIL="owner@example.com", MAIL_DEFAULT_SENDER="sender@example.com"
+ )
+
+ with patch("webmentions_ssg.MAIL.send") as send:
+ result = app.test_cli_runner().invoke(args=["mail", "test"])
+
+ assert result.exit_code == 0, result.output
+ send.assert_called_once()
+ message = send.call_args.args[0]
+ assert message.sender == "sender@example.com"
+ assert message.recipients == ["owner@example.com"]
+ assert "test email" in message.subject.lower()
+ assert "outgoing mail configuration" in message.body
+ assert "Test email sent to owner@example.com." in result.output
+
+
+def test_mail_cli_overrides_configured_recipient(app: Flask) -> None:
+ app.config.update(
+ NOTIFICATION_EMAIL="owner@example.com", MAIL_DEFAULT_SENDER="sender@example.com"
+ )
+
+ with patch("webmentions_ssg.MAIL.send") as send:
+ result = app.test_cli_runner().invoke(
+ args=["mail", "test", "--to", "other@example.com"]
+ )
+
+ assert result.exit_code == 0, result.output
+ send.assert_called_once()
+ assert send.call_args.args[0].recipients == ["other@example.com"]
+
+
+def test_mail_cli_requires_recipient(app: Flask) -> None:
+ app.config.update(NOTIFICATION_EMAIL=None, MAIL_DEFAULT_SENDER="sender@example.com")
+
+ with patch("webmentions_ssg.MAIL.send") as send:
+ result = app.test_cli_runner().invoke(args=["mail", "test"])
+
+ assert result.exit_code != 0
+ assert "Set NOTIFICATION_EMAIL or pass --to" in result.output
+ send.assert_not_called()
+
+
+def test_mail_cli_requires_default_sender(app: Flask) -> None:
+ app.config.update(NOTIFICATION_EMAIL="owner@example.com", MAIL_DEFAULT_SENDER=None)
+
+ with patch("webmentions_ssg.MAIL.send") as send:
+ result = app.test_cli_runner().invoke(args=["mail", "test"])
+
+ assert result.exit_code != 0
+ assert "MAIL_DEFAULT_SENDER is not configured" in result.output
+ send.assert_not_called()
+
+
+def test_mail_cli_reports_smtp_failure(app: Flask) -> None:
+ app.config.update(
+ NOTIFICATION_EMAIL="owner@example.com", MAIL_DEFAULT_SENDER="sender@example.com"
+ )
+
+ with patch(
+ "webmentions_ssg.MAIL.send", side_effect=ConnectionError("SMTP unavailable")
+ ) as send:
+ result = app.test_cli_runner().invoke(args=["mail", "test"])
+
+ assert result.exit_code != 0
+ assert "Could not send test email: SMTP unavailable" in result.output
+ send.assert_called_once()
+
+
+def _add_user(app: Flask, username: str, password: str = "original") -> None:
+ """Persist a user using the same model as the CLI."""
+ with app.app_context():
+ DATABASE.session.add(User(username=username, password=password))
+ DATABASE.session.commit()
+
+
+def _get_user(app: Flask, username: str) -> User | None:
+ with app.app_context():
+ return DATABASE.session.scalar(sa.select(User).where(User.username == username))
+
+
+def test_users_cli_help_lists_management_commands(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(args=["users", "--help"])
+
+ assert result.exit_code == 0, result.output
+ for command in ("create", "list", "set-password", "delete"):
+ assert command in result.output
+
+
+def test_users_cli_create_with_prompts_hashes_password(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(
+ args=["users", "create"],
+ input="alice\nmy new secret passphrase\nmy new secret passphrase\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert "Created user 'alice'." in result.output
+ assert "my new secret passphrase" not in result.output
+ user = _get_user(app, "alice")
+ assert user is not None
+ assert user.check_password("my new secret passphrase")
+ assert user.password_hash != "my new secret passphrase"
+
+
+def test_users_cli_create_with_username_option(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(
+ args=["users", "create", "--username", "alice"],
+ input="my new secret passphrase\nmy new secret passphrase\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert _get_user(app, "alice") is not None
+
+
+def test_users_cli_create_rejects_duplicate(app: Flask) -> None:
+ _add_user(app, "alice")
+
+ result = app.test_cli_runner().invoke(
+ args=[
+ "users",
+ "create",
+ "--username",
+ "alice",
+ "--password",
+ "a stronger duplicate password",
+ ]
+ )
+
+ assert result.exit_code != 0
+ assert "User 'alice' already exists." in result.output
+ user = _get_user(app, "alice")
+ assert user is not None
+ assert user.check_password("original")
+
+
+@pytest.mark.parametrize("username", ["", " "])
+def test_users_cli_create_rejects_invalid_username(app: Flask, username: str) -> None:
+ result = app.test_cli_runner().invoke(
+ args=[
+ "users",
+ "create",
+ "--username",
+ username,
+ "--password",
+ "a strong password for testing",
+ ]
+ )
+
+ assert result.exit_code != 0
+ assert "Username must not" in result.output
+
+
+def test_users_cli_create_rejects_empty_password(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(
+ args=["users", "create", "--username", "alice", "--password", ""]
+ )
+
+ assert result.exit_code != 0
+ assert "Password must not be empty." in result.output
+ assert _get_user(app, "alice") is None
+
+
+def test_users_cli_list_empty(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(args=["users", "list"])
+
+ assert result.exit_code == 0, result.output
+ assert "No users found." in result.output
+
+
+def test_users_cli_list_is_sorted_and_excludes_passwords(app: Flask) -> None:
+ _add_user(app, "zoe")
+ _add_user(app, "alice")
+
+ result = app.test_cli_runner().invoke(args=["users", "list"])
+
+ assert result.exit_code == 0, result.output
+ lines = result.output.splitlines()
+ assert lines[0] == "ID\tUSERNAME"
+ assert lines[1].endswith("\talice")
+ assert lines[2].endswith("\tzoe")
+ assert "original" not in result.output
+
+
+def test_users_cli_set_password_updates_hash(app: Flask) -> None:
+ _add_user(app, "alice")
+ old_hash = _get_user(app, "alice").password_hash # type: ignore[union-attr]
+
+ result = app.test_cli_runner().invoke(
+ args=["users", "set-password", "alice"],
+ input="a long replacement passphrase\na long replacement passphrase\n",
+ )
+
+ assert result.exit_code == 0, result.output
+ assert "Updated password for user 'alice'." in result.output
+ assert "a long replacement passphrase" not in result.output
+ user = _get_user(app, "alice")
+ assert user is not None
+ assert user.password_hash != old_hash
+ assert not user.check_password("original")
+ assert user.check_password("a long replacement passphrase")
+
+
+def test_users_cli_set_password_missing_user(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(
+ args=[
+ "users",
+ "set-password",
+ "missing",
+ "--password",
+ "a long replacement passphrase",
+ ]
+ )
+
+ assert result.exit_code != 0
+ assert "User 'missing' does not exist." in result.output
+
+
+def test_users_cli_set_password_rejects_empty_password(app: Flask) -> None:
+ _add_user(app, "alice")
+
+ result = app.test_cli_runner().invoke(
+ args=["users", "set-password", "alice", "--password", ""]
+ )
+
+ assert result.exit_code != 0
+ assert "Password must not be empty." in result.output
+ user = _get_user(app, "alice")
+ assert user is not None
+ assert user.check_password("original")
+
+
+def test_users_cli_delete_with_confirmation(app: Flask) -> None:
+ _add_user(app, "alice")
+
+ result = app.test_cli_runner().invoke(
+ args=["users", "delete", "alice"], input="y\n"
+ )
+
+ assert result.exit_code == 0, result.output
+ assert "Delete user 'alice'?" in result.output
+ assert "Deleted user 'alice'." in result.output
+ assert _get_user(app, "alice") is None
+
+
+def test_users_cli_delete_confirmation_rejected(app: Flask) -> None:
+ _add_user(app, "alice")
+
+ result = app.test_cli_runner().invoke(
+ args=["users", "delete", "alice"], input="n\n"
+ )
+
+ assert result.exit_code != 0
+ assert "Aborted" in result.output
+ assert _get_user(app, "alice") is not None
+
+
+def test_users_cli_delete_yes_only_deletes_target(app: Flask) -> None:
+ _add_user(app, "alice")
+ _add_user(app, "bob")
+
+ result = app.test_cli_runner().invoke(args=["users", "delete", "alice", "--yes"])
+
+ assert result.exit_code == 0, result.output
+ assert "Deleted user 'alice'." in result.output
+ assert _get_user(app, "alice") is None
+ assert _get_user(app, "bob") is not None
+
+
+def test_users_cli_delete_missing_user(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(args=["users", "delete", "missing", "-y"])
+
+ assert result.exit_code != 0
+ assert "User 'missing' does not exist." in result.output
+
+
+def test_users_cli_delete_missing_blank_username(app: Flask) -> None:
+ result = app.test_cli_runner().invoke(args=["users", "delete", " ", "--yes"])
+
+ assert result.exit_code != 0
+ assert "User ' ' does not exist." in result.output
+
+
+def test_users_cli_can_manage_legacy_whitespace_username(app: Flask) -> None:
+ _add_user(app, " alice ")
+
+ reset = app.test_cli_runner().invoke(
+ args=[
+ "users",
+ "set-password",
+ " alice ",
+ "--password",
+ "a long replacement passphrase",
+ ]
+ )
+
+ assert reset.exit_code == 0, reset.output
+ user = _get_user(app, " alice ")
+ assert user is not None
+ assert user.check_password("a long replacement passphrase")
+
+ deleted = app.test_cli_runner().invoke(args=["users", "delete", " alice ", "--yes"])
+ assert deleted.exit_code == 0, deleted.output
+ assert _get_user(app, " alice ") is None
+
+
+def test_users_cli_create_rolls_back_on_duplicate_race(app: Flask) -> None:
+ database_error = IntegrityError("INSERT", {}, Exception("duplicate"))
+
+ with app.app_context():
+ with (
+ patch.object(DATABASE.session, "commit", side_effect=database_error),
+ patch.object(DATABASE.session, "rollback") as rollback,
+ ):
+ result = app.test_cli_runner().invoke(
+ args=[
+ "users",
+ "create",
+ "--username",
+ "alice",
+ "--password",
+ "a long secret for testing",
+ ]
+ )
+ rollback.assert_called_once()
+
+ assert result.exit_code != 0
+ assert "User 'alice' already exists." in result.output
+
+
+@pytest.mark.parametrize(
+ ("password", "error"),
+ [
+ ("short", "at least 8 characters"),
+ ("good passphrase with\tab", "control characters"),
+ ],
+)
+@pytest.mark.parametrize("operation", ["create", "set-password"])
+def test_users_cli_enforces_password_policy(
+ app: Flask, password: str, error: str, operation: str
+) -> None:
+ _add_user(app, "existing")
+ if operation == "create":
+ command = ["users", "create", "--username", "new"]
+ else:
+ command = ["users", "set-password", "existing"]
+
+ result = app.test_cli_runner().invoke(args=[*command, "--password", password])
+ assert result.exit_code != 0
+ assert error in result.output
+ assert _get_user(app, "new") is None
+ existing = _get_user(app, "existing")
+ assert existing is not None and existing.check_password("original")
+
+
+def test_users_cli_accepts_long_unicode_passphrase(app: Flask) -> None:
+ passphrase = "🦊 several words of my passphrase 🪁"
+ result = app.test_cli_runner().invoke(
+ args=["users", "create", "--username", "alice", "--password", passphrase]
+ )
+ assert result.exit_code == 0, result.output
+ user = _get_user(app, "alice")
+ assert user is not None and user.check_password(passphrase)
+
+
+@pytest.mark.parametrize("passphrase", ["12345678", " " * 8, "🦊" + "a" * 1025])
+def test_users_cli_accepts_minimum_whitespace_and_unbounded_passwords(
+ app: Flask, passphrase: str
+) -> None:
+ result = app.test_cli_runner().invoke(
+ args=["users", "create", "--username", "alice", "--password", passphrase]
+ )
+ assert result.exit_code == 0, result.output
+ user = _get_user(app, "alice")
+ assert user is not None and user.check_password(passphrase)