Simplenote MCP Server

"""Tests for edge cases in the advanced search functionality."""

from datetime import datetime, timedelta

import pytest

from simplenote_mcp.server.search.engine import SearchEngine
from simplenote_mcp.server.search.parser import QueryParser, TokenType


class TestQueryParserEdgeCases:
    """Test edge cases for QueryParser."""

    def test_empty_query(self) -> None:
        """Test parsing an empty query."""
        parser = QueryParser("")
        assert len(parser.tokens) == 0

        parser = QueryParser("   ")
        assert len(parser.tokens) == 0

    def test_basic_query_structure(self) -> None:
        """Test basic parsing of queries to ensure tokens are created properly."""
        # For now, test simpler queries since grouping with parentheses
        # might not be fully implemented yet
        parser = QueryParser("term1 AND term2 OR term3")
        tokens = parser.tokens

        # Check that the basic operators are recognized
        assert any(token.type == TokenType.AND for token in tokens)
        assert any(token.type == TokenType.OR for token in tokens)

        # Check terms
        terms = [token.value for token in tokens if token.type == TokenType.TERM]
        assert "term1" in terms
        assert "term2" in terms
        assert "term3" in terms

    def test_alternative_operators(self) -> None:
        """Test parsing with alternative operator syntax."""
        # Test that different case variations work
        parser = QueryParser("term1 and term2 OR term3")
        tokens = parser.tokens

        # Check operators (case insensitivity handled in normalization)
        assert any(token.type == TokenType.AND for token in tokens)
        assert any(token.type == TokenType.OR for token in tokens)

        # Also check NOT operator
        parser = QueryParser("term1 not term2")
        tokens = parser.tokens
        assert any(token.type == TokenType.NOT for token in tokens)

    def test_special_characters(self) -> None:
        """Test parsing with special characters."""
        # These should be handled as part of regular terms
        parser = QueryParser("term-with-dashes term_with_underscores term+with+plus")
        tokens = parser.tokens

        # Extract just the term values
        term_values = [token.value for token in tokens if token.type == TokenType.TERM]

        assert "term-with-dashes" in term_values
        assert "term_with_underscores" in term_values
        assert "term+with+plus" in term_values

    def test_case_insensitivity(self) -> None:
        """Test case insensitivity in operator parsing."""
        # Test lowercase, uppercase, and mixed case operators
        parser = QueryParser("term1 and term2 OR term3 NoT term4")
        tokens = parser.tokens

        # Count operators
        operators = [
            token.type
            for token in tokens
            if token.type in (TokenType.AND, TokenType.OR, TokenType.NOT)
        ]

        # Should have found all the operators regardless of case
        assert TokenType.AND in operators
        assert TokenType.OR in operators
        assert TokenType.NOT in operators


