Update the McpServerAutoConfigurationIT

Signed-off-by: Christian Tzolov <[email protected]>

Author: tzolov

auto-configurations/spring-ai-mcp-server/src/test/java/org/springframework/ai/autoconfigure/mcp/server/McpServerAutoConfigurationIT.java

@@ -16,14 +16,30 @@
 
 package org.springframework.ai.autoconfigure.mcp.server;
 
+import com.fasterxml.jackson.core.type.TypeReference;
+import io.modelcontextprotocol.client.McpSyncClient;
 import io.modelcontextprotocol.server.McpAsyncServer;
+import io.modelcontextprotocol.server.McpServerFeatures.AsyncToolRegistration;
+import io.modelcontextprotocol.server.McpServerFeatures.SyncToolRegistration;
+import io.modelcontextprotocol.server.McpServerFeatures.SyncResourceRegistration;
+import io.modelcontextprotocol.server.McpServerFeatures.SyncPromptRegistration;
 import io.modelcontextprotocol.server.McpSyncServer;
 import io.modelcontextprotocol.server.transport.StdioServerTransport;
+import io.modelcontextprotocol.spec.McpSchema;
 import io.modelcontextprotocol.spec.ServerMcpTransport;
+import org.mockito.Mockito;
 import org.junit.jupiter.api.Test;
-
+import org.springframework.ai.mcp.SyncMcpToolCallback;
+import org.springframework.ai.tool.ToolCallback;
 import org.springframework.boot.autoconfigure.AutoConfigurations;
 import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import reactor.core.publisher.Mono;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -65,6 +81,36 @@ void asyncConfiguration() {
 			});
 	}
 
