awslabs.cdk-mcp-server 0.1.0__tar.gz → 0.1.1__tar.gz

{awslabs_cdk_mcp_server-0.1.0 → awslabs_cdk_mcp_server-0.1.1}/.gitignore

@@ -57,3 +57,6 @@ target/
 
 # PyPI
 .pypirc
+
+# auto generated files
+scripts/generate_schema_*.py

{awslabs_cdk_mcp_server-0.1.0 → awslabs_cdk_mcp_server-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: awslabs.cdk-mcp-server
-Version: 0.1.0
+Version: 0.1.1
 Summary: An AWS CDK MCP server that provides guidance on AWS Cloud Development Kit best practices, infrastructure as code patterns, and security compliance with CDK Nag. This server offers tools to validate infrastructure designs, explain CDK Nag rules, analyze suppressions, generate Bedrock Agent schemas, and discover Solutions Constructs patterns.
 Project-URL: Homepage, https://awslabs.github.io/mcp/
 Project-URL: Documentation, https://awslabs.github.io/mcp/servers/cdk-mcp-server/

{awslabs_cdk_mcp_server-0.1.0 → awslabs_cdk_mcp_server-0.1.1}/awslabs/cdk_mcp_server/data/schema_generator.py

@@ -20,7 +20,8 @@ from typing import Any, Dict, List, Optional, Tuple
 
 def generate_fallback_script(lambda_code_path: str, output_path: str) -> str:
     """Generate a standalone script for schema generation."""
-    return f'''#!/usr/bin/env python3
+    return f'''# pyright: ignore
+#!/usr/bin/env python3
 """
 Schema Generator for Bedrock Agent Action Groups
 

{awslabs_cdk_mcp_server-0.1.0 → awslabs_cdk_mcp_server-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "awslabs.cdk-mcp-server"
-version = "0.1.0"
+version = "0.1.1"
 description = "An AWS CDK MCP server that provides guidance on AWS Cloud Development Kit best practices, infrastructure as code patterns, and security compliance with CDK Nag. This server offers tools to validate infrastructure designs, explain CDK Nag rules, analyze suppressions, generate Bedrock Agent schemas, and discover Solutions Constructs patterns."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -45,6 +45,10 @@ dev = [
     "pre-commit>=4.1.0",
     "ruff>=0.9.7",
     "pyright>=1.1.398",
+    "pytest>=8.0.0",
+    "pytest-cov>=4.1.0",
+    "pytest-mock>=3.12.0",
+    "pytest-asyncio>=0.23.5",
 ]
 
 [build-system]
@@ -107,3 +111,24 @@ packages = ["awslabs"]
 
 [tool.bandit]
 exclude_dirs = ["venv","tests"]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra -q --cov=awslabs.cdk_mcp_server --cov-report=term-missing"
+testpaths = [
+    "tests",
+]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore::UserWarning",
+]
+asyncio_mode = "auto"
+
+[tool.pyright]
+ignore = ["scripts/generate_schema_*.py"]
+
+[tool.coverage.run]
+source = ["awslabs"]

awslabs_cdk_mcp_server-0.1.1/tests/__init__.py

@@ -0,0 +1,10 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+# with the License. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.

awslabs_cdk_mcp_server-0.1.1/tests/core/test_resources.py

@@ -0,0 +1,190 @@
+import pytest
+from awslabs.cdk_mcp_server.core.resources import (
+    RulePack,
+    get_all_cdk_nag_rules,
+    get_available_sections_resource,
+    get_cdk_nag_errors,
+    get_cdk_nag_warnings,
+    get_genai_cdk_construct_nested_section_resource,
+    get_genai_cdk_construct_resource,
+    get_genai_cdk_construct_section_resource,
+    get_genai_cdk_overview_resource,
+    get_lambda_powertools_guidance,
+    get_lambda_powertools_index,
+    get_solutions_construct_pattern_resource,
+)
+from unittest.mock import patch
+
+
+@pytest.mark.asyncio
+async def test_get_all_cdk_nag_rules():
+    """Test getting all CDK Nag rules for a rule pack."""
+    with patch('awslabs.cdk_mcp_server.core.resources.get_rule_pack') as mock_get_rule_pack:
+        mock_get_rule_pack.return_value = 'Test rule pack content'
+
+        # Test with valid rule pack
+        result = await get_all_cdk_nag_rules(RulePack.AWS_SOLUTIONS.value)
+        assert result == 'Test rule pack content'
+        mock_get_rule_pack.assert_called_once_with(RulePack.AWS_SOLUTIONS)
+
+        # Test with invalid rule pack
+        result = await get_all_cdk_nag_rules('Invalid Pack')
+        assert 'Invalid rule pack' in result
+        assert RulePack.AWS_SOLUTIONS.value in result
+
+
+@pytest.mark.asyncio
+async def test_get_cdk_nag_warnings():
+    """Test getting CDK Nag warnings for a rule pack."""
+    with patch('awslabs.cdk_mcp_server.core.resources.get_warnings') as mock_get_warnings:
+        mock_get_warnings.return_value = 'Test warnings content'
+
+        # Test with valid rule pack
+        result = await get_cdk_nag_warnings(RulePack.AWS_SOLUTIONS.value)
+        assert result == 'Test warnings content'
+        mock_get_warnings.assert_called_once_with(RulePack.AWS_SOLUTIONS)
+
+        # Test with invalid rule pack
+        result = await get_cdk_nag_warnings('Invalid Pack')
+        assert 'Invalid rule pack' in result
+        assert RulePack.AWS_SOLUTIONS.value in result
+
+
+@pytest.mark.asyncio
+async def test_get_cdk_nag_errors():
+    """Test getting CDK Nag errors for a rule pack."""
+    with patch('awslabs.cdk_mcp_server.core.resources.get_errors') as mock_get_errors:
+        mock_get_errors.return_value = 'Test errors content'
+
+        # Test with valid rule pack
+        result = await get_cdk_nag_errors(RulePack.AWS_SOLUTIONS.value)
+        assert result == 'Test errors content'
+        mock_get_errors.assert_called_once_with(RulePack.AWS_SOLUTIONS)
+
+        # Test with invalid rule pack
+        result = await get_cdk_nag_errors('Invalid Pack')
+        assert 'Invalid rule pack' in result
+        assert RulePack.AWS_SOLUTIONS.value in result
+
+
+@pytest.mark.asyncio
+async def test_get_lambda_powertools_guidance():
+    """Test getting Lambda Powertools guidance."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_lambda_powertools_section'
+    ) as mock_get_section:
+        mock_get_section.return_value = 'Test guidance content'
+
+        # Test with specific topic
+        result = await get_lambda_powertools_guidance('logging')
+        assert result == 'Test guidance content'
+        mock_get_section.assert_called_once_with('logging')
+
+        # Test with empty topic
+        result = await get_lambda_powertools_guidance()
+        assert result == 'Test guidance content'
+        mock_get_section.assert_called_with('')
+
+
+@pytest.mark.asyncio
+async def test_get_lambda_powertools_index():
+    """Test getting Lambda Powertools index."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_lambda_powertools_section'
+    ) as mock_get_section:
+        mock_get_section.return_value = 'Test index content'
+
+        result = await get_lambda_powertools_index()
+        assert result == 'Test index content'
+        mock_get_section.assert_called_once_with('index')
+
+
+@pytest.mark.asyncio
+async def test_get_solutions_construct_pattern_resource():
+    """Test getting Solutions Construct pattern resource."""
+    with patch('awslabs.cdk_mcp_server.core.resources.get_pattern_raw') as mock_get_pattern:
+        # Test with valid pattern
+        mock_get_pattern.return_value = {'content': 'Test pattern content'}
+        result = await get_solutions_construct_pattern_resource('aws-lambda-dynamodb')
+        assert result == 'Test pattern content'
+        mock_get_pattern.assert_called_once_with('aws-lambda-dynamodb')
+
+        # Test with invalid pattern
+        mock_get_pattern.return_value = {'error': 'Pattern not found'}
+        with patch('awslabs.cdk_mcp_server.data.solutions_constructs_parser') as mock_fetch_list:
+            mock_fetch_list.return_value = ['pattern1', 'pattern2']
+            result = await get_solutions_construct_pattern_resource('invalid-pattern')
+            assert "Pattern 'invalid-pattern' not found" in result
+
+
+@pytest.mark.asyncio
+async def test_get_genai_cdk_construct_section_resource():
+    """Test getting GenAI CDK construct section resource."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_genai_cdk_construct_section'
+    ) as mock_get_section:
+        mock_get_section.return_value = 'Test section content'
+
+        result = await get_genai_cdk_construct_section_resource('bedrock', 'agent', 'actiongroups')
+        assert result == 'Test section content'
+        mock_get_section.assert_called_once_with('bedrock', 'agent', 'actiongroups')
+
+
+@pytest.mark.asyncio
+async def test_get_genai_cdk_construct_nested_section_resource():
+    """Test getting GenAI CDK construct nested section resource."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_genai_cdk_construct_section'
+    ) as mock_get_section:
+        mock_get_section.return_value = 'Test nested section content'
+
+        result = await get_genai_cdk_construct_nested_section_resource(
+            'bedrock', 'knowledgebases', 'vector', 'opensearch'
+        )
+        assert result == 'Test nested section content'
+        mock_get_section.assert_called_once_with('bedrock', 'knowledgebases', 'vector/opensearch')
+
+
+@pytest.mark.asyncio
+async def test_get_available_sections_resource():
+    """Test getting available sections resource."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.list_available_sections'
+    ) as mock_list_sections:
+        # Test with sections available
+        mock_list_sections.return_value = ['section1', 'section2']
+        result = await get_available_sections_resource('bedrock', 'agent')
+        assert 'Available Sections for Agent in Bedrock' in result
+        assert 'section1' in result
+        assert 'section2' in result
+
+        # Test with no sections
+        mock_list_sections.return_value = []
+        result = await get_available_sections_resource('bedrock', 'agent')
+        assert 'No sections found' in result
+
+
+@pytest.mark.asyncio
+async def test_get_genai_cdk_construct_resource():
+    """Test getting GenAI CDK construct resource."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_genai_cdk_construct'
+    ) as mock_get_construct:
+        mock_get_construct.return_value = 'Test construct content'
+
+        result = await get_genai_cdk_construct_resource('bedrock', 'Agent')
+        assert result == 'Test construct content'
+        mock_get_construct.assert_called_once_with('bedrock', 'Agent')
+
+
+@pytest.mark.asyncio
+async def test_get_genai_cdk_overview_resource():
+    """Test getting GenAI CDK overview resource."""
+    with patch(
+        'awslabs.cdk_mcp_server.core.resources.get_genai_cdk_overview'
+    ) as mock_get_overview:
+        mock_get_overview.return_value = 'Test overview content'
+
+        result = await get_genai_cdk_overview_resource('bedrock')
+        assert result == 'Test overview content'
+        mock_get_overview.assert_called_once_with('bedrock')

awslabs_cdk_mcp_server-0.1.1/tests/core/test_search_utils.py

@@ -0,0 +1,77 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+# with the License. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+from awslabs.cdk_mcp_server.core import search_utils
+
+
+def test_normalize_term():
+    """Test term normalization."""
+    assert search_utils.normalize_term('Test-Term') == 'test term'
+    assert search_utils.normalize_term('Test_Term') == 'test term'
+    assert search_utils.normalize_term('Test Term') == 'test term'
+    assert search_utils.normalize_term('Test%20Term') == 'test term'
+
+
+def test_get_term_variations():
+    """Test getting term variations."""
+    variations = search_utils.get_term_variations('knowledgebase')
+    assert 'knowledgebases' in variations
+    assert 'knowledge-base' in variations
+    assert 'knowledge-bases' in variations
+
+    variations = search_utils.get_term_variations('agent')
+    assert 'agents' in variations
+
+    variations = search_utils.get_term_variations('actiongroup')
+    assert 'actiongroups' in variations
+    assert 'action-group' in variations
+    assert 'action-groups' in variations
+
+
+def test_expand_search_terms():
+    """Test expanding search terms."""
+    terms = ['knowledgebase', 'agent']
+    expanded = search_utils.expand_search_terms(terms)
+    assert 'knowledgebase' in expanded
+    assert 'knowledgebases' in expanded
+    assert 'agent' in expanded
+    assert 'agents' in expanded
+
+
+def test_calculate_match_score():
+    """Test calculating match score."""
+    item_text = 'This is a test item with some content'
+    search_terms = ['test', 'content']
+    name_parts = ['TestItem']
+
+    result = search_utils.calculate_match_score(item_text, search_terms, name_parts)
+    assert result['score'] > 0
+    assert len(result['matched_terms']) > 0
+    assert result['has_match'] is True
+
+
+def test_search_items_with_terms():
+    """Test searching items with terms."""
+    items = [
+        {'name': 'TestItem1', 'description': 'This is a test item'},
+        {'name': 'TestItem2', 'description': 'This is another test item'},
+    ]
+
+    def get_text_fn(item):
+        return item['description']
+
+    def get_name_parts_fn(item):
+        return [item['name']]
+
+    results = search_utils.search_items_with_terms(items, ['test'], get_text_fn, get_name_parts_fn)
+
+    assert len(results) == 2
+    assert results[0]['score'] >= results[1]['score']
+    assert 'test' in results[0]['matched_terms']

awslabs_cdk_mcp_server-0.1.1/tests/core/test_server.py

@@ -0,0 +1,55 @@
+import pytest
+from awslabs.cdk_mcp_server.core.server import main, mcp
+from unittest.mock import patch
+
+
+def test_mcp_server_initialization():
+    """Test MCP server initialization."""
+    # Check server name
+    assert mcp.name == 'AWS CDK MCP Server'
+
+    # Check dependencies
+    assert 'pydantic' in mcp.dependencies
+    assert 'aws-lambda-powertools' in mcp.dependencies
+    assert 'httpx' in mcp.dependencies
+
+
+@pytest.mark.asyncio
+async def test_mcp_server_tool_registration():
+    """Test MCP server tool registration."""
+    # Get all registered tools
+    tools = await mcp.list_tools()
+
+    # Check CDK tools
+    assert any(t.name == 'CDKGeneralGuidance' for t in tools)
+    assert any(t.name == 'ExplainCDKNagRule' for t in tools)
+    assert any(t.name == 'CheckCDKNagSuppressions' for t in tools)
+
+    # Check Bedrock tools
+    assert any(t.name == 'GenerateBedrockAgentSchema' for t in tools)
+
+    # Check Solutions Constructs tools
+    assert any(t.name == 'GetAwsSolutionsConstructPattern' for t in tools)
+
+    # Check GenAI CDK Constructs tools
+    assert any(t.name == 'SearchGenAICDKConstructs' for t in tools)
+
+    # Check Lambda tools
+    assert any(t.name == 'LambdaLayerDocumentationProvider' for t in tools)
+
+
+@patch('awslabs.cdk_mcp_server.core.server.mcp.run')
+def test_main_with_default_args(mock_run):
+    """Test main function with default arguments."""
+    with patch('sys.argv', ['server.py']):
+        main()
+        mock_run.assert_called_once_with()
+
+
+@patch('awslabs.cdk_mcp_server.core.server.mcp.run')
+def test_main_with_sse_args(mock_run):
+    """Test main function with SSE transport arguments."""
+    with patch('sys.argv', ['server.py', '--sse', '--port', '9999']):
+        main()
+        assert mcp.settings.port == 9999
+        mock_run.assert_called_once_with(transport='sse')

awslabs_cdk_mcp_server-0.1.1/tests/core/test_tools.py

@@ -0,0 +1,153 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
+# with the License. A copy of the License is located at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# or in the 'license' file accompanying this file. This file is distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES
+# OR CONDITIONS OF ANY KIND, express or implied. See the License for the specific language governing permissions
+# and limitations under the License.
+import pytest
+from awslabs.cdk_mcp_server.core.tools import (
+    bedrock_schema_generator_from_file,
+    cdk_guidance,
+    check_cdk_nag_suppressions_tool,
+    explain_cdk_nag_rule,
+    get_aws_solutions_construct_pattern,
+    lambda_layer_documentation_provider,
+    search_genai_cdk_constructs,
+)
+from unittest.mock import MagicMock
+
+
+@pytest.fixture
+def mock_context():
+    """Fixture that provides a mocked MCP context."""
+    context = MagicMock()
+    context.settings = MagicMock()
+    return context
+
+
+@pytest.mark.asyncio
+async def test_cdk_guidance(mock_context):
+    """Test CDK guidance tool."""
+    result = await cdk_guidance(mock_context)
+    assert isinstance(result, str)
+    assert len(result) > 0
+
+
+@pytest.mark.asyncio
+async def test_explain_cdk_nag_rule(mock_context):
+    """Test CDK Nag rule explanation tool."""
+    result = await explain_cdk_nag_rule(mock_context, rule_id='AwsSolutions-APIG3')
+    assert isinstance(result, dict)
+    assert 'rule_id' in result
+    assert 'content' in result
+    assert 'source' in result
+    assert 'status' in result
+    assert result['rule_id'] == 'AwsSolutions-APIG3'
+    assert result['source'] == 'https://github.com/cdklabs/cdk-nag/blob/main/RULES.md'
+    assert result['status'] == 'success'
+
+
+@pytest.mark.asyncio
+async def test_check_cdk_nag_suppressions_tool(mock_context):
+    """Test CDK Nag suppressions check tool."""
+    result = await check_cdk_nag_suppressions_tool(mock_context, code='test code')
+    assert isinstance(result, dict)
+    assert 'has_suppressions' in result
+    assert 'message' in result
+    assert 'status' in result
+
+
+@pytest.mark.asyncio
+async def test_bedrock_schema_generator_from_file_throws_error(mock_context):
+    """Test Bedrock schema generator tool."""
+    with pytest.raises(Exception):
+        await bedrock_schema_generator_from_file(
+            mock_context,
+            lambda_code_path='test.py',  # non existing path
+            output_path='test.json',  # non existing path
+        )
+
+
+@pytest.mark.asyncio
+async def test_get_aws_solutions_construct_pattern(mock_context):
+    """Test AWS Solutions Construct pattern tool."""
+    result = await get_aws_solutions_construct_pattern(mock_context, pattern_name='aws-alb-lambda')
+    assert isinstance(result, dict)
+    assert 'description' in result
+    assert 'use_cases' in result
+    assert 'services' in result
+    assert 'documentation_uri' in result
+    assert result['pattern_name'] == 'aws-alb-lambda'
+    assert result['services'] == ['Application Load Balancer', 'Lambda']
+    assert (
+        result['description']
+        == 'This AWS Solutions Construct implements an an Application Load Balancer to an AWS Lambda function'
+    )
+    assert result['documentation_uri'] == 'aws-solutions-constructs://aws-alb-lambda'
+
+
+@pytest.mark.asyncio
+async def test_search_genai_cdk_constructs(mock_context):
+    """Test GenAI CDK constructs search tool."""
+    result = await search_genai_cdk_constructs(mock_context, query='knowledge base')
+    assert isinstance(result, dict)
+    assert 'count' in result
+    assert 'results' in result
+    assert 'status' in result
+    assert 'installation_required' in result
+    assert result['status'] == 'success'
+    assert (
+        result['installation_required']['package_name'] == '@cdklabs/generative-ai-cdk-constructs'
+    )
+    assert (
+        result['installation_required']['message']
+        == 'This construct requires the @cdklabs/generative-ai-cdk-constructs package to be installed'
+    )
+
+
+@pytest.mark.asyncio
+async def test_lambda_layer_documentation_provider_generic(mock_context):
+    """Test Lambda layer documentation provider tool."""
+    result = await lambda_layer_documentation_provider(mock_context, layer_type='generic')
+    assert isinstance(result, dict)
+    assert 'code_examples' in result
+    assert 'directory_structure' in result
+    assert 'source_url' in result
+    assert 'layer_type' in result
+    assert result['layer_type'] == 'generic'
+
+
+@pytest.mark.asyncio
+async def test_lambda_layer_documentation_provider_python(mock_context):
+    """Test Lambda layer documentation provider tool."""
+    result = await lambda_layer_documentation_provider(mock_context, layer_type='python')
+    assert isinstance(result, dict)
+    assert 'layer_type' in result
+    assert 'documentation_source' in result
+    assert 'documentation_usage_guide' in result
+    assert 'code_generation_guidance' in result
+    assert result['layer_type'] == 'python'
+    assert result['documentation_source']['server'] == 'awslabs.aws-documentation-mcp-server'
+    assert result['documentation_source']['tool'] == 'read_documentation'
+    assert result['documentation_source']['parameters']['max_length'] == 10000
+    assert (
+        result['documentation_usage_guide']['when_to_fetch_full_docs']
+        == 'Fetch full documentation to view detailed property definitions, learn about optional parameters, and find additional code examples'
+    )
+    assert result['documentation_usage_guide']['contains_sample_code'] == True  # noqa: E712
+    assert result['documentation_usage_guide']['contains_props_documentation'] == True  # noqa: E712
+    assert result['code_generation_guidance']['imports'] == [
+        "import { PythonLayerVersion } from '@aws-cdk/aws-lambda-python-alpha'"
+    ]
+    assert result['code_generation_guidance']['construct_types'] == {
+        'python': 'PythonLayerVersion'
+    }
+    assert result['code_generation_guidance']['required_properties'] == {'python': ['entry']}
+    assert (
+        result['code_generation_guidance']['sample_code']
+        == "new python.PythonLayerVersion(this, 'MyLayer', {\n  entry: '/path/to/my/layer', // point this to your library's directory\n})"
+    )