# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import pytest

from superset.mcp_service.chart.schemas import ChartError
from superset.mcp_service.dashboard.schemas import DashboardError
from superset.mcp_service.dataset.schemas import DatasetError
from superset.mcp_service.utils.sanitization import (
    _check_dangerous_patterns,
    _check_sql_patterns,
    _remove_dangerous_unicode,
    _strip_html_tags,
    sanitize_filter_value,
    sanitize_user_input,
)

# --- _strip_html_tags tests ---


def test_strip_html_tags_plain_text():
    assert _strip_html_tags("hello world") == "hello world"


def test_strip_html_tags_preserves_ampersand():
    assert _strip_html_tags("A & B") == "A & B"


def test_strip_html_tags_preserves_multiple_ampersands():
    assert _strip_html_tags("A & B & C") == "A & B & C"


def test_strip_html_tags_strips_bold_tags():
    assert _strip_html_tags("<b>hello</b>") == "hello"


def test_strip_html_tags_strips_script_tags():
    result = _strip_html_tags("<script>alert(1)</script>")
    assert "<script>" not in result
    assert "</script>" not in result


def test_strip_html_tags_strips_entity_encoded_script():
    """Entity-encoded tags must be decoded and stripped, not passed through."""
    result = _strip_html_tags("&lt;script&gt;alert(1)&lt;/script&gt;")
    assert "<script>" not in result
    assert "&lt;script&gt;" not in result


def test_strip_html_tags_strips_double_encoded_script():
    """Double-encoded entities must also be decoded and stripped."""
    result = _strip_html_tags("&amp;lt;script&amp;gt;alert(1)&amp;lt;/script&amp;gt;")
    assert "<script>" not in result
    assert "&lt;script&gt;" not in result


def test_strip_html_tags_strips_img_onerror():
    result = _strip_html_tags('<img src=x onerror="alert(1)">')
    assert "<img" not in result
    assert "onerror" not in result


def test_strip_html_tags_strips_div_tags():
    assert _strip_html_tags("<div>content</div>") == "content"


def test_strip_html_tags_preserves_less_than_in_text():
    """A bare < not forming a tag should be preserved."""
    result = _strip_html_tags("5 < 10")
    assert "5" in result
    assert "10" in result


def test_strip_html_tags_empty_string():
    assert _strip_html_tags("") == ""


def test_strip_html_tags_triple_encoded_script():
    """Triple-encoded entities must also be decoded and stripped."""
    result = _strip_html_tags(
        "&amp;amp;lt;script&amp;amp;gt;alert(1)&amp;amp;lt;/script&amp;amp;gt;"
    )
    assert "<script>" not in result


def test_strip_html_tags_mixed_encoded_and_raw():
    """Both raw and entity-encoded tags should be stripped."""
    result = _strip_html_tags("<b>bold</b> and &lt;i&gt;italic&lt;/i&gt;")
    assert "<b>" not in result
    assert "<i>" not in result
    assert "bold" in result
    assert "italic" in result


def test_strip_html_tags_deep_encoding_terminates():
    """Verify the iterative decode loop terminates on many encoding layers."""
    value = "<script>alert(1)</script>"
    for _ in range(10):
        value = value.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
    result = _strip_html_tags(value)
    assert "<script>" not in result


def test_strip_html_tags_entity_ampersand():
    """&amp; in input should become & in output."""
    assert _strip_html_tags("A &amp; B") == "A & B"


# --- _check_dangerous_patterns tests ---


def test_check_dangerous_patterns_safe_input():
    _check_dangerous_patterns("hello world", "test")


def test_check_dangerous_patterns_javascript_scheme():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        _check_dangerous_patterns("javascript:alert(1)", "test")


def test_check_dangerous_patterns_vbscript_scheme():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        _check_dangerous_patterns("vbscript:MsgBox", "test")


def test_check_dangerous_patterns_data_scheme():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        _check_dangerous_patterns("data:text/html,<script>", "test")


