feat: apply changes related to tests from Top-gg-Community#87

Author: null8626

.github/workflows/release.yml

@@ -9,7 +9,7 @@ jobs:
       - uses: actions/checkout@v5
       - uses: actions/setup-python@v6
         with:
-          python-version: 3.13
+          python-version: 3.14
       - name: Install dependencies
         run: python3 -m pip install build twine
       - name: Build and publish

.github/workflows/test.yml

@@ -9,14 +9,14 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ 3.9, '3.10', 3.11, 3.12, 3.13 ]
+        python-version: [ '3.10', 3.11, 3.12, 3.13, 3.14 ]
     steps:
       - uses: actions/checkout@v5
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install
-        run: python -m pip install .[dev]
+        run: python -m pip install . pytest mock pytest-mock pytest-asyncio
       - name: Test with pytest
         run: pytest

MANIFEST.in

@@ -1,3 +1,11 @@
-include LICENSE
-include requirements.txt
-include README.rst
+prune .github
+prune .ruff_cache
+prune docs
+prune examples
+prune tests
+exclude .gitignore
+exclude .readthedocs.yml
+exclude ruff.toml
+exclude LICENSE
+exclude ISSUE_TEMPLATE.md
+exclude PULL_REQUEST_TEMPLATE.md

tests/test_autopost.py

@@ -0,0 +1,92 @@
+import datetime
+
+import mock
+import pytest
+from aiohttp import ClientSession
+from pytest_mock import MockerFixture
+
+from topgg import DBLClient
+from topgg.autopost import AutoPoster
+from topgg.errors import HTTPException, TopGGException
+
+
+MOCK_TOKEN = ".eyJfdCI6IiIsImlkIjoiMzY0ODA2MDI5ODc2NTU1Nzc2In0=."
+
+
+@pytest.fixture
+def session() -> ClientSession:
+    return mock.Mock(ClientSession)
+
+
+@pytest.fixture
+def autopost(session: ClientSession) -> AutoPoster:
+    return AutoPoster(DBLClient(MOCK_TOKEN, session=session))
+
+
+@pytest.mark.asyncio
+async def test_AutoPoster_breaks_autopost_loop_on_401(
+    mocker: MockerFixture, session: ClientSession
+) -> None:
+    mocker.patch(
+        "topgg.DBLClient.post_guild_count",
+        side_effect=HTTPException("Unauthorized", 401),
+    )
+
+    callback = mock.Mock()
+    autopost = DBLClient(MOCK_TOKEN, session=session).autopost().stats(callback)
+
+    assert isinstance(autopost, AutoPoster)
+    assert not isinstance(autopost.stats()(callback), AutoPoster)
+
+    autopost._interval = 1
+
+    with pytest.raises(HTTPException):
+        await autopost.start()
+
+    callback.assert_called_once()
+    assert not autopost.is_running
+
+
+@pytest.mark.asyncio
+async def test_AutoPoster_raises_missing_stats(autopost: AutoPoster) -> None:
+    with pytest.raises(
+        TopGGException, match="You must provide a callback that returns the stats."
+    ):
+        await autopost.start()
+
+
+@pytest.mark.asyncio
+async def test_AutoPoster_raises_already_running(autopost: AutoPoster) -> None:
+    autopost.stats(mock.Mock()).start()
+    with pytest.raises(TopGGException, match="The autoposter is already running."):
+        await autopost.start()
+
+
+@pytest.mark.asyncio
+async def test_AutoPoster_interval_too_short(autopost: AutoPoster) -> None:
+    with pytest.raises(ValueError, match="interval must be greater than 900 seconds."):
+        autopost.set_interval(50)
+
+
+@pytest.mark.asyncio
+async def test_AutoPoster_error_callback(
+    mocker: MockerFixture, autopost: AutoPoster
+) -> None:
+    error_callback = mock.Mock()
+    side_effect = HTTPException("Internal Server Error", 500)
+
+    mocker.patch("topgg.DBLClient.post_guild_count", side_effect=side_effect)
+    task = autopost.on_error(error_callback).stats(mock.Mock()).start()
+    autopost.stop()
+    await task
+    error_callback.assert_called_once_with(side_effect)
+
+
+def test_AutoPoster_interval(autopost: AutoPoster):
+    assert autopost.interval == 900
+    autopost.set_interval(datetime.timedelta(hours=1))
+    assert autopost.interval == 3600
+    autopost.interval = datetime.timedelta(hours=2)
+    assert autopost.interval == 7200
+    autopost.interval = 3600
+    assert autopost.interval == 3600

