test: update tests to new package structure

Author: vlymar1

tests/api/__init__.py

@@ -0,0 +1,98 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from vinted.api.catalog import CatalogAPI
+from vinted.models.item import CatalogItem
+
+
+@pytest.fixture
+def mock_session():
+    session = MagicMock()
+    session.base_url = "https://www.vinted.com"
+    session.configure_from_url = MagicMock()
+    return session
+
+
+@pytest.mark.asyncio
+async def test_catalog_search_basic(mock_session):
+    catalog = CatalogAPI(mock_session)
+
+    mock_response = MagicMock()
+    mock_response.json.return_value = {
+        "items": [
+            {
+                "id": 1,
+                "title": "Test Item",
+                "price": {"amount": 10, "currency_code": "EUR"},
+                "photo": {
+                    "url": "http://example.com/photo.jpg",
+                    "high_resolution": {"timestamp": 1734796339},
+                },
+                "url": "http://example.com/item/1",
+            }
+        ]
+    }
+    mock_session.request = AsyncMock(return_value=mock_response)
+
+    items = await catalog.search(url="https://www.vinted.com/catalog?search_text=test")
+
+    assert len(items) == 1
+    assert isinstance(items[0], CatalogItem)
+    assert items[0].id == 1
+
+
+@pytest.mark.asyncio
+async def test_catalog_search_raw_data(mock_session):
+    catalog = CatalogAPI(mock_session)
+
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"items": [{"id": 1, "title": "Test"}]}
+    mock_session.request = AsyncMock(return_value=mock_response)
+
+    items = await catalog.search(url="https://www.vinted.com/catalog", raw_data=True)
+
+    assert isinstance(items, list)
+    assert isinstance(items[0], dict)
+
+
+@pytest.mark.asyncio
+async def test_catalog_search_with_order(mock_session):
+    catalog = CatalogAPI(mock_session)
+
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"items": []}
+
+    mock_session.request = AsyncMock(return_value=mock_response)
+
+    await catalog.search(url="https://www.vinted.com/catalog", order="newest_first")
+
+    call_args = mock_session.request.call_args
+    assert "order" in call_args.kwargs["params"]
+
+
+def test_extract_catalog_id_from_path():
+    catalog = CatalogAPI(MagicMock())
+
+    catalog_id = catalog._extract_catalog_id("/catalog/123-women-clothes")
+    assert catalog_id == 123
+
+
+def test_extract_catalog_id_no_catalog():
+    catalog = CatalogAPI(MagicMock())
+
+    catalog_id = catalog._extract_catalog_id("/search")
+    assert catalog_id is None
+
+
+def test_build_params():
+    catalog = CatalogAPI(MagicMock())
+
+    params = catalog._build_params(
+        url="https://www.vinted.com/catalog?search_text=nike&brand_ids[]=53", per_page=20, page=1
+    )
+
+    assert params["search_text"] == "nike"
+    assert params["brand_ids"] == "53"
+    assert params["per_page"] == 20
+    assert params["page"] == 1

tests/api/test_catalog.py

@@ -0,0 +1,64 @@
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from vinted.api.items import ItemsAPI
+from vinted.models.item import DetailedItem
+
+
+@pytest.fixture
+def mock_session():
+    session = MagicMock()
+    session.base_url = "https://www.vinted.com"
+    session.configure_from_url = MagicMock()
+    return session
+
+
+@pytest.mark.asyncio
+async def test_items_get_details(mock_session, sample_detailed_item_data):
+    items_api = ItemsAPI(mock_session)
+
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"item": sample_detailed_item_data}
+
+    mock_session.request = AsyncMock(return_value=mock_response)
+
+    item = await items_api.get_details(url="https://www.vinted.com/items/123-test-item")
+
+    assert isinstance(item, DetailedItem)
+    assert item.id == 456
+
+
+@pytest.mark.asyncio
+async def test_items_get_details_raw(mock_session, sample_detailed_item_data):
+    items_api = ItemsAPI(mock_session)
+
+    mock_response = MagicMock()
+    mock_response.json.return_value = {"item": sample_detailed_item_data}
+
+    mock_session.request = AsyncMock(return_value=mock_response)
+
+    item = await items_api.get_details(
+        url="https://www.vinted.com/items/123-test-item", raw_data=True
+    )
+
+    assert isinstance(item, dict)
+    assert item["id"] == 456
+
+
+def test_extract_product_id():
+    items_api = ItemsAPI(MagicMock())
+
+    product_id = items_api._extract_product_id("https://www.vinted.com/items/123-nike-shoes")
+
+    assert product_id == "123"
+
+
+def test_extract_product_id_complex():
+    items_api = ItemsAPI(MagicMock())
+
+    product_id = items_api._extract_product_id(
+        "https://www.vinted.fr/items/9876-adidas-sneakers-size-42"
+    )
+
+    assert product_id == "9876"

