test: Integration tests for toggle and list functionality

Branch: InitialCLI

Signed-off-by: Gabe Goodhart <ghart@us.ibm.com>

Author: gabe-l-hart

tests/commands/resources/test_a2a.py

@@ -362,3 +362,89 @@ def test_a2a_lifecycle(self, mock_console, authorized_mock_client) -> None:
             # Verify it's gone
             with pytest.raises(click.exceptions.Exit):
                 a2a_get(a2a_id)
+
+    def test_a2a_list_active_only_integration(self, mock_console, authorized_mock_client) -> None:
+        """Test --active-only flag filters correctly with real server."""
+        with patch_functions("cforge.commands.resources.a2a", print_json=None, get_console=mock_console) as mocks:
+            # Create an A2A agent
+            a2a_body = {
+                "name": "test-a2a-active",
+                "endpoint_url": "http://test.example.com",
+                "description": "Test A2A for active-only",
+            }
+            with patch("cforge.commands.resources.a2a.prompt_for_schema", return_value=a2a_body):
+                a2a_create(None)
+            a2a_id = mocks.print_json.call_args[0][0]["id"]
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it (starts enabled)
+            a2a_list(active_only=True, json_output=True)
+            active_agents = mocks.print_json.call_args[0][0]
+            assert any(a["id"] == a2a_id for a in active_agents)
+            mocks.print_json.reset_mock()
+
+            # Disable the A2A agent
+            a2a_toggle(agent_id=a2a_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should NOT include it now
+            a2a_list(active_only=True, json_output=True)
+            active_agents = mocks.print_json.call_args[0][0]
+            assert not any(a["id"] == a2a_id for a in active_agents)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=False should still include it
+            a2a_list(active_only=False, json_output=True)
+            all_agents = mocks.print_json.call_args[0][0]
+            assert any(a["id"] == a2a_id for a in all_agents)
+            mocks.print_json.reset_mock()
+
+            # Re-enable the A2A agent
+            a2a_toggle(agent_id=a2a_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it again
+            a2a_list(active_only=True, json_output=True)
+            active_agents = mocks.print_json.call_args[0][0]
+            assert any(a["id"] == a2a_id for a in active_agents)
+
+            # Clean up
+            a2a_delete(a2a_id, confirm=True)
+
+    def test_a2a_toggle_status_detection_integration(self, mock_console, authorized_mock_client) -> None:
+        """Test toggle command detects current status correctly with real server."""
+        with patch_functions("cforge.commands.resources.a2a", print_json=None, get_console=mock_console) as mocks:
+            # Create an A2A agent
+            a2a_body = {
+                "name": "test-a2a-toggle",
+                "endpoint_url": "http://test-toggle.example.com",
+                "description": "Test A2A for toggle detection",
+            }
+            with patch("cforge.commands.resources.a2a.prompt_for_schema", return_value=a2a_body):
+                a2a_create(None)
+            a2a_id = mocks.print_json.call_args[0][0]["id"]
+            initial_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert initial_status is True, "New A2A agent should start enabled"
+            mocks.print_json.reset_mock()
+
+            # Toggle (should detect enabled and switch to disabled)
+            a2a_toggle(agent_id=a2a_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed by getting it
+            a2a_get(a2a_id)
+            current_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert current_status is False, "A2A agent should now be disabled"
+            mocks.print_json.reset_mock()
+
+            # Toggle again (should detect disabled and switch to enabled)
+            a2a_toggle(agent_id=a2a_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed back
+            a2a_get(a2a_id)
+            final_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert final_status is True, "A2A agent should be enabled again"
+
+            # Clean up
+            a2a_delete(a2a_id, confirm=True)

tests/commands/resources/test_mcp_servers.py

@@ -347,3 +347,83 @@ def test_mcp_servers_lifecycle(self, mock_console, authorized_mock_client, mock_
             # Verify it's gone
             with pytest.raises(click.exceptions.Exit):
                 mcp_servers_get(mcp_server_id)
+
+    def test_mcp_servers_list_active_only_integration(self, mock_console, authorized_mock_client, mock_mcp_server) -> None:
+        """Test --active-only flag filters correctly with real server."""
+        with patch_functions("cforge.commands.resources.mcp_servers", print_json=None) as mocks:
+            # Create a new MCP Server
+            with patch("cforge.commands.resources.mcp_servers.prompt_for_schema", return_value=mock_mcp_server):
+                mcp_servers_create(None)
+            mcp_server_id = mocks.print_json.call_args[0][0]["id"]
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it (starts enabled)
+            mcp_servers_list(active_only=True, json_output=True)
+            active_servers = mocks.print_json.call_args[0][0]
+            assert any(s["id"] == mcp_server_id for s in active_servers), "Enabled server should appear in active-only list"
+            mocks.print_json.reset_mock()
+
+            # Disable it
+            mcp_servers_toggle(mcp_server_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should NOT include it
+            mcp_servers_list(active_only=True, json_output=True)
+            active_servers = mocks.print_json.call_args[0][0]
+            assert not any(s["id"] == mcp_server_id for s in active_servers), "Disabled server should NOT appear in active-only list"
+            mocks.print_json.reset_mock()
+
+            # List with active_only=False should include it
+            mcp_servers_list(active_only=False, json_output=True)
+            all_servers = mocks.print_json.call_args[0][0]
+            assert any(s["id"] == mcp_server_id for s in all_servers), "Disabled server should appear in full list"
+            mocks.print_json.reset_mock()
+
+            # Re-enable it
+            mcp_servers_toggle(mcp_server_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it again
+            mcp_servers_list(active_only=True, json_output=True)
+            active_servers = mocks.print_json.call_args[0][0]
+            assert any(s["id"] == mcp_server_id for s in active_servers), "Re-enabled server should appear in active-only list"
+
+            # Cleanup
+            mcp_servers_delete(mcp_server_id)
+
+    def test_mcp_servers_toggle_status_detection_integration(self, mock_console, authorized_mock_client, mock_mcp_server) -> None:
+        """Test toggle command detects current status correctly with real server."""
+        with patch_functions("cforge.commands.resources.mcp_servers", print_json=None, get_console=mock_console) as mocks:
+            # Create a new MCP Server (starts enabled)
+            with patch("cforge.commands.resources.mcp_servers.prompt_for_schema", return_value=mock_mcp_server):
+                mcp_servers_create(None)
+            mcp_server_id = mocks.print_json.call_args[0][0]["id"]
+            mocks.print_json.reset_mock()
+
+            # Get initial status (should be enabled)
+            mcp_servers_get(mcp_server_id)
+            initial_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert initial_status is True, "New server should start enabled"
+            mocks.print_json.reset_mock()
+
+            # Toggle (should detect enabled and switch to disabled)
+            mcp_servers_toggle(mcp_server_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed by getting it again
+            mcp_servers_get(mcp_server_id)
+            current_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert current_status is False, "Server should now be disabled"
+            mocks.print_json.reset_mock()
+
+            # Toggle again (should detect disabled and switch to enabled)
+            mcp_servers_toggle(mcp_server_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed back
+            mcp_servers_get(mcp_server_id)
+            final_status = mocks.print_json.call_args[0][0]["enabled"]
+            assert final_status is True, "Server should be enabled again"
+
+            # Cleanup
+            mcp_servers_delete(mcp_server_id)

tests/commands/resources/test_prompts.py

@@ -383,3 +383,76 @@ def test_prompts_lifecycle(self, mock_console, authorized_mock_client) -> None:
             # Make sure it's gone
             with pytest.raises(click.exceptions.Exit):
                 prompts_get(prompt_id)
+
+    def test_prompts_list_active_only_integration(self, mock_console, registered_mcp_server) -> None:
+        """Test --active-only flag filters correctly with real server."""
+        with patch_functions("cforge.commands.resources.prompts", print_json=None, get_console=mock_console) as mocks:
+            # Get the prompts from the registered server
+            prompts_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_prompts = mocks.print_json.call_args[0][0]
+            assert len(all_prompts) >= 1, "Should have at least one prompt from registered server"
+            prompt_id = all_prompts[0]["id"]
+            mocks.print_json.reset_mock()
+
+            # Verify it starts enabled (prompts from MCP servers start enabled)
+            prompts_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_prompts = mocks.print_json.call_args[0][0]
+            assert any(p["id"] == prompt_id for p in active_prompts), "Prompt should start in active-only list"
+            mocks.print_json.reset_mock()
+
+            # Disable it
+            prompts_toggle(prompt_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should NOT include it
+            prompts_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_prompts = mocks.print_json.call_args[0][0]
+            assert not any(p["id"] == prompt_id for p in active_prompts), "Disabled prompt should NOT appear in active-only list"
+            mocks.print_json.reset_mock()
+
+            # List with active_only=False should include it
+            prompts_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_prompts = mocks.print_json.call_args[0][0]
+            assert any(p["id"] == prompt_id for p in all_prompts), "Disabled prompt should appear in full list"
+            mocks.print_json.reset_mock()
+
+            # Re-enable it
+            prompts_toggle(prompt_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it again
+            prompts_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_prompts = mocks.print_json.call_args[0][0]
+            assert any(p["id"] == prompt_id for p in active_prompts), "Re-enabled prompt should appear in active-only list"
+
+    def test_prompts_toggle_status_detection_integration(self, mock_console, registered_mcp_server) -> None:
+        """Test toggle command detects current status correctly with real server."""
+        with patch_functions("cforge.commands.resources.prompts", print_json=None, get_console=mock_console) as mocks:
+            # Get a prompt from the registered server
+            prompts_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_prompts = mocks.print_json.call_args[0][0]
+            prompt_id = all_prompts[0]["id"]
+            initial_status = all_prompts[0]["isActive"]
+            assert initial_status is True, "Prompt from MCP server should start active"
+            mocks.print_json.reset_mock()
+
+            # Toggle (should detect active and switch to inactive)
+            prompts_toggle(prompt_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed by listing again
+            prompts_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_prompts = mocks.print_json.call_args[0][0]
+            prompt = [p for p in all_prompts if p["id"] == prompt_id][0]
+            assert prompt["isActive"] is False, "Prompt should now be inactive"
+            mocks.print_json.reset_mock()
+
+            # Toggle again (should detect inactive and switch to active)
+            prompts_toggle(prompt_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed back
+            prompts_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_prompts = mocks.print_json.call_args[0][0]
+            prompt = [p for p in all_prompts if p["id"] == prompt_id][0]
+            assert prompt["isActive"] is True, "Prompt should be active again"

tests/commands/resources/test_resources.py

@@ -416,3 +416,76 @@ def test_resources_lifecycle(self, mock_console, authorized_mock_client) -> None
             # Make sure it's gone
             with pytest.raises(click.exceptions.Exit):
                 resources_get(resource_id)
+
+    def test_resources_list_active_only_integration(self, mock_console, registered_mcp_server) -> None:
+        """Test --active-only flag filters correctly with real server."""
+        with patch_functions("cforge.commands.resources.resources", print_json=None, get_console=mock_console) as mocks:
+            # Get the resources from the registered server
+            resources_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_resources = mocks.print_json.call_args[0][0]
+            assert len(all_resources) >= 1, "Should have at least one resource from registered server"
+            resource_id = all_resources[0]["id"]
+            mocks.print_json.reset_mock()
+
+            # Verify it starts enabled (resources from MCP servers start enabled)
+            resources_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_resources = mocks.print_json.call_args[0][0]
+            assert any(r["id"] == resource_id for r in active_resources), "Resource should start in active-only list"
+            mocks.print_json.reset_mock()
+
+            # Disable it
+            resources_toggle(resource_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should NOT include it
+            resources_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_resources = mocks.print_json.call_args[0][0]
+            assert not any(r["id"] == resource_id for r in active_resources), "Disabled resource should NOT appear in active-only list"
+            mocks.print_json.reset_mock()
+
+            # List with active_only=False should include it
+            resources_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_resources = mocks.print_json.call_args[0][0]
+            assert any(r["id"] == resource_id for r in all_resources), "Disabled resource should appear in full list"
+            mocks.print_json.reset_mock()
+
+            # Re-enable it
+            resources_toggle(resource_id)
+            mocks.print_json.reset_mock()
+
+            # List with active_only=True should include it again
+            resources_list(mcp_server_id=None, active_only=True, json_output=True)
+            active_resources = mocks.print_json.call_args[0][0]
+            assert any(r["id"] == resource_id for r in active_resources), "Re-enabled resource should appear in active-only list"
+
+    def test_resources_toggle_status_detection_integration(self, mock_console, registered_mcp_server) -> None:
+        """Test toggle command detects current status correctly with real server."""
+        with patch_functions("cforge.commands.resources.resources", print_json=None, get_console=mock_console) as mocks:
+            # Get a resource from the registered server
+            resources_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_resources = mocks.print_json.call_args[0][0]
+            resource_id = all_resources[0]["id"]
+            initial_status = all_resources[0]["isActive"]
+            assert initial_status is True, "Resource from MCP server should start active"
+            mocks.print_json.reset_mock()
+
+            # Toggle (should detect active and switch to inactive)
+            resources_toggle(resource_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed by listing again
+            resources_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_resources = mocks.print_json.call_args[0][0]
+            resource = [r for r in all_resources if r["id"] == resource_id][0]
+            assert resource["isActive"] is False, "Resource should now be inactive"
+            mocks.print_json.reset_mock()
+
+            # Toggle again (should detect inactive and switch to active)
+            resources_toggle(resource_id)
+            mocks.print_json.reset_mock()
+
+            # Verify status changed back
+            resources_list(mcp_server_id=None, active_only=False, json_output=True)
+            all_resources = mocks.print_json.call_args[0][0]
+            resource = [r for r in all_resources if r["id"] == resource_id][0]
+            assert resource["isActive"] is True, "Resource should be active again"