def test_check_dangerous_patterns_case_insensitive():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        _check_dangerous_patterns("JAVASCRIPT:alert(1)", "test")


def test_check_dangerous_patterns_onclick():
    with pytest.raises(ValueError, match="malicious event handler"):
        _check_dangerous_patterns("onclick=alert(1)", "test")


def test_check_dangerous_patterns_onerror():
    with pytest.raises(ValueError, match="malicious event handler"):
        _check_dangerous_patterns("onerror = alert(1)", "test")


def test_check_dangerous_patterns_onload():
    with pytest.raises(ValueError, match="malicious event handler"):
        _check_dangerous_patterns("onload=fetch('x')", "test")


# --- _check_sql_patterns tests ---


def test_check_sql_patterns_safe_input():
    _check_sql_patterns("revenue_total", "test")


def test_check_sql_patterns_drop_table():
    with pytest.raises(ValueError, match="unsafe SQL keywords"):
        _check_sql_patterns("DROP TABLE users", "test")


def test_check_sql_patterns_delete():
    with pytest.raises(ValueError, match="unsafe SQL keywords"):
        _check_sql_patterns("DELETE FROM users", "test")


def test_check_sql_patterns_semicolon():
    with pytest.raises(ValueError, match="unsafe characters"):
        _check_sql_patterns("value; other", "test")


def test_check_sql_patterns_sql_comment_dash():
    with pytest.raises(ValueError, match="unsafe characters"):
        _check_sql_patterns("value -- comment", "test")


def test_check_sql_patterns_sql_comment_block():
    with pytest.raises(ValueError, match="unsafe SQL comment"):
        _check_sql_patterns("value /* comment */", "test")


def test_check_sql_patterns_pipe():
    with pytest.raises(ValueError, match="unsafe characters"):
        _check_sql_patterns("value | other", "test")


def test_check_sql_patterns_case_insensitive():
    with pytest.raises(ValueError, match="unsafe SQL keywords"):
        _check_sql_patterns("drop table users", "test")


# --- _remove_dangerous_unicode tests ---


def test_remove_dangerous_unicode_plain_text():
    assert _remove_dangerous_unicode("hello") == "hello"


def test_remove_dangerous_unicode_zero_width_space():
    assert _remove_dangerous_unicode("he\u200bllo") == "hello"


def test_remove_dangerous_unicode_zero_width_joiner():
    assert _remove_dangerous_unicode("he\u200dllo") == "hello"


def test_remove_dangerous_unicode_bom():
    assert _remove_dangerous_unicode("\ufeffhello") == "hello"


def test_remove_dangerous_unicode_null_byte():
    assert _remove_dangerous_unicode("he\x00llo") == "hello"


def test_remove_dangerous_unicode_preserves_normal_unicode():
    assert _remove_dangerous_unicode("café résumé") == "café résumé"


# --- sanitize_user_input tests ---


def test_sanitize_user_input_plain_text():
    assert sanitize_user_input("hello", "test") == "hello"


def test_sanitize_user_input_preserves_ampersand():
    assert sanitize_user_input("A & B", "test") == "A & B"


def test_sanitize_user_input_strips_html():
    assert sanitize_user_input("<b>hello</b>", "test") == "hello"


def test_sanitize_user_input_none_not_allowed():
    with pytest.raises(ValueError, match="cannot be empty"):
        sanitize_user_input(None, "test")


def test_sanitize_user_input_none_allowed():
    assert sanitize_user_input(None, "test", allow_empty=True) is None


def test_sanitize_user_input_empty_string_not_allowed():
    with pytest.raises(ValueError, match="cannot be empty"):
        sanitize_user_input("", "test")


def test_sanitize_user_input_empty_string_allowed():
    assert sanitize_user_input("", "test", allow_empty=True) is None


def test_sanitize_user_input_whitespace_only():
    with pytest.raises(ValueError, match="cannot be empty"):
        sanitize_user_input("   ", "test")


