test: Enhance Anthropic test coverage with comprehensive validation and edge cases

Comprehensive test coverage improvements for Anthropic tests

test: Enhance Vertex AI Gemini test coverage for retry mechanisms and runtime hints

Comprehensive test coverage improvements for Vertex AI Gemini module

test: Add edge case coverage for OpenAI mutate functionality and usage handling

Enhanced test coverage for OpenAI module edge cases and validation

Co-authored-by: Oleksandr Klymenko <[email protected]>
Signed-off-by: Oleksandr Klymenko <[email protected]>

Author: alxkm

models/spring-ai-anthropic/src/test/java/org/springframework/ai/anthropic/AnthropicChatOptionsTests.java

@@ -318,4 +318,157 @@ void testCopyPreservesAllFields() {
 		assertThat(copied.getToolContext()).isNotSameAs(original.getToolContext());
 	}
 
+	@Test
+	void testBoundaryValues() {
+		AnthropicChatOptions options = AnthropicChatOptions.builder()
+			.maxTokens(Integer.MAX_VALUE)
+			.temperature(1.0)
+			.topP(1.0)
+			.topK(Integer.MAX_VALUE)
+			.build();
+
+		assertThat(options.getMaxTokens()).isEqualTo(Integer.MAX_VALUE);
+		assertThat(options.getTemperature()).isEqualTo(1.0);
+		assertThat(options.getTopP()).isEqualTo(1.0);
+		assertThat(options.getTopK()).isEqualTo(Integer.MAX_VALUE);
+	}
+
+	@Test
+	void testToolContextWithVariousValueTypes() {
+		Map<String, Object> mixedMap = Map.of("string", "value", "number", 42, "boolean", true, "null_value", "null",
+				"nested_list", List.of("a", "b", "c"), "nested_map", Map.of("inner", "value"));
+
+		AnthropicChatOptions options = AnthropicChatOptions.builder().toolContext(mixedMap).build();
+
+		assertThat(options.getToolContext()).containsAllEntriesOf(mixedMap);
+		assertThat(options.getToolContext().get("string")).isEqualTo("value");
+		assertThat(options.getToolContext().get("number")).isEqualTo(42);
+		assertThat(options.getToolContext().get("boolean")).isEqualTo(true);
+	}
+
+	@Test
+	void testCopyWithMutableCollections() {
+		List<String> mutableStops = new java.util.ArrayList<>(List.of("stop1", "stop2"));
+		Map<String, Object> mutableContext = new java.util.HashMap<>(Map.of("key", "value"));
+
+		AnthropicChatOptions original = AnthropicChatOptions.builder()
+			.stopSequences(mutableStops)
+			.toolContext(mutableContext)
+			.build();
+
+		AnthropicChatOptions copied = original.copy();
+
+		// Modify original collections
+		mutableStops.add("stop3");
+		mutableContext.put("new_key", "new_value");
+
+		// Copied instance should not be affected
+		assertThat(copied.getStopSequences()).hasSize(2);
+		assertThat(copied.getToolContext()).hasSize(1);
+		assertThat(copied.getStopSequences()).doesNotContain("stop3");
+		assertThat(copied.getToolContext()).doesNotContainKey("new_key");
+	}
+
+	@Test
+	void testEqualsWithNullFields() {
+		AnthropicChatOptions options1 = new AnthropicChatOptions();
+		AnthropicChatOptions options2 = new AnthropicChatOptions();
+
+		assertThat(options1).isEqualTo(options2);
+		assertThat(options1.hashCode()).isEqualTo(options2.hashCode());
+	}
+
+	@Test
+	void testEqualsWithMixedNullAndNonNullFields() {
+		AnthropicChatOptions options1 = AnthropicChatOptions.builder()
+			.model("test")
+			.maxTokens(null)
+			.temperature(0.5)
+			.build();
+
+		AnthropicChatOptions options2 = AnthropicChatOptions.builder()
+			.model("test")
+			.maxTokens(null)
+			.temperature(0.5)
+			.build();
+
+		AnthropicChatOptions options3 = AnthropicChatOptions.builder()
+			.model("test")
+			.maxTokens(100)
+			.temperature(0.5)
+			.build();
+
+		assertThat(options1).isEqualTo(options2);
+		assertThat(options1).isNotEqualTo(options3);
+	}
+
+	@Test
+	void testCopyDoesNotShareMetadataReference() {
+		Metadata originalMetadata = new Metadata("user_123");
+		AnthropicChatOptions original = AnthropicChatOptions.builder().metadata(originalMetadata).build();
+
+		AnthropicChatOptions copied = original.copy();
+
+		// Metadata should be the same value but potentially different reference
+		assertThat(copied.getMetadata()).isEqualTo(original.getMetadata());
+
+		// Verify changing original doesn't affect copy
+		original.setMetadata(new Metadata("different_user"));
+		assertThat(copied.getMetadata()).isEqualTo(originalMetadata);
+	}
+
+	@Test
+	void testEqualsWithSelf() {
+		AnthropicChatOptions options = AnthropicChatOptions.builder().model("test").build();
+
+		assertThat(options).isEqualTo(options);
+		assertThat(options.hashCode()).isEqualTo(options.hashCode());
+	}
+
+	@Test
+	void testEqualsWithNull() {
+		AnthropicChatOptions options = AnthropicChatOptions.builder().model("test").build();
+
+		assertThat(options).isNotEqualTo(null);
+	}
+
+	@Test
+	void testEqualsWithDifferentClass() {
+		AnthropicChatOptions options = AnthropicChatOptions.builder().model("test").build();
+
+		assertThat(options).isNotEqualTo("not an AnthropicChatOptions");
+		assertThat(options).isNotEqualTo(1);
+	}
+
+	@Test
+	void testBuilderPartialConfiguration() {
+		// Test builder with only some fields set
+		AnthropicChatOptions onlyModel = AnthropicChatOptions.builder().model("model-only").build();
+
+		AnthropicChatOptions onlyTokens = AnthropicChatOptions.builder().maxTokens(10).build();
+
+		AnthropicChatOptions onlyTemperature = AnthropicChatOptions.builder().temperature(0.8).build();
+
+		assertThat(onlyModel.getModel()).isEqualTo("model-only");
+		assertThat(onlyModel.getMaxTokens()).isNull();
+
+		assertThat(onlyTokens.getModel()).isNull();
+		assertThat(onlyTokens.getMaxTokens()).isEqualTo(10);
+
+		assertThat(onlyTemperature.getModel()).isNull();
+		assertThat(onlyTemperature.getTemperature()).isEqualTo(0.8);
+	}
+
+	@Test
+	void testSetterOverwriteBehavior() {
+		AnthropicChatOptions options = AnthropicChatOptions.builder().model("initial-model").maxTokens(100).build();
+
+		// Overwrite with setters
+		options.setModel("updated-model");
+		options.setMaxTokens(10);
+
+		assertThat(options.getModel()).isEqualTo("updated-model");
+		assertThat(options.getMaxTokens()).isEqualTo(10);
+	}
+
 }