class TestSearchEngineEdgeCases:
    """Test edge cases for SearchEngine."""

    @pytest.fixture
    def edge_case_notes(self) -> dict[str, dict[str, str | list[str] | datetime]]:
        """Sample notes for edge case testing."""
        now = datetime.now()
        yesterday = now - timedelta(days=1)
        last_week = now - timedelta(days=7)

        return {
            "empty": {
                "key": "empty",
                "content": "",
                "tags": [],
                "modifydate": now.isoformat(),
            },
            "special_chars": {
                "key": "special_chars",
                "content": "Contains special chars: !@#$%^&*()_-+={}[]|\\:;\"'<>,.?/",
                "tags": ["special"],
                "modifydate": yesterday.isoformat(),
            },
            "duplicate_terms": {
                "key": "duplicate_terms",
                "content": "test test test test this has the term test repeated many times test test",
                "tags": ["test"],
                "modifydate": last_week.isoformat(),
            },
            "mixed_case": {
                "key": "mixed_case",
                "content": "This Has Mixed CASE content Test tEsT TEST test",
                "tags": ["TEST"],
                "modifydate": now.isoformat(),
            },
            "unicode": {
                "key": "unicode",
                "content": "Contains unicode: 你好 привет こんにちは مرحبا",
                "tags": ["unicode"],
                "modifydate": yesterday.isoformat(),
            },
            "invalid_date": {
                "key": "invalid_date",
                "content": "This note has an invalid date format",
                "tags": [],
                "modifydate": "not-a-date",
            },
            "no_date": {
                "key": "no_date",
                "content": "This note has no date",
                "tags": [],
            },
        }

    def test_empty_query(self, edge_case_notes: dict) -> None:
        """Test search with empty query but with filters."""
        engine = SearchEngine()

        # Empty query with tag filter (case-insensitive matching)
        results = engine.search(edge_case_notes, "", tag_filters=["test"])
        assert len(results) == 2  # Both "test" and "TEST" tags match
        result_keys = [r["key"] for r in results]
        assert "duplicate_terms" in result_keys
        assert "mixed_case" in result_keys

        # Empty query with no filters should return empty result
        results = engine.search(edge_case_notes, "")
        assert len(results) == 0

        # Empty query with date filter
        now = datetime.now()
        yesterday = now - timedelta(days=1)
        results = engine.search(edge_case_notes, "", date_range=(yesterday, now))
        # Will match notes with valid dates from yesterday and today
        assert len(results) >= 2  # At least empty and mixed_case notes

    def test_complex_boolean_expression(self, edge_case_notes: dict) -> None:
        """Test searching with complex boolean expressions."""
        engine = SearchEngine()

        # Test with simpler boolean expressions first
        results = engine.search(edge_case_notes, "test")
        assert len(results) >= 2  # Should match duplicate_terms and mixed_case

        results = engine.search(edge_case_notes, "unicode")
        assert len(results) >= 1  # Should match the unicode note

        # Test NOT operator
        results = engine.search(edge_case_notes, "test NOT mixed")
        assert len(results) >= 1  # Should match duplicate_terms but not mixed_case
        assert any(note["key"] == "duplicate_terms" for note in results)

    def test_case_insensitivity(self, edge_case_notes: dict) -> None:
        """Test case insensitivity in search terms."""
        engine = SearchEngine()

        # Search for lowercase "test" should match mixed case content and tags
        results = engine.search(edge_case_notes, "test")
        assert len(results) == 2  # should match duplicate_terms and mixed_case

        # Search for uppercase "TEST" should also match
        results = engine.search(edge_case_notes, "TEST")
        assert len(results) == 2  # same results

    def test_basic_relevance_scoring(self, edge_case_notes: dict) -> None:
        """Test basic aspects of relevance scoring mechanism."""
        engine = SearchEngine()

        # Search for "test" should return duplicate_terms and mixed_case
        results = engine.search(edge_case_notes, "test")
        assert len(results) >= 2

        # Verify all expected results are present, we don't check ranking order
        # since implementation details of scoring might change
        result_keys = [note["key"] for note in results]
        assert "duplicate_terms" in result_keys
        assert "mixed_case" in result_keys

        # But we should still check that we can match a note with a term in its first line
        # Create a new note with "test" in the title line
        test_notes = dict(edge_case_notes)
        test_notes["title_match"] = {
            "key": "title_match",
            "content": "Test in the title line\nThis is the rest of the content with no other test word",
            "tags": [],
            "modifydate": datetime.now().isoformat(),
        }

        # Search again - title_match should be included in results
        results = engine.search(test_notes, "test")
        result_keys = [note["key"] for note in results]
        assert "title_match" in result_keys

    def test_date_parsing_edge_cases(self, edge_case_notes: dict) -> None:
        """Test date parsing edge cases."""
        engine = SearchEngine()

        # Test with notes that have invalid date or no date
        # This mainly checks that the search doesn't crash
        now = datetime.now()
        yesterday = now - timedelta(days=1)

        # Should skip the notes with invalid dates when filtering by date
        results = engine.search(edge_case_notes, "", date_range=(yesterday, now))
        assert all(note["key"] != "invalid_date" for note in results)
        assert all(note["key"] != "no_date" for note in results)

        # But should still find those notes when searching by content
        results = engine.search(edge_case_notes, "invalid")
        assert len(results) == 1
        assert results[0]["key"] == "invalid_date"

    def test_unicode_content(self, edge_case_notes: dict) -> None:
        """Test searching in content with unicode characters."""
        engine = SearchEngine()

        # Search for unicode content
        results = engine.search(edge_case_notes, "unicode")
        assert len(results) == 1
        assert results[0]["key"] == "unicode"

        # Search for the actual unicode characters
        results = engine.search(edge_case_notes, "привет")
        assert len(results) == 1
        assert results[0]["key"] == "unicode"