disnake

1
# SPDX-License-Identifier: MIT
2

3
from typing import Dict, Union
4
from unittest import mock
5

6
import pytest
7

8
from disnake import AllowedMentions, Message, MessageType, Object
9

10

11
def test_classmethod_none() -> None:
12
    none = AllowedMentions.none()
13
    assert none.everyone is False
14
    assert none.roles is False
15
    assert none.users is False
16
    assert none.replied_user is False
17

18

19
def test_classmethod_all() -> None:
20
    all_mentions = AllowedMentions.all()
21
    assert all_mentions.everyone is True
22
    assert all_mentions.roles is True
23
    assert all_mentions.users is True
24
    assert all_mentions.replied_user is True
25

26

27
@pytest.mark.parametrize(
28
    ("am", "expected"),
29
    [
30
        (AllowedMentions(), {"parse": ["everyone", "users", "roles"], "replied_user": True}),
31
        (AllowedMentions.all(), {"parse": ["everyone", "users", "roles"], "replied_user": True}),
32
        (AllowedMentions(everyone=False), {"parse": ["users", "roles"], "replied_user": True}),
33
        (
34
            AllowedMentions(users=[Object(x) for x in [123, 456, 789]]),
35
            {"parse": ["everyone", "roles"], "replied_user": True, "users": [123, 456, 789]},
36
        ),
37
        (
38
            AllowedMentions(
39
                users=[Object(x) for x in [123, 456, 789]],
40
                roles=[Object(x) for x in [123, 456, 789]],
41
            ),
42
            {
43
                "parse": ["everyone"],
44
                "replied_user": True,
45
                "users": [123, 456, 789],
46
                "roles": [123, 456, 789],
47
            },
48
        ),
49
        (AllowedMentions.none(), {"parse": []}),
50
    ],
51
)
52
def test_to_dict(am: AllowedMentions, expected: Dict[str, Union[bool, list]]) -> None:
53
    assert expected == am.to_dict()
54

55

56
@pytest.mark.parametrize(
57
    ("og", "to_merge", "expected"),
58
    [
59
        (AllowedMentions.none(), AllowedMentions.none(), AllowedMentions.none()),
60
        (AllowedMentions.none(), AllowedMentions(), AllowedMentions.none()),
61
        (AllowedMentions.all(), AllowedMentions(), AllowedMentions.all()),
62
        (AllowedMentions(), AllowedMentions(), AllowedMentions()),
63
        (AllowedMentions.all(), AllowedMentions.none(), AllowedMentions.none()),
64
        (
65
            AllowedMentions(everyone=False),
66
            AllowedMentions(users=True),
67
            AllowedMentions(everyone=False, users=True),
68
        ),
69
        (
70
            AllowedMentions(users=[Object(x) for x in [123, 456, 789]]),
71
            AllowedMentions(users=False),
72
            AllowedMentions(users=False),
73
        ),
74
    ],
75
)
76
def test_merge(og: AllowedMentions, to_merge: AllowedMentions, expected: AllowedMentions) -> None:
77
    merged = og.merge(to_merge)
78

79
    assert expected.everyone is merged.everyone
80
    assert expected.users is merged.users
81
    assert expected.roles is merged.roles
82
    assert expected.replied_user is merged.replied_user
83

84

85
def test_from_message() -> None:
86
    # as we don't have a message mock yet we are faking a message here with the necessary components
87
    msg = mock.NonCallableMock()
88
    msg.mention_everyone = True
89
    users = [Object(x) for x in [123, 456, 789]]
90
    msg.mentions = users
91
    roles = [Object(x) for x in [123, 456, 789]]
92
    msg.role_mentions = roles
93
    msg.reference = None
94

95
    am = AllowedMentions.from_message(msg)
96

97
    assert am.everyone is True
98
    # check that while the list matches, it isn't the same list
99
    assert am.users == users
100
    assert am.users is not users
101

102
    assert am.roles == roles
103
    assert am.roles is not roles
104

105
    assert am.replied_user is False
106

107

108
def test_from_message_replied_user() -> None:
109
    message = mock.Mock(Message)
110
    author = Object(123)
111
    message.mentions = [author]
112
    assert AllowedMentions.from_message(message).replied_user is False
113

114
    message.type = MessageType.reply
115
    assert AllowedMentions.from_message(message).replied_user is False
116

117
    resolved = mock.Mock(Message, author=author)
118
    message.reference = mock.Mock(resolved=resolved)
119
    assert AllowedMentions.from_message(message).replied_user is True
120