Constructor and code quality

- OpenAiSpringEmbeddingModel(client)
- unit tests added
- e2e test added
- java docs

Author: rpanackal

foundation-models/openai/src/main/java/com/sap/ai/sdk/foundationmodels/openai/spring/OpenAiSpringEmbeddingModel.java

@@ -1,14 +1,13 @@
 package com.sap.ai.sdk.foundationmodels.openai.spring;
 
+import com.google.common.annotations.Beta;
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiClient;
-import com.sap.ai.sdk.foundationmodels.openai.OpenAiModel;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.EmbeddingsCreate200Response;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.EmbeddingsCreateRequest;
 import com.sap.ai.sdk.foundationmodels.openai.generated.model.EmbeddingsCreateRequestInput;
 import java.util.Objects;
 import java.util.stream.IntStream;
 import javax.annotation.Nonnull;
-import lombok.NoArgsConstructor;
 import org.springframework.ai.chat.metadata.DefaultUsage;
 import org.springframework.ai.document.Document;
 import org.springframework.ai.embedding.Embedding;
@@ -17,29 +16,45 @@
 import org.springframework.ai.embedding.EmbeddingResponse;
 import org.springframework.ai.embedding.EmbeddingResponseMetadata;
 
-@NoArgsConstructor
+/**
+ * SpringAI integration with {@link OpenAiClient} to generate embeddings.
+ *
+ * <p>This model transforms an {@link EmbeddingRequest} into an Azure OpenAI request, processes the
+ * response, and returns a Spring AI {@link EmbeddingResponse}.
+ *
+ * @since 1.5.0
+ */
+@Beta
 public class OpenAiSpringEmbeddingModel implements EmbeddingModel {
 
+  private final OpenAiClient client;
+
+  /**
+   * Constructs an {@code OpenAiSpringEmbeddingModel} with the specified {@link OpenAiClient} of
+   * some model.
+   *
+   * @param client the OpenAI client
+   */
+  public OpenAiSpringEmbeddingModel(@Nonnull final OpenAiClient client) {
+    this.client = client;
+  }
+
   @Override
+  @Nonnull
   public EmbeddingResponse call(@Nonnull final EmbeddingRequest request) {
-    var modelName =
-        Objects.requireNonNull(
-            request.getOptions().getModel(), "Model name is required if client is not set");
-    var client = OpenAiClient.forModel(new OpenAiModel(modelName, null));
-
-    var openAiRequest = createEmbeddingCreateRequest(request);
-    var openAiResponse = client.embedding(openAiRequest);
+    final var openAiRequest = createEmbeddingCreateRequest(request);
+    final var openAiResponse = client.embedding(openAiRequest);
 
     return createSpringAiEmbeddingResponse(openAiResponse);
   }
 
   @Override
-  public float[] embed(@Nonnull final Document document) {
+  @Nonnull
+  public float[] embed(@Nonnull final Document document) throws UnsupportedOperationException {
     if (document.isText()) {
-      return embed(document.getText());
+      return embed(Objects.requireNonNull(document.getText(), "Document text is null"));
     }
-    throw new UnsupportedOperationException(
-        "Only text type document supported. Metadata contains " + document.getMetadata());
+    throw new UnsupportedOperationException("Only text type document supported for embedding");
   }
 
   private EmbeddingsCreateRequest createEmbeddingCreateRequest(
@@ -49,15 +64,17 @@ private EmbeddingsCreateRequest createEmbeddingCreateRequest(
         .input(EmbeddingsCreateRequestInput.create(request.getInstructions()));
   }
 
-  private EmbeddingResponse createSpringAiEmbeddingResponse(EmbeddingsCreate200Response response) {
-    var embeddings =
+  private EmbeddingResponse createSpringAiEmbeddingResponse(
+      @Nonnull final EmbeddingsCreate200Response response) {
+    final var embeddings =
         IntStream.range(0, response.getData().size())
             .mapToObj(i -> new Embedding(response.getData().get(i).getEmbedding(), i))
             .toList();
 
-    var openAiUsage = response.getUsage();
-    var usage = new DefaultUsage(openAiUsage.getPromptTokens(), null, openAiUsage.getTotalTokens());
-    var metadata = new EmbeddingResponseMetadata(response.getModel(), usage);
+    final var openAiUsage = response.getUsage();
+    final var usage =
+        new DefaultUsage(openAiUsage.getPromptTokens(), null, openAiUsage.getTotalTokens());
+    final var metadata = new EmbeddingResponseMetadata(response.getModel(), usage);
 
     return new EmbeddingResponse(embeddings, metadata);
   }

foundation-models/openai/src/test/java/com/sap/ai/sdk/foundationmodels/openai/spring/EmbeddingModelTest.java

@@ -1,9 +1,10 @@
 package com.sap.ai.sdk.foundationmodels.openai.spring;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.when;
 
 import com.sap.ai.sdk.foundationmodels.openai.OpenAiClient;
@@ -15,24 +16,23 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.ai.chat.metadata.DefaultUsage;
+import org.springframework.ai.document.Document;
 import org.springframework.ai.embedding.Embedding;
 import org.springframework.ai.embedding.EmbeddingOptionsBuilder;
 import org.springframework.ai.embedding.EmbeddingRequest;
 import org.springframework.ai.embedding.EmbeddingResponse;
 import org.springframework.ai.embedding.EmbeddingResponseMetadata;
 
 class EmbeddingModelTest {
-  private OpenAiSpringEmbeddingModel model;
   private OpenAiClient client;
 
   @BeforeEach
   void setUp() {
     client = mock(OpenAiClient.class);
-    model = new OpenAiSpringEmbeddingModel();
   }
 
   @Test
-  void testCall() {
+  void callWithValidRequest() {
     var request =
         new EmbeddingRequest(
             List.of("instructions"),
@@ -52,12 +52,37 @@ void testCall() {
 
     when(client.embedding(any(EmbeddingsCreateRequest.class))).thenReturn(openAiResponse);
 
-    try (var mockedStatic = mockStatic(OpenAiClient.class)) {
-      mockedStatic.when(() -> OpenAiClient.forModel(any())).thenReturn(client);
+    var actualResponse = new OpenAiSpringEmbeddingModel(client).call(request);
 
-      var actualResponse = model.call(request);
+    assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(actualResponse);
+  }
+
+  @Test
+  void embedDocumentInvokesDefaultMethod() {
+    Document document = new Document("Some content");
+
+    OpenAiSpringEmbeddingModel model =
+        new OpenAiSpringEmbeddingModel(client) {
+          @Override
+          public float[] embed(String text) {
+            // For testing, just return any array
+            return new float[] {1, 2, 3};
+          }
+        };
+
+    float[] result = model.embed(document);
+    assertArrayEquals(new float[] {1, 2, 3}, result);
+  }
+
+  @Test
+  void embedDocumentThrowsException() {
+    var document = mock(Document.class);
+    when(document.isText()).thenReturn(false);
+
+    var model = new OpenAiSpringEmbeddingModel(client);
 
-      assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(actualResponse);
-    }
+    assertThatThrownBy(() -> model.embed(document))
+        .isInstanceOf(UnsupportedOperationException.class)
+        .hasMessage("Only text type document supported for embedding");
   }
 }

sample-code/spring-app/src/main/java/com/sap/ai/sdk/app/services/SpringAiOpenAiService.java

@@ -1,25 +1,45 @@
 package com.sap.ai.sdk.app.services;
 
+import com.sap.ai.sdk.foundationmodels.openai.OpenAiClient;
+import com.sap.ai.sdk.foundationmodels.openai.OpenAiModel;
 import com.sap.ai.sdk.foundationmodels.openai.spring.OpenAiSpringEmbeddingModel;
 import java.util.List;
+import javax.annotation.Nonnull;
+import org.springframework.ai.document.Document;
 import org.springframework.ai.embedding.EmbeddingOptionsBuilder;
 import org.springframework.ai.embedding.EmbeddingRequest;
 import org.springframework.ai.embedding.EmbeddingResponse;
 import org.springframework.stereotype.Service;
 
+/** Service class for Spring AI integration with OpenAI */
 @Service
 public class SpringAiOpenAiService {
-  public EmbeddingResponse embeddingWithStrings(String modelName) {
 
-    var options =
-        EmbeddingOptionsBuilder.builder().withModel(modelName).withDimensions(128).build();
+  private final OpenAiClient client = OpenAiClient.forModel(OpenAiModel.TEXT_EMBEDDING_3_SMALL);
 
-    var springAiRequest =
-        new EmbeddingRequest(
-            List.of(
-                "The quick brown fox jumps over the lazy dog.",
-                "To be or not to be, that is the question."),
-            options);
-    return new OpenAiSpringEmbeddingModel().call(springAiRequest);
+  /**
+   * Embeds a list of strings using the OpenAI embedding model.
+   *
+   * @param strings the list of strings to embed
+   * @return an {@code EmbeddingResponse} containing the embeddings and metadata
+   */
+  @Nonnull
+  public EmbeddingResponse embedWithEmbeddingRequest(@Nonnull final List<String> strings) {
+    final var options = EmbeddingOptionsBuilder.builder().withDimensions(128).build();
+    final var springAiRequest = new EmbeddingRequest(strings, options);
+
+    return new OpenAiSpringEmbeddingModel(client).call(springAiRequest);
+  }
+
+  /**
+   * Embeds the content of a document using the OpenAI embedding model.
+   *
+   * @param content the content of the document to embed
+   * @return a float array representing the embedding of the document's content
+   */
+  @Nonnull
+  public float[] embedWithDocument(@Nonnull final String content) {
+    final var document = new Document(content);
+    return new OpenAiSpringEmbeddingModel(client).embed(document);
   }
 }

sample-code/spring-app/src/test/java/com/sap/ai/sdk/app/controllers/SpringAiOpenAiTest.java

@@ -3,18 +3,29 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.sap.ai.sdk.app.services.SpringAiOpenAiService;
+import com.sap.ai.sdk.foundationmodels.openai.OpenAiModel;
+import java.util.List;
 import org.junit.jupiter.api.Test;
 
 class SpringAiOpenAiTest {
 
-  private SpringAiOpenAiService service = new SpringAiOpenAiService();
+  private final SpringAiOpenAiService service = new SpringAiOpenAiService();
 
   @Test
-  void testEmbeddingWithStrings() {
+  void testEmbedWithEmbeddingRequest() {
 
-    var response = service.embeddingWithStrings("text-embedding-3-small");
+    var response =
+        service.embedWithEmbeddingRequest(
+            List.of(
+                "The quick brown fox jumps over the lazy dog.",
+                "To be or not to be, that is the question."));
 
     assertThat(response).isNotNull();
     assertThat(response.getResults()).hasSize(2);
+    assertThat(response.getResults().get(0).getOutput()).hasSize(128);
+    assertThat(response.getMetadata().getUsage().getPromptTokens()).isNotNull();
+    assertThat(response.getMetadata().getUsage().getTotalTokens()).isNotNull();
+    assertThat(response.getMetadata().getModel())
+        .isEqualTo(OpenAiModel.TEXT_EMBEDDING_3_SMALL.name());
   }
 }