Merge branch 'aiogram:dev-2.x' into dev-2.x-bot-download

tests/conftest.py

@@ -1,28 +1,53 @@
+import aioredis
 import pytest
 from _pytest.config import UsageError
-import aioredis.util
+
+try:
+    import aioredis.util
+except ImportError:
+    pass
 
 
 def pytest_addoption(parser):
-    parser.addoption("--redis", default=None,
-                     help="run tests which require redis connection")
+    parser.addoption(
+        "--redis",
+        default=None,
+        help="run tests which require redis connection",
+    )
 
 
 def pytest_configure(config):
-    config.addinivalue_line("markers", "redis: marked tests require redis connection to run")
+    config.addinivalue_line(
+        "markers",
+        "redis: marked tests require redis connection to run",
+    )
 
 
 def pytest_collection_modifyitems(config, items):
     redis_uri = config.getoption("--redis")
     if redis_uri is None:
-        skip_redis = pytest.mark.skip(reason="need --redis option with redis URI to run")
+        skip_redis = pytest.mark.skip(
+            reason="need --redis option with redis URI to run"
+        )
         for item in items:
             if "redis" in item.keywords:
                 item.add_marker(skip_redis)
         return
+
+    redis_version = int(aioredis.__version__.split(".")[0])
+    options = None
+    if redis_version == 1:
+        (host, port), options = aioredis.util.parse_url(redis_uri)
+        options.update({'host': host, 'port': port})
+    elif redis_version == 2:
+        try:
+            options = aioredis.connection.parse_url(redis_uri)
+        except ValueError as e:
+            raise UsageError(f"Invalid redis URI {redis_uri!r}: {e}")
+
     try:
-        address, options = aioredis.util.parse_url(redis_uri)
-        assert isinstance(address, tuple), "Only redis and rediss schemas are supported, eg redis://foo."
+        assert isinstance(options, dict), \
+            "Only redis and rediss schemas are supported, eg redis://foo."
     except AssertionError as e:
         raise UsageError(f"Invalid redis URI {redis_uri!r}: {e}")
 
@@ -30,6 +55,20 @@ def pytest_collection_modifyitems(config, items):
 @pytest.fixture(scope='session')
 def redis_options(request):
     redis_uri = request.config.getoption("--redis")
-    (host, port), options = aioredis.util.parse_url(redis_uri)
-    options.update({'host': host, 'port': port})
-    return options
+    if redis_uri is None:
+        pytest.skip("need --redis option with redis URI to run")
+        return
+
+    redis_version = int(aioredis.__version__.split(".")[0])
+    if redis_version == 1:
+        (host, port), options = aioredis.util.parse_url(redis_uri)
+        options.update({'host': host, 'port': port})
+        return options
+
+    if redis_version == 2:
+        try:
+            return aioredis.connection.parse_url(redis_uri)
+        except ValueError as e:
+            raise UsageError(f"Invalid redis URI {redis_uri!r}: {e}")
+
+    raise UsageError("Unsupported aioredis version")

tests/contrib/fsm_storage/test_storage.py

@@ -1,12 +1,16 @@
+import aioredis
 import pytest
-
+from pytest_lazyfixture import lazy_fixture
 from aiogram.contrib.fsm_storage.memory import MemoryStorage
-from aiogram.contrib.fsm_storage.redis import RedisStorage2, RedisStorage
+from aiogram.contrib.fsm_storage.redis import RedisStorage, RedisStorage2
 
 
 @pytest.fixture()
 @pytest.mark.redis
 async def redis_store(redis_options):
+    if int(aioredis.__version__.split(".")[0]) == 2:
+        pytest.skip('aioredis v2 is not supported.')
+        return
     s = RedisStorage(**redis_options)
     try:
         yield s
@@ -37,9 +41,9 @@ async def memory_store():
 
 @pytest.mark.parametrize(
     "store", [
-        pytest.lazy_fixture('redis_store'),
-        pytest.lazy_fixture('redis_store2'),
-        pytest.lazy_fixture('memory_store'),
+        lazy_fixture('redis_store'),
+        lazy_fixture('redis_store2'),
+        lazy_fixture('memory_store'),
     ]
 )
 class TestStorage:
@@ -63,8 +67,8 @@ class TestStorage:
 
 @pytest.mark.parametrize(
     "store", [
-        pytest.lazy_fixture('redis_store'),
-        pytest.lazy_fixture('redis_store2'),
+        lazy_fixture('redis_store'),
+        lazy_fixture('redis_store2'),
     ]
 )
 class TestRedisStorage2:
