ArchiveBox/archivebox/tests/test_cli_search.py

#!/usr/bin/env python3
"""
Tests for archivebox search command.
Verify search queries snapshots from DB.
"""

import json
import os
import subprocess


def test_search_finds_snapshots(tmp_path, process, disable_extractors_dict):
    """Test that search command finds matching snapshots."""
    os.chdir(tmp_path)

    # Add snapshots
    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
    )

    # Search for it
    result = subprocess.run(
        ['archivebox', 'search', 'example'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0
    assert 'example' in result.stdout


def test_search_returns_no_results_for_missing_term(tmp_path, process, disable_extractors_dict):
    """Test search returns empty for non-existent term."""
    os.chdir(tmp_path)

    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
    )

    result = subprocess.run(
        ['archivebox', 'search', 'nonexistentterm12345'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    # Should complete with no results
    assert result.returncode in [0, 1]


def test_search_on_empty_archive(tmp_path, process):
    """Test search works on empty archive."""
    os.chdir(tmp_path)

    result = subprocess.run(
        ['archivebox', 'search', 'anything'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    # Should complete without error
    assert result.returncode in [0, 1]


def test_search_json_outputs_matching_snapshots(tmp_path, process, disable_extractors_dict):
    """Test that search --json returns parseable matching snapshot rows."""
    os.chdir(tmp_path)
    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
        check=True,
    )

    result = subprocess.run(
        ['archivebox', 'search', '--json'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0, result.stderr
    payload = json.loads(result.stdout)
    assert any('example.com' in row.get('url', '') for row in payload)


def test_search_json_with_headers_wraps_links_payload(tmp_path, process, disable_extractors_dict):
    """Test that search --json --with-headers returns a headers envelope."""
    os.chdir(tmp_path)
    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
        check=True,
    )

    result = subprocess.run(
        ['archivebox', 'search', '--json', '--with-headers'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0, result.stderr
    payload = json.loads(result.stdout)
    links = payload.get('links', payload)
    assert any('example.com' in row.get('url', '') for row in links)


def test_search_html_outputs_markup(tmp_path, process, disable_extractors_dict):
    """Test that search --html renders an HTML response."""
    os.chdir(tmp_path)
    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
        check=True,
    )

    result = subprocess.run(
        ['archivebox', 'search', '--html'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0, result.stderr
    assert '<' in result.stdout


def test_search_csv_outputs_requested_column(tmp_path, process, disable_extractors_dict):
    """Test that search --csv emits the requested fields."""
    os.chdir(tmp_path)
    subprocess.run(
        ['archivebox', 'add', '--index-only', '--depth=0', 'https://example.com'],
        capture_output=True,
        env=disable_extractors_dict,
        check=True,
    )

    result = subprocess.run(
        ['archivebox', 'search', '--csv', 'url', '--with-headers'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0, result.stderr
    assert 'url' in result.stdout
    assert 'example.com' in result.stdout


def test_search_with_headers_requires_structured_output_format(tmp_path, process):
    """Test that --with-headers is rejected without --json, --html, or --csv."""
    os.chdir(tmp_path)

    result = subprocess.run(
        ['archivebox', 'search', '--with-headers'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode != 0
    assert 'requires' in result.stderr.lower() or 'json' in result.stderr.lower()


def test_search_sort_option_runs_successfully(tmp_path, process, disable_extractors_dict):
    """Test that search --sort accepts sortable fields."""
    os.chdir(tmp_path)
    for url in ['https://iana.org', 'https://example.com']:
        subprocess.run(
            ['archivebox', 'add', '--index-only', '--depth=0', url],
            capture_output=True,
            env=disable_extractors_dict,
            check=True,
        )

    result = subprocess.run(
        ['archivebox', 'search', '--csv', 'url', '--sort=url'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0, result.stderr
    assert 'example.com' in result.stdout or 'iana.org' in result.stdout


def test_search_help_lists_supported_filters(tmp_path, process):
    """Test that search --help documents the available filters and output modes."""
    os.chdir(tmp_path)

    result = subprocess.run(
        ['archivebox', 'search', '--help'],
        capture_output=True,
        text=True,
        timeout=30,
    )

    assert result.returncode == 0
    assert '--filter-type' in result.stdout or '-f' in result.stdout
    assert '--status' in result.stdout
    assert '--sort' in result.stdout