disnake

1
# SPDX-License-Identifier: MIT
2

3
import datetime
4
from typing import Any, Tuple
5

6
import pytest
7

8
from disnake.ext import commands
9
from disnake.ext.tasks import LF, Loop, loop
10

11

12
class TestLoops:
13
    def test_decorator(self) -> None:
14
        class Cog(commands.Cog):
15
            @loop(seconds=30, minutes=0, hours=0)
16
            async def task(self) -> None:
17
                ...
18

19
        for c in (Cog, Cog()):
20
            assert c.task.seconds == 30
21

22
        with pytest.raises(TypeError, match="must be a coroutine"):
23

24
            @loop()  # type: ignore
25
            def task() -> None:
26
                ...
27

28
    def test_mixing_time(self) -> None:
29
        async def callback() -> None:
30
            pass
31

32
        with pytest.raises(TypeError):
33
            Loop(callback, seconds=30, time=datetime.time())
34

35
        with pytest.raises(TypeError):
36

37
            @loop(seconds=30, time=datetime.time())
38
            async def task() -> None:
39
                ...
40

41
    def test_inheritance(self) -> None:
42
        class HyperLoop(Loop[LF]):
43
            def __init__(self, coro: LF, time_tup: Tuple[float, float, float]) -> None:
44
                s, m, h = time_tup
45
                super().__init__(coro, seconds=s, minutes=m, hours=h)
46

47
            def clone(self):
48
                instance = type(self)(self.coro, (self._seconds, self._minutes, self._hours))
49
                instance._time = self._time
50
                instance.count = self.count
51
                instance.reconnect = self.reconnect
52
                instance.loop = self.loop
53
                instance._before_loop = self._before_loop
54
                instance._after_loop = self._after_loop
55
                instance._error = self._error
56
                instance._injected = self._injected
57
                return instance
58

59
        class WhileTrueLoop:
60
            def __init__(self, coro: Any) -> None:
61
                ...
62

63
        async def callback() -> None:
64
            pass
65

66
        HyperLoop(callback, (1, 2, 3))
67

68
        class Cog(commands.Cog):
69
            @loop(cls=HyperLoop[Any], time_tup=(1, 2, 3))
70
            async def task(self) -> None:
71
                ...
72

73
        for c in (Cog, Cog()):
74
            assert (c.task.seconds, c.task.minutes, c.task.hours) == (1, 2, 3)
75

76
        with pytest.raises(TypeError, match="subclass of Loop"):
77

78
            @loop(cls=WhileTrueLoop)  # type: ignore
79
            async def task() -> None:
80
                ...
81