test: Improve test coverage in various classes

- Add edge case tests for MimeTypeDetector and CoherenceFilterExpressionConverter
- Add test for numeric comparison with category field
- Tests CoherenceFilterExpressionConverter handling of greater-than-or-equal
- Add comprehensive test coverage for QdrantObjectFactory and QdrantVectorStore.Builder
- Add test for QdrantVectorStoreBuilderTests
- Add comprehensive test coverage for QdrantObjectFactory and QdrantVectorStore.Builder.
- Add comprehensive test coverage for QuestionAnswerAdvisor and VectorStoreChatMemoryAdvisor
- Add comprehensive media content tests for MessageTypeContentTests
- Addcomprehensive test coverage for various media content scenarios in chat message handling, focusing on edge cases and mixed content types.
- Add comprehensive test coverage for DefaultChatClient and DefaultChatClientBuilder
- Add comprehensive edge case tests for Ollama embedding and chat models
- Add comprehensive test coverage for edge cases and boundary conditions in Ollama model implementations:

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

Author: alxkm

advisors/spring-ai-advisors-vector-store/src/test/java/org/springframework/ai/chat/client/advisor/vectorstore/QuestionAnswerAdvisorTests.java

@@ -243,4 +243,163 @@ public void qaAdvisorTakesUserParameterizedUserMessagesIntoAccountForSimilarityS
 		Assertions.assertThat(this.vectorSearchCaptor.getValue().getQuery()).isEqualTo(expectedQuery);
 	}
 
