Implement tests

Author: GoogolGenius

.github/workflows/lint.yml

@@ -13,7 +13,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]
+        python-version: [3.8, "3.12"]
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v3

.github/workflows/test.yml

@@ -0,0 +1,31 @@
+# Some things borrowed from Hikari CI workflows
+name: test
+
+on: [push, pull_request]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python-version: [3.8, 3.9, "3.10", "3.11", "3.12"]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: 3.12
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install -r dev_requirements.txt
+    - name: Run tests
+      run: |
+        pytest

dev_requirements.txt

@@ -1,7 +1,10 @@
+aioresponses==0.7.8
 black==25.1.0
 isort==6.0.1
 pyright==1.1.403
 mypy==1.17.0
 mkdocs-material==9.6.15
 mkdocstrings==0.29.1
 mkdocstrings[python]==0.29.1
+pytest==8.4.1
+pytest-asyncio==1.1.0

ravyapi/api/models/guilds.py

@@ -39,7 +39,7 @@ class GetGuildResponse:
 
     def __init__(self, data: dict[str, Any]) -> None:
         self._data: dict[str, Any] = data
-        self._trust: Trust = data["trust"]
+        self._trust: Trust = Trust(data["trust"])
         self._bans: list[BanEntryResponse] = [
             BanEntryResponse(ban) for ban in data["bans"]
         ]

tests/conftest.py

@@ -0,0 +1,192 @@
+"""Fixtures for tests."""
+
+from __future__ import annotations
+
+from typing import Any, Generator
+from unittest.mock import AsyncMock
+
+import pytest
+from aioresponses import aioresponses
+
+from ravyapi.api.endpoints import Avatars, Guilds, KSoft, Tokens, URLs, Users
+from ravyapi.client import Client
+from ravyapi.http import HTTPClient
+
+
+@pytest.fixture
+def valid_ravy_token() -> str:
+    """Valid Ravy token for testing."""
+    return "abcdefghijklmnopqrstuvwx.1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
+
+
+@pytest.fixture
+def valid_ksoft_token() -> str:
+    """Valid KSoft token for testing."""
+    return "1234567890abcdef1234567890abcdef12345678"
+
+
+@pytest.fixture
+def invalid_token() -> str:
+    """Invalid token for testing."""
+    return "invalid_token"
+
+
+@pytest.fixture
+def sample_check_avatar_response():
+    """Sample check avatar response."""
+    return {
+        "matched": True,
+        "key": "test_key",
+        "similarity": 0.95,
+    }
+
+
+@pytest.fixture
+def sample_get_token_response():
+    """Sample get token response."""
+    return {
+        "user": 12345,
+        "access": ["users", "avatars", "urls"],
+        "application": 67890,
+        "token_type": "ravy",
+    }
+
+
+@pytest.fixture
+def mock_aioresponses() -> Generator[aioresponses, Any, None]:
+    """Mock aioresponses fixture."""
+    with aioresponses() as m:
+        yield m
+
+
+@pytest.fixture
+def mock_http_client(valid_ravy_token: str) -> HTTPClient:
+    """Mock HTTPClient for testing."""
+    # Create a mock session to avoid the event loop issue
+    mock_session = AsyncMock()
+    client = HTTPClient.__new__(HTTPClient)
+    client._token = valid_ravy_token  # type: ignore
+    client._permissions = None  # type: ignore
+    client._phisherman_token = None  # type: ignore
+    client._headers = {  # type: ignore
+        "Authorization": valid_ravy_token,
+        "User-Agent": "Test-Agent",
+    }
+    client._session = mock_session  # type: ignore
+    return client
+
+
+@pytest.fixture
+def mock_client(valid_ravy_token: str, mock_http_client: HTTPClient) -> Client:
+    """Mock Client for testing."""
+    client = Client.__new__(Client)
+    client._token = valid_ravy_token  # type: ignore
+    client._http = mock_http_client  # type: ignore
+    client._closed = False  # type: ignore
+    client._avatars = Avatars(mock_http_client)  # type: ignore
+    client._guilds = Guilds(mock_http_client)  # type: ignore
+    client._ksoft = KSoft(mock_http_client)  # type: ignore
+    client._users = Users(mock_http_client)  # type: ignore
+    client._urls = URLs(mock_http_client)  # type: ignore
+    client._tokens = Tokens(mock_http_client)  # type: ignore
+    return client
+
+
+@pytest.fixture
+def mock_avatars_endpoint(mock_http_client: HTTPClient) -> Avatars:
+    """Mock Avatars endpoint for testing."""
+    return Avatars(mock_http_client)
+
+
+@pytest.fixture
+def mock_tokens_endpoint(mock_http_client: HTTPClient) -> Tokens:
+    """Mock Tokens endpoint for testing."""
+    return Tokens(mock_http_client)
+
+
+@pytest.fixture
+def sample_get_guild_response():
+    """Sample get guild response."""
+    return {
+        "trust": {"level": 3, "label": "Neutral"},
+        "bans": [
+            {
+                "provider": "ravy",
+                "reason": "Test reason",
+                "moderator": "987654321",
+                "reason_key": "test_key",
+            }
+        ],
+    }
+
+
+@pytest.fixture
+def sample_get_user_response():
+    """Sample get user response."""
+    return {
+        "pronouns": "he/him",
+        "trust": {"level": 3, "label": "Neutral"},
+        "whitelists": [
+            {"provider": "ravy", "reason": "Test whitelist", "moderator": "987654321"}
+        ],
+        "bans": [
+            {
+                "provider": "ravy",
+                "reason": "Test ban",
+                "moderator": "987654321",
+                "reason_key": "test_key",
+            }
+        ],
+        "rep": [{"provider": "ravy", "reputation": 100, "moderator": "987654321"}],
+        "sentinel": {
+            "tracked": True,
+            "reason": "Test sentinel",
+            "moderator": "987654321",
+        },
+    }
+
+
+@pytest.fixture
+def sample_get_website_response():
+    """Sample get website response."""
+    return {
+        "is_fraudulent": False,
+        "message": "Safe website",
+        "scan_date": "2023-01-01T00:00:00Z",
+    }
+
+
+@pytest.fixture
+def sample_get_ksoft_ban_response():
+    """Sample get KSoft ban response."""
+    return {
+        "banned": True,
+        "reason": "Test ban reason",
+        "moderator": "987654321",
+        "appeal": "https://example.com/appeal",
+        "date": "2023-01-01T00:00:00Z",
+    }
+
+
+@pytest.fixture
+def mock_guilds_endpoint(mock_http_client: HTTPClient) -> Guilds:
+    """Mock Guilds endpoint for testing."""
+    return Guilds(mock_http_client)
+
+
+@pytest.fixture
+def mock_users_endpoint(mock_http_client: HTTPClient) -> Users:
+    """Mock Users endpoint for testing."""
+    return Users(mock_http_client)
+
+
+@pytest.fixture
+def mock_urls_endpoint(mock_http_client: HTTPClient) -> URLs:
+    """Mock URLs endpoint for testing."""
+    return URLs(mock_http_client)
+
+
+@pytest.fixture
+def mock_ksoft_endpoint(mock_http_client: HTTPClient) -> KSoft:
+    """Mock KSoft endpoint for testing."""
+    return KSoft(mock_http_client)

