test: Improve unit test coverage for various components

 - Add comprehensive validation tests for OpenAI runtime hints registration
 - Add tests for MistralAI retry logic and AOT native image support
 - Add comprehensive test coverage for Azure OpenAI chat and embedding options
 - Remove shouldHandleVeryLargeInputList to reduce load during build
 - Add comprehensive edge case tests for ChatModel, ChatResponse, and ListOutputConverter
 - Add whenMultipleGenerationsWithToolCallsThenReturnTrue test
 - Add comprehensive edge case tests for OllamaOptions and OllamaRuntimeHints
 - Add additional test coverage for edge cases and boundary conditions in Ollama components
 - Add verifyHintsRegistration test
 - Add edge case tests for SimpleVectorStore document handling and filtering
 - Add validation and edge case tests for ObservabilityHelper and AiOperationMetadata
 - Add builtWithValidValuesThenFieldsAreAccessible test

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

Author: alxkm

models/spring-ai-azure-openai/src/test/java/org/springframework/ai/azure/openai/AzureEmbeddingsOptionsTests.java

@@ -16,6 +16,7 @@
 
 package org.springframework.ai.azure.openai;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -158,4 +159,45 @@ public void shouldHandleConcurrentRequests() {
 		assertThat(options2.getUser()).isEqualTo("USER2");
 	}
 
+	@Test
+	public void shouldHandleEmptyStringInputs() {
+		List<String> inputsWithEmpty = Arrays.asList("", "Valid text", "", "Another valid text");
+		var requestOptions = client.toEmbeddingOptions(new EmbeddingRequest(inputsWithEmpty, null));
+
+		assertThat(requestOptions.getInput()).hasSize(4);
+		assertThat(requestOptions.getInput()).containsExactly("", "Valid text", "", "Another valid text");
+	}
+
+	@Test
+	public void shouldHandleDifferentClientConfigurations() {
+		var clientWithDifferentDefaults = new AzureOpenAiEmbeddingModel(mockClient, MetadataMode.EMBED,
+				AzureOpenAiEmbeddingOptions.builder().deploymentName("DIFFERENT_DEFAULT").build());
+
+		var requestOptions = clientWithDifferentDefaults
+			.toEmbeddingOptions(new EmbeddingRequest(List.of("Test content"), null));
+
+		assertThat(requestOptions.getModel()).isEqualTo("DIFFERENT_DEFAULT");
+		assertThat(requestOptions.getUser()).isNull(); // No default user set
+	}
+
+	@Test
+	public void shouldHandleWhitespaceOnlyInputs() {
+		List<String> whitespaceInputs = Arrays.asList("   ", "\t\t", "\n\n", "  valid text  ");
+		var requestOptions = client.toEmbeddingOptions(new EmbeddingRequest(whitespaceInputs, null));
+
+		assertThat(requestOptions.getInput()).hasSize(4);
+		assertThat(requestOptions.getInput()).containsExactlyElementsOf(whitespaceInputs);
+	}
+
+	@Test
+	public void shouldValidateInputListIsNotModified() {
+		List<String> originalInputs = Arrays.asList("Input 1", "Input 2", "Input 3");
+		List<String> inputsCopy = new ArrayList<>(originalInputs);
+
+		client.toEmbeddingOptions(new EmbeddingRequest(inputsCopy, null));
+
+		// Verify original list wasn't modified
+		assertThat(inputsCopy).isEqualTo(originalInputs);
+	}
+
 }

models/spring-ai-azure-openai/src/test/java/org/springframework/ai/azure/openai/AzureOpenAiChatOptionsTests.java

@@ -195,4 +195,49 @@ void testDefaultValues() {
 		assertThat(options.getModel()).isNull();
 	}
 