models/spring-ai-anthropic/src/test/java/org/springframework/ai/anthropic/aot/AnthropicRuntimeHintsTests.java

@@ -145,4 +145,86 @@ void verifyEnumTypesAreRegistered() {
 		assertThat(registeredTypes.contains(TypeReference.of(AnthropicApi.EventType.class))).isTrue();
 	}
 
+	@Test
+	void verifyNestedClassesAreRegistered() {
+		anthropicRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Verify nested classes within AnthropicApi are registered
+		assertThat(registeredTypes.contains(TypeReference.of(AnthropicApi.ChatCompletionRequest.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(AnthropicApi.AnthropicMessage.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(AnthropicApi.ContentBlock.class))).isTrue();
+	}
+
+	@Test
+	void verifyNoProxyHintsAreRegistered() {
+		anthropicRuntimeHints.registerHints(runtimeHints, null);
+
+		// This implementation should only register reflection hints, not proxy hints
+		long proxyHintCount = runtimeHints.proxies().jdkProxyHints().count();
+		assertThat(proxyHintCount).isEqualTo(0);
+	}
+
+	@Test
+	void verifyNoSerializationHintsAreRegistered() {
+		anthropicRuntimeHints.registerHints(runtimeHints, null);
+
+		// This implementation should only register reflection hints, not serialization
+		// hints
+		long serializationHintCount = runtimeHints.serialization().javaSerializationHints().count();
+		assertThat(serializationHintCount).isEqualTo(0);
+	}
+
+	@Test
+	void verifyJsonAnnotatedClassesContainExpectedTypes() {
+		Set<TypeReference> jsonAnnotatedClasses = findJsonAnnotatedClassesInPackage("org.springframework.ai.anthropic");
+
+		// Verify that key API classes are found
+		boolean containsApiClass = jsonAnnotatedClasses.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("AnthropicApi")
+					|| typeRef.getName().contains("ChatCompletion") || typeRef.getName().contains("AnthropicMessage"));
+
+		assertThat(containsApiClass).isTrue();
+	}
+
+	@Test
+	void verifyConsistencyAcrossInstances() {
+		RuntimeHints hints1 = new RuntimeHints();
+		RuntimeHints hints2 = new RuntimeHints();
+
+		AnthropicRuntimeHints anthropicHints1 = new AnthropicRuntimeHints();
+		AnthropicRuntimeHints anthropicHints2 = new AnthropicRuntimeHints();
+
+		anthropicHints1.registerHints(hints1, null);
+		anthropicHints2.registerHints(hints2, null);
+
+		// Different instances should register the same hints
+		Set<TypeReference> types1 = new HashSet<>();
+		Set<TypeReference> types2 = new HashSet<>();
+
+		hints1.reflection().typeHints().forEach(hint -> types1.add(hint.getType()));
+		hints2.reflection().typeHints().forEach(hint -> types2.add(hint.getType()));
+
+		assertThat(types1).isEqualTo(types2);
+	}
+
+	@Test
+	void verifyPackageSpecificity() {
+		Set<TypeReference> jsonAnnotatedClasses = findJsonAnnotatedClassesInPackage("org.springframework.ai.anthropic");
+
+		// All found classes should be from the anthropic package specifically
+		for (TypeReference classRef : jsonAnnotatedClasses) {
+			assertThat(classRef.getName()).startsWith("org.springframework.ai.anthropic");
+		}
+
+		// Should not include classes from other AI packages
+		for (TypeReference classRef : jsonAnnotatedClasses) {
+			assertThat(classRef.getName()).doesNotContain("vertexai");
+			assertThat(classRef.getName()).doesNotContain("openai");
+			assertThat(classRef.getName()).doesNotContain("ollama");
+		}
+	}
+
 }

