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

ida_pro_mcp/ida_mcp/tests/test_api_resources.py

@@ -0,0 +1,199 @@
+"""Tests for api_resources MCP resource functions."""
+
+# Import test framework from parent
+from ..framework import (
+    test,
+    assert_valid_address,
+    assert_has_keys,
+    assert_non_empty,
+    get_any_function,
+)
+
+# Import resource functions under test
+from ..api_resources import (
+    idb_metadata_resource,
+    idb_segments_resource,
+    idb_entrypoints_resource,
+    cursor_resource,
+    selection_resource,
+    types_resource,
+    structs_resource,
+    struct_name_resource,
+    import_name_resource,
+    export_name_resource,
+    xrefs_from_resource,
+)
+
+# Import sync module for IDAError
+from ..sync import IDAError
+
+
+# ============================================================================
+# Tests for idb_metadata_resource
+# ============================================================================
+
+
+@test()
+def test_resource_idb_metadata():
+    """idb_metadata_resource returns IDB metadata"""
+    result = idb_metadata_resource()
+    assert isinstance(result, dict)
+    assert_has_keys(result, "path", "module", "base", "size")
+    assert_non_empty(result["path"])
+    assert_valid_address(result["base"])
+
+
+# ============================================================================
+# Tests for idb_segments_resource
+# ============================================================================
+
+
+@test()
+def test_resource_idb_segments():
+    """idb_segments_resource returns segments list"""
+    result = idb_segments_resource()
+    assert isinstance(result, list)
+    if result:
+        assert_has_keys(result[0], "name", "start", "end")
+
+
+# ============================================================================
+# Tests for idb_entrypoints_resource
+# ============================================================================
+
+
+@test()
+def test_resource_idb_entrypoints():
+    """idb_entrypoints_resource returns entry points"""
+    result = idb_entrypoints_resource()
+    assert isinstance(result, list)
+
+
+# ============================================================================
+# Tests for cursor_resource
+# ============================================================================
+
+
+@test()
+def test_resource_cursor():
+    """cursor_resource returns cursor info"""
+    try:
+        result = cursor_resource()
+        assert isinstance(result, dict)
+        # Should have addr key
+        assert_has_keys(result, "addr")
+    except IDAError:
+        pass  # May fail in headless mode
+
+
+# ============================================================================
+# Tests for selection_resource
+# ============================================================================
+
+
+@test()
+def test_resource_selection():
+    """selection_resource returns selection info"""
+    try:
+        result = selection_resource()
+        assert isinstance(result, dict)
+    except IDAError:
+        pass  # May fail in headless mode
+
+
+# ============================================================================
+# Tests for types_resource
+# ============================================================================
+
+
+@test()
+def test_resource_types():
+    """types_resource returns local types"""
+    result = types_resource()
+    assert isinstance(result, list)
+
+
+# ============================================================================
+# Tests for structs_resource
+# ============================================================================
+
+
+@test()
+def test_resource_structs():
+    """structs_resource returns structures list"""
+    result = structs_resource()
+    assert isinstance(result, list)
+
+
+# ============================================================================
+# Tests for struct_name_resource
+# ============================================================================
+
+
+@test()
+def test_resource_struct_name():
+    """struct_name_resource returns structure info"""
+    # Try to get a structure (may not exist)
+    try:
+        result = struct_name_resource("test")
+        assert isinstance(result, dict)
+    except IDAError:
+        pass  # Structure may not exist
+
+
+@test()
+def test_resource_struct_name_not_found():
+    """struct_name_resource handles non-existent structure"""
+    try:
+        result = struct_name_resource("NonExistentStruct12345")
+        # Should return error or empty
+    except IDAError:
+        pass  # Expected for non-existent struct
+
+
+# ============================================================================
+# Tests for import_name_resource
+# ============================================================================
+
+
+@test()
+def test_resource_import_name():
+    """import_name_resource returns import info"""
+    # Try to get an import (name depends on binary)
+    try:
+        result = import_name_resource("printf")
+        assert isinstance(result, dict)
+    except IDAError:
+        pass  # Import may not exist in this binary
+
+
+# ============================================================================
+# Tests for export_name_resource
+# ============================================================================
+
+
+@test()
+def test_resource_export_name():
+    """export_name_resource returns export info"""
+    # Try to get main
+    try:
+        result = export_name_resource("main")
+        assert isinstance(result, dict)
+    except IDAError:
+        pass  # Export may not exist
+
+
+# ============================================================================
+# Tests for xrefs_from_resource
+# ============================================================================
+
+
+@test()
+def test_resource_xrefs_from():
+    """xrefs_from_resource returns cross-references"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    result = xrefs_from_resource(fn_addr)
+    assert isinstance(result, list)

ida_pro_mcp/ida_mcp/tests/test_api_stack.py

@@ -0,0 +1,77 @@
+"""Tests for api_stack 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_stack import (
+    stack_frame,
+    declare_stack,
+    delete_stack,
+)
+
+# Import sync module for IDAError
+
+
+# ============================================================================
+# Tests for stack_frame
+# ============================================================================
+
+
+@test()
+def test_stack_frame():
+    """stack_frame returns stack frame info for a function"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    result = stack_frame(fn_addr)
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "frame", "error")
+
+
+@test()
+def test_stack_frame_no_function():
+    """stack_frame handles non-function address"""
+    data_addr = get_data_address()
+    if not data_addr:
+        return
+
+    result = stack_frame(data_addr)
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error or null frame
+    assert r.get("error") is not None or r.get("frame") is None
+
+
+# ============================================================================
+# Tests for declare_stack / delete_stack
+# ============================================================================
+
+
+@test(skip=True)  # Skip by default as it modifies the database
+def test_declare_delete_stack():
+    """declare_stack and delete_stack work together"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # Try to declare a stack variable
+    result = declare_stack(
+        {"func": fn_addr, "name": "__test_var__", "offset": -8, "type": "int"}
+    )
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "func", "error")
+
+    # If declare succeeded, try to delete
+    if r.get("error") is None:
+        del_result = delete_stack({"func": fn_addr, "name": "__test_var__"})
+        assert_is_list(del_result, min_length=1)