tests/test_client.py

@@ -1,25 +1,11 @@
-import asyncio
-from typing import Optional
-
 import mock
 import pytest
 from aiohttp import ClientSession
-from discord import Client
-from discord.ext.commands import Bot
-from pytest import CaptureFixture
-from pytest_mock import MockerFixture
 
-from topgg import DBLClient
-from topgg.errors import ClientException, Unauthorized, UnauthorizedDetected
+import topgg
 
 
-@pytest.fixture
-def bot() -> Client:
-    bot = mock.Mock(Client)
-    bot.loop = asyncio.get_event_loop()
-    bot.guilds = []
-    bot.is_closed.return_value = False
-    return bot
+MOCK_TOKEN = ".eyJfdCI6IiIsImlkIjoiMzY0ODA2MDI5ODc2NTU1Nzc2In0=."
 
 
 @pytest.fixture
@@ -28,162 +14,52 @@ def session() -> ClientSession:
 
 
 @pytest.fixture
-def exc() -> Exception:
-    return Exception("Test Exception")
-
-
-@pytest.mark.parametrize(
-    "autopost, post_shard_count, autopost_interval",
-    [
-        (True, True, 900),
-        (True, False, 900),
-        (True, True, None),
-        (True, False, None),
-        (False, False, None),
-        (False, False, 0),
-    ],
-)
-@pytest.mark.asyncio
-async def test_DBLClient_validates_constructor_and_passes_for_valid_values(
-    bot: Client,
-    mocker: MockerFixture,
-    autopost: bool,
-    post_shard_count: bool,
-    autopost_interval: Optional[int],
-    session: ClientSession,
-) -> None:
-    mocker.patch("topgg.DBLClient._auto_post", new_callable=mock.AsyncMock)  # type: ignore
-    DBLClient(
-        bot,
-        "",
-        session=session,
-        autopost=autopost,
-        post_shard_count=post_shard_count,
-        autopost_interval=autopost_interval,
-    )
-
-
-@pytest.mark.parametrize(
-    "autopost, post_shard_count, autopost_interval",
-    [
-        (True, True, 0),
-        (True, False, 500),
-        (False, True, 0),
-        (False, True, 900),
-        (False, True, None),
-        (False, False, 1800),
-    ],
-)
-def test_DBLClient_validates_constructor_and_fails_for_invalid_values(
-    bot: Client,
-    mocker: MockerFixture,
-    autopost: bool,
-    post_shard_count: bool,
-    autopost_interval: Optional[int],
-    session: ClientSession,
-) -> None:
-    with pytest.raises(ClientException):
-        DBLClient(
-            bot,
-            "",
-            session=session,
-            autopost=autopost,
-            post_shard_count=post_shard_count,
-            autopost_interval=autopost_interval,
-        )
+def client(session: ClientSession) -> topgg.DBLClient:
+    return topgg.DBLClient(MOCK_TOKEN, session=session)
 
 
 @pytest.mark.asyncio
-async def test_DBLClient_breaks_autopost_loop_on_401(
-    bot: Client, mocker: MockerFixture, session: ClientSession
-) -> None:
-    response = mock.Mock("reason, status")
-    response.reason = "Unauthorized"
-    response.status = 401
-
-    mocker.patch(
-        "topgg.DBLClient.post_guild_count", side_effect=Unauthorized(response, {})
-    )
-    mocker.patch(
-        "topgg.DBLClient._ensure_bot_user",
-        new_callable=mock.AsyncMock,  # type: ignore
-    )
-
-    obj = DBLClient(bot, "", False, session=session)
-
-    with pytest.raises(Unauthorized):
-        await obj._auto_post()
+async def test_DBLClient_post_guild_count_with_no_args(client: topgg.DBLClient):
+    with pytest.raises(ValueError, match="Got an invalid server count. Got None."):
+        await client.post_guild_count()
 
 
 @pytest.mark.asyncio