models/spring-ai-openai/src/test/java/org/springframework/ai/openai/api/OpenAiChatModelMutateTests.java

@@ -131,4 +131,63 @@ void mutateAndCloneAreEquivalent() {
 		assertThat(mutated).isNotSameAs(cloned);
 	}
 
+	@Test
+	void testApiMutateWithComplexHeaders() {
+		LinkedMultiValueMap<String, String> complexHeaders = new LinkedMultiValueMap<>();
+		complexHeaders.add("Authorization", "Bearer custom-token");
+		complexHeaders.add("X-Custom-Header", "value1");
+		complexHeaders.add("X-Custom-Header", "value2");
+		complexHeaders.add("User-Agent", "Custom-Client/1.0");
+
+		OpenAiApi mutatedApi = this.baseApi.mutate().headers(complexHeaders).build();
+
+		assertThat(mutatedApi.getHeaders()).containsKey("Authorization");
+		assertThat(mutatedApi.getHeaders()).containsKey("X-Custom-Header");
+		assertThat(mutatedApi.getHeaders()).containsKey("User-Agent");
+		assertThat(mutatedApi.getHeaders().get("X-Custom-Header")).hasSize(2);
+	}
+
+	@Test
+	void testMutateWithEmptyOptions() {
+		OpenAiChatOptions emptyOptions = OpenAiChatOptions.builder().build();
+
+		OpenAiChatModel mutated = this.baseModel.mutate().defaultOptions(emptyOptions).build();
+
+		assertThat(mutated.getDefaultOptions()).isNotNull();
+		assertThat(mutated.getDefaultOptions()).isNotSameAs(this.baseModel.getDefaultOptions());
+	}
+
+	@Test
+	void testApiMutateWithEmptyHeaders() {
+		LinkedMultiValueMap<String, String> emptyHeaders = new LinkedMultiValueMap<>();
+
+		OpenAiApi mutatedApi = this.baseApi.mutate().headers(emptyHeaders).build();
+
+		assertThat(mutatedApi.getHeaders()).isEmpty();
+	}
+
+	@Test
+	void testCloneAndMutateIndependence() {
+		// Test that clone and mutate produce independent instances
+		OpenAiChatModel cloned = this.baseModel.clone();
+		OpenAiChatModel mutated = this.baseModel.mutate().build();
+
+		// Modify cloned instance (if options are mutable)
+		// This test verifies that operations on one don't affect the other
+		assertThat(cloned).isNotSameAs(mutated);
+		assertThat(cloned).isNotSameAs(this.baseModel);
+		assertThat(mutated).isNotSameAs(this.baseModel);
+	}
+
+	@Test
+	void testMutateBuilderValidation() {
+		// Test that mutate builder validates inputs appropriately
+		assertThat(this.baseModel.mutate()).isNotNull();
+
+		// Test building without any changes
+		OpenAiChatModel unchanged = this.baseModel.mutate().build();
+		assertThat(unchanged).isNotNull();
+		assertThat(unchanged).isNotSameAs(this.baseModel);
+	}
+
 }