tests/api/test_items.py

@@ -1,79 +1,74 @@
-from pathlib import Path
-from typing import Any, Callable, Generator
+from unittest.mock import AsyncMock, MagicMock
 
 import pytest
-
-from vinted_api_kit import VintedApi
-from vinted_api_kit.client.vinted_http_client import VintedHttpClient
-from vinted_api_kit.services.item_service import ItemService
-
-
-@pytest.fixture
-def vinted_http_client(tmp_path: Path) -> Generator[VintedHttpClient, Any, None]:
-    client = VintedHttpClient(
-        locale="fr",
-        proxies={"http": "http://127.0.0.1:8888"},
-        client_ip="123.123.123.123",
-        cookies_dir=tmp_path,
-        persist_cookies=False,
-    )
-    yield client
-    import asyncio
-
-    asyncio.run(client.close())
-
-
-@pytest.fixture
-def item_service(vinted_http_client: VintedHttpClient):
-    return ItemService(client=vinted_http_client)
-
-
-@pytest.fixture
-async def vinted_api():
-    async with VintedApi() as api:
-        yield api
+from curl_cffi.requests import Response
 
 
 @pytest.fixture
-def sample_catalog_item_data() -> Callable[[int], dict[str, Any]]:
-    def factory(ts: int = 1710000000) -> dict[str, Any]:
-        return {
-            "id": 77,
-            "title": "Vintage Jeans",
-            "brand_title": "Levis",
-            "size_title": "32",
-            "price": {"currency_code": "EUR", "amount": 45},
-            "photo": {
-                "url": "https://cdn.vinted.net/catalog.jpg",
-                "high_resolution": {"timestamp": ts},
-            },
-            "photos": [{"high_resolution": {"timestamp": ts}}],
-            "url": "https://www.vinted.it/items/77-vintage-jeans",
-        }
-
-    return factory
+def sample_catalog_item_data():
+    return {
+        "id": 123,
+        "title": "Nike Air Max",
+        "brand_title": "Nike",
+        "size_title": "42",
+        "price": {"amount": 50.0, "currency_code": "EUR"},
+        "photo": {
+            "url": "https://example.com/photo.jpg",
+            "high_resolution": {"timestamp": 1734796339},
+        },
+        "url": "https://vinted.com/items/123-nike-air-max",
+    }
 
 
 @pytest.fixture
-def sample_detailed_item_data() -> dict[str, Any]:
+def sample_detailed_item_data():
     return {
-        "id": 42,
-        "title": "Test Product",
-        "description": "Very rare Vinted item",
-        "brand_dto": {"title": "Nike", "slug": "nike"},
-        "price": {"currency_code": "EUR", "amount": 19.99},
-        "total_item_price": {"amount": 22.49},
+        "id": 456,
+        "title": "Adidas Sneakers",
+        "description": "Great condition",
+        "brand_dto": {"title": "Adidas", "slug": "adidas"},
+        "price": {"amount": 75.0, "currency_code": "USD"},
+        "total_item_price": {"amount": 80.0, "currency_code": "USD"},
         "photos": [
-            {
-                "url": "https://cdn.vinted.net/images.jpg",
-                "high_resolution": {"timestamp": 1710000000},
-            }
+            {"url": "https://example.com/photo1.jpg", "high_resolution": {"timestamp": 1734796339}}
         ],
-        "url": "https://www.vinted.it/items/42-test-product",
+        "url": "https://vinted.com/items/456",
         "plugins": [
             {
                 "name": "attributes",
-                "data": {"attributes": [{"code": "size", "data": {"value": "M"}}]},
+                "data": {"attributes": [{"code": "size", "data": {"value": "44"}}]},
             }
         ],
     }