-@pytest.mark.parametrize(
-    "token",
-    [None, ""],
-    # treat None as str to suppress mypy
-)
-async def test_HTTPClient_fails_for_no_token(
-    bot: Client, token: str, session: ClientSession
-) -> None:
-    with pytest.raises(UnauthorizedDetected):
-        await DBLClient(bot=bot, token=token, session=session).post_guild_count()
+async def test_DBLClient_get_weekend_status(monkeypatch, client: topgg.DBLClient):
+    monkeypatch.setattr("topgg.DBLClient._DBLClient__request", mock.AsyncMock())
+    await client.get_weekend_status()
+    client._DBLClient__request.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_Client_with_default_autopost_error_handler(
-    mocker: MockerFixture,
-    capsys: CaptureFixture[str],
-    session: ClientSession,
-    exc: Exception,
-) -> None:
-    client = Client()
-    mocker.patch("topgg.DBLClient._auto_post", new_callable=mock.AsyncMock)  # type: ignore
-    dbl = DBLClient(client, "", True, session=session)
-    assert client.on_autopost_error == dbl.on_autopost_error
-    await client.on_autopost_error(exc)
-    assert "Ignoring exception in auto post loop" in capsys.readouterr().err
+async def test_DBLClient_post_guild_count(monkeypatch, client: topgg.DBLClient):
+    monkeypatch.setattr("topgg.DBLClient._DBLClient__request", mock.AsyncMock())
+    await client.post_guild_count(guild_count=123)
+    client._DBLClient__request.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_Client_with_custom_autopost_error_handler(
-    mocker: MockerFixture, session: ClientSession, exc: Exception
-) -> None:
-    client = Client()
-    state = False
+async def test_DBLClient_get_guild_count(monkeypatch, client: topgg.DBLClient):
+    monkeypatch.setattr(
+        "topgg.DBLClient._DBLClient__request", mock.AsyncMock(return_value={})
+    )
+    await client.get_guild_count()
+    client._DBLClient__request.assert_called_once()
 
-    @client.event
-    async def on_autopost_error(exc: Exception) -> None:
-        nonlocal state
-        state = True
 
-    mocker.patch("topgg.DBLClient._auto_post", new_callable=mock.AsyncMock)  # type: ignore
-    DBLClient(client, "", True, session=session)
-    await client.on_autopost_error(exc)
-    assert state
+@pytest.mark.asyncio
+async def test_DBLClient_get_bot_votes(monkeypatch, client: topgg.DBLClient):
+    monkeypatch.setattr(
+        "topgg.DBLClient._DBLClient__request", mock.AsyncMock(return_value=[])
+    )
+    await client.get_bot_votes()
+    client._DBLClient__request.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_Bot_with_autopost_error_listener(
-    mocker: MockerFixture,
-    capsys: CaptureFixture[str],
-    session: ClientSession,
-    exc: Exception,
-) -> None:
-    bot = Bot("")
-    state = False
-
-    @bot.listen()
-    async def on_autopost_error(exc: Exception) -> None:
-        nonlocal state
-        state = True
-
-    mocker.patch("topgg.DBLClient._auto_post", new_callable=mock.AsyncMock)  # type: ignore
-    DBLClient(bot, "", True, session=session)
-
-    # await to make sure all the listeners were run before asserting
-    # as <Bot>.dispatch schedules the events and will continue
-    # to the assert line without finishing the event callbacks
-    await bot.on_autopost_error(exc)
-    await on_autopost_error(exc)
-
-    assert "Ignoring exception in auto post loop" not in capsys.readouterr().err
-    assert state
+async def test_DBLClient_get_user_vote(monkeypatch, client: topgg.DBLClient):
+    monkeypatch.setattr(
+        "topgg.DBLClient._DBLClient__request", mock.AsyncMock(return_value={"voted": 1})
+    )
+    await client.get_user_vote(1234)
+    client._DBLClient__request.assert_called_once()