+	@Test
+	public void qaAdvisorWithMultipleFilterParameters() {
+		given(this.chatModel.call(this.promptCaptor.capture()))
+				.willReturn(new ChatResponse(List.of(new Generation(new AssistantMessage("Filtered response"))),
+						ChatResponseMetadata.builder().build()));
+
+		given(this.vectorStore.similaritySearch(this.vectorSearchCaptor.capture()))
+				.willReturn(List.of(new Document("doc1"), new Document("doc2")));
+
+		var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
+				.searchRequest(SearchRequest.builder().topK(10).build())
+				.build();
+
+		var chatClient = ChatClient.builder(this.chatModel)
+				.defaultAdvisors(qaAdvisor)
+				.build();
+
+		chatClient.prompt()
+				.user("Complex query")
+				.advisors(a -> a.param(QuestionAnswerAdvisor.FILTER_EXPRESSION, "type == 'Documentation' AND status == 'Published'"))
+				.call()
+				.chatResponse();
+
+		var capturedFilter = this.vectorSearchCaptor.getValue().getFilterExpression();
+		assertThat(capturedFilter).isNotNull();
+		// The filter should be properly constructed with AND operation
+		assertThat(capturedFilter.toString()).contains("type");
+		assertThat(capturedFilter.toString()).contains("Documentation");
+	}
+
+	@Test
+	public void qaAdvisorWithDifferentSimilarityThresholds() {
+		given(this.chatModel.call(this.promptCaptor.capture()))
+				.willReturn(new ChatResponse(List.of(new Generation(new AssistantMessage("High threshold response"))),
+						ChatResponseMetadata.builder().build()));
+
+		given(this.vectorStore.similaritySearch(this.vectorSearchCaptor.capture()))
+				.willReturn(List.of(new Document("relevant doc")));
+
+		var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
+				.searchRequest(SearchRequest.builder().similarityThreshold(0.95).topK(3).build())
+				.build();
+
+		var chatClient = ChatClient.builder(this.chatModel)
+				.defaultAdvisors(qaAdvisor)
+				.build();
+
+		chatClient.prompt()
+				.user("Specific question requiring high similarity")
+				.call()
+				.chatResponse();
+
+		assertThat(this.vectorSearchCaptor.getValue().getSimilarityThreshold()).isEqualTo(0.95);
+		assertThat(this.vectorSearchCaptor.getValue().getTopK()).isEqualTo(3);
+	}
+
+	@Test
+	public void qaAdvisorWithComplexParameterizedTemplate() {
+		given(this.chatModel.call(this.promptCaptor.capture()))
+				.willReturn(new ChatResponse(List.of(new Generation(new AssistantMessage("Complex template response"))),
+						ChatResponseMetadata.builder().build()));
+
+		given(this.vectorStore.similaritySearch(this.vectorSearchCaptor.capture()))
+				.willReturn(List.of(new Document("template doc")));
+
+		var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
+				.searchRequest(SearchRequest.builder().build())
+				.build();
+
+		var chatClient = ChatClient.builder(this.chatModel)
+				.defaultAdvisors(qaAdvisor)
+				.build();
+
+		var complexTemplate = "Please analyze {topic} considering {aspect1} and {aspect2} for user {userId}";
+		chatClient.prompt()
+				.user(u -> u.text(complexTemplate)
+						.param("topic", "machine learning")
+						.param("aspect1", "performance")
+						.param("aspect2", "scalability")
+						.param("userId", "user1"))
+				.call()
+				.chatResponse();
+
+		var expectedQuery = "Please analyze machine learning considering performance and scalability for user user1";
+		assertThat(this.vectorSearchCaptor.getValue().getQuery()).isEqualTo(expectedQuery);
+
+		Message userMessage = this.promptCaptor.getValue().getInstructions().get(0);
+		assertThat(userMessage.getText()).contains(expectedQuery);
+		assertThat(userMessage.getText()).doesNotContain("{topic}");
+		assertThat(userMessage.getText()).doesNotContain("{aspect1}");
+		assertThat(userMessage.getText()).doesNotContain("{aspect2}");
+		assertThat(userMessage.getText()).doesNotContain("{userId}");
+	}
+
+	@Test
+	public void qaAdvisorWithDocumentsContainingMetadata() {
+		given(this.chatModel.call(this.promptCaptor.capture()))
+				.willReturn(new ChatResponse(List.of(new Generation(new AssistantMessage("Metadata response"))),
+						ChatResponseMetadata.builder().build()));
+
+		var docWithMetadata1 = new Document("First document content", Map.of("source", "wiki", "author", "John"));
+		var docWithMetadata2 = new Document("Second document content", Map.of("source", "manual", "version", "2.1"));
+
+		given(this.vectorStore.similaritySearch(this.vectorSearchCaptor.capture()))
+				.willReturn(List.of(docWithMetadata1, docWithMetadata2));
+
+		var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
+				.searchRequest(SearchRequest.builder().topK(2).build())
+				.build();
+
+		var chatClient = ChatClient.builder(this.chatModel)
+				.defaultAdvisors(qaAdvisor)
+				.build();
+
+		chatClient.prompt()
+				.user("Question about documents with metadata")
+				.call()
+				.chatResponse();
+
+		Message userMessage = this.promptCaptor.getValue().getInstructions().get(0);
+		assertThat(userMessage.getText()).contains("First document content");
+		assertThat(userMessage.getText()).contains("Second document content");
+	}
+
+	@Test
+	public void qaAdvisorBuilderValidation() {
+		// Test that builder validates required parameters
+		Assertions.assertThatThrownBy(() -> QuestionAnswerAdvisor.builder(null))
+				.isInstanceOf(IllegalArgumentException.class);
+
+		// Test successful builder creation
+		var advisor = QuestionAnswerAdvisor.builder(this.vectorStore).build();
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	public void qaAdvisorWithZeroTopK() {
+		given(this.chatModel.call(this.promptCaptor.capture()))
+				.willReturn(new ChatResponse(List.of(new Generation(new AssistantMessage("Zero docs response"))),
+						ChatResponseMetadata.builder().build()));
+
+		given(this.vectorStore.similaritySearch(this.vectorSearchCaptor.capture()))
+				.willReturn(List.of());
+
+		var qaAdvisor = QuestionAnswerAdvisor.builder(this.vectorStore)
+				.searchRequest(SearchRequest.builder().topK(0).build())
+				.build();
+
+		var chatClient = ChatClient.builder(this.chatModel)
+				.defaultAdvisors(qaAdvisor)
+				.build();
+
+		chatClient.prompt()
+				.user("Question with zero topK")
+				.call()
+				.chatResponse();
+
+		assertThat(this.vectorSearchCaptor.getValue().getTopK()).isEqualTo(0);
+	}
 }

