test: Add comprehensive validation tests for OpenAI runtime hints registration

Adds new tests to ensure OpenAI runtime hints are properly registered and stream functionality

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

Author: alxkm

models/spring-ai-openai/src/test/java/org/springframework/ai/openai/aot/OpenAiRuntimeHintsTests.java

@@ -189,4 +189,127 @@ void verifyNestedClassesAreRegistered() {
 		assertThat(registeredTypes.contains(TypeReference.of(OpenAiApi.FunctionTool.Function.class))).isTrue();
 	}
 
+	@Test
+	void verifyPackageSpecificity() {
+		Set<TypeReference> jsonAnnotatedClasses = findJsonAnnotatedClassesInPackage("org.springframework.ai.openai");
+
+		// All found classes should be from the openai package specifically
+		for (TypeReference classRef : jsonAnnotatedClasses) {
+			assertThat(classRef.getName()).startsWith("org.springframework.ai.openai");
+		}
+
+		// Should not include classes from other AI packages
+		for (TypeReference classRef : jsonAnnotatedClasses) {
+			assertThat(classRef.getName()).doesNotContain("anthropic");
+			assertThat(classRef.getName()).doesNotContain("vertexai");
+			assertThat(classRef.getName()).doesNotContain("ollama");
+		}
+	}
+
+	@Test
+	void verifyConsistencyAcrossInstances() {
+		RuntimeHints hints1 = new RuntimeHints();
+		RuntimeHints hints2 = new RuntimeHints();
+
+		OpenAiRuntimeHints openaiHints1 = new OpenAiRuntimeHints();
+		OpenAiRuntimeHints openaiHints2 = new OpenAiRuntimeHints();
+
+		openaiHints1.registerHints(hints1, null);
+		openaiHints2.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 verifySpecificApiClassDetails() {
+		openAiRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Verify critical OpenAI API classes are registered
+		assertThat(registeredTypes.contains(TypeReference.of(OpenAiApi.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(OpenAiAudioApi.class))).isTrue();
+		assertThat(registeredTypes.contains(TypeReference.of(OpenAiImageApi.class))).isTrue();
+
+		// Verify important nested/inner classes
+		boolean containsChatCompletion = registeredTypes.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("ChatCompletion"));
+		assertThat(containsChatCompletion).isTrue();
+
+		boolean containsFunctionTool = registeredTypes.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("FunctionTool"));
+		assertThat(containsFunctionTool).isTrue();
+	}
+
+	@Test
+	void verifyClassLoaderIndependence() {
+		RuntimeHints hintsWithNull = new RuntimeHints();
+		RuntimeHints hintsWithClassLoader = new RuntimeHints();
+
+		ClassLoader customClassLoader = Thread.currentThread().getContextClassLoader();
+
+		openAiRuntimeHints.registerHints(hintsWithNull, null);
+		openAiRuntimeHints.registerHints(hintsWithClassLoader, customClassLoader);
+
+		// Both should register the same types regardless of ClassLoader
+		Set<TypeReference> typesWithNull = new HashSet<>();
+		Set<TypeReference> typesWithClassLoader = new HashSet<>();
+
+		hintsWithNull.reflection().typeHints().forEach(hint -> typesWithNull.add(hint.getType()));
+		hintsWithClassLoader.reflection().typeHints().forEach(hint -> typesWithClassLoader.add(hint.getType()));
+
+		assertThat(typesWithNull).isEqualTo(typesWithClassLoader);
+	}
+
+	@Test
+	void verifyAllApiModulesAreIncluded() {
+		openAiRuntimeHints.registerHints(runtimeHints, null);
+
+		Set<TypeReference> registeredTypes = new HashSet<>();
+		runtimeHints.reflection().typeHints().forEach(typeHint -> registeredTypes.add(typeHint.getType()));
+
+		// Verify all main OpenAI API modules are represented
+		boolean hasMainApi = registeredTypes.stream().anyMatch(typeRef -> typeRef.getName().contains("OpenAiApi"));
+		boolean hasAudioApi = registeredTypes.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("OpenAiAudioApi"));
+		boolean hasImageApi = registeredTypes.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("OpenAiImageApi"));
+		boolean hasChatOptions = registeredTypes.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("OpenAiChatOptions"));
+
+		assertThat(hasMainApi).isTrue();
+		assertThat(hasAudioApi).isTrue();
+		assertThat(hasImageApi).isTrue();
+		assertThat(hasChatOptions).isTrue();
+	}
+
+	@Test
+	void verifyJsonAnnotatedClassesContainCriticalTypes() {
+		Set<TypeReference> jsonAnnotatedClasses = findJsonAnnotatedClassesInPackage("org.springframework.ai.openai");
+
+		// Verify that critical OpenAI types are found
+		boolean containsApiClass = jsonAnnotatedClasses.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("OpenAiApi") || typeRef.getName().contains("ChatCompletion")
+					|| typeRef.getName().contains("OpenAiChatOptions"));
+
+		assertThat(containsApiClass).isTrue();
+
+		// Verify audio and image API classes are found
+		boolean containsAudioApi = jsonAnnotatedClasses.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("AudioApi"));
+		boolean containsImageApi = jsonAnnotatedClasses.stream()
+			.anyMatch(typeRef -> typeRef.getName().contains("ImageApi"));
+
+		assertThat(containsAudioApi).isTrue();
+		assertThat(containsImageApi).isTrue();
+	}
+
 }

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

