blocket-cli 0.1.0__tar.gz

blocket_cli-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install ruff
+      - run: ruff check .
+      - run: ruff format --check .
+
+  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

blocket_cli-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

blocket_cli-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/

blocket_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lennart Johansson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

blocket_cli-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: blocket-cli
+Version: 0.1.0
+Summary: Fast CLI for searching Blocket.se — optimized for agents and scripting
+Author: Lennart Johansson
+License-Expression: MIT
+License-File: LICENSE
+Keywords: blocket,cli,marketplace,search,sweden
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# blocket-cli
+
+[![CI](https://github.com/lennart-johansson/blocket-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/lennart-johansson/blocket-cli/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Fast CLI for searching [Blocket.se](https://www.blocket.se) — Sweden's largest marketplace.
+
+Designed for agents, scripts, and quick terminal lookups. Minimal dependencies, structured output.
+
+## Install
+
+```bash
+pip install blocket-cli
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install blocket-cli
+```
+
+## Usage
+
+### Search listings
+
+```bash
+blocket search "soffa"
+blocket search "iphone 15" -l stockholm --price-max 8000
+blocket search "mountainbike" -c sports --sort price-asc -n 10
+blocket search "ps5" -c electronics -o json | jq '.results[:3]'
+```
+
+### Get ad details
+
+```bash
+blocket ad 20851738
+blocket ad 20851738 -o json
+```
+
+### Browse filters
+
+```bash
+blocket categories
+blocket locations
+```
+
+## Output formats
+
+| Flag | Format | Use case |
+|------|--------|----------|
+| (default) | Human-readable table | Terminal browsing |
+| `-o json` | Compact JSON | Piping to `jq`, API consumption |
+| `-o jsonl` | One JSON object per line | Streaming, log processing |
+
+## Search options
+
+| Option | Description |
+|--------|-------------|
+| `-l`, `--location` | Filter by Swedish county (e.g. `stockholm`, `skane`) |
+| `-c`, `--category` | Filter by category (e.g. `electronics`, `furniture`) |
+| `--price-min` | Minimum price in SEK |
+| `--price-max` | Maximum price in SEK |
+| `--sort` | Sort order (`relevance`, `price-asc`, `price-desc`, `date`) |
+| `-n`, `--limit` | Max results to display |
+| `-p`, `--page` | Page number |
+| `-o`, `--output` | Output format (`table`, `json`, `jsonl`) |
+
+## Agent integration
+
+The JSON output is designed for LLM agents and automation:
+
+```bash
+# Structured search results
+blocket search "cykel" -l stockholm --price-max 5000 -o json
+
+# Stream results line by line
+blocket search "soffa" -o jsonl
+
+# Filter by category
+blocket search "lampa" -c furniture -o json | jq '[.results[] | {title: .heading, price: .price.amount, location}]'
+```
+
+## License
+
+MIT

blocket_cli-0.1.0/README.md

@@ -0,0 +1,86 @@
+# blocket-cli
+
+[![CI](https://github.com/lennart-johansson/blocket-cli/actions/workflows/ci.yml/badge.svg)](https://github.com/lennart-johansson/blocket-cli/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Fast CLI for searching [Blocket.se](https://www.blocket.se) — Sweden's largest marketplace.
+
+Designed for agents, scripts, and quick terminal lookups. Minimal dependencies, structured output.
+
+## Install
+
+```bash
+pip install blocket-cli
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install blocket-cli
+```
+
+## Usage
+
+### Search listings
+
+```bash
+blocket search "soffa"
+blocket search "iphone 15" -l stockholm --price-max 8000
+blocket search "mountainbike" -c sports --sort price-asc -n 10
+blocket search "ps5" -c electronics -o json | jq '.results[:3]'
+```
+
+### Get ad details
+
+```bash
+blocket ad 20851738
+blocket ad 20851738 -o json
+```
+
+### Browse filters
+
+```bash
+blocket categories
+blocket locations
+```
+
+## Output formats
+
+| Flag | Format | Use case |
+|------|--------|----------|
+| (default) | Human-readable table | Terminal browsing |
+| `-o json` | Compact JSON | Piping to `jq`, API consumption |
+| `-o jsonl` | One JSON object per line | Streaming, log processing |
+
+## Search options
+
+| Option | Description |
+|--------|-------------|
+| `-l`, `--location` | Filter by Swedish county (e.g. `stockholm`, `skane`) |
+| `-c`, `--category` | Filter by category (e.g. `electronics`, `furniture`) |
+| `--price-min` | Minimum price in SEK |
+| `--price-max` | Maximum price in SEK |
+| `--sort` | Sort order (`relevance`, `price-asc`, `price-desc`, `date`) |
+| `-n`, `--limit` | Max results to display |
+| `-p`, `--page` | Page number |
+| `-o`, `--output` | Output format (`table`, `json`, `jsonl`) |
+
+## Agent integration
+
+The JSON output is designed for LLM agents and automation:
+
+```bash
+# Structured search results
+blocket search "cykel" -l stockholm --price-max 5000 -o json
+
+# Stream results line by line
+blocket search "soffa" -o jsonl
+
+# Filter by category
+blocket search "lampa" -c furniture -o json | jq '[.results[] | {title: .heading, price: .price.amount, location}]'
+```
+
+## License
+
+MIT

blocket_cli-0.1.0/blocket_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Fast CLI for searching Blocket.se — optimized for agents and scripting."""
+
+__version__ = "0.1.0"

blocket_cli-0.1.0/blocket_cli/api.py

@@ -0,0 +1,159 @@
+"""Blocket.se search API client."""
+
+from __future__ import annotations
+
+import json
+from html.parser import HTMLParser
+
+import httpx
+
+BASE = "https://www.blocket.se"
+SEARCH_URL = f"{BASE}/recommerce/forsale/search/api/search/SEARCH_ID_BAP_COMMON"
+
+HEADERS = {
+    "User-Agent": "blocket-cli/0.1.0 (https://github.com/lennart-johansson/blocket-cli)",
+}
+
+LOCATIONS = {
+    "blekinge": "0.300010",
+    "dalarna": "0.300020",
+    "gotland": "0.300009",
+    "gavleborg": "0.300021",
+    "halland": "0.300013",
+    "jamtland": "0.300023",
+    "jonkoping": "0.300006",
+    "kalmar": "0.300008",
+    "kronoberg": "0.300007",
+    "norrbotten": "0.300025",
+    "skane": "0.300012",
+    "stockholm": "0.300001",
+    "sodermanland": "0.300004",
+    "uppsala": "0.300003",
+    "varmland": "0.300017",
+    "vasterbotten": "0.300024",
+    "vasternorrland": "0.300022",
+    "vastmanland": "0.300019",
+    "vastra-gotaland": "0.300014",
+    "orebro": "0.300018",
+    "ostergotland": "0.300005",
+}
+
+CATEGORIES = {
+    "business": "0.91",
+    "home-garden": "0.67",
+    "pets": "0.77",
+    "electronics": "0.93",
+    "vehicle-parts": "0.90",
+    "family": "0.68",
+    "fashion": "0.71",
+    "art": "0.76",
+    "furniture": "0.78",
+    "sports": "0.69",
+    "hobby": "0.86",
+}
+
+# Swedish display names for categories
+CATEGORY_LABELS = {
+    "business": "Affärsverksamhet",
+    "home-garden": "Bygg och trädgård",
+    "pets": "Djur och tillbehör",
+    "electronics": "Elektronik och vitvaror",
+    "vehicle-parts": "Fordonstillbehör",
+    "family": "Föräldrar och barn",
+    "fashion": "Kläder, kosmetika och accessoarer",
+    "art": "Konst och antikt",
+    "furniture": "Möbler och inredning",
+    "sports": "Sport och friluftsliv",
+    "hobby": "Underhållning och hobby",
+}
+
+
+def _resolve_location(name: str) -> str:
+    code = LOCATIONS.get(name.lower())
+    if not code:
+        raise ValueError(f"Unknown location '{name}'. Valid: {', '.join(sorted(LOCATIONS))}")
+    return code
+
+
+def _resolve_category(name: str) -> str:
+    code = CATEGORIES.get(name.lower())
+    if not code:
+        raise ValueError(f"Unknown category '{name}'. Valid: {', '.join(sorted(CATEGORIES))}")
+    return code
+
+
+def search(
+    query: str,
+    *,
+    location: str | None = None,
+    category: str | None = None,
+    price_min: int | None = None,
+    price_max: int | None = None,
+    sort: str | None = None,
+    page: int = 1,
+) -> dict:
+    """Search listings on Blocket."""
+    params: list[tuple[str, str]] = [("q", query), ("page", str(page))]
+    if location:
+        params.append(("location", _resolve_location(location)))
+    if category:
+        params.append(("category", _resolve_category(category)))
+    if price_min is not None:
+        params.append(("price_from", str(price_min)))
+    if price_max is not None:
+        params.append(("price_to", str(price_max)))
+    if sort:
+        params.append(("sort", sort))
+
+    r = httpx.get(SEARCH_URL, params=params, headers=HEADERS, timeout=15, follow_redirects=True)
+    r.raise_for_status()
+    return r.json()
+
+
+def get_ad(ad_id: int | str) -> dict:
+    """Fetch full ad details from the item page's structured data."""
+    # Try recommerce first (most common), fall back to mobility
+    for path in ("recommerce/forsale/item", "mobility/item"):
+        url = f"{BASE}/{path}/{ad_id}"
+        r = httpx.get(url, headers=HEADERS, timeout=15, follow_redirects=True)
+        if r.status_code == 200:
+            result = _extract_product_data(r.text)
+            if result:
+                return result
+
+    return {"error": f"Could not find ad {ad_id}"}
+
+
+def _extract_product_data(html: str) -> dict | None:
+    """Extract JSON-LD Product data from HTML."""
+
+    class _LDJsonExtractor(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self._capture = False
+            self.scripts: list[str] = []
+
+        def handle_starttag(self, tag, attrs):
+            if tag == "script" and dict(attrs).get("type") == "application/ld+json":
+                self._capture = True
+
+        def handle_data(self, data):
+            if self._capture:
+                self.scripts.append(data)
+
+        def handle_endtag(self, tag):
+            if tag == "script":
+                self._capture = False
+
+    parser = _LDJsonExtractor()
+    parser.feed(html)
+
+    for script in parser.scripts:
+        try:
+            data = json.loads(script)
+            if isinstance(data, dict) and data.get("@type") == "Product":
+                return data
+        except json.JSONDecodeError:
+            continue
+
+    return None

blocket_cli-0.1.0/blocket_cli/cli.py

@@ -0,0 +1,111 @@
+"""Blocket CLI — search Blocket.se from the terminal."""
+
+from __future__ import annotations
+
+import sys
+
+import click
+
+from . import api, format
+
+
+@click.group()
+@click.version_option()
+def main():
+    """Search Blocket.se from the command line.
+
+    Fast, minimal CLI for searching Sweden's largest marketplace.
+    Designed for scripting, agents, and quick lookups.
+    """
+    pass
+
+
+@main.command()
+@click.argument("query")
+@click.option("-l", "--location", help="County filter (e.g. stockholm, skane)")
+@click.option("-c", "--category", help="Category filter (use 'blocket categories' to list)")
+@click.option("--price-min", type=int, help="Minimum price (SEK)")
+@click.option("--price-max", type=int, help="Maximum price (SEK)")
+@click.option(
+    "--sort",
+    type=click.Choice(["relevance", "price-asc", "price-desc", "date"], case_sensitive=False),
+    help="Sort order",
+)
+@click.option("-n", "--limit", type=int, help="Max results to show")
+@click.option("-p", "--page", type=int, default=1, help="Page number")
+@click.option("-o", "--output", type=click.Choice(["table", "json", "jsonl"]), default="table", help="Output format")
+@click.option("--raw", is_flag=True, help="Full API response (default: slim agent-friendly fields)")
+def search(
+    query: str,
+    location: str | None,
+    category: str | None,
+    price_min: int | None,
+    price_max: int | None,
+    sort: str | None,
+    limit: int | None,
+    page: int,
+    output: str,
+    raw: bool,
+):
+    """Search listings on Blocket.
+
+    \b
+    Examples:
+        blocket search "soffa" -l stockholm --price-max 5000
+        blocket search "iphone 15" -c electronics --sort price-asc
+        blocket search "cykel" -c sports -o json
+    """
+    sort_map = {
+        "relevance": "RELEVANCE",
+        "price-asc": "PRICE_ASC",
+        "price-desc": "PRICE_DESC",
+        "date": "PUBLISHED_DESC",
+    }
+    try:
+        data = api.search(
+            query,
+            location=location,
+            category=category,
+            price_min=price_min,
+            price_max=price_max,
+            sort=sort_map.get(sort, sort) if sort else None,
+            page=page,
+        )
+        format.print_results(data, output=output, limit=limit, raw=raw)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("ad_id")
+@click.option("-o", "--output", type=click.Choice(["table", "json"]), default="table", help="Output format")
+def ad(ad_id: str, output: str):
+    """Get full details for a specific ad.
+
+    \b
+    Examples:
+        blocket ad 20851738
+        blocket ad 20851738 -o json
+    """
+    try:
+        data = api.get_ad(ad_id)
+        format.print_ad(data, output=output)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+def categories():
+    """List available categories."""
+    for name in sorted(api.CATEGORIES):
+        label = api.CATEGORY_LABELS.get(name, "")
+        click.echo(f"{name:<20} {label}")
+
+
+@main.command()
+def locations():
+    """List available locations (Swedish counties)."""
+    for name in sorted(api.LOCATIONS):
+        click.echo(name)

blocket_cli-0.1.0/blocket_cli/format.py

@@ -0,0 +1,107 @@
+"""Output formatting for Blocket CLI."""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime, timezone
+from typing import Any
+
+
+def _json_compact(data: Any) -> str:
+    return json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+
+
+def _slim(doc: dict) -> dict:
+    """Strip a listing to agent-essential fields."""
+    price = doc.get("price", {})
+    out: dict[str, Any] = {
+        "id": doc.get("id"),
+        "heading": doc.get("heading"),
+        "price": price.get("amount"),
+        "currency": price.get("currency_code", "SEK"),
+        "location": doc.get("location"),
+        "url": doc.get("canonical_url"),
+    }
+    ts = doc.get("timestamp")
+    if ts:
+        out["date"] = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).strftime("%Y-%m-%d")
+    for extra in doc.get("extras", []):
+        if extra.get("id") == "brand" and extra.get("values"):
+            out["brand"] = extra["values"][0]
+    return out
+
+
+def print_results(data: dict, *, output: str = "table", limit: int | None = None, raw: bool = False) -> None:
+    """Print search results."""
+    docs = data.get("docs", [])
+    total = data.get("metadata", {}).get("result_size", {}).get("match_count", len(docs))
+
+    if limit:
+        docs = docs[:limit]
+
+    if output == "json":
+        results = docs if raw else [_slim(d) for d in docs]
+        print(_json_compact({"total": total, "results": results}))
+        return
+
+    if output == "jsonl":
+        for doc in docs:
+            print(_json_compact(doc if raw else _slim(doc)))
+        return
+
+    if not docs:
+        print("No results found.", file=sys.stderr)
+        return
+
+    print(f"Found {total:,} listings (showing {len(docs)}):\n")
+
+    for doc in docs:
+        price = doc.get("price", {})
+        amount = price.get("amount")
+        currency = price.get("price_unit", "kr")
+        location = doc.get("location", "")
+        heading = doc.get("heading", "Untitled")
+        url = doc.get("canonical_url", "")
+
+        price_str = f"{amount:,} {currency}".replace(",", " ") if amount else "—"
+
+        print(f"  {heading}")
+        print(f"  {price_str} · {location}")
+        print(f"  {url}")
+        print()
+
+
+def print_ad(data: dict, *, output: str = "table") -> None:
+    """Print ad details."""
+    if output == "json":
+        print(_json_compact(data))
+        return
+
+    if "error" in data:
+        print(f"Error: {data['error']}", file=sys.stderr)
+        return
+
+    title = data.get("name", data.get("title", "Untitled"))
+    desc = data.get("description", "")
+    offers = data.get("offers", {})
+    price = offers.get("price", "")
+    currency = offers.get("priceCurrency", "SEK")
+    condition = data.get("itemCondition", "").split("/")[-1] if data.get("itemCondition") else ""
+    brand = ""
+    if isinstance(data.get("brand"), dict):
+        brand = data["brand"].get("name", "")
+    url = data.get("url", "")
+
+    print(title)
+    print("=" * min(len(title), 60))
+    if brand:
+        print(f"Brand:     {brand}")
+    if price:
+        print(f"Price:     {price} {currency}")
+    if condition:
+        print(f"Condition: {condition}")
+    if desc:
+        print(f"\n{desc}")
+    if url:
+        print(f"\n{url}")

blocket_cli-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "blocket-cli"
+version = "0.1.0"
+description = "Fast CLI for searching Blocket.se — optimized for agents and scripting"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Lennart Johansson" }]
+keywords = ["blocket", "cli", "search", "marketplace", "sweden"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "click>=8.0",
+    "httpx>=0.27",
+]
+
+[project.scripts]
+blocket = "blocket_cli.cli:main"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "ruff>=0.9"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

blocket_cli-0.1.0/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

blocket_cli-0.1.0/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

blocket_cli-0.1.0/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