bauer/cordra-mcp
1
0
Fork 0
mirror of https://github.com/dnlbauer/cordra-mcp.git synced 2026-09-10 21:55:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: implement pagination for schema resource fetching

Browse Source 
The schema resource registration was only fetching the first page of
schemas from Cordra, causing schemas beyond the page limit to not be
registered as MCP resources.

Changes:
- Enhanced find() method to support pagination with page_size/page_num
- Modified schema registration to paginate through all results
- Updated return structure to include pagination metadata
- Added comprehensive test coverage for pagination scenarios
- Maintains backward compatibility with existing code

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Daniel Bauer
2025-07-05 12:16:38 +02:00
parent 6dcc039470
commit f32b4c9448
4 changed files with 241 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
tests/test_client.py
View File

@@ -170,6 +170,8 @@ class TestCordraClient:
{"name": "Document", "identifier": "test/doc-schema"},
],
"size": 3,
"pageNum": 0,
"pageSize": 20,
}
mock_response = mock_get.return_value
mock_response.status_code = 200
@@ -178,21 +180,25 @@ class TestCordraClient:
result = await client.find("type:Schema")
assert len(result) == 3
assert result[0]["name"] == "User"
assert result[1]["name"] == "Project"
assert result[2]["name"] == "Document"
assert isinstance(result, dict)
assert len(result["results"]) == 3
assert result["results"][0]["name"] == "User"
assert result["results"][1]["name"] == "Project"
assert result["results"][2]["name"] == "Document"
assert result["total_size"] == 3
assert result["page_num"] == 0
assert result["page_size"] == 20
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Schema"},
params={"query": "type:Schema", "pageSize": "20", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_empty_results(self, mock_get, client):
"""Test find with empty results."""
mock_response_data = {"results": [], "size": 0}
mock_response_data = {"results": [], "size": 0, "pageNum": 0, "pageSize": 20}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = mock_response_data
@@ -200,26 +206,17 @@ class TestCordraClient:
result = await client.find("type:NonExistent")
assert result == []
assert isinstance(result, dict)
assert result["results"] == []
assert result["total_size"] == 0
assert result["page_num"] == 0
assert result["page_size"] == 20
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:NonExistent"},
params={"query": "type:NonExistent", "pageSize": "20", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_no_results_key(self, mock_get, client):
"""Test find with response missing results key."""
mock_response_data = {"size": 0} # No results key
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = mock_response_data
mock_response.raise_for_status.return_value = None
result = await client.find("type:Schema")
assert result == []
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_error(self, mock_get, client):
"""Test find error handling."""
@@ -236,64 +233,108 @@ class TestCordraClient:
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_with_type_filter(self, mock_get, client):
"""Test find operation with type filter constructs correct query."""
mock_response_data = {"results": [], "size": 0, "pageNum": 0, "pageSize": 20}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
mock_response.json.return_value = mock_response_data
mock_response.ok = True
await client.find("name:John", object_type="Person")
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Person AND (name:John)"},
params={"query": "type:Person AND (name:John)", "pageSize": "20", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_with_limit(self, mock_get, client):
"""Test find operation with limit adds pageSize parameter."""
async def test_find_with_page_size(self, mock_get, client):
"""Test find operation with custom page size."""
mock_response_data = {"results": [], "size": 0, "pageNum": 0, "pageSize": 50}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
mock_response.json.return_value = mock_response_data
mock_response.ok = True
await client.find("type:Test", limit=50)
await client.find("type:Test", page_size=50)
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Test", "pageSize": "50"},
params={"query": "type:Test", "pageSize": "50", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_with_type_and_limit(self, mock_get, client):
"""Test find operation with both type filter and limit."""
async def test_find_with_type_and_page_size(self, mock_get, client):
"""Test find operation with both type filter and page size."""
mock_response_data = {"results": [], "size": 0, "pageNum": 0, "pageSize": 25}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
mock_response.json.return_value = mock_response_data
mock_response.ok = True
await client.find("title:Report", object_type="Document", limit=25)
await client.find("title:Report", object_type="Document", page_size=25)
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Document AND (title:Report)", "pageSize": "25"},
params={"query": "type:Document AND (title:Report)", "pageSize": "25", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_no_optional_params(self, mock_get, client):
"""Test find operation with no optional parameters."""
async def test_find_default_params(self, mock_get, client):
"""Test find operation with default parameters."""
mock_response_data = {"results": [], "size": 0, "pageNum": 0, "pageSize": 20}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = {"results": []}
mock_response.json.return_value = mock_response_data
mock_response.ok = True
await client.find("content:test")
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "content:test"},
params={"query": "content:test", "pageSize": "20", "pageNum": "0"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_with_page_num(self, mock_get, client):
"""Test find operation with specific page number."""
mock_response_data = {"results": [], "size": 100, "pageNum": 2, "pageSize": 20}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = mock_response_data
mock_response.ok = True
result = await client.find("type:Schema", page_num=2)
assert result["page_num"] == 2
assert result["page_size"] == 20
assert result["total_size"] == 100
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Schema", "pageSize": "20", "pageNum": "2"},
timeout=30,
)
@patch("cordra_mcp.client.requests.Session.get")
async def test_find_with_custom_page_size_and_num(self, mock_get, client):
"""Test find operation with custom page size and page number."""
mock_response_data = {"results": [], "size": 500, "pageNum": 5, "pageSize": 10}
mock_response = mock_get.return_value
mock_response.status_code = 200
mock_response.json.return_value = mock_response_data
mock_response.ok = True
result = await client.find("type:Document", page_size=10, page_num=5)
assert result["page_num"] == 5
assert result["page_size"] == 10
assert result["total_size"] == 500
mock_get.assert_called_once_with(
"https://test.example.com/search",
params={"query": "type:Document", "pageSize": "10", "pageNum": "5"},
timeout=30,
)

165
tests/test_server.py
View File

@@ -190,12 +190,17 @@ class TestSchemaResourceFunctions:
@patch('cordra_mcp.server.cordra_client')
async def test_register_schema_resources_success(self, mock_client):
"""Test successful schema resource registration."""
mock_schemas = [
{"content": {"name": "User"}, "id": "test/user-schema"},
{"content": {"name": "Project"}, "id": "test/project-schema"},
{"content": {"name": "Document"}, "id": "test/doc-schema"}
]
mock_client.find = AsyncMock(return_value=mock_schemas)
mock_search_result = {
"results": [
{"content": {"name": "User"}, "id": "test/user-schema"},
{"content": {"name": "Project"}, "id": "test/project-schema"},
{"content": {"name": "Document"}, "id": "test/doc-schema"}
],
"total_size": 3,
"page_num": 0,
"page_size": 20
}
mock_client.find = AsyncMock(return_value=mock_search_result)
# Mock the mcp.add_resource method
with patch('cordra_mcp.server.mcp') as mock_mcp:
@@ -203,7 +208,7 @@ class TestSchemaResourceFunctions:
await register_schema_resources()
# Verify the client was called with correct query
mock_client.find.assert_called_once_with("type:Schema")
mock_client.find.assert_called_once_with("type:Schema", page_size=20, page_num=0)
# Verify add_resource was called for each schema
assert mock_mcp.add_resource.call_count == 3
@@ -211,12 +216,17 @@ class TestSchemaResourceFunctions:
@patch('cordra_mcp.server.cordra_client')
async def test_register_schema_resources_missing_name(self, mock_client):
"""Test schema resource registration with objects missing name field."""
mock_schemas = [
{"content": {"name": "User"}, "id": "test/user-schema"},
{"content": {}, "id": "test/no-name-schema"}, # Missing name field
{"content": {"name": "Project"}, "id": "test/project-schema"}
]
mock_client.find = AsyncMock(return_value=mock_schemas)
mock_search_result = {
"results": [
{"content": {"name": "User"}, "id": "test/user-schema"},
{"content": {}, "id": "test/no-name-schema"}, # Missing name field
{"content": {"name": "Project"}, "id": "test/project-schema"}
],
"total_size": 3,
"page_num": 0,
"page_size": 20
}
mock_client.find = AsyncMock(return_value=mock_search_result)
with patch('cordra_mcp.server.mcp') as mock_mcp:
from cordra_mcp.server import register_schema_resources
@@ -234,7 +244,45 @@ class TestSchemaResourceFunctions:
from cordra_mcp.server import register_schema_resources
await register_schema_resources() # Should complete without raising
mock_client.find.assert_called_once_with("type:Schema")
mock_client.find.assert_called_once_with("type:Schema", page_size=20, page_num=0)
@patch('cordra_mcp.server.cordra_client')
async def test_register_schema_resources_pagination(self, mock_client):
"""Test schema resource registration with pagination."""
# Mock multiple pages of results
# First page with full 20 results (simulating more schemas)
first_page_schemas = [{"content": {"name": f"Schema{i}"}, "id": f"test/schema{i}"} for i in range(20)]
first_page = {
"results": first_page_schemas,
"total_size": 25,
"page_num": 0,
"page_size": 20
}
# Second page with fewer results (indicating last page)
second_page = {
"results": [
{"content": {"name": "Document"}, "id": "test/doc-schema"},
],
"total_size": 25,
"page_num": 1,
"page_size": 20
}
# Return first page, then second page (with fewer results indicating last page)
mock_client.find = AsyncMock(side_effect=[first_page, second_page])
with patch('cordra_mcp.server.mcp') as mock_mcp:
from cordra_mcp.server import register_schema_resources
await register_schema_resources()
# Verify pagination calls
assert mock_client.find.call_count == 2
mock_client.find.assert_any_call("type:Schema", page_size=20, page_num=0)
mock_client.find.assert_any_call("type:Schema", page_size=20, page_num=1)
# Verify all 21 schemas were registered (20 from first page + 1 from second page)
assert mock_mcp.add_resource.call_count == 21
class TestSearchObjects:
@@ -245,11 +293,16 @@ class TestSearchObjects:
async def test_search_objects_success(self, mock_config, mock_client):
"""Test successful object search."""
mock_config.max_search_results = 1000
mock_results = [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
{"id": "people/jane-smith", "type": "Person", "content": {"name": "Jane Smith"}},
]
mock_client.find = AsyncMock(return_value=mock_results)
mock_search_result = {
"results": [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
{"id": "people/jane-smith", "type": "Person", "content": {"name": "Jane Smith"}},
],
"total_size": 2,
"page_num": 0,
"page_size": 1000
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("name:John")
@@ -260,17 +313,22 @@ class TestSearchObjects:
assert parsed_result[1]["id"] == "people/jane-smith"
# Verify the client was called with correct parameters
mock_client.find.assert_called_once_with("name:John", object_type=None, limit=1000)
mock_client.find.assert_called_once_with("name:John", object_type=None, page_size=1000)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
async def test_search_objects_with_type_filter(self, mock_config, mock_client):
"""Test object search with type filter."""
mock_config.max_search_results = 1000
mock_results = [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
]
mock_client.find = AsyncMock(return_value=mock_results)
mock_search_result = {
"results": [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
],
"total_size": 1,
"page_num": 0,
"page_size": 1000
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("name:John", type="Person")
@@ -280,17 +338,22 @@ class TestSearchObjects:
assert parsed_result[0]["type"] == "Person"
# Verify the client was called with type filter
mock_client.find.assert_called_once_with("name:John", object_type="Person", limit=1000)
mock_client.find.assert_called_once_with("name:John", object_type="Person", page_size=1000)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
async def test_search_objects_with_limit(self, mock_config, mock_client):
"""Test object search with custom limit."""
mock_config.max_search_results = 1000
mock_results = [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
]
mock_client.find = AsyncMock(return_value=mock_results)
mock_search_result = {
"results": [
{"id": "people/john-doe", "type": "Person", "content": {"name": "John Doe"}},
],
"total_size": 1,
"page_num": 0,
"page_size": 50
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("name:John", limit=50)
@@ -299,17 +362,22 @@ class TestSearchObjects:
assert len(parsed_result) == 1
# Verify the client was called with custom limit
mock_client.find.assert_called_once_with("name:John", object_type=None, limit=50)
mock_client.find.assert_called_once_with("name:John", object_type=None, page_size=50)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
async def test_search_objects_with_all_parameters(self, mock_config, mock_client):
"""Test object search with all parameters."""
mock_config.max_search_results = 1000
mock_results = [
{"id": "documents/report-123", "type": "Document", "content": {"title": "Report"}},
]
mock_client.find = AsyncMock(return_value=mock_results)
mock_search_result = {
"results": [
{"id": "documents/report-123", "type": "Document", "content": {"title": "Report"}},
],
"total_size": 1,
"page_num": 0,
"page_size": 25
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("title:Report", type="Document", limit=25)
@@ -319,14 +387,20 @@ class TestSearchObjects:
assert parsed_result[0]["type"] == "Document"
# Verify the client was called with all parameters
mock_client.find.assert_called_once_with("title:Report", object_type="Document", limit=25)
mock_client.find.assert_called_once_with("title:Report", object_type="Document", page_size=25)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
async def test_search_objects_empty_results(self, mock_config, mock_client):
"""Test object search with no results."""
mock_config.max_search_results = 1000
mock_client.find = AsyncMock(return_value=[])
mock_search_result = {
"results": [],
"total_size": 0,
"page_num": 0,
"page_size": 1000
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("nonexistent:data")
@@ -334,7 +408,7 @@ class TestSearchObjects:
parsed_result = json.loads(result)
assert parsed_result == []
mock_client.find.assert_called_once_with("nonexistent:data", object_type=None, limit=1000)
mock_client.find.assert_called_once_with("nonexistent:data", object_type=None, page_size=1000)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
@@ -347,7 +421,7 @@ class TestSearchObjects:
await search_objects("test:query")
assert "Search failed:" in str(exc_info.value)
mock_client.find.assert_called_once_with("test:query", object_type=None, limit=1000)
mock_client.find.assert_called_once_with("test:query", object_type=None, page_size=1000)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
@@ -360,17 +434,22 @@ class TestSearchObjects:
await search_objects("invalid:query")
assert "Invalid search parameters:" in str(exc_info.value)
mock_client.find.assert_called_once_with("invalid:query", object_type=None, limit=1000)
mock_client.find.assert_called_once_with("invalid:query", object_type=None, page_size=1000)
@patch('cordra_mcp.server.cordra_client')
@patch('cordra_mcp.server.config')
async def test_search_objects_json_formatting(self, mock_config, mock_client):
"""Test that search results are properly formatted as JSON."""
mock_config.max_search_results = 1000
mock_results = [
{"id": "test/object", "type": "Test", "content": {"data": "value"}},
]
mock_client.find = AsyncMock(return_value=mock_results)
mock_search_result = {
"results": [
{"id": "test/object", "type": "Test", "content": {"data": "value"}},
],
"total_size": 1,
"page_num": 0,
"page_size": 1000
}
mock_client.find = AsyncMock(return_value=mock_search_result)
result = await search_objects("test:query")