+	@Test
+	void testModelAndDeploymentNameRelationship() {
+		AzureOpenAiChatOptions options = new AzureOpenAiChatOptions();
+
+		// Test setting deployment name first
+		options.setDeploymentName("deployment-1");
+		assertThat(options.getDeploymentName()).isEqualTo("deployment-1");
+		assertThat(options.getModel()).isEqualTo("deployment-1");
+
+		// Test setting model overwrites deployment name
+		options.setModel("model-1");
+		assertThat(options.getDeploymentName()).isEqualTo("model-1");
+		assertThat(options.getModel()).isEqualTo("model-1");
+	}
+
+	@Test
+	void testResponseFormatVariations() {
+		// Test with JSON response format
+		AzureOpenAiResponseFormat jsonFormat = AzureOpenAiResponseFormat.builder()
+			.type(AzureOpenAiResponseFormat.Type.JSON_OBJECT)
+			.build();
+
+		AzureOpenAiChatOptions options = AzureOpenAiChatOptions.builder().responseFormat(jsonFormat).build();
+
+		assertThat(options.getResponseFormat()).isEqualTo(jsonFormat);
+		assertThat(options.getResponseFormat().getType()).isEqualTo(AzureOpenAiResponseFormat.Type.JSON_OBJECT);
+	}
+
+	@Test
+	void testEnhancementsConfiguration() {
+		AzureChatEnhancementConfiguration enhancements = new AzureChatEnhancementConfiguration();
+		AzureChatOCREnhancementConfiguration ocrConfig = new AzureChatOCREnhancementConfiguration(false);
+		AzureChatGroundingEnhancementConfiguration groundingConfig = new AzureChatGroundingEnhancementConfiguration(
+				false);
+
+		enhancements.setOcr(ocrConfig);
+		enhancements.setGrounding(groundingConfig);
+
+		AzureOpenAiChatOptions options = AzureOpenAiChatOptions.builder().enhancements(enhancements).build();
+
+		assertThat(options.getEnhancements()).isEqualTo(enhancements);
+		assertThat(options.getEnhancements().getOcr()).isEqualTo(ocrConfig);
+		assertThat(options.getEnhancements().getGrounding()).isEqualTo(groundingConfig);
+	}
+
 }

models/spring-ai-mistral-ai/src/test/java/org/springframework/ai/mistralai/MistralAiRetryTests.java

@@ -178,6 +178,19 @@ public void mistralAiEmbeddingNonTransientError() {
 			.call(new org.springframework.ai.embedding.EmbeddingRequest(List.of("text1", "text2"), null)));
 	}
 
+	@Test
+	public void mistralAiChatMixedTransientAndNonTransientErrors() {
+		given(this.mistralAiApi.chatCompletionEntity(isA(ChatCompletionRequest.class)))
+			.willThrow(new TransientAiException("Transient Error"))
+			.willThrow(new RuntimeException("Non Transient Error"));
+
+		// Should fail immediately on non-transient error, no further retries
+		assertThrows(RuntimeException.class, () -> this.chatModel.call(new Prompt("text")));
+
+		// Should have 1 retry attempt before hitting non-transient error
+		assertThat(this.retryListener.onErrorRetryCount).isEqualTo(2);
+	}
+
 	private static class TestRetryListener implements RetryListener {
 
 		int onErrorRetryCount = 0;

models/spring-ai-mistral-ai/src/test/java/org/springframework/ai/mistralai/aot/MistralAiRuntimeHintsTests.java

@@ -118,4 +118,60 @@ void verifyPackageScanningWorks() {
 		assertThat(jsonAnnotatedClasses.size()).isGreaterThan(0);
 	}
 
+	@Test
+	void verifyAllCriticalApiClassesAreRegistered() {
+		RuntimeHints runtimeHints = new RuntimeHints();
+		MistralAiRuntimeHints mistralAiRuntimeHints = new MistralAiRuntimeHints();
+		mistralAiRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Ensure critical API classes are registered for GraalVM native image reflection
+		String[] criticalClasses = { "MistralAiApi$ChatCompletionRequest", "MistralAiApi$ChatCompletionMessage",
+				"MistralAiApi$EmbeddingRequest", "MistralAiApi$EmbeddingList", "MistralAiApi$Usage" };
+
+		for (String className : criticalClasses) {
+			assertThat(registeredTypes.stream()
+				.anyMatch(tr -> tr.getName().contains(className.replace("$", "."))
+						|| tr.getName().contains(className.replace("$", "$"))))
+				.as("Critical class %s should be registered", className)
+				.isTrue();
+		}
+	}
+
+	@Test
+	void verifyEnumTypesAreRegistered() {
+		RuntimeHints runtimeHints = new RuntimeHints();
+		MistralAiRuntimeHints mistralAiRuntimeHints = new MistralAiRuntimeHints();
+		mistralAiRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Enums are critical for JSON deserialization in native images
+		assertThat(registeredTypes.contains(TypeReference.of(MistralAiApi.ChatModel.class)))
+			.as("ChatModel enum should be registered")
+			.isTrue();
+
+		assertThat(registeredTypes.contains(TypeReference.of(MistralAiApi.EmbeddingModel.class)))
+			.as("EmbeddingModel enum should be registered")
+			.isTrue();
+	}
+
+	@Test
+	void verifyReflectionHintsIncludeConstructors() {
+		RuntimeHints runtimeHints = new RuntimeHints();
+		MistralAiRuntimeHints mistralAiRuntimeHints = new MistralAiRuntimeHints();
+		mistralAiRuntimeHints.registerHints(runtimeHints, null);
+
+		// Verify that reflection hints include constructor access
+		boolean hasConstructorHints = runtimeHints.reflection()
+			.typeHints()
+			.anyMatch(typeHint -> typeHint.constructors().findAny().isPresent() || typeHint.getMemberCategories()
+				.contains(org.springframework.aot.hint.MemberCategory.INVOKE_DECLARED_CONSTRUCTORS));
+
+		assertThat(hasConstructorHints).as("Should register constructor hints for JSON deserialization").isTrue();
+	}
+
 }

