textAnnotation) {
+ CdsElement el = mock(CdsElement.class);
+ when(el.getName()).thenReturn(name);
+ CdsType type = mock(CdsType.class);
+ lenient().when(type.getQualifiedName()).thenReturn(cdsType);
+ lenient().when(el.getType()).thenReturn(type);
+ when(el.findAnnotation("@Common.ValueList")).thenReturn(Optional.empty());
+ Optional valueListAnn =
+ hasValueList ? Optional.of(mock(CdsAnnotation.class)) : Optional.empty();
+ when(el.findAnnotation("@Common.ValueListWithFixedValues")).thenReturn(valueListAnn);
+ lenient().when(el.findAnnotation("@Common.Text")).thenReturn((Optional) textAnnotation);
+ return el;
+ }
+}
diff --git a/srv/src/test/java/com/sap/cds/feature/ai/client/AICoreClientPredictionTest.java b/srv/src/test/java/com/sap/cds/feature/ai/client/AICoreClientPredictionTest.java
new file mode 100644
index 0000000..bdf43a0
--- /dev/null
+++ b/srv/src/test/java/com/sap/cds/feature/ai/client/AICoreClientPredictionTest.java
@@ -0,0 +1,232 @@
+/*
+ * © 2026 SAP SE or an SAP affiliate company and cds-feature-ai contributors.
+ */
+package com.sap.cds.feature.ai.client;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sap.cds.feature.ai.client.setup.AICoreSetupHandler;
+import com.sap.cds.services.environment.CdsEnvironment;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.mockito.Mockito;
+
+/**
+ * Integration test verifying the full prediction flow against a real AI Core instance.
+ *
+ * Required environment variables: AICORE_SERVICE_KEY – Full AI Core service key JSON: {
+ * "clientid": "...", "clientsecret": "...", "url": "...", "serviceurls": { "AI_API_URL": "..." } }
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class AICoreClientPredictionTest {
+
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+
+ private AICoreClient cut;
+ private Map credentials;
+ private String resourceGroup;
+
+ @BeforeAll
+ void setup() throws Exception {
+ String serviceKey = System.getenv("AICORE_SERVICE_KEY");
+ assumeTrue(serviceKey != null, "Skipping integration test: AICORE_SERVICE_KEY env var not set");
+
+ credentials = MAPPER.readValue(serviceKey, new TypeReference<>() {});
+ resourceGroup = "default";
+ CdsEnvironment environment = Mockito.mock(CdsEnvironment.class);
+ cut = new AICoreClient(new AICoreSetupHandler(environment));
+ }
+
+ /**
+ * Full prediction flow: 1. Check deployments in the resource group 2. If no RUNNING rpt-1
+ * deployment exists, create one and wait for it to reach RUNNING 3. Call fetchPredictions with a
+ * small context row and a [PREDICT] row 4. Verify predictions are returned
+ */
+ @Test
+ void prediction_deploymentMissingOrPresent_returnsPredictions() throws Exception {
+ String aiApiUrl = ((Map) credentials.get("serviceurls")).get("AI_API_URL").toString();
+ String token = fetchToken();
+
+ // Step 1+2: ensure a RUNNING rpt-1 deployment exists (create if missing)
+ ensureRunningRpt1Deployment(aiApiUrl, token);
+
+ // Step 3: build rows — two context rows + one [PREDICT] row
+ Map contextRow1 = new HashMap<>();
+ contextRow1.put("ID", "ctx-1");
+ contextRow1.put("genre_ID", 10);
+ contextRow1.put("title", "Eleonora");
+
+ Map contextRow2 = new HashMap<>();
+ contextRow2.put("ID", "ctx-2");
+ contextRow2.put("genre_ID", 20);
+ contextRow2.put("title", "Another Book");
+
+ Map predictRow = new HashMap<>();
+ predictRow.put("ID", "predict-1");
+ predictRow.put("genre_ID", "[PREDICT]");
+ predictRow.put("title", "Eleonora");
+
+ List> predictions =
+ cut.fetchPredictions(
+ List.of(contextRow1, contextRow2, predictRow), List.of("genre_ID"), null);
+
+ // Step 4: verify
+ assertThat(predictions)
+ .as("Should return at least one prediction result")
+ .isNotNull()
+ .isNotEmpty();
+
+ Map prediction = predictions.get(0);
+ assertThat(prediction).containsKey("genre_ID");
+ }
+
+ // ── helpers ──────────────────────────────────────────────────────────────
+
+ /**
+ * Checks whether a RUNNING rpt-1 deployment exists. If not, creates one and polls until it
+ * reaches RUNNING (up to ~5 minutes with exponential back-off).
+ */
+ private void ensureRunningRpt1Deployment(String aiApiUrl, String token) throws Exception {
+ HttpClient client = HttpClient.newHttpClient();
+
+ // Check existing deployments
+ HttpResponse listResponse =
+ client.send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/lm/deployments"))
+ .header("Authorization", "Bearer " + token)
+ .header("AI-Resource-Group", resourceGroup)
+ .GET()
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+
+ Map listResult =
+ MAPPER.readValue(listResponse.body(), new TypeReference<>() {});
+ List> deployments =
+ MAPPER.convertValue(listResult.get("resources"), new TypeReference<>() {});
+
+ boolean hasRunning =
+ deployments != null
+ && deployments.stream()
+ .anyMatch(
+ d ->
+ d.get("configurationName") != null
+ && d.get("configurationName").toString().contains("rpt-1")
+ && "RUNNING".equals(d.get("status")));
+
+ if (hasRunning) {
+ return; // nothing to do
+ }
+
+ // Find the rpt-1 configuration
+ HttpResponse cfgResponse =
+ client.send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/lm/configurations"))
+ .header("Authorization", "Bearer " + token)
+ .header("AI-Resource-Group", resourceGroup)
+ .GET()
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+
+ Map cfgResult = MAPPER.readValue(cfgResponse.body(), new TypeReference<>() {});
+ List> configurations =
+ MAPPER.convertValue(cfgResult.get("resources"), new TypeReference<>() {});
+ assertThat(configurations)
+ .as(
+ "No rpt-1 configuration found in resource group "
+ + resourceGroup
+ + " — cannot create a deployment. Ensure the configuration exists.")
+ .isNotNull()
+ .isNotEmpty();
+
+ String configurationId =
+ configurations.stream()
+ .filter(c -> c.get("name") != null && c.get("name").toString().contains("rpt-1"))
+ .map(c -> c.get("id").toString())
+ .findFirst()
+ .orElseThrow(
+ () ->
+ new AssertionError(
+ "No rpt-1 configuration found in resource group: " + resourceGroup));
+
+ // Create the deployment
+ String createBody = MAPPER.writeValueAsString(Map.of("configurationId", configurationId));
+ HttpResponse createResponse =
+ client.send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/lm/deployments"))
+ .header("Authorization", "Bearer " + token)
+ .header("Content-Type", "application/json")
+ .header("AI-Resource-Group", resourceGroup)
+ .POST(HttpRequest.BodyPublishers.ofString(createBody))
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+
+ Map created = MAPPER.readValue(createResponse.body(), new TypeReference<>() {});
+ String deploymentId = created.get("id").toString();
+
+ // Poll until RUNNING
+ for (int i = 0; i < 10; i++) {
+ long delay = 300L * (1L << i);
+ System.out.printf(
+ "Waiting %dms for deployment %s to reach RUNNING (attempt %d/10)%n",
+ delay, deploymentId, i + 1);
+ Thread.sleep(delay);
+
+ token = fetchToken();
+ HttpResponse statusResponse =
+ client.send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/lm/deployments/" + deploymentId))
+ .header("Authorization", "Bearer " + token)
+ .header("AI-Resource-Group", resourceGroup)
+ .GET()
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+
+ Map status =
+ MAPPER.readValue(statusResponse.body(), new TypeReference<>() {});
+ if ("RUNNING".equals(status.get("status"))) {
+ return;
+ }
+ }
+ throw new AssertionError(
+ "Deployment " + deploymentId + " did not reach RUNNING within timeout");
+ }
+
+ /** Fetches a fresh OAuth token using service key credentials. */
+ private String fetchToken() throws Exception {
+ String body =
+ "grant_type=client_credentials"
+ + "&client_id="
+ + URLEncoder.encode(credentials.get("clientid").toString(), "UTF-8")
+ + "&client_secret="
+ + URLEncoder.encode(credentials.get("clientsecret").toString(), "UTF-8");
+
+ HttpResponse response =
+ HttpClient.newHttpClient()
+ .send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(credentials.get("url") + "/oauth/token"))
+ .header("Content-Type", "application/x-www-form-urlencoded")
+ .POST(HttpRequest.BodyPublishers.ofString(body))
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+
+ Map data = MAPPER.readValue(response.body(), new TypeReference<>() {});
+ return data.get("access_token").toString();
+ }
+}
diff --git a/srv/src/test/java/com/sap/cds/feature/ai/client/MockAIClientTest.java b/srv/src/test/java/com/sap/cds/feature/ai/client/MockAIClientTest.java
new file mode 100644
index 0000000..b9649ec
--- /dev/null
+++ b/srv/src/test/java/com/sap/cds/feature/ai/client/MockAIClientTest.java
@@ -0,0 +1,146 @@
+/*
+ * © 2026 SAP SE or an SAP affiliate company and cds-feature-ai contributors.
+ */
+package com.sap.cds.feature.ai.client;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class MockAIClientTest {
+
+ private MockAIClient cut;
+
+ @BeforeEach
+ void setup() {
+ cut = new MockAIClient();
+ }
+
+ @Test
+ void noRowsReturnsEmpty() {
+ List> result =
+ cut.fetchPredictions(new ArrayList<>(), List.of("genre_ID"), null);
+ assertThat(result).isEmpty();
+ }
+
+ @Test
+ void rowWithoutPredictPlaceholderIsSkipped() {
+ Map row = new HashMap<>();
+ row.put("ID", "id-1");
+ row.put("genre_ID", 10);
+
+ List> result =
+ cut.fetchPredictions(List.of(row), List.of("genre_ID"), null);
+
+ assertThat(result).isEmpty();
+ }
+
+ @Test
+ void rowWithPredictPlaceholderReturnsPrediction() {
+ Map contextRow = new HashMap<>();
+ contextRow.put("ID", "id-1");
+ contextRow.put("genre_ID", 10);
+
+ Map predictRow = new HashMap<>();
+ predictRow.put("ID", "id-2");
+ predictRow.put("genre_ID", "[PREDICT]");
+
+ List> result =
+ cut.fetchPredictions(List.of(contextRow, predictRow), List.of("genre_ID"), null);
+
+ assertThat(result).hasSize(1);
+ assertThat(result.get(0).get("ID")).isEqualTo("id-2");
+
+ @SuppressWarnings("unchecked")
+ List> preds = (List>) result.get(0).get("genre_ID");
+ assertThat(preds).hasSize(1);
+ assertThat(preds.get(0).get("prediction")).isEqualTo(10);
+ }
+
+ @Test
+ void predictionPicksValueFromContextRows() {
+ Map c1 = new HashMap<>();
+ c1.put("ID", "id-1");
+ c1.put("genre_ID", 10);
+
+ Map c2 = new HashMap<>();
+ c2.put("ID", "id-2");
+ c2.put("genre_ID", 20);
+
+ Map predictRow = new HashMap<>();
+ predictRow.put("ID", "id-3");
+ predictRow.put("genre_ID", "[PREDICT]");
+
+ List> result =
+ cut.fetchPredictions(List.of(c1, c2, predictRow), List.of("genre_ID"), null);
+
+ assertThat(result).hasSize(1);
+ @SuppressWarnings("unchecked")
+ List> preds = (List>) result.get(0).get("genre_ID");
+ assertThat(preds.get(0).get("prediction")).isIn(10, 20);
+ }
+
+ @Test
+ void multipleColumnsEachGetPrediction() {
+ Map contextRow = new HashMap<>();
+ contextRow.put("ID", "id-1");
+ contextRow.put("genre_ID", 10);
+ contextRow.put("currency_code", "EUR");
+
+ Map predictRow = new HashMap<>();
+ predictRow.put("ID", "id-2");
+ predictRow.put("genre_ID", "[PREDICT]");
+ predictRow.put("currency_code", "[PREDICT]");
+
+ List> result =
+ cut.fetchPredictions(
+ List.of(contextRow, predictRow), List.of("genre_ID", "currency_code"), null);
+
+ assertThat(result).hasSize(1);
+ Map prediction = result.get(0);
+ assertThat(prediction).containsKey("genre_ID");
+ assertThat(prediction).containsKey("currency_code");
+ }
+
+ @Test
+ void noContextValuesResultsInNullPrediction() {
+ // Only the predict row, no context rows with real values
+ Map predictRow = new HashMap<>();
+ predictRow.put("ID", "id-1");
+ predictRow.put("genre_ID", "[PREDICT]");
+
+ List> result =
+ cut.fetchPredictions(List.of(predictRow), List.of("genre_ID"), null);
+
+ assertThat(result).hasSize(1);
+ @SuppressWarnings("unchecked")
+ List> preds = (List>) result.get(0).get("genre_ID");
+ assertThat(preds.get(0).get("prediction")).isNull();
+ }
+
+ @Test
+ void multipleRowsWithPredictEachGetPredicted() {
+ Map contextRow = new HashMap<>();
+ contextRow.put("ID", "id-1");
+ contextRow.put("genre_ID", 10);
+
+ Map predictRow1 = new HashMap<>();
+ predictRow1.put("ID", "id-2");
+ predictRow1.put("genre_ID", "[PREDICT]");
+
+ Map predictRow2 = new HashMap<>();
+ predictRow2.put("ID", "id-3");
+ predictRow2.put("genre_ID", "[PREDICT]");
+
+ List> result =
+ cut.fetchPredictions(
+ List.of(contextRow, predictRow1, predictRow2), List.of("genre_ID"), null);
+
+ assertThat(result).hasSize(2);
+ }
+}
diff --git a/srv/src/test/java/com/sap/cds/feature/ai/client/setup/AICoreSetupHandlerTest.java b/srv/src/test/java/com/sap/cds/feature/ai/client/setup/AICoreSetupHandlerTest.java
new file mode 100644
index 0000000..5d40fd7
--- /dev/null
+++ b/srv/src/test/java/com/sap/cds/feature/ai/client/setup/AICoreSetupHandlerTest.java
@@ -0,0 +1,216 @@
+/*
+ * © 2026 SAP SE or an SAP affiliate company and cds-feature-ai contributors.
+ */
+package com.sap.cds.feature.ai.client.setup;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+import static org.mockito.Mockito.*;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.sap.cds.feature.ai.client.AICoreClient;
+import com.sap.cds.services.environment.CdsEnvironment;
+import com.sap.cds.services.mt.SubscribeEventContext;
+import com.sap.cds.services.mt.UnsubscribeEventContext;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Integration test verifying the full AICoreSetup lifecycle against a real AI Core instance.
+ * Requires an AI Core service instance bound to the app (VCAP_SERVICES).
+ */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class AICoreSetupHandlerTest {
+
+ private static final String TEST_TENANT = "it-test-tenant-" + System.currentTimeMillis();
+ private static final String TENANT_LABEL_KEY = "ext.ai.sap.com/CDS_TENANT_ID";
+ private static final ObjectMapper MAPPER = new ObjectMapper();
+ private static final Logger logger = LoggerFactory.getLogger(AICoreSetupHandlerTest.class);
+
+ private AICoreSetupHandler cut;
+ private AICoreClient client;
+ private Map credentials;
+ private String aiApiUrl;
+
+ @BeforeAll
+ void setup() throws Exception {
+ String vcap = System.getenv("VCAP_SERVICES");
+ String serviceKey = null;
+ if (vcap != null) {
+ Map vcapServices = MAPPER.readValue(vcap, new TypeReference<>() {});
+ List> aicoreBindings =
+ MAPPER.convertValue(vcapServices.get("aicore"), new TypeReference<>() {});
+ if (aicoreBindings != null && !aicoreBindings.isEmpty()) {
+ serviceKey = MAPPER.writeValueAsString(aicoreBindings.get(0).get("credentials"));
+ }
+ }
+ assumeTrue(
+ serviceKey != null, "Skipping integration test: VCAP_SERVICES with aicore binding not set");
+
+ credentials = MAPPER.readValue(serviceKey, new TypeReference<>() {});
+ aiApiUrl = ((Map) credentials.get("serviceurls")).get("AI_API_URL").toString();
+
+ System.setProperty("cds.multitenancy.enabled", "true");
+ CdsEnvironment environment = mock(CdsEnvironment.class);
+ cut = new AICoreSetupHandler(environment);
+ client = new AICoreClient(cut);
+ }
+
+ @AfterAll
+ void tearDown() {
+ System.clearProperty("cds.multitenancy.enabled");
+ }
+
+ /**
+ * Full lifecycle: 1. Subscribe → resource group created online + in local cache 2.
+ * fetchPredictions → RPT-1 deployment created online + in local cache 3. Unsubscribe → resource
+ * group deleted online + removed from both caches
+ */
+ @Test
+ void lifecycle_subscribeCreatesPredictCreatesDeploymentUnsubscribeDeletesAll() throws Exception {
+
+ // ── 1. Subscribe ──────────────────────────────────────────────────────
+ SubscribeEventContext subCtx = mock(SubscribeEventContext.class);
+ when(subCtx.getTenant()).thenReturn(TEST_TENANT);
+ cut.afterSubscribe(subCtx);
+
+ String token = fetchToken();
+ String resourceGroupId = findResourceGroupByTenant(token, TEST_TENANT);
+ assertThat(resourceGroupId)
+ .as("Resource group should exist online after subscribe")
+ .isNotNull();
+ assertThat(cut.getTenantResourceGroupCache())
+ .as("Resource group should be cached after subscribe")
+ .containsKey(TEST_TENANT);
+
+ // ── 2. fetchPredictions ───────────────────────────────────────────────
+ // This triggers RPT-1 deployment creation + polling until RUNNING.
+ // The inference call itself may fail (due to no meaningful data) but the deployment
+ // must be RUNNING before inference is attempted.
+ try {
+ client.fetchPredictions(
+ List.of(Map.of("ID", "1", "title", "test book")), List.of("genre"), TEST_TENANT);
+ } catch (RuntimeException e) {
+ // Inference errors are acceptable; we only assert the deployment was created.
+ }
+
+ token = fetchToken();
+ String deploymentId = findDeploymentForResourceGroup(token, resourceGroupId);
+ assertThat(deploymentId)
+ .as("RPT-1 deployment should exist online after fetchPredictions")
+ .isNotNull();
+ assertThat(cut.getResourceGroupDeploymentCache())
+ .as("Deployment should be cached after fetchPredictions")
+ .containsEntry(resourceGroupId, deploymentId);
+
+ // ── 3. Unsubscribe ────────────────────────────────────────────────────
+ UnsubscribeEventContext unsubCtx = mock(UnsubscribeEventContext.class);
+ when(unsubCtx.getTenant()).thenReturn(TEST_TENANT);
+ cut.beforeUnsubscribe(unsubCtx);
+
+ // Caches are cleared synchronously
+ assertThat(cut.getTenantResourceGroupCache())
+ .as("Resource group should be removed from cache after unsubscribe")
+ .doesNotContainKey(TEST_TENANT);
+ assertThat(cut.getResourceGroupDeploymentCache())
+ .as("Deployment should be removed from cache after unsubscribe")
+ .doesNotContainKey(resourceGroupId);
+
+ // AI Core deletes resource groups asynchronously — poll until gone
+ waitUntilResourceGroupGone(TEST_TENANT);
+ }
+
+ // ── helpers ──────────────────────────────────────────────────────────────
+
+ private void waitUntilResourceGroupGone(String tenant) throws Exception {
+ long delay = 500;
+ int maxRetries = 10;
+ for (int i = 0; i < maxRetries; i++) {
+ Thread.sleep(delay);
+ String id = findResourceGroupByTenant(fetchToken(), tenant);
+ if (id == null) return;
+ logger.debug(
+ "Resource group still present after unsubscribe, retrying in {} ms ({}/{})",
+ delay * 2,
+ i + 1,
+ maxRetries);
+ delay *= 2;
+ }
+ assertThat(findResourceGroupByTenant(fetchToken(), tenant))
+ .as("Resource group should be gone online after unsubscribe")
+ .isNull();
+ }
+
+ private String findResourceGroupByTenant(String token, String tenant) throws Exception {
+ String encoded = URLEncoder.encode(TENANT_LABEL_KEY + "=" + tenant, "UTF-8");
+ HttpResponse response =
+ HttpClient.newHttpClient()
+ .send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/admin/resourceGroups?labelSelector=" + encoded))
+ .header("Authorization", "Bearer " + token)
+ .GET()
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+ Map result = MAPPER.readValue(response.body(), new TypeReference<>() {});
+ List> resources =
+ MAPPER.convertValue(result.get("resources"), new TypeReference<>() {});
+ if (resources == null || resources.isEmpty()) return null;
+ return resources.get(0).get("resourceGroupId").toString();
+ }
+
+ private String findDeploymentForResourceGroup(String token, String resourceGroupId)
+ throws Exception {
+ HttpResponse response =
+ HttpClient.newHttpClient()
+ .send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(aiApiUrl + "/v2/lm/deployments"))
+ .header("Authorization", "Bearer " + token)
+ .header("AI-Resource-Group", resourceGroupId)
+ .GET()
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+ Map result = MAPPER.readValue(response.body(), new TypeReference<>() {});
+ List> resources =
+ MAPPER.convertValue(result.get("resources"), new TypeReference<>() {});
+ if (resources == null || resources.isEmpty()) return null;
+ return resources.stream()
+ .filter(d -> "RUNNING".equals(d.get("status")) || "PENDING".equals(d.get("status")))
+ .findFirst()
+ .map(d -> d.get("id").toString())
+ .orElse(null);
+ }
+
+ private String fetchToken() throws Exception {
+ String body =
+ "grant_type=client_credentials"
+ + "&client_id="
+ + URLEncoder.encode(credentials.get("clientid").toString(), "UTF-8")
+ + "&client_secret="
+ + URLEncoder.encode(credentials.get("clientsecret").toString(), "UTF-8");
+ HttpResponse response =
+ HttpClient.newHttpClient()
+ .send(
+ HttpRequest.newBuilder()
+ .uri(URI.create(credentials.get("url") + "/oauth/token"))
+ .header("Content-Type", "application/x-www-form-urlencoded")
+ .POST(HttpRequest.BodyPublishers.ofString(body))
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+ Map data = MAPPER.readValue(response.body(), new TypeReference<>() {});
+ return data.get("access_token").toString();
+ }
+}