test_hook.py

"""Unit tests for the bits of logic that actually branch.

Run with:
    python3 -m unittest test_hook.py -v
"""
from __future__ import annotations

import json
import os
import tempfile
import unittest
from pathlib import Path

import claude_hook


class DelayForDurationTests(unittest.TestCase):
    """Each band boundary maps to its expected delay."""

    def test_short_turn(self):
        self.assertEqual(claude_hook._delay_for_duration(10), 20)

    def test_medium_turn(self):
        self.assertEqual(claude_hook._delay_for_duration(90), 15)

    def test_long_turn(self):
        self.assertEqual(claude_hook._delay_for_duration(200), 10)

    def test_very_long_turn_no_delay(self):
        self.assertEqual(claude_hook._delay_for_duration(600), 0)

    def test_band_boundaries(self):
        # < 60 → 20, [60, 120) → 15, [120, 300) → 10, >= 300 → 0
        self.assertEqual(claude_hook._delay_for_duration(59.9), 20)
        self.assertEqual(claude_hook._delay_for_duration(60), 15)
        self.assertEqual(claude_hook._delay_for_duration(120), 10)
        self.assertEqual(claude_hook._delay_for_duration(300), 0)


class ToolErroredTests(unittest.TestCase):
    def test_is_error_true(self):
        self.assertTrue(claude_hook.tool_errored({"tool_response": {"is_error": True}}))

    def test_nonzero_exit_code_camel(self):
        self.assertTrue(claude_hook.tool_errored({"tool_response": {"exitCode": 1}}))

    def test_nonzero_exit_code_snake(self):
        self.assertTrue(claude_hook.tool_errored({"tool_response": {"exit_code": 2}}))

    def test_zero_exit_code_is_clean(self):
        self.assertFalse(claude_hook.tool_errored({"tool_response": {"exitCode": 0}}))

    def test_is_error_false(self):
        self.assertFalse(claude_hook.tool_errored({"tool_response": {"is_error": False}}))

    def test_error_string(self):
        self.assertTrue(claude_hook.tool_errored({"tool_response": {"error": "boom"}}))

    def test_status_failed(self):
        self.assertTrue(claude_hook.tool_errored({"tool_response": {"status": "FAILED"}}))

    def test_empty_response_is_clean(self):
        self.assertFalse(claude_hook.tool_errored({"tool_response": {}}))

    def test_non_dict_response_is_clean(self):
        self.assertFalse(claude_hook.tool_errored({"tool_response": "ok"}))


class ResponseIndicatesErrorTests(unittest.TestCase):
    def _msg(self, text):
        return {"last_assistant_message": text}

    def test_plain_error_phrase(self):
        self.assertTrue(claude_hook.response_indicates_error(
            self._msg("I encountered an error while reading the file.")))

    def test_failed_to_phrase(self):
        self.assertTrue(claude_hook.response_indicates_error(
            self._msg("Failed to connect to the database.")))

    def test_negation_overrides_phrase(self):
        self.assertFalse(claude_hook.response_indicates_error(
            self._msg("Ran the test suite - no errors found.")))

    def test_mid_sentence_phrase_does_not_match(self):
        # "could not have gone better" should NOT be treated as an error,
        # because "could not" only counts at sentence start.
        self.assertFalse(claude_hook.response_indicates_error(
            self._msg("It could not have gone better.")))

    def test_sentence_boundary_phrase_matches(self):
        # After a sentence break, "Failed to ..." still counts.
        self.assertTrue(claude_hook.response_indicates_error(
            self._msg("Did the build. Failed to push the artifact.")))

    def test_successfully_overrides(self):
        self.assertFalse(claude_hook.response_indicates_error(
            self._msg("Successfully deployed; could not have gone better.")))

    def test_empty_message_is_clean(self):
        self.assertFalse(claude_hook.response_indicates_error(self._msg("")))

    def test_case_insensitive(self):
        self.assertTrue(claude_hook.response_indicates_error(
            self._msg("UNABLE TO open the connection.")))


class CleanTests(unittest.TestCase):
    def test_strips_bold_and_backticks(self):
        self.assertEqual(claude_hook.clean("**bold** and `code`"), "bold and code")

    def test_collapses_whitespace(self):
        self.assertEqual(claude_hook.clean("a  b\n\nc\td"), "a b c d")

    def test_empty(self):
        self.assertEqual(claude_hook.clean(""), "")