tests/test_about.py

@@ -0,0 +1,145 @@
+# Copyright 2022-Present GoogolGenius
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for package metadata."""
+
+from __future__ import annotations
+
+from ravyapi._about import (
+    __all__,
+    __author__,
+    __copyright__,
+    __email__,
+    __license__,
+    __maintainer__,
+    __repository__,
+    __status__,
+    __version__,
+)
+
+
+class TestAbout:
+    """Test cases for package metadata."""
+
+    def test_author(self) -> None:
+        """Test __author__ constant."""
+        assert __author__ == "GoogolGenius"
+        assert isinstance(__author__, str)
+
+    def test_repository(self) -> None:
+        """Test __repository__ constant."""
+        assert __repository__ == "https://github.com/GoogolGenius/RavyAPI.py"
+        assert isinstance(__repository__, str)
+        assert __repository__.startswith("https://github.com/")
+
+    def test_copyright(self) -> None:
+        """Test __copyright__ constant."""
+        assert __copyright__ == "Copyright 2022-Present GoogolGenius"
+        assert isinstance(__copyright__, str)
+        assert "GoogolGenius" in __copyright__
+
+    def test_license(self) -> None:
+        """Test __license__ constant."""
+        assert __license__ == "Apache v2"
+        assert isinstance(__license__, str)
+
+    def test_version(self) -> None:
+        """Test __version__ constant."""
+        assert __version__ == "0.1.0a"
+        assert isinstance(__version__, str)
+
+    def test_maintainer(self) -> None:
+        """Test __maintainer__ constant."""
+        assert __maintainer__ == "GoogolGenius"
+        assert isinstance(__maintainer__, str)
+
+    def test_email(self) -> None:
+        """Test __email__ constant."""
+        assert __email__ == "erich.nguyen@outlook.com"
+        assert isinstance(__email__, str)
+        assert "@" in __email__
+
+    def test_status(self) -> None:
+        """Test __status__ constant."""
+        assert __status__ == "Development"
+        assert isinstance(__status__, str)
+
+    def test_all_exports(self) -> None:
+        """Test __all__ contains all expected exports."""
+        expected_exports = {
+            "__author__",
+            "__repository__",
+            "__copyright__",
+            "__license__",
+            "__version__",
+            "__maintainer__",
+            "__email__",
+            "__status__",
+        }
+        assert set(__all__) == expected_exports
+
+    def test_all_is_tuple(self) -> None:
+        """Test __all__ is a tuple."""
+        assert isinstance(__all__, tuple)
+
+    def test_version_format(self) -> None:
+        """Test version follows semantic versioning format."""
+        # Basic check for version format (major.minor.patch with optional alpha/beta)
+        version_parts = __version__.split(".")
+        assert len(version_parts) >= 2  # At least major.minor
+
+        # Check that the first part is numeric
+        assert version_parts[0].isdigit()
+        assert version_parts[1].isdigit()
+
+    def test_email_format(self) -> None:
+        """Test email follows basic email format."""
+        assert "@" in __email__
+        assert "." in __email__
+        parts = __email__.split("@")
+        assert len(parts) == 2
+        assert len(parts[0]) > 0  # Username part
+        assert len(parts[1]) > 0  # Domain part
+
+    def test_repository_format(self) -> None:
+        """Test repository URL format."""
+        assert __repository__.startswith("https://github.com/")
+        assert __repository__.endswith("/RavyAPI.py")
+
+        # Extract username/repo
+        repo_path = __repository__.replace("https://github.com/", "")
+        assert "/" in repo_path
+        username, repo_name = repo_path.split("/")
+        assert username == "GoogolGenius"
+        assert repo_name == "RavyAPI.py"
+
+    def test_constants_are_strings(self) -> None:
+        """Test all constants are strings."""
+        constants = [
+            __author__,
+            __repository__,
+            __copyright__,
+            __license__,
+            __version__,
+            __maintainer__,
+            __email__,
+            __status__,
+        ]
+
+        for constant in constants:
+            assert isinstance(constant, str)
+            assert len(constant) > 0  # Non-empty strings
+
+    def test_author_and_maintainer_consistency(self) -> None:
+        """Test author and maintainer are the same."""
+        assert __author__ == __maintainer__