advisors/spring-ai-advisors-vector-store/src/test/java/org/springframework/ai/chat/client/advisor/vectorstore/VectorStoreChatMemoryAdvisorTests.java

@@ -206,4 +206,155 @@ void whenBuilderWithCustomSystemPromptTemplateThenSuccess() {
 		assertThat(advisor).isNotNull();
 	}
 
+	@Test
+	void whenBuilderWithEmptyStringConversationIdThenThrow() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		assertThatThrownBy(() -> VectorStoreChatMemoryAdvisor.builder(vectorStore).conversationId("").build())
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("defaultConversationId cannot be null or empty");
+	}
+
+	@Test
+	void whenBuilderWithWhitespaceOnlyConversationIdThenThrow() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		assertThatThrownBy(() -> VectorStoreChatMemoryAdvisor.builder(vectorStore).conversationId("\t\n\r ").build())
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("defaultConversationId cannot be null or empty");
+	}
+
+	@Test
+	void whenBuilderWithSpecialCharactersInConversationIdThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.conversationId("[email protected]")
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderWithMaxIntegerTopKThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.defaultTopK(Integer.MAX_VALUE)
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderWithNegativeTopKThenThrow() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		assertThatThrownBy(() -> VectorStoreChatMemoryAdvisor.builder(vectorStore).defaultTopK(-100).build())
+			.isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("topK must be greater than 0");
+	}
+
+	@Test
+	void whenBuilderChainedWithAllParametersThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+		Scheduler scheduler = Mockito.mock(Scheduler.class);
+		PromptTemplate systemPromptTemplate = Mockito.mock(PromptTemplate.class);
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.conversationId("chained-test")
+			.defaultTopK(42)
+			.scheduler(scheduler)
+			.systemPromptTemplate(systemPromptTemplate)
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderParametersSetInDifferentOrderThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+		Scheduler scheduler = Mockito.mock(Scheduler.class);
+		PromptTemplate systemPromptTemplate = Mockito.mock(PromptTemplate.class);
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.systemPromptTemplate(systemPromptTemplate)
+			.defaultTopK(7)
+			.scheduler(scheduler)
+			.conversationId("order-test")
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderWithOverriddenParametersThenUseLastValue() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.conversationId("first-id")
+			.conversationId("second-id") // This should override the first
+			.defaultTopK(5)
+			.defaultTopK(10) // This should override the first
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderReusedThenCreatesSeparateInstances() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		// Simulate builder reuse (if the builder itself is stateful)
+		var builder = VectorStoreChatMemoryAdvisor.builder(vectorStore).conversationId("shared-config");
+
+		VectorStoreChatMemoryAdvisor advisor1 = builder.build();
+		VectorStoreChatMemoryAdvisor advisor2 = builder.build();
+
+		assertThat(advisor1).isNotNull();
+		assertThat(advisor2).isNotNull();
+		assertThat(advisor1).isNotSameAs(advisor2);
+	}
+
+	@Test
+	void whenBuilderWithLongConversationIdThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+		String longId = "a".repeat(1000); // 1000 character conversation ID
+
+		VectorStoreChatMemoryAdvisor advisor = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.conversationId(longId)
+			.build();
+
+		assertThat(advisor).isNotNull();
+	}
+
+	@Test
+	void whenBuilderCalledWithNullAfterValidValueThenThrow() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		assertThatThrownBy(() -> VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.conversationId("valid-id")
+			.conversationId(null) // Set to null after valid value
+			.build()).isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("defaultConversationId cannot be null or empty");
+	}
+
+	@Test
+	void whenBuilderWithTopKBoundaryValuesThenSuccess() {
+		VectorStore vectorStore = Mockito.mock(VectorStore.class);
+
+		// Test with value 1 (minimum valid)
+		VectorStoreChatMemoryAdvisor advisor1 = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.defaultTopK(1)
+			.build();
+
+		// Test with a reasonable upper bound
+		VectorStoreChatMemoryAdvisor advisor2 = VectorStoreChatMemoryAdvisor.builder(vectorStore)
+			.defaultTopK(10000)
+			.build();
+
+		assertThat(advisor1).isNotNull();
+		assertThat(advisor2).isNotNull();
+	}
+
 }