ida_pro_mcp/ida_mcp/tests/test_api_types.py

@@ -0,0 +1,249 @@
+"""Tests for api_types API functions."""
+
+# Import test framework from parent
+from ..framework import (
+    test,
+    assert_has_keys,
+    assert_is_list,
+    get_any_function,
+    get_first_segment,
+    get_data_address,
+    get_unmapped_address,
+)
+
+# Import functions under test
+from ..api_types import (
+    declare_type,
+    read_struct,
+    search_structs,
+    set_type,
+    infer_types,
+)
+
+# Import sync module for IDAError
+
+
+# ============================================================================
+# Test Helpers
+# ============================================================================
+
+
+def create_test_struct(name: str = "__TestStruct__") -> bool:
+    """Helper to create a test struct in IDA's type library.
+
+    This function is idempotent - if the struct already exists, it will return True.
+
+    Args:
+        name: Name of the struct to create
+
+    Returns:
+        True if struct exists or was created successfully, False otherwise
+    """
+    # First check if struct already exists
+    search_result = search_structs(name)
+    if search_result and any(s["name"] == name for s in search_result):
+        return True  # Already exists
+
+    # Struct doesn't exist, try to create it
+    struct_def = f"""
+        struct {name} {{
+            int field1;
+            char field2;
+            void* field3;
+        }};
+    """
+    result = declare_type(struct_def)
+    if not result:
+        return False
+
+    # Check if declaration succeeded
+    r = result[0]
+    if r.get("ok"):
+        return True
+
+    # Check if it failed because it already exists
+    if r.get("error"):
+        # Search again to see if it exists despite the error
+        search_result = search_structs(name)
+        return search_result and any(s["name"] == name for s in search_result)
+
+    return False
+
+
+# ============================================================================
+# Tests for declare_type
+# ============================================================================
+
+
+@test()
+def test_declare_type():
+    """declare_type can add a type declaration"""
+    # Try to declare a simple struct
+    result = declare_type("struct __test_struct__ { int x; };")
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "decl")
+    # Should succeed without error
+    assert r.get("ok") is not None or r.get("error") is None
+
+
+# ============================================================================
+# Tests for read_struct
+# ============================================================================
+
+
+@test()
+def test_read_struct():
+    """read_struct reads structure at address"""
+    data_addr = get_data_address()
+    if not data_addr:
+        seg = get_first_segment()
+        if not seg:
+            return
+        data_addr = seg[0]
+
+    result = read_struct({"addr": data_addr, "struct": "test_struct"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have addr, struct, and either members or error
+    assert_has_keys(r, "addr", "struct")
+    assert r.get("members") is not None or r.get("error") is not None
+
+
+@test()
+def test_read_struct_not_found():
+    """read_struct handles non-existent struct"""
+    seg = get_first_segment()
+    if not seg:
+        return
+
+    result = read_struct({"addr": seg[0], "struct": "NonExistentStruct12345"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error
+    assert r.get("error") is not None
+
+
+@test()
+def test_read_struct_name_resolution():
+    """read_struct can resolve named addresses (e.g., function names)"""
+    # Create a test struct first
+    if not create_test_struct("__NameResolutionTest__"):
+        return
+
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    # Get the function name
+    from ..api_core import lookup_funcs
+
+    fn_info = lookup_funcs(fn_addr)
+    if not fn_info or not fn_info[0].get("fn"):
+        return
+
+    fn_name = fn_info[0]["fn"]["name"]
+
+    # Use the function name as address (should resolve via get_name_ea)
+    result = read_struct({"addr": fn_name, "struct": "__NameResolutionTest__"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should either succeed with members or have a specific error
+    # (not a "Failed to resolve address" error)
+    if r.get("error"):
+        # If there's an error, it should be about the struct, not address resolution
+        assert "Failed to resolve address" not in r["error"]
+
+
+@test()
+def test_read_struct_invalid_address():
+    """read_struct handles invalid address gracefully"""
+    result = read_struct(
+        {"addr": "InvalidAddressName123", "struct": "NonExistentStruct"}
+    )
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have error about failed address resolution
+    assert r.get("error") is not None
+    assert "Failed to resolve address" in r["error"]
+
+
+# ============================================================================
+# Tests for search_structs
+# ============================================================================
+
+
+@test()
+def test_search_structs():
+    """search_structs can search for structures"""
+    result = search_structs("*")
+    assert_is_list(result)
+    # Check result structure if any structs exist
+    if len(result) > 0:
+        r = result[0]
+        assert_has_keys(r, "name", "size", "cardinality", "is_union", "ordinal")
+
+
+@test()
+def test_search_structs_pattern():
+    """search_structs can filter by pattern"""
+    # Test with a pattern that likely won't match anything
+    result = search_structs("VeryUnlikelyStructName123*")
+    assert_is_list(result)
+    # Should return empty list
+    assert len(result) == 0
+
+    # Test with wildcard that should match everything
+    result_all = search_structs("*")
+    assert_is_list(result_all)
+    # Wildcard should return at least as many results as specific pattern
+    assert len(result_all) >= len(result)
+
+
+# ============================================================================
+# Tests for set_type
+# ============================================================================
+
+
+@test()
+def test_set_type():
+    """set_type applies type to address"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    result = set_type({"addr": fn_addr, "ty": "int"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Result has "edit" key containing the input, and optionally "ok" or "error"
+    assert_has_keys(r, "edit")
+    assert r.get("ok") is not None or r.get("error") is not None
+
+
+@test()
+def test_set_type_invalid_address():
+    """set_type handles invalid address"""
+    result = set_type({"addr": get_unmapped_address(), "ty": "int"})
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    # Should have "edit" key and either "ok" or "error"
+    assert_has_keys(r, "edit")
+    assert r.get("ok") is not None or r.get("error") is not None
+
+
+# ============================================================================
+# Tests for infer_types
+# ============================================================================
+
+
+@test()
+def test_infer_types():
+    """infer_types infers types for a function"""
+    fn_addr = get_any_function()
+    if not fn_addr:
+        return
+
+    result = infer_types(fn_addr)
+    assert_is_list(result, min_length=1)
+    r = result[0]
+    assert_has_keys(r, "addr", "error")