Move packages

tests/test_flags/test_decorator.py

@@ -0,0 +1,66 @@
+import pytest
+
+from aiogram.dispatcher.flags import Flag, FlagDecorator, FlagGenerator
+
+
+@pytest.fixture(name="flag")
+def flag_fixture() -> Flag:
+    return Flag("test", True)
+
+
+@pytest.fixture(name="flag_decorator")
+def flag_decorator_fixture(flag: Flag) -> FlagDecorator:
+    return FlagDecorator(flag)
+
+
+@pytest.fixture(name="flag_generator")
+def flag_flag_generator() -> FlagGenerator:
+    return FlagGenerator()
+
+
+class TestFlagDecorator:
+    def test_with_value(self, flag_decorator: FlagDecorator):
+        new_decorator = flag_decorator._with_value(True)
+
+        assert new_decorator is not flag_decorator
+        assert new_decorator.flag is not flag_decorator.flag
+        assert new_decorator.flag
+
+    def test_call_invalid(self, flag_decorator: FlagDecorator):
+        with pytest.raises(ValueError):
+            flag_decorator(True, test=True)
+
+    def test_call_with_function(self, flag_decorator: FlagDecorator):
+        def func():
+            pass
+
+        decorated = flag_decorator(func)
+        assert decorated is func
+        assert hasattr(decorated, "aiogram_flag")
+
+    def test_call_with_arg(self, flag_decorator: FlagDecorator):
+        new_decorator = flag_decorator("hello")
+        assert new_decorator is not flag_decorator
+        assert new_decorator.flag.value == "hello"
+
+    def test_call_with_kwargs(self, flag_decorator: FlagDecorator):
+        new_decorator = flag_decorator(test=True)
+        assert new_decorator is not flag_decorator
+        assert isinstance(new_decorator.flag.value, dict)
+        assert "test" in new_decorator.flag.value
+
+
+class TestFlagGenerator:
+    def test_getattr(self):
+        generator = FlagGenerator()
+        assert isinstance(generator.foo, FlagDecorator)
+        assert isinstance(generator.bar, FlagDecorator)
+
+        assert generator.foo is not generator.foo
+        assert generator.foo is not generator.bar
+
+    def test_failed_getattr(self):
+        generator = FlagGenerator()
+
+        with pytest.raises(AttributeError):
+            generator._something

tests/test_flags/test_getter.py

@@ -0,0 +1,64 @@
+from unittest.mock import patch
+
+import pytest
+
+from aiogram import F
+from aiogram.dispatcher.event.handler import HandlerObject
+from aiogram.dispatcher.flags import (
+    check_flags,
+    extract_flags,
+    extract_flags_from_object,
+    get_flag,
+)
+
+
+class TestGetters:
+    def test_extract_flags_from_object(self):
+        def func():
+            pass
+
+        assert extract_flags_from_object(func) == {}
+
+        func.aiogram_flag = {"test": True}
+        assert extract_flags_from_object(func) == func.aiogram_flag
+
+    @pytest.mark.parametrize(
+        "obj,result",
+        [
+            [None, {}],
+            [{}, {}],
+            [{"handler": None}, {}],
+            [{"handler": HandlerObject(lambda: True, flags={"test": True})}, {"test": True}],
+        ],
+    )
+    def test_extract_flags(self, obj, result):
+        assert extract_flags(obj) == result
+
+    @pytest.mark.parametrize(
+        "obj,name,default,result",
+        [
+            [None, "test", None, None],
+            [None, "test", 42, 42],
+            [{}, "test", None, None],
+            [{}, "test", 42, 42],
+            [{"handler": None}, "test", None, None],
+            [{"handler": None}, "test", 42, 42],
+            [{"handler": HandlerObject(lambda: True, flags={"test": True})}, "test", None, True],
+            [{"handler": HandlerObject(lambda: True, flags={"test": True})}, "test2", None, None],
+            [{"handler": HandlerObject(lambda: True, flags={"test": True})}, "test2", 42, 42],
+        ],
+    )
+    def test_get_flag(self, obj, name, default, result):
+        assert get_flag(obj, name, default=default) == result
+
+    @pytest.mark.parametrize(
+        "flags,magic,result",
+        [
+            [{}, F.test, None],
+            [{"test": True}, F.test, True],
+            [{"test": True}, F.spam, None],
+        ],
+    )
+    def test_check_flag(self, flags, magic, result):
+        with patch("aiogram.dispatcher.flags.extract_flags", return_value=flags):
+            assert check_flags(object(), magic) == result