models/spring-ai-google-genai/src/test/java/org/springframework/ai/google/genai/MimeTypeDetectorTests.java

@@ -26,11 +26,13 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import org.springframework.ai.google.genai.MimeTypeDetector;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.springframework.core.io.PathResource;
 import org.springframework.util.MimeType;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatCode;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThatThrownBy;
 import static org.springframework.ai.google.genai.MimeTypeDetector.GEMINI_MIME_TYPES;
 
 /**
@@ -90,4 +92,49 @@ void getMimeTypeByString(String extension, MimeType expectedMimeType) {
 		assertThat(mimeType).isEqualTo(expectedMimeType);
 	}
 
+	@ParameterizedTest
+	@ValueSource(strings = { " ", "\t", "\n" })
+	void getMimeTypeByStringWithInvalidInputShouldThrowException(String invalidPath) {
+		assertThatThrownBy(() -> MimeTypeDetector.getMimeType(invalidPath)).isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("Unable to detect the MIME type");
+	}
+
+	@ParameterizedTest
+	@ValueSource(strings = { "JPG", "PNG", "GIF" })
+	void getMimeTypeByStringWithUppercaseExtensionsShouldWork(String uppercaseExt) {
+		String upperFileName = "test." + uppercaseExt;
+		String lowerFileName = "test." + uppercaseExt.toLowerCase();
+
+		// Should throw for uppercase (not in map) but work for lowercase
+		assertThatThrownBy(() -> MimeTypeDetector.getMimeType(upperFileName))
+			.isInstanceOf(IllegalArgumentException.class);
+
+		// Lowercase should work if it's a supported extension
+		if (GEMINI_MIME_TYPES.containsKey(uppercaseExt.toLowerCase())) {
+			assertThatCode(() -> MimeTypeDetector.getMimeType(lowerFileName)).doesNotThrowAnyException();
+		}
+	}
+
+	@ParameterizedTest
+	@ValueSource(strings = { "test.jpg", "test.png", "test.gif" })
+	void getMimeTypeSupportedFileAcrossDifferentMethodsShouldBeConsistent(String fileName) {
+		MimeType stringResult = MimeTypeDetector.getMimeType(fileName);
+		MimeType fileResult = MimeTypeDetector.getMimeType(new File(fileName));
+		MimeType pathResult = MimeTypeDetector.getMimeType(Path.of(fileName));
+
+		// All methods should return the same result for supported extensions
+		assertThat(stringResult).isEqualTo(fileResult);
+		assertThat(stringResult).isEqualTo(pathResult);
+	}
+
+	@ParameterizedTest
+	@ValueSource(strings = { "https://example.com/documents/file.pdf", "https://example.com/data/file.json",
+			"https://example.com/files/document.txt" })
+	void getMimeTypeByURIWithUnsupportedExtensionsShouldThrowException(String url) {
+		URI uri = URI.create(url);
+
+		assertThatThrownBy(() -> MimeTypeDetector.getMimeType(uri)).isInstanceOf(IllegalArgumentException.class)
+			.hasMessageContaining("Unable to detect the MIME type");
+	}
+
 }