Add tests, CI, and py.typed marker

lennart-johansson · lennart-johansson · commit 147610b87f97 · 2026-02-15T10:45:49.000+01:00
29 tests covering API resolvers, HTML extraction, slim output, and all
CLI commands. GitHub Actions runs pytest on Python 3.10–3.13.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -0,0 +1,21 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: pytest -v
diff --git a/blocket_cli/py.typed b/blocket_cli/py.typed
diff --git a/pyproject.toml b/pyproject.toml
@@ -23,6 +23,12 @@ dependencies = [
 [project.scripts]
 blocket = "blocket_cli.cli:main"
 
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/test_api.py b/tests/test_api.py
@@ -0,0 +1,75 @@
+"""Tests for the API client (no network calls)."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from blocket_cli.api import (
+    CATEGORIES,
+    LOCATIONS,
+    _extract_product_data,
+    _resolve_category,
+    _resolve_location,
+)
+
+
+class TestResolveLocation:
+    def test_valid(self):
+        assert _resolve_location("stockholm") == "0.300001"
+
+    def test_case_insensitive(self):
+        assert _resolve_location("Stockholm") == "0.300001"
+
+    def test_invalid(self):
+        with pytest.raises(ValueError, match="Unknown location 'narnia'"):
+            _resolve_location("narnia")
+
+    def test_all_locations_have_codes(self):
+        for name, code in LOCATIONS.items():
+            assert code.startswith("0.3000"), f"{name} has unexpected code {code}"
+
+
+class TestResolveCategory:
+    def test_valid(self):
+        assert _resolve_category("electronics") == "0.93"
+
+    def test_case_insensitive(self):
+        assert _resolve_category("Electronics") == "0.93"
+
+    def test_invalid(self):
+        with pytest.raises(ValueError, match="Unknown category 'weapons'"):
+            _resolve_category("weapons")
+
+    def test_all_categories_have_codes(self):
+        for name, code in CATEGORIES.items():
+            assert code.startswith("0."), f"{name} has unexpected code {code}"
+
+
+class TestExtractProductData:
+    def test_extracts_product(self):
+        product = {"@type": "Product", "name": "Soffa", "offers": {"price": "500"}}
+        html = f'<html><head><script type="application/ld+json">{json.dumps(product)}</script></head></html>'
+        assert _extract_product_data(html) == product
+
+    def test_ignores_non_product(self):
+        other = {"@type": "Organization", "name": "Blocket"}
+        html = f'<html><script type="application/ld+json">{json.dumps(other)}</script></html>'
+        assert _extract_product_data(html) is None
+
+    def test_handles_multiple_scripts(self):
+        org = {"@type": "Organization", "name": "Blocket"}
+        product = {"@type": "Product", "name": "Cykel"}
+        html = (
+            f'<script type="application/ld+json">{json.dumps(org)}</script>'
+            f'<script type="application/ld+json">{json.dumps(product)}</script>'
+        )
+        assert _extract_product_data(html) == product
+
+    def test_handles_invalid_json(self):
+        html = '<script type="application/ld+json">not json</script>'
+        assert _extract_product_data(html) is None
+
+    def test_handles_no_scripts(self):
+        assert _extract_product_data("<html><body>Hello</body></html>") is None
diff --git a/tests/test_cli.py b/tests/test_cli.py
@@ -0,0 +1,111 @@
+"""Tests for CLI commands (mocked HTTP)."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+from click.testing import CliRunner
+
+from blocket_cli.cli import main
+
+SEARCH_RESPONSE = {
+    "docs": [
+        {
+            "id": "1",
+            "heading": "Test soffa",
+            "price": {"amount": 2000, "currency_code": "SEK", "price_unit": "kr"},
+            "location": "Stockholm",
+            "canonical_url": "https://www.blocket.se/item/1",
+            "timestamp": 1700000000000,
+            "extras": [],
+            "image_urls": ["https://img.com/1.jpg"],
+            "coordinates": {"lat": 59.0, "lon": 18.0},
+        }
+    ],
+    "metadata": {"result_size": {"match_count": 1}},
+}
+
+
+def _mock_search(*args, **kwargs):
+    return SEARCH_RESPONSE
+
+
+def _mock_get_ad(*args, **kwargs):
+    return {
+        "@type": "Product",
+        "name": "Test soffa",
+        "description": "En fin soffa",
+        "offers": {"price": "2000", "priceCurrency": "SEK"},
+        "url": "https://www.blocket.se/item/1",
+    }
+
+
+class TestSearchCommand:
+    def test_table_output(self):
+        with patch("blocket_cli.cli.api.search", _mock_search):
+            result = CliRunner().invoke(main, ["search", "soffa"])
+        assert result.exit_code == 0
+        assert "Test soffa" in result.output
+        assert "2 000 kr" in result.output
+
+    def test_json_output_is_slim(self):
+        with patch("blocket_cli.cli.api.search", _mock_search):
+            result = CliRunner().invoke(main, ["search", "soffa", "-o", "json"])
+        data = json.loads(result.output)
+        listing = data["results"][0]
+        assert listing["id"] == "1"
+        assert listing["price"] == 2000
+        assert "image_urls" not in listing
+        assert "coordinates" not in listing
+
+    def test_json_raw_output(self):
+        with patch("blocket_cli.cli.api.search", _mock_search):
+            result = CliRunner().invoke(main, ["search", "soffa", "-o", "json", "--raw"])
+        data = json.loads(result.output)
+        listing = data["results"][0]
+        assert "image_urls" in listing
+        assert "coordinates" in listing
+
+    def test_limit(self):
+        with patch("blocket_cli.cli.api.search", _mock_search):
+            result = CliRunner().invoke(main, ["search", "soffa", "-o", "json", "-n", "1"])
+        data = json.loads(result.output)
+        assert len(data["results"]) == 1
+
+    def test_invalid_category(self):
+        result = CliRunner().invoke(main, ["search", "x", "-c", "badcat"])
+        assert result.exit_code == 1
+        assert "Unknown category" in result.output
+
+    def test_invalid_location(self):
+        result = CliRunner().invoke(main, ["search", "x", "-l", "narnia"])
+        assert result.exit_code == 1
+        assert "Unknown location" in result.output
+
+
+class TestAdCommand:
+    def test_table_output(self):
+        with patch("blocket_cli.cli.api.get_ad", _mock_get_ad):
+            result = CliRunner().invoke(main, ["ad", "1"])
+        assert result.exit_code == 0
+        assert "Test soffa" in result.output
+        assert "2000 SEK" in result.output
+
+    def test_json_output(self):
+        with patch("blocket_cli.cli.api.get_ad", _mock_get_ad):
+            result = CliRunner().invoke(main, ["ad", "1", "-o", "json"])
+        data = json.loads(result.output)
+        assert data["name"] == "Test soffa"
+
+
+class TestListCommands:
+    def test_categories(self):
+        result = CliRunner().invoke(main, ["categories"])
+        assert result.exit_code == 0
+        assert "electronics" in result.output
+
+    def test_locations(self):
+        result = CliRunner().invoke(main, ["locations"])
+        assert result.exit_code == 0
+        assert "stockholm" in result.output
diff --git a/tests/test_format.py b/tests/test_format.py
@@ -0,0 +1,102 @@
+"""Tests for output formatting."""
+
+from __future__ import annotations
+
+import json
+
+from blocket_cli.format import _slim
+
+
+class TestSlim:
+    def test_essential_fields(self):
+        doc = {
+            "id": "123",
+            "heading": "Test item",
+            "price": {"amount": 500, "currency_code": "SEK", "price_unit": "kr"},
+            "location": "Stockholm",
+            "canonical_url": "https://www.blocket.se/item/123",
+            "timestamp": 1700000000000,
+        }
+        result = _slim(doc)
+        assert result == {
+            "id": "123",
+            "heading": "Test item",
+            "price": 500,
+            "currency": "SEK",
+            "location": "Stockholm",
+            "url": "https://www.blocket.se/item/123",
+            "date": "2023-11-14",
+        }
+
+    def test_strips_images_and_coordinates(self):
+        doc = {
+            "id": "1",
+            "heading": "X",
+            "price": {"amount": 100, "currency_code": "SEK"},
+            "location": "A",
+            "canonical_url": "https://example.com",
+            "image": {"url": "https://img.com/1.jpg", "width": 800, "height": 600},
+            "image_urls": ["https://img.com/1.jpg", "https://img.com/2.jpg"],
+            "coordinates": {"lat": 59.0, "lon": 18.0},
+            "flags": ["private"],
+            "labels": [{"id": "private", "text": "Privat"}],
+            "ad_type": 67,
+            "distance": 0.0,
+            "main_search_key": "SEARCH_ID_BAP_ALL",
+        }
+        result = _slim(doc)
+        assert "image" not in result
+        assert "image_urls" not in result
+        assert "coordinates" not in result
+        assert "flags" not in result
+        assert "labels" not in result
+        assert "ad_type" not in result
+        assert "distance" not in result
+        assert "main_search_key" not in result
+
+    def test_extracts_brand(self):
+        doc = {
+            "id": "1",
+            "heading": "Phone",
+            "price": {"amount": 3000, "currency_code": "SEK"},
+            "location": "Malmö",
+            "canonical_url": "https://example.com",
+            "extras": [{"id": "brand", "values": ["Apple"]}],
+        }
+        assert _slim(doc)["brand"] == "Apple"
+
+    def test_no_brand_when_missing(self):
+        doc = {
+            "id": "1",
+            "heading": "Thing",
+            "price": {"amount": 100, "currency_code": "SEK"},
+            "location": "A",
+            "canonical_url": "https://example.com",
+            "extras": [],
+        }
+        assert "brand" not in _slim(doc)
+
+    def test_no_timestamp(self):
+        doc = {
+            "id": "1",
+            "heading": "X",
+            "price": {},
+            "location": "A",
+            "canonical_url": "https://example.com",
+        }
+        result = _slim(doc)
+        assert "date" not in result
+
+    def test_output_is_json_serializable(self):
+        doc = {
+            "id": "1",
+            "heading": "Ö-ring",
+            "price": {"amount": 50, "currency_code": "SEK"},
+            "location": "Göteborg",
+            "canonical_url": "https://example.com",
+            "timestamp": 1700000000000,
+            "extras": [{"id": "brand", "values": ["IKEA"]}],
+        }
+        dumped = json.dumps(_slim(doc), ensure_ascii=False)
+        assert "Ö-ring" in dumped
+        assert "Göteborg" in dumped