@@ -162,4 +162,46 @@ public void chunkToChatCompletion_whenInputIsValid() {
 		assertThat(result.choices()).hasSize(2);
 	}
 
-}
+	@Test
+	public void mergeCombinesChunkFieldsCorrectly() {
+		var previous = new OpenAiApi.ChatCompletionChunk(null, null, 123456789L, "gpt-4", "default", null, null, null);
+		var current = new OpenAiApi.ChatCompletionChunk("chat-123", Collections.emptyList(), null, null, null, "fp-456",
+				"chat.completion.chunk", null);
+
+		var result = helper.merge(previous, current);
+
+		assertThat(result.id()).isEqualTo("chat-123");
+		assertThat(result.created()).isEqualTo(123456789L);
+		assertThat(result.model()).isEqualTo("gpt-4");
+		assertThat(result.systemFingerprint()).isEqualTo("fp-456");
+	}
+
+	@Test
+	public void isStreamingToolFunctionCallReturnsFalseForNullOrEmptyChunks() {
+		assertThat(helper.isStreamingToolFunctionCall(null)).isFalse();
+
+		var emptyChunk = new OpenAiApi.ChatCompletionChunk(null, Collections.emptyList(), null, null, null, null, null,
+				null);
+		assertThat(helper.isStreamingToolFunctionCall(emptyChunk)).isFalse();
+	}
+
+	@Test
+	public void isStreamingToolFunctionCall_returnsTrueForValidToolCalls() {
+		var toolCall = Mockito.mock(OpenAiApi.ChatCompletionMessage.ToolCall.class);
+		var delta = new OpenAiApi.ChatCompletionMessage(null, null, null, null, List.of(toolCall), null, null, null);
+		var choice = new OpenAiApi.ChatCompletionChunk.ChunkChoice(null, null, delta, null);
+		var chunk = new OpenAiApi.ChatCompletionChunk(null, List.of(choice), null, null, null, null, null, null);
+
+		assertThat(helper.isStreamingToolFunctionCall(chunk)).isTrue();
+	}
+
+	@Test
+	public void isStreamingToolFunctionCallFinishDetectsToolCallsFinishReason() {
+		var choice = new OpenAiApi.ChatCompletionChunk.ChunkChoice(OpenAiApi.ChatCompletionFinishReason.TOOL_CALLS,
+				null, new OpenAiApi.ChatCompletionMessage(null, null), null);
+		var chunk = new OpenAiApi.ChatCompletionChunk(null, List.of(choice), null, null, null, null, null, null);
+
+		assertThat(helper.isStreamingToolFunctionCallFinish(chunk)).isTrue();
+	}
+
+}