feat: add get images (#20)

Author: jja6312

src/openstack_mcp_server/prompts/__init__.py

@@ -0,0 +1,14 @@
+from fastmcp import FastMCP
+
+
+def register_prompt(mcp: FastMCP):
+    """
+    Register OpenStack MCP prompts.
+    """
+
+    # Add image tools prompt
+    mcp.add_prompt(
+        "image_tools",
+        "ImageTools Usage Guide - Only use parameters that the user explicitly requests",
+        "prompts/image_tools_prompt.md",
+    )

src/openstack_mcp_server/prompts/image_tools_prompt.md

@@ -0,0 +1,49 @@
+# ImageTools Usage Guide
+
+## get_images Method
+
+### Core Principles
+- **Only use parameters that the user explicitly requests**
+- **Do NOT add default values or assume values for parameters not mentioned**
+- **Leave parameters as null if the user doesn't specify them**
+
+### Usage Examples
+
+#### 1. "Show me public images"
+```json
+{
+  "visibility": "public"
+}
+```
+- `status` and `name` are not set (null)
+
+#### 2. "Show me active status images"  
+```json
+{
+  "status": "active"
+}
+```
+- `visibility` and `name` are not set (null)
+
+#### 3. "Show me ubuntu images"
+```json
+{
+  "name": "ubuntu"
+}
+```
+- `status` and `visibility` are not set (null)
+
+#### 4. "Show me public active images"
+```json
+{
+  "visibility": "public",
+  "status": "active"
+}
+```
+- `name` is not set (null)
+
+### Important Notes
+- If user asks for "public images only", do NOT automatically set `status` to "active"
+- If user asks for "list of images", leave all parameters as null
+- When in doubt, ask the user for clarification rather than making assumptions
+- Always respect the user's explicit requests and avoid adding unrequested filters

src/openstack_mcp_server/tools/image_tools.py

@@ -16,26 +16,45 @@ def register_tools(self, mcp: FastMCP):
         Register Image-related tools with the FastMCP instance.
         """
 
-        mcp.tool()(self.get_image_images)
+        mcp.tool()(self.get_images)
         mcp.tool()(self.create_image)
 
-    def get_image_images(self) -> str:
+    def get_images(
+        self,
+        name: str | None = None,
+        status: str | None = None,
+        visibility: str | None = None,
+    ) -> list[Image]:
         """
-        Get the list of Image images by invoking the registered tool.
+        Get the list of OpenStack images with optional filtering.
 
-        :return: A string containing the names, IDs, and statuses of the images.
+        Prompt:
+            See prompts/image_tools_prompt.md for detailed usage examples.
+
+        Args:
+            name: Filter by image name
+            status: Filter by status (e.g., 'active', 'queued', 'killed')
+            visibility: Filter by visibility (e.g., 'public', 'private', 'shared')
+
+        Returns:
+            A list of Image objects.
         """
-        # Initialize connection
         conn = get_openstack_conn()
 
-        # List the servers
+        # Build filters for the image query
+        filters = {}
+        if name and name.strip():
+            filters["name"] = name.strip()
+        if status and status.strip():
+            filters["status"] = status.strip()
+        if visibility and visibility.strip():
+            filters["visibility"] = visibility.strip()
+
         image_list = []
-        for image in conn.image.images():
-            image_list.append(
-                f"{image.name} ({image.id}) - Status: {image.status}",
-            )
+        for image in conn.image.images(**filters):
+            image_list.append(Image(**image))
 
-        return "\n".join(image_list)
+        return image_list
 
     def create_image(self, image_data: CreateImage) -> Image:
         """Create a new Openstack image.

tests/tools/test_image_tools.py

@@ -2,6 +2,8 @@
 
 from unittest.mock import Mock
 
+import pytest
+
 from openstack_mcp_server.tools.image_tools import ImageTools
 from openstack_mcp_server.tools.request.image import CreateImage
 from openstack_mcp_server.tools.response.image import Image
@@ -46,80 +48,135 @@ def image_factory(**overrides):
 
         return defaults
 
-    def test_get_image_images_success(self, mock_get_openstack_conn_image):
+    def test_get_images_success(self, mock_get_openstack_conn_image):
         """Test getting image images successfully."""
         mock_conn = mock_get_openstack_conn_image
 
-        # Create mock image objects
-        mock_image1 = Mock()
-        mock_image1.name = "ubuntu-20.04-server"
-        mock_image1.id = "img-123-abc-def"
-        mock_image1.status = "active"
+        mock_image1 = self.image_factory(
+            id="img-123-abc-def",
+            name="ubuntu-20.04-server",
+            status="active",
+            visibility="public",
+            checksum="abc123",
+            size=1073741824,
+        )
 
-        mock_image2 = Mock()
-        mock_image2.name = "centos-8-stream"
-        mock_image2.id = "img-456-ghi-jkl"
-        mock_image2.status = "active"
+        mock_image2 = self.image_factory(
+            id="img-456-ghi-jkl",
+            name="centos-8-stream",
+            status="active",
+            visibility="public",
+            checksum="def456",
+            size=2147483648,
+        )
 
-        # Configure mock image.images()
         mock_conn.image.images.return_value = [mock_image1, mock_image2]
 
-        # Test ImageTools
-        image_tools = ImageTools()
-        result = image_tools.get_image_images()
+        result = ImageTools().get_images()
 
-        # Verify results
-        expected_output = (
-            "ubuntu-20.04-server (img-123-abc-def) - Status: active\n"
-            "centos-8-stream (img-456-ghi-jkl) - Status: active"
-        )
+        expected_output = [
+            Image(**mock_image1),
+            Image(**mock_image2),
+        ]
         assert result == expected_output
 
-        # Verify mock calls
         mock_conn.image.images.assert_called_once()
 
-    def test_get_image_images_empty_list(self, mock_get_openstack_conn_image):
+    def test_get_images_empty_list(self, mock_get_openstack_conn_image):
         """Test getting image images when no images exist."""
         mock_conn = mock_get_openstack_conn_image
-
-        # Empty image list
         mock_conn.image.images.return_value = []
 
-        image_tools = ImageTools()
-        result = image_tools.get_image_images()
-
-        # Verify empty string
-        assert result == ""
+        result = ImageTools().get_images()
 
+        assert result == []
         mock_conn.image.images.assert_called_once()
 
-    def test_get_image_images_with_empty_name(
+    @pytest.mark.parametrize(
+        "filter_name,filter_value,expected_count",
+        [
+            ("name", "ubuntu-20.04-server", 1),  # exact name match
+            ("name", "ubuntu", 0),  # partial match not supported
+            ("name", "nonexistent", 0),  # non-existent name
+            ("name", "", 2),  # empty filter value
+            ("name", "   ", 2),  # whitespace only
+            ("status", "active", 2),
+            ("visibility", "public", 2),
+            ("status", "deleted", 0),
+            ("visibility", "private", 0),
+        ],
+    )
+    def test_get_images_with_filters(
         self,
         mock_get_openstack_conn_image,
+        filter_name,
+        filter_value,
+        expected_count,
     ):
-        """Test images with empty or None names."""
+        """Test getting images with various filters."""
         mock_conn = mock_get_openstack_conn_image
 
-        # Images with empty name (edge case)
-        mock_image1 = Mock()
-        mock_image1.name = "normal-image"
-        mock_image1.id = "img-normal"
-        mock_image1.status = "active"
-
-        mock_image2 = Mock()
-        mock_image2.name = ""  # Empty name
-        mock_image2.id = "img-empty-name"
-        mock_image2.status = "active"
-
-        mock_conn.image.images.return_value = [mock_image1, mock_image2]
-
-        image_tools = ImageTools()
-        result = image_tools.get_image_images()
+        mock_image1 = self.image_factory(
+            id="img-123-abc-def",
+            name="ubuntu-20.04-server",
+            status="active",
+            visibility="public",
+            checksum="abc123",
+            size=1073741824,
+        )
 
-        assert "normal-image (img-normal) - Status: active" in result
-        assert " (img-empty-name) - Status: active" in result  # Empty name
+        mock_image2 = self.image_factory(
+            id="img-456-ghi-jkl",
+            name="centos-8-stream",
+            status="active",
+            visibility="public",
+            checksum="def456",
+            size=2147483648,
+        )
 
-        mock_conn.image.images.assert_called_once()
+        if filter_name == "name":
+            if filter_value == "ubuntu-20.04-server":
+                mock_conn.image.images.return_value = [mock_image1]
+            elif filter_value in ["", "   "]:
+                mock_conn.image.images.return_value = [
+                    mock_image1,
+                    mock_image2,
+                ]
+            else:
+                mock_conn.image.images.return_value = []
+        elif filter_name == "status":
+            if filter_value == "active":
+                mock_conn.image.images.return_value = [
+                    mock_image1,
+                    mock_image2,
+                ]
+            else:
+                mock_conn.image.images.return_value = []
+        elif filter_name == "visibility":
+            if filter_value == "public":
+                mock_conn.image.images.return_value = [
+                    mock_image1,
+                    mock_image2,
+                ]
+            else:
+                mock_conn.image.images.return_value = []
+
+        result = ImageTools().get_images(**{filter_name: filter_value})
+
+        if expected_count == 0:
+            assert result == []
+        elif expected_count == 1:
+            assert result == [Image(**mock_image1)]
+        else:
+            assert result == [Image(**mock_image1), Image(**mock_image2)]
+
+        # For empty/whitespace filters, no filter should be applied
+        if filter_value in ["", "   "]:
+            mock_conn.image.images.assert_called_once_with()
+        else:
+            mock_conn.image.images.assert_called_once_with(
+                **{filter_name: filter_value}
+            )
 
     def test_create_image_success_with_volume_id(
         self,