+	@Test
+	void transportConfiguration() {
+		this.contextRunner.withUserConfiguration(CustomTransportConfiguration.class).run(context -> {
+			assertThat(context).hasSingleBean(ServerMcpTransport.class);
+			assertThat(context.getBean(ServerMcpTransport.class)).isInstanceOf(CustomServerTransport.class);
+		});
+	}
+
+	@Test
+	void serverNotificationConfiguration() {
+		this.contextRunner
+			.withPropertyValues("spring.ai.mcp.server.tool-change-notification=false",
+					"spring.ai.mcp.server.resource-change-notification=false")
+			.run(context -> {
+				McpServerProperties properties = context.getBean(McpServerProperties.class);
+				assertThat(properties.isToolChangeNotification()).isFalse();
+				assertThat(properties.isResourceChangeNotification()).isFalse();
+			});
+	}
+
+	// @Test
+	void invalidConfigurationThrowsException() {
+		this.contextRunner.withPropertyValues("spring.ai.mcp.server.version=invalid-version").run(context -> {
+			assertThat(context).hasFailed();
+			assertThat(context).getFailure()
+				.hasRootCauseInstanceOf(IllegalArgumentException.class)
+				.hasMessageContaining("Invalid version format");
+		});
+	}
+
 	@Test
 	void disabledConfiguration() {
 		this.contextRunner.withPropertyValues("spring.ai.mcp.server.enabled=false").run(context -> {
@@ -88,4 +134,178 @@ void notificationConfiguration() {
 			});
 	}
 
+	@Test
+	void stdioConfiguration() {
+		this.contextRunner.withPropertyValues("spring.ai.mcp.server.stdio=true").run(context -> {
+			McpServerProperties properties = context.getBean(McpServerProperties.class);
+			assertThat(properties.isStdio()).isTrue();
+		});
+	}
+
+	@Test
+	void serverCapabilitiesConfiguration() {
+		this.contextRunner.run(context -> {
+			assertThat(context).hasSingleBean(McpSchema.ServerCapabilities.Builder.class);
+			McpSchema.ServerCapabilities.Builder builder = context.getBean(McpSchema.ServerCapabilities.Builder.class);
+			assertThat(builder).isNotNull();
+		});
+	}
+
+	@Test
+	void toolRegistrationConfiguration() {
+		this.contextRunner.withUserConfiguration(TestToolConfiguration.class).run(context -> {
+			List<SyncToolRegistration> tools = context.getBean("syncTools", List.class);
+			assertThat(tools).hasSize(1);
+		});
+	}
+
+	@Test
+	void resourceRegistrationConfiguration() {
+		this.contextRunner.withUserConfiguration(TestResourceConfiguration.class).run(context -> {
+			McpSyncServer server = context.getBean(McpSyncServer.class);
+			assertThat(server).isNotNull();
+		});
+	}
+
+	@Test
+	void promptRegistrationConfiguration() {
+		this.contextRunner.withUserConfiguration(TestPromptConfiguration.class).run(context -> {
+			McpSyncServer server = context.getBean(McpSyncServer.class);
+			assertThat(server).isNotNull();
+		});
+	}
+
+	@Test
+	void asyncToolRegistrationConfiguration() {
+		this.contextRunner.withPropertyValues("spring.ai.mcp.server.type=ASYNC")
+			.withUserConfiguration(TestToolConfiguration.class)
+			.run(context -> {
+				List<AsyncToolRegistration> tools = context.getBean("asyncTools", List.class);
+				assertThat(tools).hasSize(1);
+			});
+	}
+
+	@Test
+	void customCapabilitiesBuilder() {
+		this.contextRunner.withUserConfiguration(CustomCapabilitiesConfiguration.class).run(context -> {
+			assertThat(context).hasSingleBean(McpSchema.ServerCapabilities.Builder.class);
+			assertThat(context.getBean(McpSchema.ServerCapabilities.Builder.class))
+				.isInstanceOf(CustomCapabilitiesBuilder.class);
+		});
+	}
+
+	@Test
+	void rootsChangeConsumerConfiguration() {
+		this.contextRunner.withUserConfiguration(TestRootsChangeConfiguration.class).run(context -> {
+			McpSyncServer server = context.getBean(McpSyncServer.class);
+			assertThat(server).isNotNull();
+		});
+	}
+
+	@Configuration
+	static class TestResourceConfiguration {
+
+		@Bean
+		List<SyncResourceRegistration> testResources() {
+			return List.of();
+		}
+
+	}
+
+	@Configuration
+	static class TestPromptConfiguration {
+
+		@Bean
+		List<SyncPromptRegistration> testPrompts() {
+			return List.of();
+		}
+
+	}
+
+	@Configuration
+	static class CustomCapabilitiesConfiguration {
+
+		@Bean
+		McpSchema.ServerCapabilities.Builder customCapabilitiesBuilder() {
+			return new CustomCapabilitiesBuilder();
+		}
+
+	}
+
+	static class CustomCapabilitiesBuilder extends McpSchema.ServerCapabilities.Builder {
+
+		// Custom implementation for testing
+
+	}
+
+	@Configuration
+	static class TestToolConfiguration {
+
+		@Bean
+		List<ToolCallback> testTool() {
+			McpSyncClient mockClient = Mockito.mock(McpSyncClient.class);
+			McpSchema.Tool mockTool = Mockito.mock(McpSchema.Tool.class);
+			McpSchema.CallToolResult mockResult = Mockito.mock(McpSchema.CallToolResult.class);
+
+			Mockito.when(mockTool.name()).thenReturn("test-tool");
+			Mockito.when(mockTool.description()).thenReturn("Test Tool");
+			Mockito.when(mockClient.callTool(Mockito.any(McpSchema.CallToolRequest.class))).thenReturn(mockResult);
+
+			return List.of(new SyncMcpToolCallback(mockClient, mockTool));
+		}
+
+	}
+
+	@Configuration
+	static class TestRootsChangeConfiguration {
+
+		@Bean
+		Consumer<List<McpSchema.Root>> rootsChangeConsumer() {
+			return roots -> {
+				// Test implementation
+			};
+		}
+
+	}
+
+	static class CustomServerTransport implements ServerMcpTransport {
+
+		@Override
+		public Mono<Void> connect(
+				Function<Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>> messageHandler) {
+			return Mono.empty(); // Test implementation
+		}
+
+		@Override
+		public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+			return Mono.empty(); // Test implementation
+		}
+
+		@Override
+		public <T> T unmarshalFrom(Object value, TypeReference<T> type) {
+			return null; // Test implementation
+		}
+
+		@Override
+		public void close() {
+			// Test implementation
+		}
+
+		@Override
+		public Mono<Void> closeGracefully() {
+			return Mono.empty(); // Test implementation
+		}
+
+	}
+
+	@Configuration
+	static class CustomTransportConfiguration {
+
+		@Bean
+		ServerMcpTransport customTransport() {
+			return new CustomServerTransport();
+		}
+
+	}
+
 }