models/spring-ai-ollama/src/test/java/org/springframework/ai/ollama/aot/OllamaRuntimeHintsTests.java

@@ -150,4 +150,46 @@ void verifyNestedClassHintsAreRegistered() {
 		assertThat(nestedClassCount).isGreaterThan(0);
 	}
 
+	@Test
+	void verifyEmbeddingRelatedClassesAreRegistered() {
+		RuntimeHints runtimeHints = new RuntimeHints();
+		OllamaRuntimeHints ollamaRuntimeHints = new OllamaRuntimeHints();
+		ollamaRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Verify embedding-related classes are registered for reflection
+		assertThat(registeredTypes.contains(TypeReference.of(OllamaApi.EmbeddingsRequest.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(OllamaApi.EmbeddingsResponse.class))).isTrue();
+
+		// Count classes related to embedding functionality
+		long embeddingClassCount = registeredTypes.stream()
+			.filter(typeRef -> typeRef.getName().toLowerCase().contains("embedding"))
+			.count();
+		assertThat(embeddingClassCount).isGreaterThan(0);
+	}
+
+	@Test
+	void verifyHintsRegistrationWithCustomClassLoader() {
+		RuntimeHints runtimeHints = new RuntimeHints();
+		OllamaRuntimeHints ollamaRuntimeHints = new OllamaRuntimeHints();
+
+		// Create a custom class loader
+		ClassLoader customClassLoader = Thread.currentThread().getContextClassLoader();
+
+		// Should work with custom class loader
+		org.assertj.core.api.Assertions
+			.assertThatCode(() -> ollamaRuntimeHints.registerHints(runtimeHints, customClassLoader))
+			.doesNotThrowAnyException();
+
+		// Verify hints are still registered properly
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		assertThat(registeredTypes.size()).isGreaterThan(0);
+		assertThat(registeredTypes.contains(TypeReference.of(OllamaApi.ChatRequest.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(OllamaOptions.class))).isTrue();
+	}
+
 }

models/spring-ai-ollama/src/test/java/org/springframework/ai/ollama/api/OllamaModelOptionsTests.java

@@ -204,4 +204,42 @@ public void testDeprecatedMethods() {
 		assertThat(options.getToolNames()).containsExactly("function1");
 	}
 
+	@Test
+	public void testEmptyOptions() {
+		var options = OllamaOptions.builder().build();
+
+		var optionsMap = options.toMap();
+		assertThat(optionsMap).isEmpty();
+
+		// Verify all getters return null/empty
+		assertThat(options.getModel()).isNull();
+		assertThat(options.getTemperature()).isNull();
+		assertThat(options.getTopK()).isNull();
+		assertThat(options.getToolNames()).isEmpty();
+		assertThat(options.getToolContext()).isEmpty();
+	}
+
+	@Test
+	public void testNullValuesNotIncludedInMap() {
+		var options = OllamaOptions.builder().model("llama2").temperature(null).topK(null).stop(null).build();
+
+		var optionsMap = options.toMap();
+		assertThat(optionsMap).containsEntry("model", "llama2");
+		assertThat(optionsMap).doesNotContainKey("temperature");
+		assertThat(optionsMap).doesNotContainKey("top_k");
+		assertThat(optionsMap).doesNotContainKey("stop");
+	}
+
+	@Test
+	public void testZeroValuesIncludedInMap() {
+		var options = OllamaOptions.builder().temperature(0.0).topK(0).mainGPU(0).numGPU(0).seed(0).build();
+
+		var optionsMap = options.toMap();
+		assertThat(optionsMap).containsEntry("temperature", 0.0);
+		assertThat(optionsMap).containsEntry("top_k", 0);
+		assertThat(optionsMap).containsEntry("main_gpu", 0);
+		assertThat(optionsMap).containsEntry("num_gpu", 0);
+		assertThat(optionsMap).containsEntry("seed", 0);
+	}
+
 }