ida-pro-mcp-xjoker 1.0.1__py3-none-any.whl

ida_pro_mcp/ida_mcp/tests/test_api_core.py

@@ -0,0 +1,237 @@
+"""Tests for api_core API functions."""
+
+# Import test framework from parent
+from ..framework import (
+    test,
+    assert_has_keys,
+    assert_is_list,
+    assert_all_have_keys,
+    get_any_function,
+    get_data_address,
+)
+
+# Import functions under test
+from ..api_core import (
+    lookup_funcs,
+    int_convert,
+    list_funcs,
+    list_globals,
+    imports,
+    find_regex,
+)
+
+# Import sync module for IDAError
+
+
+# ============================================================================
+# Tests for lookup_funcs
+# ============================================================================
+
+
+@test()
+def test_lookup_funcs_by_address():
+    """lookup_funcs can find function by address"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return  # Skip if no functions
+
+    result = lookup_funcs(fn_addr)
+    assert_is_list(result, min_length=1)
+    assert result[0]["fn"] is not None
+    assert result[0]["error"] is None
+    assert_has_keys(result[0]["fn"], "addr", "name", "size")
+
+
+@test()
+def test_lookup_funcs_invalid():
+    """lookup_funcs returns error for invalid address"""
+    # Use an address that's unlikely to be a valid function
+    result = lookup_funcs("0xDEADBEEFDEADBEEF")
+    assert_is_list(result, min_length=1)
+    assert result[0]["fn"] is None
+    assert result[0]["error"] is not None
+
+
+@test()
+def test_lookup_funcs_wildcard():
+    """lookup_funcs with '*' returns all functions"""
+    result = lookup_funcs("*")
+    assert_is_list(result, min_length=1)
+    # All results should have query="*" and a function
+    for r in result:
+        assert r["query"] == "*"
+        assert r["fn"] is not None
+
+
+@test()
+def test_lookup_funcs_empty():
+    """lookup_funcs with empty string returns all functions"""
+    result = lookup_funcs("")
+    assert_is_list(result, min_length=1)
+    assert result[0]["query"] == "*"
+
+
+@test()
+def test_lookup_funcs_malformed_hex():
+    """lookup_funcs handles malformed hex address"""
+    # This looks like an address but isn't valid hex
+    result = lookup_funcs("0xZZZZ")
+    assert_is_list(result, min_length=1)
+    # Should return error since it's not a valid address or name
+    assert result[0]["error"] is not None
+
+
+@test()
+def test_lookup_funcs_data_address():
+    """lookup_funcs with valid address but not a function"""
+    data_addr = get_data_address()
+    if not data_addr:
+        return  # Skip if no data segments
+
+    result = lookup_funcs(data_addr)
+    assert_is_list(result, min_length=1)
+    # Should return "Not a function" error
+    assert result[0]["fn"] is None
+    assert "Not a function" in str(result[0]["error"]) or "Not found" in str(
+        result[0]["error"]
+    )
+
+
+# ============================================================================
+# Tests for int_convert
+# ============================================================================
+
+
+@test()
+def test_int_convert():
+    """int_convert properly converts numbers"""
+    result = int_convert({"text": "0x41"})
+    assert_is_list(result, min_length=1)
+    assert result[0]["error"] is None
+    assert result[0]["result"] is not None
+    conv = result[0]["result"]
+    assert_has_keys(conv, "decimal", "hexadecimal", "bytes", "binary")
+    assert conv["decimal"] == "65"
+    assert conv["hexadecimal"] == "0x41"
+    assert conv["ascii"] == "A"
+
+
+@test()
+def test_int_convert_invalid_text():
+    """int_convert handles invalid number text"""
+    result = int_convert({"text": "not_a_number"})
+    assert_is_list(result, min_length=1)
+    assert result[0]["result"] is None
+    assert result[0]["error"] is not None
+    assert "Invalid number" in result[0]["error"]
+
+
+@test()
+def test_int_convert_overflow():
+    """int_convert handles overflow with small size"""
+    # Try to fit a large number into 1 byte
+    result = int_convert({"text": "0xFFFF", "size": 1})
+    assert_is_list(result, min_length=1)
+    assert result[0]["result"] is None
+    assert result[0]["error"] is not None
+    assert "too big" in result[0]["error"]
+
+
+@test()
+def test_int_convert_non_ascii():
+    """int_convert handles non-ASCII bytes"""
+    # 0x01 is not a printable ASCII character (control char)
+    result = int_convert({"text": "0x01"})
+    assert_is_list(result, min_length=1)
+    assert result[0]["error"] is None
+    # ascii should be None for non-printable bytes
+    assert result[0]["result"]["ascii"] is None
+
+
+# ============================================================================
+# Tests for list_funcs
+# ============================================================================
+
+
+@test()
+def test_list_funcs():
+    """list_funcs returns functions with proper structure"""
+    result = list_funcs({})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert_has_keys(page, "data", "offset", "count", "total")
+    if page["data"]:
+        assert_all_have_keys(page["data"], "addr", "name", "size")
+
+
+@test()
+def test_list_funcs_pagination():
+    """list_funcs respects pagination parameters"""
+    result = list_funcs({"offset": 0, "count": 5})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert page["offset"] == 0
+    assert len(page["data"]) <= 5
+
+
+# ============================================================================
+# Tests for list_globals
+# ============================================================================
+
+
+@test()
+def test_list_globals():
+    """list_globals returns globals with proper structure"""
+    result = list_globals({})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert_has_keys(page, "data", "offset", "count", "total")
+
+
+@test()
+def test_list_globals_pagination():
+    """list_globals respects pagination parameters"""
+    result = list_globals({"offset": 0, "count": 5})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert page["offset"] == 0
+    assert len(page["data"]) <= 5
+
+
+# ============================================================================
+# Tests for imports
+# ============================================================================
+
+
+@test()
+def test_imports():
+    """imports returns import list with proper structure"""
+    result = imports({})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert_has_keys(page, "data", "offset", "count", "total")
+
+
+@test()
+def test_imports_pagination():
+    """imports respects pagination parameters"""
+    result = imports({"offset": 0, "count": 5})
+    assert_is_list(result, min_length=1)
+    page = result[0]
+    assert page["offset"] == 0
+    assert len(page["data"]) <= 5
+
+
+# ============================================================================
+# Tests for find_regex
+# ============================================================================
+
+
+@test()
+def test_find_regex():
+    """find_regex can search for patterns"""
+    # Search for a common pattern that should exist in most binaries
+    result = find_regex({"pattern": ".*"})
+    assert_is_list(result, min_length=1)
+    # Result structure should have matches
+    assert_has_keys(result[0], "query", "matches", "error")

ida_pro_mcp/ida_mcp/tests/test_api_memory.py

@@ -0,0 +1,207 @@
+"""Tests for api_memory API functions."""
+
+# Import test framework from parent
+from ..framework import (
+    test,
+    assert_has_keys,
+    assert_is_list,
+    get_any_string,
+    get_first_segment,
+    get_data_address,
+    get_unmapped_address,
+)
+
+# Import functions under test
+from ..api_memory import (
+    get_bytes,
+    get_int,
+    get_string,
+    get_global_value,
+    patch,
+)
+
+# Import sync module for IDAError
+
+
+# ============================================================================
+# Tests for get_bytes
+# ============================================================================
+
+
+@test()
+def test_get_bytes():
+    """get_bytes reads bytes from a valid address"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = get_bytes({"addr": start_addr, "size": 16})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "hex", "error")
+    if r["error"] is None:
+        assert r["hex"] is not None
+
+
+@test()
+def test_get_bytes_invalid():
+    """get_bytes handles invalid address"""
+    result = get_bytes({"addr": get_unmapped_address(), "size": 16})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error or empty data
+    assert r.get("error") is not None or r.get("hex") == ""
+
+
+# ============================================================================
+# Tests for get_int
+# ============================================================================
+
+
+@test()
+def test_get_int_u8():
+    """get_int reads 8-bit unsigned integer"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = get_int({"addr": start_addr, "size": 1})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "value", "error")
+
+
+@test()
+def test_get_int_u16():
+    """get_int reads 16-bit unsigned integer"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = get_int({"addr": start_addr, "size": 2})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "value", "error")
+
+
+@test()
+def test_get_int_u32():
+    """get_int reads 32-bit unsigned integer"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = get_int({"addr": start_addr, "size": 4})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "value", "error")
+
+
+@test()
+def test_get_int_u64():
+    """get_int reads 64-bit unsigned integer"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = get_int({"addr": start_addr, "size": 8})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "value", "error")
+
+
+# ============================================================================
+# Tests for get_string
+# ============================================================================
+
+
+@test()
+def test_get_string():
+    """get_string reads string from a valid address"""
+    str_addr = get_any_string()
+    if not str_addr:
+        return
+
+    result = get_string(str_addr)
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "value", "error")
+
+
+# ============================================================================
+# Tests for get_global_value
+# ============================================================================
+
+
+@test()
+def test_get_global_value():
+    """get_global_value retrieves global variable value"""
+    # Try to get value at a data address
+    data_addr = get_data_address()
+    if not data_addr:
+        seg = get_first_segment()
+        if not seg:
+            return
+        data_addr = seg[0]
+
+    result = get_global_value(data_addr)
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "error")
+
+
+# ============================================================================
+# Tests for patch
+# ============================================================================
+
+
+@test(skip=True)  # Skip by default as it modifies the database
+def test_patch():
+    """patch writes bytes to address"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    # Read original bytes first
+    original = get_bytes({"addr": start_addr, "size": 4})
+
+    try:
+        result = patch({"addr": start_addr, "hex": "90909090"})
+        assert_is_list(result, min_length=1)
+        r = result[0]
+        assert_has_keys(r, "addr", "error")
+    finally:
+        # Restore original bytes
+        if original and original[0].get("hex"):
+            patch({"addr": start_addr, "hex": original[0]["hex"]})
+
+
+@test()
+def test_patch_invalid_address():
+    """patch handles invalid address"""
+    result = patch({"addr": get_unmapped_address(), "hex": "90"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error
+    assert r.get("error") is not None
+
+
+@test()
+def test_patch_invalid_hex_data():
+    """patch handles invalid hex data"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    start_addr, _ = seg
+    result = patch({"addr": start_addr, "hex": "ZZZZ"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error for invalid hex
+    assert r.get("error") is not None

ida_pro_mcp/ida_mcp/tests/test_api_modify.py

@@ -0,0 +1,123 @@
+"""Tests for api_modify API functions."""
+
+# Import test framework from parent
+from ..framework import (
+    test,
+    assert_has_keys,
+    assert_is_list,
+    get_any_function,
+    get_data_address,
+)
+
+# Import functions under test
+from ..api_modify import (
+    set_comments,
+    patch_asm,
+    rename,
+)
+
+# Import sync module for IDAError
+
+
+# ============================================================================
+# Tests for set_comments
+# ============================================================================
+
+
+@test()
+def test_set_comment_roundtrip():
+    """set_comments can add and remove comments"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # Add a comment
+    result = set_comments({"addr": fn_addr, "comment": "__TEST_COMMENT__"})
+    assert_is_list(result, min_length=1)
+
+    # Clear the comment
+    result = set_comments({"addr": fn_addr, "comment": ""})
+    assert_is_list(result, min_length=1)
+
+
+# ============================================================================
+# Tests for patch_asm
+# ============================================================================
+
+
+@test(skip=True)  # Skip by default as it modifies the database
+def test_patch_asm():
+    """patch_asm can patch assembly"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # This is a risky test - patching assembly could corrupt the binary
+    result = patch_asm({"addr": fn_addr, "asm": "nop"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "error")
+
+
+# ============================================================================
+# Tests for rename
+# ============================================================================
+
+
+@test()
+def test_rename_function_roundtrip():
+    """rename function works and can be undone"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # Import to get original name
+    from ..api_core import lookup_funcs
+
+    # Get original name
+    lookup_result = lookup_funcs(fn_addr)
+    if not lookup_result or not lookup_result[0].get("fn"):
+        return
+
+    original_name = lookup_result[0]["fn"]["name"]
+
+    try:
+        # Rename
+        result = rename({"func": [{"addr": fn_addr, "name": "__test_rename__"}]})
+        assert isinstance(result, dict)
+
+        # Verify rename worked
+        lookup_result = lookup_funcs(fn_addr)
+        new_name = lookup_result[0]["fn"]["name"]
+        assert new_name == "__test_rename__"
+    finally:
+        # Restore
+        rename({"func": [{"addr": fn_addr, "name": original_name}]})
+
+
+@test()
+def test_rename_global_roundtrip():
+    """rename global variable works"""
+    data_addr = get_data_address()
+    if not data_addr:
+        return
+
+    try:
+        result = rename({"global": [{"addr": data_addr, "name": "__test_global__"}]})
+        assert isinstance(result, dict)
+    except Exception:
+        pass  # May fail if no suitable global exists
+
+
+@test(skip=True)  # Local variable renaming requires decompilation
+def test_rename_local_roundtrip():
+    """rename local variable works"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # This requires the function to be decompilable and have local variables
+    result = rename(
+        {"local": [{"func": fn_addr, "name": "old_var", "new_name": "__test_local__"}]}
+    )
+    assert isinstance(result, dict)