Provides utilities for: + *
For tests that require LLM, use either: + *
Tests various DBA question categories: + *
Configuration requirements: + *
Performance targets: + *
Tests in this class require LLM configuration and will be skipped if not available. */ @DisplayName("Chat Prompt Integration Tests") +@RequiresLlm(chat = true) class ChatPromptIntegrationTest extends BaseIntegrationTest { @Autowired diff --git a/backend/src/test/java/com/dbaagent/support/LlmAvailabilityCondition.java b/backend/src/test/java/com/dbaagent/support/LlmAvailabilityCondition.java new file mode 100644 index 0000000..8632cf7 --- /dev/null +++ b/backend/src/test/java/com/dbaagent/support/LlmAvailabilityCondition.java @@ -0,0 +1,112 @@ +package com.dbaagent.support; + +import org.junit.jupiter.api.extension.ConditionEvaluationResult; +import org.junit.jupiter.api.extension.ExecutionCondition; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.platform.commons.support.AnnotationSupport; + +import java.util.Optional; + +/** + * JUnit 5 ExecutionCondition that checks whether LLM configuration is available. + * + *
This condition checks the {@code DEEPSQL_CHAT_*} and {@code DEEPSQL_EMBEDDING_*} + * environment variables to determine if LLM is configured. It uses the same resolution + * logic as {@code LlmConfigResolver.fromEnvironment()}. + * + *
For integration tests running within a Spring context, the actual
+ * {@code LlmConfigResolver} bean should be used via {@link LlmTestSupport} for
+ * more accurate checks that include database-stored configuration.
+ */
+public class LlmAvailabilityCondition implements ExecutionCondition {
+
+ private static final String CHAT_PROVIDER_ENV = "DEEPSQL_CHAT_PROVIDER";
+ private static final String CHAT_API_KEY_ENV = "DEEPSQL_CHAT_API_KEY";
+ private static final String EMBEDDING_PROVIDER_ENV = "DEEPSQL_EMBEDDING_PROVIDER";
+ private static final String EMBEDDING_API_KEY_ENV = "DEEPSQL_EMBEDDING_API_KEY";
+
+ @Override
+ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+ Optional This mirrors the logic in {@code LlmConfigResolver.fromEnvironment("CHAT")}.
+ */
+ public static boolean isChatConfigured() {
+ String provider = System.getenv(CHAT_PROVIDER_ENV);
+ String apiKey = System.getenv(CHAT_API_KEY_ENV);
+ return isConfigured(provider, apiKey);
+ }
+
+ /**
+ * Checks if embedding LLM is configured via environment variables.
+ *
+ * This mirrors the logic in {@code LlmConfigResolver.fromEnvironment("EMBEDDING")}.
+ */
+ public static boolean isEmbeddingConfigured() {
+ String provider = System.getenv(EMBEDDING_PROVIDER_ENV);
+ String apiKey = System.getenv(EMBEDDING_API_KEY_ENV);
+ return isConfigured(provider, apiKey);
+ }
+
+ private static boolean isConfigured(String provider, String apiKey) {
+ return provider != null && !provider.isBlank()
+ && apiKey != null && !apiKey.isBlank();
+ }
+
+ /**
+ * Returns a human-readable description of the current LLM configuration status.
+ * Useful for test diagnostic output.
+ */
+ public static String describeConfiguration() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("LLM Configuration Status:\n");
+ sb.append(" Chat: ").append(isChatConfigured() ? "CONFIGURED" : "NOT CONFIGURED");
+ if (!isChatConfigured()) {
+ sb.append(" (set DEEPSQL_CHAT_PROVIDER and DEEPSQL_CHAT_API_KEY)");
+ }
+ sb.append("\n");
+ sb.append(" Embedding: ").append(isEmbeddingConfigured() ? "CONFIGURED" : "NOT CONFIGURED");
+ if (!isEmbeddingConfigured()) {
+ sb.append(" (set DEEPSQL_EMBEDDING_PROVIDER and DEEPSQL_EMBEDDING_API_KEY)");
+ }
+ return sb.toString();
+ }
+}
diff --git a/backend/src/test/java/com/dbaagent/support/LlmAvailabilityConditionTest.java b/backend/src/test/java/com/dbaagent/support/LlmAvailabilityConditionTest.java
new file mode 100644
index 0000000..7d0a1da
--- /dev/null
+++ b/backend/src/test/java/com/dbaagent/support/LlmAvailabilityConditionTest.java
@@ -0,0 +1,56 @@
+package com.dbaagent.support;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for {@link LlmAvailabilityCondition}.
+ *
+ * These tests verify the static check methods work correctly.
+ * The actual annotation behavior is tested by the skipped tests
+ * in classes like {@code ChatPromptIntegrationTest}.
+ */
+class LlmAvailabilityConditionTest {
+
+ @Test
+ void describeConfigurationReturnsReadableOutput() {
+ String description = LlmAvailabilityCondition.describeConfiguration();
+
+ assertThat(description)
+ .contains("LLM Configuration Status")
+ .contains("Chat:")
+ .contains("Embedding:");
+ }
+
+ @Test
+ void isChatConfiguredReturnsFalseWhenEnvNotSet() {
+ // This test verifies the check method works when env vars are not set.
+ // If DEEPSQL_CHAT_PROVIDER and DEEPSQL_CHAT_API_KEY are set in the
+ // test environment, this would return true - that's correct behavior.
+ boolean configured = LlmAvailabilityCondition.isChatConfigured();
+
+ // We can't assert false here because the test might run in an env with LLM configured.
+ // Instead, verify the method returns a boolean without throwing.
+ assertThat(configured).isIn(true, false);
+ }
+
+ @Test
+ void isEmbeddingConfiguredReturnsFalseWhenEnvNotSet() {
+ boolean configured = LlmAvailabilityCondition.isEmbeddingConfigured();
+
+ assertThat(configured).isIn(true, false);
+ }
+
+ @Test
+ void describeConfigurationShowsNotConfiguredWhenMissing() {
+ // Without mocking System.getenv, we verify the output format is correct
+ String description = LlmAvailabilityCondition.describeConfiguration();
+
+ // Should contain configuration hints
+ assertThat(description).containsAnyOf(
+ "CONFIGURED",
+ "NOT CONFIGURED"
+ );
+ }
+}
diff --git a/backend/src/test/java/com/dbaagent/support/LlmTestSupport.java b/backend/src/test/java/com/dbaagent/support/LlmTestSupport.java
new file mode 100644
index 0000000..1c8c1df
--- /dev/null
+++ b/backend/src/test/java/com/dbaagent/support/LlmTestSupport.java
@@ -0,0 +1,165 @@
+package com.dbaagent.support;
+
+import com.dbaagent.llm.LlmConfigResolver;
+import com.dbaagent.llm.api.LlmCredentials;
+import org.opentest4j.TestAbortedException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * Test support utility for checking LLM availability within Spring integration tests.
+ *
+ * This component uses the actual {@link LlmConfigResolver} bean to check LLM
+ * configuration, which includes both environment variables and database-stored
+ * configuration. This provides more accurate checks than the standalone
+ * {@link LlmAvailabilityCondition} which only checks environment variables.
+ *
+ * Usage in integration tests:
+ * Tests annotated with this will be skipped (not failed) when LLM credentials
+ * are not configured via {@code DEEPSQL_CHAT_*} or {@code DEEPSQL_EMBEDDING_*}
+ * environment variables, or via the database configuration.
+ *
+ * This uses the same resolution logic as the production {@code LlmConfigResolver},
+ * ensuring tests skip only when the production code would also fail.
+ *
+ * Usage:
+ * {@code
+ * @SpringBootTest
+ * class MyIntegrationTest {
+ *
+ * @Autowired
+ * private LlmTestSupport llmTestSupport;
+ *
+ * @Test
+ * void testRequiringChat() {
+ * llmTestSupport.requireChat("my test");
+ * // test code that needs chat LLM
+ * }
+ *
+ * @Test
+ * void testOptionallyUsingLlm() {
+ * if (llmTestSupport.isChatAvailable()) {
+ * // test with LLM
+ * } else {
+ * // fallback test path
+ * }
+ * }
+ * }
+ * }
+ */
+@Component
+public class LlmTestSupport {
+
+ private final LlmConfigResolver resolver;
+
+ @Autowired
+ public LlmTestSupport(LlmConfigResolver resolver) {
+ this.resolver = resolver;
+ }
+
+ /**
+ * Checks if chat LLM is configured and available.
+ *
+ * @return true if chat LLM credentials are configured
+ */
+ public boolean isChatAvailable() {
+ return resolver.resolveChat() != null;
+ }
+
+ /**
+ * Checks if embedding LLM is configured and available.
+ *
+ * @return true if embedding LLM credentials are configured
+ */
+ public boolean isEmbeddingAvailable() {
+ return resolver.resolveEmbedding() != null;
+ }
+
+ /**
+ * Aborts the test if chat LLM is not configured.
+ *
+ * @param purpose description of what the test needs chat LLM for
+ * @throws TestAbortedException if chat LLM is not configured
+ */
+ public void requireChat(String purpose) {
+ if (!isChatAvailable()) {
+ throw new TestAbortedException(
+ "Chat LLM not configured, skipping test for " + purpose + ". "
+ + "Set DEEPSQL_CHAT_PROVIDER and DEEPSQL_CHAT_API_KEY environment variables, "
+ + "or configure via the setup wizard at /onboarding.");
+ }
+ }
+
+ /**
+ * Aborts the test if embedding LLM is not configured.
+ *
+ * @param purpose description of what the test needs embedding LLM for
+ * @throws TestAbortedException if embedding LLM is not configured
+ */
+ public void requireEmbedding(String purpose) {
+ if (!isEmbeddingAvailable()) {
+ throw new TestAbortedException(
+ "Embedding LLM not configured, skipping test for " + purpose + ". "
+ + "Set DEEPSQL_EMBEDDING_PROVIDER and DEEPSQL_EMBEDDING_API_KEY environment variables, "
+ + "or configure via the setup wizard at /onboarding.");
+ }
+ }
+
+ /**
+ * Aborts the test if either chat or embedding LLM is not configured.
+ *
+ * @param purpose description of what the test needs full LLM for
+ * @throws TestAbortedException if any LLM component is not configured
+ */
+ public void requireBoth(String purpose) {
+ requireChat(purpose);
+ requireEmbedding(purpose);
+ }
+
+ /**
+ * Returns the resolved chat credentials, or null if not configured.
+ * Useful for tests that need to inspect the configuration.
+ */
+ public LlmCredentials getChatCredentials() {
+ return resolver.resolveChat();
+ }
+
+ /**
+ * Returns the resolved embedding credentials, or null if not configured.
+ * Useful for tests that need to inspect the configuration.
+ */
+ public LlmCredentials getEmbeddingCredentials() {
+ return resolver.resolveEmbedding();
+ }
+
+ /**
+ * Returns a human-readable description of the current LLM configuration status.
+ * Useful for diagnostic output in tests.
+ */
+ public String describeConfiguration() {
+ LlmCredentials chat = resolver.resolveChat();
+ LlmCredentials embedding = resolver.resolveEmbedding();
+
+ StringBuilder sb = new StringBuilder();
+ sb.append("LLM Configuration Status (via LlmConfigResolver):\n");
+
+ sb.append(" Chat: ");
+ if (chat != null) {
+ sb.append("CONFIGURED (provider=").append(chat.providerId());
+ String model = chat.get("model");
+ if (model != null) {
+ sb.append(", model=").append(model);
+ }
+ sb.append(")");
+ } else {
+ sb.append("NOT CONFIGURED");
+ }
+ sb.append("\n");
+
+ sb.append(" Embedding: ");
+ if (embedding != null) {
+ sb.append("CONFIGURED (provider=").append(embedding.providerId());
+ String model = embedding.get("model");
+ if (model != null) {
+ sb.append(", model=").append(model);
+ }
+ sb.append(")");
+ } else {
+ sb.append("NOT CONFIGURED");
+ }
+
+ return sb.toString();
+ }
+}
diff --git a/backend/src/test/java/com/dbaagent/support/RequiresLlm.java b/backend/src/test/java/com/dbaagent/support/RequiresLlm.java
new file mode 100644
index 0000000..c0e4904
--- /dev/null
+++ b/backend/src/test/java/com/dbaagent/support/RequiresLlm.java
@@ -0,0 +1,60 @@
+package com.dbaagent.support;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a test class or method as requiring LLM configuration to run.
+ *
+ * {@code
+ * @RequiresLlm
+ * class ChatIntegrationTest {
+ * // All tests in this class require LLM
+ * }
+ *
+ * class MixedTest {
+ * @Test
+ * void testWithoutLlm() { }
+ *
+ * @Test
+ * @RequiresLlm
+ * void testWithLlm() { }
+ * }
+ *
+ * @RequiresLlm(chat = true, embedding = false)
+ * class ChatOnlyTest {
+ * // Only requires chat LLM, not embedding
+ * }
+ * }
+ */
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@ExtendWith(LlmAvailabilityCondition.class)
+public @interface RequiresLlm {
+
+ /**
+ * Whether the test requires chat LLM to be configured.
+ * Defaults to {@code true}.
+ */
+ boolean chat() default true;
+
+ /**
+ * Whether the test requires embedding LLM to be configured.
+ * Defaults to {@code false} since many chat tests don't need embeddings.
+ */
+ boolean embedding() default false;
+}