models/spring-ai-openai/src/test/java/org/springframework/ai/openai/metadata/OpenAiUsageTests.java

@@ -208,4 +208,22 @@ void whenPromptCacheMissTokensIsPresent() {
 		assertThat(nativeUsage.promptTokensDetails().cachedTokens()).isEqualTo(15);
 	}
 
+	@Test
+	void whenAllTokenCountsAreZero() {
+		OpenAiApi.Usage openAiUsage = new OpenAiApi.Usage(0, 0, 0);
+		DefaultUsage usage = getDefaultUsage(openAiUsage);
+		assertThat(usage.getPromptTokens()).isEqualTo(0);
+		assertThat(usage.getCompletionTokens()).isEqualTo(0);
+		assertThat(usage.getTotalTokens()).isEqualTo(0);
+	}
+
+	@Test
+	void whenAllTokenCountsAreNull() {
+		OpenAiApi.Usage openAiUsage = new OpenAiApi.Usage(null, null, null);
+		DefaultUsage usage = getDefaultUsage(openAiUsage);
+		assertThat(usage.getPromptTokens()).isEqualTo(0);
+		assertThat(usage.getCompletionTokens()).isEqualTo(0);
+		assertThat(usage.getTotalTokens()).isEqualTo(0);
+	}
+
 }

models/spring-ai-vertex-ai-gemini/src/test/java/org/springframework/ai/vertexai/gemini/VertexAiGeminiRetryTests.java

@@ -134,4 +134,46 @@ public <T, E extends Throwable> void onError(RetryContext context, RetryCallback
 
 	}
 
+	@Test
+	public void vertexAiGeminiChatSuccessOnFirstAttempt() throws Exception {
+		// Create a mocked successful response
+		GenerateContentResponse mockedResponse = GenerateContentResponse.newBuilder()
+			.addCandidates(Candidate.newBuilder()
+				.setContent(Content.newBuilder()
+					.addParts(Part.newBuilder().setText("First Attempt Success").build())
+					.build())
+				.build())
+			.build();
+
+		given(this.mockGenerativeModel.generateContent(any(List.class))).willReturn(mockedResponse);
+
+		// Call the chat model
+		ChatResponse result = this.chatModel.call(new Prompt("test prompt"));
+
+		// Assertions
+		assertThat(result).isNotNull();
+		assertThat(result.getResult().getOutput().getText()).isEqualTo("First Attempt Success");
+		assertThat(this.retryListener.onSuccessRetryCount).isEqualTo(0); // No retries
+																			// needed
+		assertThat(this.retryListener.onErrorRetryCount).isEqualTo(0);
+	}
+
+	@Test
+	public void vertexAiGeminiChatWithEmptyResponse() throws Exception {
+		// Test handling of empty response after retries
+		GenerateContentResponse emptyResponse = GenerateContentResponse.newBuilder().build();
+
+		given(this.mockGenerativeModel.generateContent(any(List.class)))
+			.willThrow(new TransientAiException("Temporary issue"))
+			.willReturn(emptyResponse);
+
+		// Call the chat model
+		ChatResponse result = this.chatModel.call(new Prompt("test prompt"));
+
+		// Should handle empty response gracefully
+		assertThat(result).isNotNull();
+		assertThat(this.retryListener.onSuccessRetryCount).isEqualTo(1);
+		assertThat(this.retryListener.onErrorRetryCount).isEqualTo(1);
+	}
+
 }