aiogram-testing 1.1.0__py3-none-any.whl

aiogram_testing-1.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: aiogram-testing
+Version: 1.1.0
+Summary: A library for testing your bots on aiogram
+License: MIT
+Author: k0te1ch
+Author-email: khvostov40@gmail.com
+Requires-Python: >=3.12,<3.15
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: aiogram (>=3.28,<4.0)
+Project-URL: Homepage, https://github.com/k0te1ch/aiogram_tests
+Project-URL: Repository, https://github.com/k0te1ch/aiogram_tests
+Description-Content-Type: text/markdown
+
+# Aiogram Tests
+
+***aiogram_tests*** is a testing library for bots written on [aiogram]("https://github.com/aiogram/aiogram")</a>
+
+## 📦 Installation
+
+```bash
+pip install aiogram-testing
+```
+
+The import name stays `aiogram_tests`:
+
+```python
+from aiogram_tests import MockedRequester
+```
+
+## 📚 Simple examples
+
+### Simple handler test
+
+#### Simple bot
+
+```python
+from aiogram import Bot, Dispatcher, types
+from aiogram.fsm.context import FSMContext
+
+# Please, keep your bot tokens on environments, this code only example
+bot = Bot('123456789:AABBCCDDEEFFaabbccddeeff-1234567890')
+dp = Dispatcher()
+
+
+@dp.message()
+async def echo(message: types.Message, state: FSMContext) -> None:
+    await message.answer(message.text)
+
+
+if __name__ == '__main__':
+    dp.run_polling(bot)
+
+
+```
+
+#### Test cases
+
+```python
+import pytest
+
+from bot import echo
+
+from aiogram_tests import MockedRequester
+from aiogram_tests.handler import MessageHandler
+from aiogram_tests.types.dataset import MESSAGE
+
+
+@pytest.mark.asyncio
+async def test_echo():
+    request = MockedRequester(MessageHandler(echo))
+    calls = await request.query(message=MESSAGE.as_object(text="Hello, Bot!"))
+    answer_message = calls.send_message.fetchone()
+    assert answer_message.text == "Hello, Bot!"
+
+```
+
+### [▶️ More]("https://github.com/aiogram-tests/aiogram_tests/tree/master/examples") examples
+

aiogram_testing-1.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+aiogram_tests/__init__.py,sha256=JOazEvtgjekpejpdLS43BgW-0u_vNzLxV_e2V8CFEGY,92
+aiogram_tests/exceptions.py,sha256=cgyhFFntzudw_3Lw6QwpC9nKtMr_mMSQPUGbBDKRybQ,50
+aiogram_tests/handler/__init__.py,sha256=ftP0YTO-L8NMVNKv2mXlHas-TDlwv7jB6chmZ3QXZck,265
+aiogram_tests/handler/base.py,sha256=0JXRTsmmh26AUQMZd_qWtCOQiMYaIuHbJD_tUY8fPG4,2667
+aiogram_tests/handler/handler.py,sha256=pHTjSOYsOa34AKcok9ocyt1Dpe3X8EAR8MILcWWZ0nA,2773
+aiogram_tests/mocked_bot.py,sha256=2xdajeMDz3arc8C1eh6ghDgvUBpC-IMh9hfId3Fcni0,3413
+aiogram_tests/requester.py,sha256=IUM_OyNe82219bQJpyJxMrWC3qW2tbAViaCMMBY2Co4,2745
+aiogram_tests/types/__init__.py,sha256=1mKDyeY_uRovMCC49M3Ow3WXGAxkrbyqsw9G-WEWrDY,46
+aiogram_tests/types/dataset/__init__.py,sha256=RSPtOgPhsUU1T9buRb6VO8rd_Ayt7PU8TD7_5NcySIw,14718
+aiogram_tests/types/dataset/base.py,sha256=7oJKipuldXkpsOG20bDfttBHtFqFiWPCSArA9Tkqdq0,1987
+aiogram_tests/utils.py,sha256=PnKkxzEQ6vXcXXPnpTbyjlv4RoJzoTTLyj4MathU09M,112
+aiogram_testing-1.1.0.dist-info/METADATA,sha256=Y8gaA0QGL4RyHqfDczcbLyIPyykAECC708QsbIbqVuA,2167
+aiogram_testing-1.1.0.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+aiogram_testing-1.1.0.dist-info/RECORD,,