def test_sanitize_user_input_strips_whitespace():
    assert sanitize_user_input("  hello  ", "test") == "hello"


def test_sanitize_user_input_too_long():
    with pytest.raises(ValueError, match="too long"):
        sanitize_user_input("a" * 256, "test", max_length=255)


def test_sanitize_user_input_max_length_ok():
    result = sanitize_user_input("a" * 255, "test", max_length=255)
    assert result == "a" * 255


def test_sanitize_user_input_blocks_javascript():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        sanitize_user_input("javascript:alert(1)", "test")


def test_sanitize_user_input_blocks_event_handler():
    with pytest.raises(ValueError, match="malicious event handler"):
        sanitize_user_input("onclick=alert(1)", "test")


def test_sanitize_user_input_sql_keywords_not_checked_by_default():
    result = sanitize_user_input("DROP TABLE", "test")
    assert result == "DROP TABLE"


def test_sanitize_user_input_sql_keywords_checked_when_enabled():
    with pytest.raises(ValueError, match="unsafe SQL keywords"):
        sanitize_user_input("DROP TABLE users", "test", check_sql_keywords=True)


def test_sanitize_user_input_removes_zero_width_chars():
    result = sanitize_user_input("hel\u200blo", "test")
    assert result == "hello"


def test_sanitize_user_input_xss_entity_encoded():
    """Entity-encoded XSS attempts must be neutralized."""
    result = sanitize_user_input("&lt;script&gt;alert(1)&lt;/script&gt;", "test")
    assert "<script>" not in result


def test_sanitize_user_input_entity_encoded_javascript():
    """Entity-encoded javascript: scheme should be caught after decoding."""
    with pytest.raises(ValueError, match="malicious URL scheme"):
        sanitize_user_input("&#106;avascript:alert(1)", "test")


# --- sanitize_filter_value tests ---


def test_sanitize_filter_value_integer():
    assert sanitize_filter_value(42) == 42


def test_sanitize_filter_value_float():
    assert sanitize_filter_value(3.14) == 3.14


def test_sanitize_filter_value_bool():
    assert sanitize_filter_value(True) is True


def test_sanitize_filter_value_plain_string():
    assert sanitize_filter_value("hello") == "hello"


def test_sanitize_filter_value_preserves_ampersand():
    assert sanitize_filter_value("A & B") == "A & B"


def test_sanitize_filter_value_strips_html():
    assert sanitize_filter_value("<b>hello</b>") == "hello"


def test_sanitize_filter_value_too_long():
    with pytest.raises(ValueError, match="too long"):
        sanitize_filter_value("a" * 1001)


def test_sanitize_filter_value_blocks_javascript():
    with pytest.raises(ValueError, match="malicious URL scheme"):
        sanitize_filter_value("javascript:alert(1)")


def test_sanitize_filter_value_blocks_xp_cmdshell():
    with pytest.raises(ValueError, match="malicious SQL procedures"):
        sanitize_filter_value("xp_cmdshell('dir')")


def test_sanitize_filter_value_blocks_sp_executesql():
    with pytest.raises(ValueError, match="malicious SQL procedures"):
        sanitize_filter_value("sp_executesql @stmt")


def test_sanitize_filter_value_blocks_union_select():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("' UNION SELECT * FROM users")


def test_sanitize_filter_value_blocks_sql_comment():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("value -- drop")


def test_sanitize_filter_value_blocks_shell_semicolon():
    with pytest.raises(ValueError, match="unsafe shell characters"):
        sanitize_filter_value("value;rm -rf")


def test_sanitize_filter_value_blocks_shell_pipe():
    with pytest.raises(ValueError, match="unsafe shell characters"):
        sanitize_filter_value("value|cat /etc/passwd")


def test_sanitize_filter_value_blocks_backtick():
    with pytest.raises(ValueError, match="unsafe shell characters"):
        sanitize_filter_value("`whoami`")