class TruncateTests(unittest.TestCase):
    def test_under_limit_unchanged(self):
        self.assertEqual(claude_hook.truncate("hello", 10), "hello")

    def test_exactly_limit_unchanged(self):
        self.assertEqual(claude_hook.truncate("abcde", 5), "abcde")

    def test_over_limit_ellipsized(self):
        out = claude_hook.truncate("abcdefghij", 5)
        self.assertEqual(len(out), 5)
        self.assertTrue(out.endswith("..."))

    def test_truncate_runs_clean_first(self):
        # Markdown should be stripped before length check.
        self.assertEqual(claude_hook.truncate("**bold**", 10), "bold")


class FormatToolHintTests(unittest.TestCase):
    def test_bash_takes_first_line_only(self):
        out = claude_hook.format_tool_hint(
            "Bash", {"command": "ls -la\nrm -rf /"})
        self.assertEqual(out, "ls -la")

    def test_edit_uses_basename(self):
        self.assertEqual(
            claude_hook.format_tool_hint("Edit", {"file_path": "/long/path/to/foo.py"}),
            "foo.py")

    def test_read_uses_basename(self):
        self.assertEqual(
            claude_hook.format_tool_hint("Read", {"file_path": "/a/b/c.txt"}),
            "c.txt")

    def test_webfetch_uses_url(self):
        self.assertEqual(
            claude_hook.format_tool_hint("WebFetch", {"url": "https://example.com/x"}),
            "https://example.com/x")

    def test_grep_uses_pattern(self):
        self.assertEqual(
            claude_hook.format_tool_hint("Grep", {"pattern": "TODO"}),
            "TODO")

    def test_fallback_picks_longest_string(self):
        # Unknown tool: longest stringy value wins.
        out = claude_hook.format_tool_hint(
            "MysteryTool", {"short": "x", "long": "the longer description"})
        self.assertEqual(out, "the longer description")

    def test_fallback_skips_none_values(self):
        # None must not win against shorter strings via json.dumps(None) == "null".
        out = claude_hook.format_tool_hint(
            "MysteryTool", {"meta": None, "x": "abc"})
        self.assertEqual(out, "abc")

    def test_max_len_caps_output(self):
        long_cmd = "a" * 500
        out = claude_hook.format_tool_hint("Bash", {"command": long_cmd}, max_len=50)
        self.assertEqual(len(out), 50)


class ParsePendingToolTests(unittest.TestCase):
    def test_empty_path_returns_none(self):
        self.assertIsNone(claude_hook.parse_pending_tool(""))

    def test_missing_file_returns_none(self):
        self.assertIsNone(claude_hook.parse_pending_tool("/nonexistent/path"))

    def test_finds_most_recent_tool_use(self):
        # JSONL transcript, scanned bottom-up: last tool_use wins.
        lines = [
            {"message": {"content": [{"type": "tool_use", "name": "OldTool",
                                       "input": {"x": 1}}]}},
            {"message": {"content": [{"type": "text", "text": "hi"}]}},
            {"message": {"content": [{"type": "tool_use", "name": "Bash",
                                       "input": {"command": "ls"}}]}},
        ]
        with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False) as f:
            for line in lines:
                f.write(json.dumps(line) + "\n")
            path = f.name
        try:
            result = claude_hook.parse_pending_tool(path)
            self.assertIsNotNone(result)
            name, inp = result
            self.assertEqual(name, "Bash")
            self.assertEqual(inp, {"command": "ls"})
        finally:
            os.unlink(path)

    def test_no_tool_use_returns_none(self):
        with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False) as f:
            f.write(json.dumps({"message": {"content": [{"type": "text"}]}}) + "\n")
            path = f.name
        try:
            self.assertIsNone(claude_hook.parse_pending_tool(path))
        finally:
            os.unlink(path)

    def test_skips_malformed_lines(self):
        with tempfile.NamedTemporaryFile("w", suffix=".jsonl", delete=False) as f:
            f.write("not json at all\n")
            f.write(json.dumps({"message": {"content": [{"type": "tool_use",
                                "name": "Read", "input": {"file_path": "/x"}}]}}) + "\n")
            path = f.name
        try:
            result = claude_hook.parse_pending_tool(path)
            self.assertEqual(result[0], "Read")
        finally:
            os.unlink(path)


class OptedOutTests(unittest.TestCase):
    def test_marker_present_opts_out(self):
        with tempfile.TemporaryDirectory() as d:
            (Path(d) / claude_hook.OPT_OUT_MARKER).touch()
            self.assertTrue(claude_hook.opted_out({"cwd": d}))

    def test_marker_absent_does_not_opt_out(self):
        with tempfile.TemporaryDirectory() as d:
            self.assertFalse(claude_hook.opted_out({"cwd": d}))


if __name__ == "__main__":
    unittest.main()