aiogram_testing-1.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aiogram_tests/__init__.py

@@ -0,0 +1,4 @@
+from .requester import MockedRequester
+
+__all__ = ["MockedRequester"]
+__version__ = "1.1.0"

aiogram_tests/exceptions.py

@@ -0,0 +1,2 @@
+class MethodIsNotCalledError(Exception):
+    pass

aiogram_tests/handler/__init__.py

@@ -0,0 +1,6 @@
+from .base import RequestHandler
+from .handler import CallbackQueryHandler
+from .handler import MessageHandler
+from .handler import TelegramEventObserverHandler
+
+__all__ = ["MessageHandler", "CallbackQueryHandler", "TelegramEventObserverHandler", "RequestHandler"]

aiogram_tests/handler/base.py

@@ -0,0 +1,79 @@
+from collections.abc import Iterable
+
+from aiogram import BaseMiddleware
+from aiogram import Dispatcher
+from aiogram.dispatcher.event.telegram import TelegramEventObserver
+from aiogram.fsm.storage.memory import MemoryStorage
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Response
+from aiogram.methods.base import TelegramType
+
+from aiogram_tests.mocked_bot import DEFAULT_AUTO_MOCK_SUCCESS
+from aiogram_tests.mocked_bot import MockedBot
+
+
+class RequestHandler:
+    def __init__(
+        self,
+        dp_middlewares: Iterable[BaseMiddleware] = None,
+        exclude_observer_methods: Iterable[str] = None,
+        auto_mock_success: bool = DEFAULT_AUTO_MOCK_SUCCESS,
+        dp: Dispatcher | None = None,
+        **kwargs,
+    ):
+        self.bot = MockedBot(auto_mock_success=auto_mock_success)
+        if dp is None:
+            dp = Dispatcher(storage=MemoryStorage())
+        self.dp = dp
+
+        if dp_middlewares is None:
+            dp_middlewares = ()
+
+        if exclude_observer_methods is None:
+            exclude_observer_methods = []
+
+        dispatcher_methods = self._get_dispatcher_event_observers()
+        available_methods = tuple(set(dispatcher_methods) - set(exclude_observer_methods))
+        self._register_middlewares(available_methods, tuple(dp_middlewares))
+
+    def _get_dispatcher_event_observers(self) -> list[str]:
+        """
+        Returns a names for bot event observers, like message, callback_query etc.
+        """
+
+        result = []
+        for name in dir(self.dp):
+            if isinstance(getattr(self.dp, name), TelegramEventObserver):
+                result.append(name)
+
+        return result
+
+    def _register_middlewares(self, event_observer: Iterable, middlewares: Iterable) -> None:
+        for eo_name in event_observer:
+            for m in middlewares:
+                eo_obj = getattr(self.dp, eo_name)
+                eo_obj.middleware.register(m)
+
+    async def __call__(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def add_result_for(
+        self,
+        method: type[TelegramMethod[TelegramType]],
+        ok: bool,
+        result: TelegramType = None,
+        description: str | None = None,
+        error_code: int = 200,
+        migrate_to_chat_id: int | None = None,
+        retry_after: int | None = None,
+    ) -> Response[TelegramType]:
+        response = self.bot.add_result_for(
+            method=method,
+            ok=ok,
+            result=result,
+            description=description,
+            error_code=error_code,
+            migrate_to_chat_id=migrate_to_chat_id,
+            retry_after=retry_after,
+        )
+        return response

aiogram_tests/handler/handler.py

@@ -0,0 +1,86 @@
+from collections.abc import Callable
+from collections.abc import Iterable
+
+from aiogram import types
+from aiogram.filters import Filter
+from aiogram.filters import StateFilter
+from aiogram.fsm.context import FSMContext
+from aiogram.fsm.state import State
+
+from .base import RequestHandler
+
+
+class TelegramEventObserverHandler(RequestHandler):
+    def __init__(
+        self,
+        callback: Callable,
+        *filters: Filter,
+        state: State | str | None = None,
+        state_data: dict = None,
+        state_context: FSMContext | None = None,
+        dp_middlewares: Iterable = None,
+        exclude_observer_methods: Iterable = None,
+        **kwargs,
+    ):
+        super().__init__(dp_middlewares, exclude_observer_methods, **kwargs)
+
+        self._callback = callback
+        self._filters: list = list(filters)
+        self._state: State | str | None = state
+        self._state_data: dict = state_data
+        self._state_context: FSMContext = state_context
+
+        if self._state_context:
+            self._state_context = state_context
+
+        if self._state_data is None:
+            self._state_data = {}
+
+        if self._filters is None:
+            self._filters = []
+
+        if not isinstance(self._state_data, dict):
+            raise ValueError("state_data is not a dict")
+
+    async def __call__(self, *args, **kwargs):
+        if self._state:
+            self._filters.append(StateFilter(self._state))
+
+        self.register_handler()
+
+        if self._state_context or self._state:
+            state = self.dp.fsm.get_context(self.bot, user_id=12345678, chat_id=12345678)
+            await state.set_state(self._state)
+            await state.update_data(**self._state_data)
+
+        await self.feed_update(*args, **kwargs)
+
+    def register_handler(self) -> None:
+        """
+        Register TelegramEventObserver in dispatcher
+        """
+
+        raise NotImplementedError
+
+    async def feed_update(self, *args, **kwargs) -> None:
+        """
+        Feed dispatcher updates
+        """
+
+        raise NotImplementedError
+
+
+class MessageHandler(TelegramEventObserverHandler):
+    def register_handler(self) -> None:
+        self.dp.message.register(self._callback, *self._filters)
+
+    async def feed_update(self, message: types.Message, *args, **kwargs) -> None:
+        await self.dp.feed_update(self.bot, types.Update(update_id=12345678, message=message))
+
+
+class CallbackQueryHandler(TelegramEventObserverHandler):
+    def register_handler(self) -> None:
+        self.dp.callback_query.register(self._callback, *self._filters)
+
+    async def feed_update(self, callback_query: types.CallbackQuery, *args, **kwargs) -> None:
+        await self.dp.feed_update(self.bot, types.Update(update_id=12345678, callback_query=callback_query))

aiogram_tests/mocked_bot.py

@@ -0,0 +1,104 @@
+from collections import deque
+from collections.abc import AsyncGenerator
+
+from aiogram import Bot
+from aiogram.client.session.base import BaseSession
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Request
+from aiogram.methods.base import Response
+from aiogram.methods.base import TelegramType
+from aiogram.types import ResponseParameters
+from aiogram.types import User
+from aiogram.types.base import UNSET_TYPE
+
+DEFAULT_AUTO_MOCK_SUCCESS = True
+
+
+class MockedSession(BaseSession):
+    def __init__(self):
+        super().__init__()
+        self.responses: deque[Response[TelegramType]] = deque()
+        self.requests: deque[Request] = deque()
+        self.closed = True
+
+    def add_result(self, response: Response[TelegramType]) -> Response[TelegramType]:
+        self.responses.appendleft(response)
+        return response
+
+    def get_request(self) -> Request | None:
+        if self.requests:
+            return self.requests[-1]
+
+        return None
+
+    async def close(self):
+        self.closed = True
+
+    async def make_request(
+        self,
+        bot: Bot,
+        method: TelegramMethod[TelegramType],
+        timeout: int | None = UNSET_TYPE,
+    ) -> TelegramType:
+        self.closed = False
+        request = Request(method=method.__api_method__, data=method.__dict__, files=None)
+        self.requests.append(request)
+        response: Response[TelegramType] = self.responses.pop()
+        self.check_response(
+            method=method,
+            status_code=response.error_code,
+            content=response.model_dump_json(),
+            bot=bot,
+        )
+        return response.result  # type: ignore
+
+    async def stream_content(
+        self, url: str, timeout: int, chunk_size: int
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        yield b""
+
+
+class MockedBot(Bot):
+    def __init__(self, auto_mock_success: bool = DEFAULT_AUTO_MOCK_SUCCESS, **kwargs):
+        super().__init__(kwargs.pop("token", "42:TEST"), session=MockedSession(), **kwargs)
+        self.session = MockedSession()
+        self._me = User(
+            id=self.id,
+            is_bot=True,
+            first_name="FirstName",
+            last_name="LastName",
+            username="username",
+            language_code="ru",
+        )
+        self.auto_mock_success = auto_mock_success
+
+    def add_result_for(
+        self,
+        method: type[TelegramMethod[TelegramType]],
+        ok: bool,
+        result: TelegramType = None,
+        description: str | None = None,
+        error_code: int = 200,
+        migrate_to_chat_id: int | None = None,
+        retry_after: int | None = None,
+    ) -> Response[TelegramType]:
+        response = Response[method.__returning__](  # type: ignore
+            ok=ok,
+            result=result,
+            description=description,
+            error_code=error_code,
+            parameters=ResponseParameters(
+                migrate_to_chat_id=migrate_to_chat_id,
+                retry_after=retry_after,
+            ),
+        )
+        self.session.add_result(response)
+        return response
+
+    async def __call__(self, method: TelegramMethod, request_timeout: int | None = None):
+        if self.auto_mock_success:
+            self.add_result_for(method.__class__, ok=True)
+        return await super().__call__(method, request_timeout)
+
+    def get_request(self) -> Request:
+        return self.session.get_request()

aiogram_tests/requester.py

@@ -0,0 +1,94 @@
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Response
+from aiogram.methods.base import TelegramType
+
+from .exceptions import MethodIsNotCalledError
+from .handler.base import RequestHandler
+from .utils import camel_case2snake_case
+
+
+class CallsList(list):
+    def fetchone(self):
+        if len(self) > 0:
+            return self[-1]
+        else:
+            return None
+
+    def fetchall(self):
+        return self
+
+
+class Calls:
+    def _get_attributes(self):
+        res = []
+        for item in dir(self):
+            if item.startswith("_") or item.endswith("_"):
+                continue
+
+            if not callable(getattr(self, item)):
+                res.append(item)
+
+        return tuple(res)
+
+    def __getattr__(self, item):
+        if item in dir(self):
+            return getattr(self, item)
+        else:
+            raise MethodIsNotCalledError(
+                f"method '{item}' is not called by bot, so you cant to get this attribute. "
+                f"Called methods: {self._get_attributes()}"
+            )
+
+
+class MockedRequester:
+    def __init__(self, request_handler: RequestHandler):
+        self._handler: RequestHandler = request_handler
+
+    async def query(self, *args, **kwargs) -> Calls:
+        try:
+            await self._handler(*args, **kwargs)
+        except TypeError as e:
+            raise AttributeError(f"incorrect argument name. {e}")
+
+        requests = self._handler.bot.session.requests
+        result = {}
+        for r in requests:
+            method_name = camel_case2snake_case(r.method)
+
+            if method_name not in result:
+                result[method_name] = CallsList()
+
+            result[method_name].append(self._dict_to_obj(r.data))
+
+        return self._generate_result_obj(result)
+
+    def add_result_for(
+        self,
+        method: type[TelegramMethod[TelegramType]],
+        ok: bool,
+        result: TelegramType = None,
+        description: str | None = None,
+        error_code: int = 200,
+        migrate_to_chat_id: int | None = None,
+        retry_after: int | None = None,
+    ) -> Response[TelegramType]:
+        response = self._handler.add_result_for(
+            method=method,
+            ok=ok,
+            result=result,
+            description=description,
+            error_code=error_code,
+            migrate_to_chat_id=migrate_to_chat_id,
+            retry_after=retry_after,
+        )
+        return response
+
+    @staticmethod
+    def _dict_to_obj(data: dict):
+        GeneratedResponse = type("GeneratedResponse", (), data)
+        return GeneratedResponse()
+
+    @staticmethod
+    def _generate_result_obj(data: dict):
+        GeneratedCalls = type("GeneratedCalls", (Calls,), data)
+        return GeneratedCalls()

aiogram_tests/types/__init__.py

@@ -0,0 +1,3 @@
+from . import dataset
+
+__all__ = ("dataset",)

aiogram_tests/types/dataset/__init__.py

@@ -0,0 +1,673 @@
+from aiogram import types
+
+from .base import DatasetItem
+
+USER = DatasetItem(
+    {
+        "id": 12345678,
+        "is_bot": False,
+        "first_name": "FirstName",
+        "last_name": "LastName",
+        "username": "username",
+        "language_code": "ru",
+    },
+    model=types.User,
+)
+
+CHAT = DatasetItem(
+    {
+        "id": 12345678,
+        "first_name": "FirstName",
+        "last_name": "LastName",
+        "username": "username",
+        "type": "private",
+    },
+    model=types.Chat,
+)
+
+CHAT_PHOTO = DatasetItem(
+    {
+        "small_file_id": "small_file_id",
+        "small_file_unique_id": "small_file_unique_id",
+        "big_file_id": "big_file_id",
+        "big_file_unique_id": "big_file_unique_id",
+    },
+    model=types.ChatPhoto,
+)
+
+PHOTO = DatasetItem(
+    {
+        "file_id": "AgADBAADFak0G88YZAf8OAug7bHyS9x2ZxkABHVfpJywcloRAAGAAQABAg",
+        "file_unique_id": "file_unique_id",
+        "file_size": 1101,
+        "width": 90,
+        "height": 51,
+    },
+    model=types.PhotoSize,
+)
+
+AUDIO = DatasetItem(
+    {
+        "duration": 236,
+        "mime_type": "audio/mpeg3",
+        "title": "The Best Song",
+        "performer": "The Best Singer",
+        "file_id": "CQADAgADbQEAAsnrIUpNoRRNsH7_hAI",
+        "file_size": 9507774,
+        "file_unique_id": "file_unique_id",
+    },
+    model=types.Audio,
+)
+
+BOT_COMMAND = DatasetItem(
+    {
+        "command": "start",
+        "description": "Start bot",
+    },
+    model=types.BotCommand,
+)
+
+CHAT_MEMBER = DatasetItem(
+    {
+        "user": USER,
+        "status": "administrator",
+        "can_be_edited": False,
+        "can_manage_chat": True,
+        "can_change_info": True,
+        "can_delete_messages": True,
+        "can_invite_users": True,
+        "can_restrict_members": True,
+        "can_pin_messages": True,
+        "can_promote_members": False,
+        "can_manage_voice_chats": True,  # Deprecated
+        "can_manage_video_chats": True,
+        "is_anonymous": False,
+    },
+    model=types.ChatMember,
+)
+
+CHAT_MEMBER_OWNER = DatasetItem(
+    {
+        "user": USER,
+        "status": "creator",
+        "is_anonymous": False,
+    },
+    model=types.ChatMemberOwner,
+)
+
+CONTACT = DatasetItem(
+    {
+        "phone_number": "88005553535",
+        "first_name": "John",
+        "last_name": "Smith",
+    },
+    model=types.Contact,
+)
+
+DICE = DatasetItem({"value": 6, "emoji": "🎲"}, model=types.Dice)
+
+DOCUMENT = DatasetItem(
+    {
+        "file_name": "test.docx",
+        "mime_type": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "file_id": "BQADAgADpgADy_JxS66XQTBRHFleAg",
+        "file_unique_id": "file_unique_id",
+        "file_size": 21331,
+    },
+    model=types.Document,
+)
+
+ANIMATION = DatasetItem(
+    {"file_id": "file_id", "file_unique_id": "file_unique_id", "width": 50, "height": 50, "duration": 50},
+    model=types.Animation,
+)
+
+ENTITY_BOLD = DatasetItem(
+    {
+        "offset": 5,
+        "length": 2,
+        "type": "bold",
+    }
+)
+
+ENTITY_ITALIC = DatasetItem(
+    {
+        "offset": 8,
+        "length": 1,
+        "type": "italic",
+    }
+)
+
+ENTITY_LINK = DatasetItem(
+    {
+        "offset": 10,
+        "length": 6,
+        "type": "text_link",
+        "url": "https://google.com/",
+    }
+)
+
+ENTITY_CODE = DatasetItem(
+    {
+        "offset": 17,
+        "length": 7,
+        "type": "code",
+    }
+)
+
+ENTITY_PRE = DatasetItem(
+    {
+        "offset": 30,
+        "length": 4,
+        "type": "pre",
+    }
+)
+
+ENTITY_MENTION = DatasetItem(
+    {
+        "offset": 47,
+        "length": 9,
+        "type": "mention",
+    }
+)
+
+GAME = DatasetItem(
+    {
+        "title": "Karate Kido",
+        "description": "No trees were harmed in the making of this game :)",
+        "photo": [PHOTO, PHOTO, PHOTO],
+        "animation": ANIMATION,
+    },
+    model=types.Game,
+)
+
+INVOICE = DatasetItem(
+    {
+        "title": "Working Time Machine",
+        "description": "Want to visit your great-great-great-grandparents? "
+        "Make a fortune at the races? "
+        "Shake hands with Hammurabi and take a stroll in the Hanging Gardens? "
+        "Order our Working Time Machine today!",
+        "start_parameter": "time-machine-example",
+        "currency": "USD",
+        "total_amount": 6250,
+    },
+    model=types.Invoice,
+)
+
+LOCATION = DatasetItem(
+    {
+        "latitude": 50.693416,
+        "longitude": 30.624605,
+    },
+    model=types.Location,
+)
+
+VENUE = DatasetItem(
+    {
+        "location": LOCATION,
+        "title": "Venue Name",
+        "address": "Venue Address",
+        "foursquare_id": "4e6f2cec483bad563d150f98",
+    },
+    model=types.Venue,
+)
+
+SHIPPING_ADDRESS = DatasetItem(
+    {
+        "country_code": "US",
+        "state": "State",
+        "city": "DefaultCity",
+        "street_line1": "Central",
+        "street_line2": "Middle",
+        "post_code": "424242",
+    },
+    model=types.ShippingAddress,
+)
+
+STICKER = DatasetItem(
+    {
+        "width": 512,
+        "height": 512,
+        "emoji": "🛠",
+        "set_name": "StickerSet",
+        "thumb": PHOTO,
+        "file_id": "AAbbCCddEEffGGhh1234567890",
+        "file_size": 12345,
+        "file_unique_id": "file_unique_id",
+        "type": "type",
+        "is_animated": False,
+        "is_video": False,
+    },
+    model=types.Sticker,
+)
+
+SUCCESSFUL_PAYMENT = DatasetItem(
+    {
+        "currency": "USD",
+        "total_amount": 6250,
+        "invoice_payload": "HAPPY FRIDAYS COUPON",
+        "telegram_payment_charge_id": "_",
+        "provider_payment_charge_id": "12345678901234_test",
+    },
+    model=types.SuccessfulPayment,
+)
+
+VIDEO = DatasetItem(
+    {
+        "duration": 52,
+        "width": 853,
+        "height": 480,
+        "mime_type": "video/quicktime",
+        "thumb": PHOTO,
+        "file_id": "BAADAgpAADdawy_JxS72kRvV3cortAg",
+        "file_unique_id": "file_unique_id",
+        "file_size": 10099782,
+    },
+    model=types.Video,
+)
+
+VIDEO_NOTE = DatasetItem(
+    {
+        "duration": 4,
+        "length": 240,
+        "thumb": PHOTO,
+        "file_id": "AbCdEfGhIjKlMnOpQrStUvWxYz",
+        "file_unique_id": "file_unique_id",
+        "file_size": 186562,
+    },
+    model=types.VideoNote,
+)
+
+VOICE = DatasetItem(
+    {
+        "duration": 1,
+        "mime_type": "audio/ogg",
+        "file_id": "AwADawAgADADy_JxS2gopIVIIxlhAg",
+        "file_unique_id": "file_unique_id",
+        "file_size": 4321,
+    },
+    model=types.Voice,
+)
+
+MESSAGE = DatasetItem(
+    {
+        "message_id": 11223,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508709711,
+        "text": "Hi, world!",
+    },
+    model=types.Message,
+)
+
+CALLBACK_QUERY = DatasetItem(
+    {"id": "12345678", "chat_instance": "AABBCC", "from_user": USER, "message": MESSAGE, "data": "data"},
+    model=types.CallbackQuery,
+)
+
+CHANNEL = DatasetItem(
+    {
+        "type": "channel",
+        "username": "best_channel_ever",
+        "id": -1001065170817,
+    },
+    model=types.Chat,
+)
+
+CHANNEL_POST = DatasetItem(
+    {"message_id": 12345, "sender_chat": CHANNEL, "chat": CHANNEL, "date": 1508825372, "text": "Hi, channel!"},
+    model=types.Message,
+)
+
+EDITED_CHANNEL_POST = DatasetItem(
+    {
+        "message_id": 12345,
+        "sender_chat": CHANNEL,
+        "chat": CHANNEL,
+        "date": 1508825372,
+        "edit_date": 1508825379,
+        "text": "Hi, channel! (edited)",
+    },
+    model=types.Message,
+)
+
+EDITED_MESSAGE = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508825372,
+        "edit_date": 1508825379,
+        "text": "hi there (edited)",
+    },
+    model=types.Message,
+)
+
+FORWARDED_MESSAGE = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1522828529,
+        "forward_from_chat": CHAT,
+        "forward_from_message_id": 123,
+        "forward_date": 1522749037,
+        "text": "Forwarded text with entities from public channel ",
+        "entities": [ENTITY_BOLD, ENTITY_CODE, ENTITY_ITALIC, ENTITY_LINK, ENTITY_LINK, ENTITY_MENTION, ENTITY_PRE],
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_AUDIO = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508739776,
+        "audio": AUDIO,
+        "caption": "This is my favourite song",
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_CONTACT = DatasetItem(
+    {
+        "message_id": 56006,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1522850298,
+        "contact": CONTACT,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_DICE = DatasetItem(
+    {"message_id": 12345, "from": USER, "chat": CHAT, "date": 1508768012, "dice": DICE}, model=types.Message
+)
+
+MESSAGE_WITH_DOCUMENT = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508768012,
+        "document": DOCUMENT,
+        "caption": "Read my document",
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_GAME = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508824810,
+        "game": GAME,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_INVOICE = DatasetItem(
+    {
+        "message_id": 9772,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508761719,
+        "invoice": INVOICE,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_LOCATION = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508755473,
+        "location": LOCATION,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_MIGRATE_TO_CHAT_ID = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1526943253,
+        "migrate_to_chat_id": -1234567890987,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_MIGRATE_FROM_CHAT_ID = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1526943253,
+        "migrate_from_chat_id": -123456789,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_PHOTO = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508825154,
+        "photo": [PHOTO, PHOTO, PHOTO, PHOTO],
+        "caption": "photo description",
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_MEDIA_GROUP = DatasetItem(
+    {
+        "message_id": 55966,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1522843665,
+        "media_group_id": "12182749320567362",
+        "photo": [PHOTO, PHOTO, PHOTO, PHOTO],
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_STICKER = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508771450,
+        "sticker": STICKER,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_SUCCESSFUL_PAYMENT = DatasetItem(
+    {
+        "message_id": 9768,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508761169,
+        "successful_payment": SUCCESSFUL_PAYMENT,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_VENUE = DatasetItem(
+    {
+        "message_id": 56004,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1522849819,
+        "location": LOCATION,
+        "venue": VENUE,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_VIDEO = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508756494,
+        "video": VIDEO,
+        "caption": "description",
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_VIDEO_NOTE = DatasetItem(
+    {
+        "message_id": 55934,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1522835890,
+        "video_note": VIDEO_NOTE,
+    },
+    model=types.Message,
+)
+
+MESSAGE_WITH_VOICE = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508768403,
+        "voice": VOICE,
+    },
+    model=types.Message,
+)
+
+MESSAGE_FROM_CHANNEL = DatasetItem(
+    {
+        "message_id": 123432,
+        "from": None,
+        "chat": CHANNEL,
+        "date": 1508768405,
+        "text": "Hi, world!",
+    },
+    model=types.Message,
+)
+
+PRE_CHECKOUT_QUERY = DatasetItem(
+    {
+        "id": "262181558630368727",
+        "from": USER,
+        "currency": "USD",
+        "total_amount": 6250,
+        "invoice_payload": "HAPPY FRIDAYS COUPON",
+    },
+    model=types.PreCheckoutQuery,
+)
+
+REPLY_MESSAGE = DatasetItem(
+    {
+        "message_id": 12345,
+        "from": USER,
+        "chat": CHAT,
+        "date": 1508751866,
+        "reply_to_message": MESSAGE,
+        "text": "Reply to quoted message",
+    },
+    model=types.Message,
+)
+
+SHIPPING_QUERY = DatasetItem(
+    {
+        "id": "262181558684397422",
+        "from": USER,
+        "invoice_payload": "HAPPY FRIDAYS COUPON",
+        "shipping_address": SHIPPING_ADDRESS,
+    },
+    model=types.ShippingQuery,
+)
+
+USER_PROFILE_PHOTOS = DatasetItem(
+    {
+        "total_count": 1,
+        "photos": [
+            [PHOTO, PHOTO, PHOTO],
+        ],
+    },
+    model=types.UserProfilePhotos,
+)
+
+FILE = DatasetItem(
+    {"file_id": "XXXYYYZZZ", "file_size": 5254, "file_path": "voice/file_8", "file_unique_id": "file_unique_id"},
+    model=types.File,
+)
+
+UPDATE = DatasetItem(
+    {
+        "update_id": 123456789,
+        "message": MESSAGE,
+    },
+    model=types.Update,
+)
+
+WEBHOOK_INFO = DatasetItem(
+    {
+        "url": "",
+        "has_custom_certificate": False,
+        "pending_update_count": 0,
+    },
+    model=types.WebhookInfo,
+)
+
+REPLY_KEYBOARD_MARKUP = DatasetItem(
+    {
+        "keyboard": [[{"text": "something here"}]],
+        "resize_keyboard": True,
+    },
+    model=types.ReplyKeyboardMarkup,
+)
+
+CHAT_PERMISSIONS = DatasetItem(
+    {
+        "can_send_messages": True,
+        "can_send_media_messages": True,
+        "can_send_polls": True,
+        "can_send_other_messages": True,
+        "can_add_web_page_previews": True,
+        "can_change_info": True,
+        "can_invite_users": True,
+        "can_pin_messages": True,
+    },
+    model=types.ChatPermissions,
+)
+
+CHAT_LOCATION = DatasetItem(
+    {
+        "location": LOCATION,
+        "address": "address",
+    },
+    model=types.ChatLocation,
+)
+
+FULL_CHAT = DatasetItem(
+    {
+        **CHAT,
+        "photo": CHAT_PHOTO,
+        "bio": "bio",
+        "has_private_forwards": False,
+        "description": "description",
+        "invite_link": "invite_link",
+        "pinned_message": MESSAGE,
+        "permissions": CHAT_PERMISSIONS,
+        "slow_mode_delay": 10,
+        "message_auto_delete_time": 60,
+        "has_protected_content": True,
+        "sticker_set_name": "sticker_set_name",
+        "can_set_sticker_set": True,
+        "linked_chat_id": -1234567890,
+        "location": CHAT_LOCATION,
+    },
+    model=types.Chat,
+)

aiogram_tests/types/dataset/base.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+from typing import Any
+
+
+class DatasetItem(Mapping):
+    def __init__(self, data: dict, *, model=None, name=None):
+        self._data = data
+        self._name = name
+        self._model = model
+
+    @property
+    def data(self) -> dict:
+        return self._data
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def model(self) -> Any:
+        return self._model
+
+    def as_object(self, **replace_args) -> Any | None:
+        """
+        Return an object from dict
+
+        :return: Any | None
+        """
+        try:
+            data = self._data.copy()
+            data.update(**replace_args)
+            if self._model and isinstance(self._data, dict):
+                return self._recursive_as_object(data, self._model)
+            else:
+                return data
+        except (AttributeError, TypeError):
+            return None
+
+    def _recursive_as_object(self, data: dict, model: Any):
+        """
+        This method is converting dict data to object, if one of the params is the DatasetItem method will be
+        recursive convert it;
+
+        :param data: the dict that should be as object
+        :param model: the object that will be returned
+        :return:
+        """
+        result_data = data.copy()
+        for key, value in data.items():
+            if isinstance(value, DatasetItem):
+                result_data[key] = self._recursive_as_object(value.data, value.model)
+            elif isinstance(value, list):
+                for index, item in enumerate(value):
+                    if not isinstance(item, (DatasetItem, list)):
+                        continue
+
+                    result_data[key][index] = self._recursive_as_object(item.data, item.model)
+
+        return model(**result_data)
+
+    def __iter__(self):
+        return iter(self._data.keys())
+
+    def __getitem__(self, item):
+        return self._data[item]
+
+    def __len__(self):
+        return len(self._data)

aiogram_tests/utils.py

@@ -0,0 +1,5 @@
+import re
+
+
+def camel_case2snake_case(var: str) -> str:
+    return re.sub(r"(?<!^)(?=[A-Z])", "_", var).lower()