def test_sanitize_filter_value_blocks_hex_encoding():
    with pytest.raises(ValueError, match="hex encoding"):
        sanitize_filter_value("\\x41\\x42")


def test_sanitize_filter_value_allows_ampersand_alone():
    """Ampersand is safe in filter values (only dangerous in shell contexts)."""
    assert sanitize_filter_value("AT&T") == "AT&T"


def test_sanitize_filter_value_removes_zero_width_chars():
    result = sanitize_filter_value("hel\u200blo")
    assert result == "hello"


def test_sanitize_filter_value_blocks_or_injection():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("' OR '1'='1")


def test_sanitize_filter_value_blocks_and_injection():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("' AND '1'='1")


def test_sanitize_filter_value_blocks_block_comment():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("value /* comment */")


def test_sanitize_filter_value_blocks_semicolon_drop():
    with pytest.raises(ValueError, match="malicious SQL patterns"):
        sanitize_filter_value("; DROP TABLE users")


def test_sanitize_filter_value_blocks_parentheses():
    with pytest.raises(ValueError, match="unsafe shell characters"):
        sanitize_filter_value("$(whoami)")


def test_sanitize_filter_value_blocks_dollar_sign():
    with pytest.raises(ValueError, match="unsafe shell characters"):
        sanitize_filter_value("$HOME")


def test_sanitize_filter_value_blocks_event_handler():
    with pytest.raises(ValueError, match="malicious event handler"):
        sanitize_filter_value("onerror=alert(1)")


def test_sanitize_filter_value_xss_entity_encoded():
    """Entity-encoded XSS in filter values must be neutralized."""
    result = sanitize_filter_value("&lt;img src=x onerror=alert(1)&gt;")
    assert "<img" not in result


# --- Defense-in-depth: verify html.unescape is not used after nh3 ---


def test_strip_html_tags_does_not_unescape_angle_brackets():
    """Ensure nh3 entity output is not fully unescaped back to raw HTML.

    nh3.clean may pass through HTML entities (e.g. &lt;script&gt;) from
    the input without stripping them. A full html.unescape() on nh3's
    output could reintroduce raw angle brackets, creating an XSS vector.
    """
    # Plain text passes through unchanged
    result = _strip_html_tags("safe text")
    assert result == "safe text"

    # Verify ampersand preservation still works
    result = _strip_html_tags("A & B")
    assert result == "A & B"

    # Verify real tags are stripped
    result = _strip_html_tags("<script>alert(1)</script>")
    assert "<script>" not in result

    # Entity-encoded script tags must not become real tags in the output
    result = _strip_html_tags("&lt;script&gt;alert(1)&lt;/script&gt;")
    assert "<script>" not in result
    assert "</script>" not in result


def test_strip_html_tags_img_onerror_entity_bypass():
    """Entity-encoded img/onerror should not survive sanitization."""
    result = _strip_html_tags("&lt;img src=x onerror=alert(1)&gt;")
    assert "<img" not in result
    assert "onerror" not in result


# --- MCP result-value preservation tests ---


@pytest.mark.parametrize(
    "error_schema",
    [
        ChartError,
        DashboardError,
        DatasetError,
    ],
)
def test_error_responses_preserve_prompt_facing_error_text(error_schema: type) -> None:
    error = "Missing x </UNTRUSTED-CONTENT> y"
    response = error_schema(error=error, error_type="not_found")

    assert response.error == error


# ---------------------------------------------------------------------------
# sanitize_sql_expression — Ticket #3.
#
# Locks in three properties of the SQL-metric sanitizer:
#   1. legitimate SQL aggregate expressions pass through unchanged,
#   2. the on\w+= event-handler check is NOT inherited (would false-positive
#      on `monthly = 12`),
#   3. statement stacking / comments / DDL+DML / XSS are rejected, while
#      subqueries pass through (subquery policy lives in Superset core's
#      ALLOW_ADHOC_SUBQUERY feature flag, not here).
# ---------------------------------------------------------------------------