+
+
+@pytest.fixture
+def mock_async_session():
+    session = AsyncMock()
+    session.cookies = MagicMock()
+    session.cookies.get = MagicMock(return_value=None)
+    session.headers = {}
+    return session
+
+
+@pytest.fixture
+def mock_http_response():
+    response = MagicMock(spec=Response)
+    response.status_code = 200
+    response.json.return_value = {
+        "items": [
+            {
+                "id": 1,
+                "title": "Item 1",
+                "price": {"amount": 10, "currency_code": "EUR"},
+            }
+        ]
+    }
+    return response
+
+
+@pytest.fixture
+def temp_cookies_dir(tmp_path):
+    cookies_dir = tmp_path / "cookies"
+    cookies_dir.mkdir()
+    return cookies_dir

tests/conftest.py

@@ -1,63 +1,54 @@
-from datetime import datetime, timedelta, timezone
-from typing import Callable
+from datetime import datetime, timezone
 
 import pytest
 
-from vinted_api_kit.models import CatalogItem
+from vinted.models.item import CatalogItem
 
 
-def test_basic_catalog_item_parsing(sample_catalog_item_data: Callable[[int], dict]):
-    data = sample_catalog_item_data(1710000000)
+def test_catalog_item_creation(sample_catalog_item_data):
+    item = CatalogItem(raw_data=sample_catalog_item_data)
 
-    item = CatalogItem(data)
-
-    assert item.id == 77
-    assert item.title == "Vintage Jeans"
-    assert item.brand_title == "Levis"
-    assert item.size_title == "32"
+    assert item.id == 123
+    assert item.title == "Nike Air Max"
+    assert item.brand_title == "Nike"
+    assert item.size_title == "42"
     assert item.currency == "EUR"
-    assert item.price == 45
-    assert item.photo == "https://cdn.vinted.net/catalog.jpg"
-    assert item.url.startswith("https://www.vinted.it/items/")
+    assert item.price == 50.0
+    assert item.photo == "https://example.com/photo.jpg"
+    assert item.url == "https://vinted.com/items/123-nike-air-max"
     assert isinstance(item.created_at_ts, datetime)
-    assert item.raw_timestamp == 1710000000
+    assert item.raw_timestamp == 1734796339
 
 
-@pytest.mark.parametrize(
-    "delta_seconds, expected",
-    [
-        (30, True),
-        (120 * 60, False),
-    ],
-)
-def test_is_new_item_parametrized(
-    sample_catalog_item_data: Callable[[int], dict], delta_seconds: int, expected: bool
-):
-    ts = int((datetime.now(timezone.utc) - timedelta(seconds=delta_seconds)).timestamp())
-    data = sample_catalog_item_data(ts)
+def test_catalog_item_equality(sample_catalog_item_data):
+    item1 = CatalogItem(raw_data=sample_catalog_item_data)
+    item2 = CatalogItem(raw_data=sample_catalog_item_data)
+    item3 = CatalogItem(raw_data={**sample_catalog_item_data, "id": 999})
 
-    item = CatalogItem(data)
+    assert item1 == item2
+    assert item1 != item3
 
-    assert item.is_new_item(minutes=1) is expected
 
+def test_catalog_item_hash(sample_catalog_item_data):
+    item1 = CatalogItem(raw_data=sample_catalog_item_data)
+    item2 = CatalogItem(raw_data=sample_catalog_item_data)
 
-def test_equality_and_hash(sample_catalog_item_data: Callable[[int], dict]):
-    data1 = sample_catalog_item_data(1710000000)
-    data2 = sample_catalog_item_data(1710000000)
+    assert hash(item1) == hash(item2)
+    assert len({item1, item2}) == 1
 
-    item1 = CatalogItem(data1)
-    item2 = CatalogItem(data2)
 
-    assert item1 == item2
-    assert hash(item1) == hash(item2)
+def test_catalog_item_is_new(sample_catalog_item_data):
+    data = {**sample_catalog_item_data}
+    data["photo"]["high_resolution"]["timestamp"] = int(datetime.now(timezone.utc).timestamp())
 
+    item = CatalogItem(raw_data=data)
+    assert item.is_new_item(minutes=1) is True
 
-def test_missing_fields_dont_crash():
-    data = {"id": 15, "title": "stub", "brand_title": None, "size_title": None, "url": None}
 
-    item = CatalogItem(data)
+@pytest.mark.parametrize("missing_field", ["price", "photo", "url"])
+def test_catalog_item_with_missing_fields(sample_catalog_item_data, missing_field):
+    data = {**sample_catalog_item_data}
+    del data[missing_field]
 
-    assert item.price is None
-    assert item.currency is None
-    assert item.photo is None
-    assert item.raw_timestamp is None
+    item = CatalogItem(raw_data=data)
+    assert item.id == 123