aboutsummaryrefslogtreecommitdiff
path: root/tests/models/test_received.py
blob: 6f74d2d47ff8ad82a88e8babf1e85188b1dfb41b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
#
# SPDX-License-Identifier: BSD-3-Clause

import uuid

import pytest
import sqlalchemy as sa
from flask import Flask
from sqlalchemy.exc import IntegrityError

from webmentions_ssg import db
from webmentions_ssg.models.received import ReceivedWebmention, ReceivedWebmentionStatus
from webmentions_ssg.models.utils import source_target_digest


@pytest.mark.parametrize(
    ("status", "expected"),
    [
        (ReceivedWebmentionStatus.RECEIVED, False),
        (ReceivedWebmentionStatus.VERIFYING, False),
        (ReceivedWebmentionStatus.VERIFIED, True),
        (ReceivedWebmentionStatus.FAILED, False),
        (ReceivedWebmentionStatus.SOURCE_REMOVED, False),
    ],
)
def test_received_webmention_verified(
    status: ReceivedWebmentionStatus, expected: bool
) -> None:
    webmention = ReceivedWebmention(
        uuid=uuid.uuid7(),
        source="https://source.example/post",
        target="https://dennisfink.me/blog/example/",
        status=status,
    )

    assert webmention.verified is expected


def test_received_webmention_repr() -> None:
    webmention = ReceivedWebmention(
        uuid=uuid.uuid7(),
        source="https://source.example/post",
        target="https://dennisfink.me/blog/example/",
    )

    assert repr(webmention) == (
        "<ReceivedWebmention 'https://source.example/post' -> "
        "'https://dennisfink.me/blog/example/'>"
    )


def test_received_status_uses_non_native_enum() -> None:
    status_type = ReceivedWebmention.__table__.c.status.type

    assert isinstance(status_type, sa.Enum)
    assert status_type.enum_class is ReceivedWebmentionStatus
    assert status_type.native_enum is False
    assert status_type.enums == [status.value for status in ReceivedWebmentionStatus]


def test_received_status_round_trips_as_enum(app: Flask) -> None:
    with app.app_context():
        identifier = uuid.uuid7()
        mention = ReceivedWebmention(
            uuid=identifier,
            source="https://source.example/post",
            target="https://dennisfink.me/blog/example/",
            status=ReceivedWebmentionStatus.VERIFIED,
        )
        db.session.add(mention)
        db.session.commit()

        assert (
            db.session.scalar(
                sa.text("SELECT status FROM received_webmentions WHERE uuid = :uuid"),
                {"uuid": identifier.hex},
            )
            == "verified"
        )

        db.session.expunge_all()
        loaded = db.session.get(ReceivedWebmention, identifier)
        assert loaded is not None
        assert loaded.status is ReceivedWebmentionStatus.VERIFIED


def test_received_verification_reset_is_reusable_for_atomic_updates() -> None:
    mention = ReceivedWebmention(
        uuid=uuid.uuid7(),
        source="https://source.example/post",
        target="https://dennisfink.me/post",
        status=ReceivedWebmentionStatus.FAILED,
        failure_reason="Old error",
        recovery_attempts=3,
    )
    assert mention.reopen_verification() is None
    assert mention.status == ReceivedWebmentionStatus.RECEIVED
    assert mention.failure_reason is None
    assert mention.recovery_attempts == 0
    assert mention.updated_at is not None


def test_long_received_pair_can_be_stored_with_unique_digest(app: Flask) -> None:
    long_source = "https://source.example/" + "a" * 4000
    long_target = "https://dennisfink.me/" + "b" * 4000
    with app.app_context():
        db.session.add(
            ReceivedWebmention(
                uuid=uuid.uuid7(), source=long_source, target=long_target
            )
        )
        db.session.commit()
        match = db.session.scalar(
            sa.select(ReceivedWebmention).where(
                ReceivedWebmention.source_target_digest
                == source_target_digest(long_source, long_target)
            )
        )
        assert match is not None
        assert match.source == long_source
        assert match.target == long_target
        db.session.add(
            ReceivedWebmention(
                uuid=uuid.uuid7(), source=long_source, target=long_target
            )
        )
        with pytest.raises(IntegrityError):
            db.session.commit()
        db.session.rollback()