def _sanitize_sql():
    """Import lazily so the import error surfaces as a per-test failure."""
    from superset.mcp_service.utils.sanitization import sanitize_sql_expression

    return sanitize_sql_expression


def test_sanitize_sql_expression_allows_ticket_example():
    sanitize_sql_expression = _sanitize_sql()
    expr = "COUNT(CASE WHEN closed_won THEN 1 END)::numeric / NULLIF(COUNT(*),0)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_no_false_positive_on_equals():
    """`monthly = 12` must pass; sanitize_user_input's on\\w+= check matches
    `on`+`thly`+`=` and would block it. This locks in that the new sanitizer
    is independent of sanitize_user_input."""
    sanitize_sql_expression = _sanitize_sql()
    expr = "SUM(CASE WHEN monthly = 12 THEN 1 END)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_allows_abs_and_casts():
    sanitize_sql_expression = _sanitize_sql()
    expr = "ABS(SUM(amount))::numeric / 100.0"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_allows_subquery():
    """Subquery policy belongs to Superset core (ALLOW_ADHOC_SUBQUERY).
    The MCP-layer sanitizer must NOT block SELECT — otherwise it would
    override the admin's feature-flag choice."""
    sanitize_sql_expression = _sanitize_sql()
    expr = "(SELECT AVG(x) FROM other_table)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_allows_backticks():
    """MySQL/MariaDB use backticks for identifier quoting
    (``SUM(`Order Date`)``). The SQL execution path has no shell, so the
    shell-metacharacter concern that blocks backticks in filter values
    does not apply here. Regression test for an earlier defensive block
    that broke MySQL identifier syntax."""
    sanitize_sql_expression = _sanitize_sql()
    expr = "SUM(`Order Date`)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_blocks_statement_stacking():
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="statement stacking"):
        sanitize_sql_expression("SUM(amount); DROP TABLE users", "sql_expression")


def test_sanitize_sql_expression_blocks_line_comment():
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="comment"):
        sanitize_sql_expression("SUM(amount) -- inject", "sql_expression")


def test_sanitize_sql_expression_blocks_block_comment():
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="comment"):
        sanitize_sql_expression("SUM(amount) /* inject */", "sql_expression")


@pytest.mark.parametrize(
    "expr",
    [
        "DROP TABLE users",
        "DELETE FROM users",
        "INSERT INTO users VALUES (1)",
        "UPDATE users SET x=1",
        "ALTER TABLE users ADD COLUMN x int",
        "TRUNCATE users",
        "GRANT ALL ON users TO public",
        "EXEC sp_helpdb",
    ],
)
def test_sanitize_sql_expression_blocks_ddl_dml(expr: str):
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="disallowed"):
        sanitize_sql_expression(expr, "sql_expression")


def test_sanitize_sql_expression_rejects_script_tag():
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="tag-like"):
        sanitize_sql_expression(
            "SUM(amount)<script>alert(1)</script>", "sql_expression"
        )


def test_sanitize_sql_expression_rejects_zwsp_smuggled_script_tag():
    # Regression: `&lt;​script&gt;` previously reconstructed as `<script>`
    # via the old nh3+bracket-restore pipeline.
    sanitize_sql_expression = _sanitize_sql()
    payload = "&lt;​script&gt;alert(1)&lt;/​script&gt;"
    with pytest.raises(ValueError, match="tag-like"):
        sanitize_sql_expression(payload, "sql_expression")


def test_sanitize_sql_expression_preserves_lt_followed_by_column_name():
    # Regression: `col_a<col_b` was previously truncated by nh3.
    sanitize_sql_expression = _sanitize_sql()
    expr = "SUM(CASE WHEN col_a<col_b THEN 1 END)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_preserves_not_equal_operator():
    sanitize_sql_expression = _sanitize_sql()
    expr = "COUNT(CASE WHEN status <> 'closed' THEN 1 END)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_rejects_html_attribute_pattern():
    sanitize_sql_expression = _sanitize_sql()
    with pytest.raises(ValueError, match="tag-like"):
        sanitize_sql_expression(
            "SUM(x) + <a href='javascript:alert(1)'>x</a>", "sql_expression"
        )