@@ -74,6 +78,7 @@ class TestRedisStorage2:
         assert await store.get_data(chat='1234') == {'foo': 'bar'}
         pool_id = id(store._redis)
         await store.close()
+        await store.wait_closed()
         assert await store.get_data(chat='1234') == {
             'foo': 'bar'}  # new pool was opened at this point
         assert id(store._redis) != pool_id

tests/types/test_mixins.py

@@ -0,0 +1,102 @@
+import os
+from io import BytesIO
+from pathlib import Path
+
+import pytest
+
+from aiogram import Bot
+from aiogram.types import File
+from aiogram.types.mixins import Downloadable
+from tests import TOKEN
+from tests.types.dataset import FILE
+
+pytestmark = pytest.mark.asyncio
+
+
+@pytest.fixture(name='bot')
+async def bot_fixture():
+    """ Bot fixture """
+    _bot = Bot(TOKEN)
+    yield _bot
+    await _bot.session.close()
+
+
+@pytest.fixture
+def tmppath(tmpdir, request):
+    os.chdir(tmpdir)
+    yield Path(tmpdir)
+    os.chdir(request.config.invocation_dir)
+
+
+@pytest.fixture
+def downloadable(bot):
+    async def get_file():
+        return File(**FILE)
+
+    downloadable = Downloadable()
+    downloadable.get_file = get_file
+    downloadable.bot = bot
+
+    return downloadable
+
+
+class TestDownloadable:
+    async def test_download_make_dirs_false_nodir(self, tmppath, downloadable):
+        with pytest.raises(FileNotFoundError):
+            await downloadable.download(make_dirs=False)
+
+    async def test_download_make_dirs_false_mkdir(self, tmppath, downloadable):
+        os.mkdir('voice')
+        await downloadable.download(make_dirs=False)
+        assert os.path.isfile(tmppath.joinpath(FILE["file_path"]))
+
+    async def test_download_make_dirs_true(self, tmppath, downloadable):
+        await downloadable.download(make_dirs=True)
+        assert os.path.isfile(tmppath.joinpath(FILE["file_path"]))
+
+    async def test_download_deprecation_warning(self, tmppath, downloadable):
+        with pytest.deprecated_call():
+            await downloadable.download("test.file")
+
+    async def test_download_destination(self, tmppath, downloadable):
+        with pytest.deprecated_call():
+            await downloadable.download("test.file")
+        assert os.path.isfile(tmppath.joinpath('test.file'))
+
+    async def test_download_destination_dir_exist(self, tmppath, downloadable):
+        os.mkdir("test_folder")
+        with pytest.deprecated_call():
+            await downloadable.download("test_folder")
+        assert os.path.isfile(tmppath.joinpath('test_folder', FILE["file_path"]))
+
+    async def test_download_destination_with_dir(self, tmppath, downloadable):
+        with pytest.deprecated_call():
+            await downloadable.download(os.path.join('dir_name', 'file_name'))
+        assert os.path.isfile(tmppath.joinpath('dir_name', 'file_name'))
+
+    async def test_download_destination_io_bytes(self, tmppath, downloadable):
+        file = BytesIO()
+        with pytest.deprecated_call():
+            await downloadable.download(file)
+        assert len(file.read()) != 0
+
+    async def test_download_raise_value_error(self, tmppath, downloadable):
+        with pytest.raises(ValueError):
+            await downloadable.download(destination_dir="a", destination_file="b")
+
+    async def test_download_destination_dir(self, tmppath, downloadable):
+        await downloadable.download(destination_dir='test_dir')
+        assert os.path.isfile(tmppath.joinpath('test_dir', FILE["file_path"]))
+
+    async def test_download_destination_file(self, tmppath, downloadable):
+        await downloadable.download(destination_file='file_name')
+        assert os.path.isfile(tmppath.joinpath('file_name'))
+
+    async def test_download_destination_file_with_dir(self, tmppath, downloadable):
+        await downloadable.download(destination_file=os.path.join('dir_name', 'file_name'))
+        assert os.path.isfile(tmppath.joinpath('dir_name', 'file_name'))
+
+    async def test_download_io_bytes(self, tmppath, downloadable):
+        file = BytesIO()
+        await downloadable.download(destination_file=file)
+        assert len(file.read()) != 0