feat: Add get-domain, get-domains tool (#40)

* feat(identity): Add get-domain, get-domains(#31)

- Change response/keystone.py -> response/identity
- Add get-domain, get-domains tool

* feat(identity): Register tool(#31)

Author: S0okJu

src/openstack_mcp_server/tools/identity_tools.py

@@ -1,7 +1,7 @@
 from fastmcp import FastMCP
 
 from .base import get_openstack_conn
-from .response.keystone import Region
+from .response.identity import Region, Domain
 
 
 class IdentityTools:
@@ -19,6 +19,9 @@ def register_tools(self, mcp: FastMCP):
         mcp.tool()(self.create_region)
         mcp.tool()(self.delete_region)
         mcp.tool()(self.update_region)
+        
+        mcp.tool()(self.get_domains)
+        mcp.tool()(self.get_domain)
 
     def get_regions(self) -> list[Region]:
         """
@@ -100,3 +103,33 @@ def update_region(self, id: str, description: str = "") -> Region:
             id=updated_region.id,
             description=updated_region.description,
         )
+        
+    def get_domains(self) -> list[Domain]:
+        """
+        Get the list of Identity domains.
+
+        :return: A list of Domain objects representing the domains.
+        """
+        conn = get_openstack_conn()
+
+        domain_list = []
+        for domain in conn.identity.domains():
+            domain_list.append(
+                Domain(id=domain.id, name=domain.name, description=domain.description, is_enabled=domain.is_enabled),
+            )
+        return domain_list
+
+    def get_domain(self, id: str) -> Domain:
+        """
+        Get a domain.
+
+        :param id: The ID of the domain. (required)
+
+        :return: The Domain object.
+        """
+        conn = get_openstack_conn()
+        
+        domain = conn.identity.get_domain(domain=id)
+
+        return Domain(id=domain.id, name=domain.name, description=domain.description, is_enabled=domain.is_enabled)
+    

src/openstack_mcp_server/tools/response/keystone.py renamed to src/openstack_mcp_server/tools/response/identity.py

@@ -6,3 +6,9 @@
 class Region(BaseModel):
     id: str
     description: str = ""
+
+class Domain(BaseModel):
+    id: str
+    name: str
+    description: str = ""
+    is_enabled: bool = False

tests/tools/test_identity_tools.py

@@ -4,7 +4,8 @@
 
 from openstack import exceptions
 
-from openstack_mcp_server.tools.identity_tools import IdentityTools, Region
+from openstack_mcp_server.tools.identity_tools import IdentityTools
+from openstack_mcp_server.tools.response.identity import Region, Domain
 
 
 class TestIdentityTools:
@@ -334,3 +335,96 @@ def test_get_region_not_found(self, mock_get_openstack_conn_identity):
         mock_conn.identity.get_region.assert_called_once_with(
             region="RegionOne",
         )
+        
+    def test_get_domains_success(self, mock_get_openstack_conn_identity):
+        """Test getting identity domains successfully."""
+        mock_conn = mock_get_openstack_conn_identity
+
+        # Create mock domain objects
+        mock_domain1 = Mock()
+        mock_domain1.id = "domainone"
+        mock_domain1.name = "DomainOne"
+        mock_domain1.description = "Domain One description"
+        mock_domain1.is_enabled = True
+
+        mock_domain2 = Mock()
+        mock_domain2.id = "domaintwo"
+        mock_domain2.name = "DomainTwo"
+        mock_domain2.description = "Domain Two description"
+        mock_domain2.is_enabled = False
+        
+        # Configure mock domain.domains()
+        mock_conn.identity.domains.return_value = [mock_domain1, mock_domain2]
+
+        # Test get_domains()
+        identity_tools = self.get_identity_tools()
+        result = identity_tools.get_domains()
+        
+        # Verify results
+        assert result == [
+            Domain(id="domainone", name="DomainOne", description="Domain One description", is_enabled=True),
+            Domain(id="domaintwo", name="DomainTwo", description="Domain Two description", is_enabled=False),
+        ]
+
+        # Verify mock calls
+        mock_conn.identity.domains.assert_called_once()
+
+    def test_get_domains_empty_list(self, mock_get_openstack_conn_identity):
+        """Test getting identity domains when there are no domains."""
+        mock_conn = mock_get_openstack_conn_identity
+        
+        # Empty domain list
+        mock_conn.identity.domains.return_value = []
+
+        # Test get_domains()
+        identity_tools = self.get_identity_tools()
+        result = identity_tools.get_domains()
+        
+        # Verify results
+        assert result == []
+        
+        # Verify mock calls
+        mock_conn.identity.domains.assert_called_once()
+
+    def test_get_domain_success(self, mock_get_openstack_conn_identity):
+        """Test getting a identity domain successfully."""
+        mock_conn = mock_get_openstack_conn_identity
+
+        # Create mock domain object
+        mock_domain = Mock()
+        mock_domain.id = "domainone"
+        mock_domain.name = "DomainOne"
+        mock_domain.description = "Domain One description"
+        mock_domain.is_enabled = True
+        
+        # Configure mock domain.get_domain()
+        mock_conn.identity.get_domain.return_value = mock_domain
+        
+        # Test get_domain()
+        identity_tools = self.get_identity_tools()
+        result = identity_tools.get_domain(id="domainone")
+        
+        # Verify results
+        assert result == Domain(id="domainone", name="DomainOne", description="Domain One description", is_enabled=True)
+        
+        # Verify mock calls
+        mock_conn.identity.get_domain.assert_called_once_with(domain="domainone")
+        
+    def test_get_domain_not_found(self, mock_get_openstack_conn_identity):
+        """Test getting a identity domain that does not exist."""
+        mock_conn = mock_get_openstack_conn_identity
+
+        # Configure mock to raise NotFoundException
+        mock_conn.identity.get_domain.side_effect = exceptions.NotFoundException(
+            "Domain 'domainone' not found",
+        )
+        
+        # Test get_domain()
+        identity_tools = self.get_identity_tools()
+        
+        # Verify exception is raised
+        with pytest.raises(exceptions.NotFoundException, match="Domain 'domainone' not found"):
+            identity_tools.get_domain(id="domainone")
+        
+        # Verify mock calls
+        mock_conn.identity.get_domain.assert_called_once_with(domain="domainone")