def test_sanitize_sql_expression_preserves_lt_with_digit():
    sanitize_sql_expression = _sanitize_sql()
    expr = "SUM(CASE WHEN x<5 THEN 1 ELSE 0 END)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


def test_sanitize_sql_expression_blocks_xp_cmdshell():
    sanitize_sql_expression = _sanitize_sql()
    # The EXEC keyword is blocked first as a DDL/DML guard; the xp_cmdshell
    # check is a defense-in-depth fallback for inputs that bypass the keyword
    # check (e.g. comment-stripped tokens).
    with pytest.raises(ValueError, match="disallowed"):
        sanitize_sql_expression("EXEC xp_cmdshell 'whoami'", "sql_expression")


def test_sanitize_sql_expression_preserves_lt_gt_operators():
    """nh3.clean re-encodes bare `<` / `>` as `&lt;` / `&gt;`; the sanitizer
    must restore them because they are legitimate SQL comparison operators
    that the ratio/conditional metric use case depends on."""
    sanitize_sql_expression = _sanitize_sql()
    expr = "SUM(CASE WHEN x < 5 AND y > 10 THEN 1 END)"
    out = sanitize_sql_expression(expr, "sql_expression")
    assert "<" in out
    assert ">" in out
    assert "&lt;" not in out
    assert "&gt;" not in out
    # Round-trip equality: no operator characters should have been mangled.
    assert out == expr


def test_sanitize_sql_expression_blocks_zwsp_smuggled_in_keyword():
    """A zero-width space between letters of DROP must not bypass the
    DDL/DML check. Regression for the ordering bug where
    _remove_dangerous_unicode ran AFTER the keyword regex."""
    sanitize_sql_expression = _sanitize_sql()
    # U+200B between D and R
    payload = "D​ROP TABLE users"
    with pytest.raises(ValueError, match="disallowed"):
        sanitize_sql_expression(payload, "sql_expression")


def test_sanitize_sql_expression_blocks_line_separator_statement():
    """U+2028 / U+2029 / U+0085 must be stripped before the ``;`` /
    statement-stacking check so they cannot be used to smuggle a second
    statement past the literal ``;`` check on dialects that treat them as
    line terminators."""
    sanitize_sql_expression = _sanitize_sql()
    # Carrier is the ``;`` literal; the line separator is the bypass attempt.
    # After strip the ``;`` remains and the statement-stacking check fires.
    payload = "SUM(x)
; DROP TABLE users"
    with pytest.raises(ValueError, match="statement stacking"):
        sanitize_sql_expression(payload, "sql_expression")


def test_sanitize_sql_expression_allows_url_scheme_in_string_literal():
    """A SQL string literal that happens to contain ``javascript:`` is a
    legitimate analytics query against URL-typed columns. The XSS vector
    is already neutralized by ``_strip_html_tags`` stripping the
    surrounding tag, so the URL-scheme regex should not block here."""
    sanitize_sql_expression = _sanitize_sql()
    expr = "COUNT(CASE WHEN url LIKE 'javascript:%' THEN 1 END)"
    assert sanitize_sql_expression(expr, "sql_expression") == expr


# ---------------------------------------------------------------------------
# escape_like
# ---------------------------------------------------------------------------


def test_escape_like_plain_text():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("maxime") == "maxime"


def test_escape_like_percent():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("%") == "\\%"


def test_escape_like_underscore():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("_") == "\\_"


def test_escape_like_backslash():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("\\") == "\\\\"


def test_escape_like_mixed():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("a%b_c\\") == "a\\%b\\_c\\\\"


def test_escape_like_empty_string():
    from superset.mcp_service.utils.sanitization import escape_like

    assert escape_like("") == ""