Fixes 29542: make the testDefinitions entityType filter case-insensitive on both the REST and MCP doors

openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/TestDefinitionResourceIT.java

@@ -1,24 +1,29 @@
 package org.openmetadata.it.tests;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.openmetadata.it.util.SdkClients;
 import org.openmetadata.it.util.TestNamespace;
+import org.openmetadata.schema.api.teams.CreateUser;
 import org.openmetadata.schema.api.tests.CreateTestDefinition;
 import org.openmetadata.schema.tests.TestDefinition;
 import org.openmetadata.schema.tests.TestPlatform;
 import org.openmetadata.schema.type.EntityHistory;
 import org.openmetadata.schema.type.TestDefinitionEntityType;
 import org.openmetadata.sdk.client.OpenMetadataClient;
+import org.openmetadata.sdk.exceptions.InvalidRequestException;
 import org.openmetadata.sdk.models.ListParams;
 import org.openmetadata.sdk.models.ListResponse;
 import org.openmetadata.service.resources.dqtests.TestDefinitionResource;
@@ -33,6 +38,11 @@
 @Execution(ExecutionMode.CONCURRENT)
 public class TestDefinitionResourceIT extends BaseEntityIT<TestDefinition, CreateTestDefinition> {
 
+  private static final List<String> ENTITY_TYPE_CASINGS =
+      List.of("COLUMN", "Column", "column", " Column ");
+  private static final List<String> BLANK_ENTITY_TYPES = List.of("", " ");
+  private static final int ENTITY_TYPE_FILTER_LIMIT = 1000000;
+
   // Disable tests that don't apply to TestDefinition
   {
     supportsFollowers = false; // TestDefinition doesn't support followers
@@ -255,4 +265,150 @@ void test_testDefinitionNameUniqueness(TestNamespace ns) {
         () -> createEntity(request2),
         "Creating duplicate test definition should fail");
   }
+
+  // ===================================================================
+  // ENTITY TYPE FILTER — issue #29542
+  // ===================================================================
+
+  @Test
+  void list_entityTypeFilterIsCaseInsensitive_200_OK(TestNamespace ns) {
+    TestDefinition columnDefinition = createColumnTestDefinition(ns, "casing_column");
+    TestDefinition tableDefinition = createTableTestDefinition(ns, "casing_table");
+
+    for (String casing : ENTITY_TYPE_CASINGS) {
+      assertColumnOnlyListing(SdkClients.adminClient(), casing, columnDefinition, tableDefinition);
+    }
+  }
+
+  @Test
+  void list_entityTypeFilterRejectsUnknownEntityType_400() {
+    InvalidRequestException exception =
+        assertThrows(
+            InvalidRequestException.class,
+            () -> listByEntityType(SdkClients.adminClient(), "Banana"));
+
+    assertEquals(400, exception.getStatusCode());
+    assertTrue(
+        exception.getMessage().contains("Banana"),
+        "Error message must name the rejected value, was: " + exception.getMessage());
+  }
+
+  @Test
+  void list_emptyEntityTypeFilterIsIgnored_200_OK(TestNamespace ns) {
+    TestDefinition columnDefinition = createColumnTestDefinition(ns, "empty_column");
+    TestDefinition tableDefinition = createTableTestDefinition(ns, "empty_table");
+
+    for (String blank : BLANK_ENTITY_TYPES) {
+      Set<String> fullyQualifiedNames =
+          fullyQualifiedNamesOf(listByEntityType(SdkClients.adminClient(), blank).getData());
+
+      assertTrue(
+          fullyQualifiedNames.contains(columnDefinition.getFullyQualifiedName()),
+          "A blank entityType must not filter out COLUMN test definitions");
+      assertTrue(
+          fullyQualifiedNames.contains(tableDefinition.getFullyQualifiedName()),
+          "A blank entityType must not filter out TABLE test definitions");
+    }
+  }
+
+  /**
+   * Proves that a caller holding no roles at all sees exactly what an admin sees, which is what the
+   * issue disputed. It does not cover the one configuration that genuinely does diverge: a
+   * {@code DomainOnlyAccessRole} holder with no domains, whose listing is broken by
+   * {@code EntityUtil.addDomainQueryParam} overwriting this very query param with the resource type.
+   * That is a separate defect, unrelated to casing, and is not fixed or exercised here.
+   */
+  @Test
+  void list_entityTypeFilterYieldsSameResultForAdminAndRoleLessUser_200_OK(TestNamespace ns) {
+    TestDefinition columnDefinition = createColumnTestDefinition(ns, "rbac_column");
+    TestDefinition tableDefinition = createTableTestDefinition(ns, "rbac_table");
+
+    OpenMetadataClient nonAdminClient = createNonAdminClient(ns);
+
+    for (String casing : ENTITY_TYPE_CASINGS) {
+      assertColumnOnlyListing(SdkClients.adminClient(), casing, columnDefinition, tableDefinition);
+      assertColumnOnlyListing(nonAdminClient, casing, columnDefinition, tableDefinition);
+    }
+  }
+
+  private OpenMetadataClient createNonAdminClient(TestNamespace ns) {
+    String name = ns.shortPrefix("etfilter");
+    String email = name + "@test.openmetadata.org";
+    SdkClients.adminClient().users().create(new CreateUser().withName(name).withEmail(email));
+
+    return SdkClients.createClient(email, email, new String[] {});
+  }
+
+  /**
+   * Asserts the filtered listing by set membership rather than by set equality: test definitions are
+   * a global collection and this class runs with {@link ExecutionMode#CONCURRENT}, so a sibling test
+   * can add or remove one between two list calls. Membership of definitions this test owns is stable
+   * and still distinguishes a working filter from one that silently returns nothing.
+   */
+  private void assertColumnOnlyListing(
+      OpenMetadataClient client,
+      String entityTypeParam,
+      TestDefinition columnDefinition,
+      TestDefinition tableDefinition) {
+    ListResponse<TestDefinition> response = listByEntityType(client, entityTypeParam);
+    List<TestDefinition> definitions = response.getData();
+    Set<String> fullyQualifiedNames = fullyQualifiedNamesOf(definitions);
+
+    assertTrue(
+        definitions.stream().allMatch(d -> d.getEntityType() == TestDefinitionEntityType.COLUMN),
+        "entityType=" + entityTypeParam + " must return only COLUMN test definitions");
+    assertTrue(
+        response.getPaging().getTotal() > 0,
+        "entityType="
+            + entityTypeParam
+            + " must produce a non-zero paging total, which is served by the DAO's separate"
+            + " listCount query");
+    assertTrue(
+        fullyQualifiedNames.contains(columnDefinition.getFullyQualifiedName()),
+        "entityType="
+            + entityTypeParam
+            + " must return the COLUMN test definition "
+            + columnDefinition.getFullyQualifiedName());
+    assertFalse(
+        fullyQualifiedNames.contains(tableDefinition.getFullyQualifiedName()),
+        "entityType="
+            + entityTypeParam
+            + " must not return the TABLE test definition "
+            + tableDefinition.getFullyQualifiedName());
+  }
+
+  private static ListResponse<TestDefinition> listByEntityType(
+      OpenMetadataClient client, String entityTypeParam) {
+    ListParams params =
+        new ListParams()
+            .setLimit(ENTITY_TYPE_FILTER_LIMIT)
+            .addFilter("entityType", entityTypeParam);
+
+    return client.testDefinitions().list(params);
+  }
+
+  private static Set<String> fullyQualifiedNamesOf(List<TestDefinition> definitions) {
+    return definitions.stream()
+        .map(TestDefinition::getFullyQualifiedName)
+        .collect(Collectors.toSet());
+  }
+
+  private TestDefinition createColumnTestDefinition(TestNamespace ns, String name) {
+    return createTestDefinition(ns, name, TestDefinitionEntityType.COLUMN);
+  }
+
+  private TestDefinition createTableTestDefinition(TestNamespace ns, String name) {
+    return createTestDefinition(ns, name, TestDefinitionEntityType.TABLE);
+  }
+
+  private TestDefinition createTestDefinition(
+      TestNamespace ns, String name, TestDefinitionEntityType entityType) {
+    CreateTestDefinition request = new CreateTestDefinition();
+    request.setName(ns.prefix(name));
+    request.setDescription("Test definition for entityType filtering");
+    request.setEntityType(entityType);
+    request.setTestPlatforms(List.of(TestPlatform.OPEN_METADATA));
+
+    return createEntity(request);
+  }
 }

openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/mcp/McpToolsValidationIT.java

@@ -160,7 +160,7 @@
             () -> {
               Map<String, Object> toolCall =
                   McpTestUtils.createSearchMetadataToolCall("mcp_val_table", 5, Entity.TABLE);
               JsonNode result = executeToolCall(toolCall);
               validateSearchMetadataResponse(result, "mcp_val_table");
             });
   }
@@ -170,7 +170,7 @@
   void testGetEntityDetailsTool() throws Exception {
     Map<String, Object> toolCall =
         McpTestUtils.createGetEntityToolCall("table", testTable.getFullyQualifiedName());
     JsonNode result = executeToolCall(toolCall);
     validateGetEntityDetailsResponse(result, testTable.getFullyQualifiedName());
   }
 
@@ -180,7 +180,7 @@
     String fqn = wideTable.getFullyQualifiedName();
 
     Map<String, Object> firstPageCall = McpTestUtils.createGetEntityToolCall("table", fqn);
     JsonNode firstPage = readEntityText(executeToolCall(firstPageCall));
 
     assertThat(firstPage.has("id")).isTrue();
     assertThat(firstPage.get("fullyQualifiedName").asText()).isEqualTo(fqn);
@@ -209,7 +209,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createGlossaryToolCall(
             randomGlossaryName, "Test glossary created for validation testing");
     JsonNode result = executeToolCall(toolCall);
     validateCreateGlossaryResponse(result, randomGlossaryName);
   }
 
@@ -219,7 +219,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createGlossaryTermToolCall(
             testGlossaryName, "ValidationTestTerm", "Test term created for validation testing");
     JsonNode result = executeToolCall(toolCall);
     validateCreateGlossaryTermResponse(result, "ValidationTestTerm", testGlossaryName);
   }
 
@@ -232,7 +232,7 @@
         McpTestUtils.createPatchEntityToolCall(
             "table", testTable.getFullyQualifiedName(), patchJson);
 
     JsonNode result = executeToolCall(toolCall);
     validatePatchEntityResponse(result, testTable.getFullyQualifiedName());
   }
 
@@ -242,7 +242,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createGetLineageToolCall("table", testTable.getFullyQualifiedName(), 2, 2);
 
     JsonNode result = executeToolCall(toolCall);
     validateLineageResponse(result, testTable.getFullyQualifiedName());
   }
 
@@ -251,7 +251,7 @@
   void testAllToolsValidation() throws Exception {
     Map<String, Object> searchCall =
         McpTestUtils.createSearchMetadataToolCall("mcp_val", 10, Entity.TABLE);
     JsonNode searchResult = executeToolCall(searchCall);
     validateSearchMetadataResponse(searchResult, "mcp_val");
 
     Map<String, Object> tableDetailsCall =
@@ -274,7 +274,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createLineageToolCall(
             "table", testTable.getId().toString(), "table", targetTable.getId().toString());
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -300,7 +300,7 @@
     arguments.put("Authorization", McpTestUtils.createAuthorizationHeader("test-token"));
     Map<String, Object> toolCall = McpTestUtils.createToolCallRequest("create_lineage", arguments);
 
     JsonNode result = executeToolCall(toolCall);
     assertThat(result.has("content")).isTrue();
     assertThat(result.has("isError")).isTrue();
     assertThat(result.get("isError").asBoolean()).isTrue();
@@ -310,7 +310,7 @@
   @Order(10)
   void testGetTestDefinitions() throws Exception {
     Map<String, Object> toolCall = McpTestUtils.createGetTestDefinitionsToolCall("TABLE");
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -329,7 +329,7 @@
   @Order(11)
   void testGetTestDefinitionsForColumn() throws Exception {
     Map<String, Object> toolCall = McpTestUtils.createGetTestDefinitionsToolCall("COLUMN");
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -343,6 +343,25 @@
     assertThat(response.get("data").isArray()).isTrue();
   }
 
+  /**
+   * The MCP door reaches the same DAO as the REST door, so it must canonicalize {@code entityType}
+   * the same way — see issue #29542. An LLM caller naturally writes {@code "Column"}, which matched
+   * nothing on PostgreSQL before the fix.
+   */
+  @Test
+  @Order(22)
+  void testGetTestDefinitionsForMixedCaseEntityType() throws Exception {
+    Map<String, Object> toolCall = McpTestUtils.createGetTestDefinitionsToolCall("Column");
+    JsonNode result = executeToolCall(toolCall);
+
+    JsonNode response = OBJECT_MAPPER.readTree(result.get("content").get(0).get("text").asText());
+    JsonNode definitions = response.get("data");
+    assertThat(definitions).isNotEmpty();
+    for (JsonNode definition : definitions) {
+      assertThat(definition.get("entityType").asText()).isEqualTo("COLUMN");
+    }
+  }
+
   @Test
   @Order(12)
   void testCreateTestCase() throws Exception {
@@ -358,7 +377,7 @@
             testTable.getFullyQualifiedName(),
             "tableRowCountToBeBetween",
             parameterValues);
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -383,7 +402,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createToolCallRequest("create_test_case", arguments);
 
     JsonNode result = executeToolCall(toolCall);
     assertThat(result.has("isError")).isTrue();
     assertThat(result.get("isError").asBoolean()).isTrue();
   }
@@ -394,7 +413,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createRootCauseAnalysisToolCall(
             testTable.getFullyQualifiedName(), "table", 3, 3);
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -415,7 +434,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createRootCauseAnalysisToolCall(
             testTable.getFullyQualifiedName(), "table", 50, 50);
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -438,7 +457,7 @@
     Map<String, Object> toolCall =
         McpTestUtils.createMetricToolCall(
             metricName, "Test metric created via MCP tool", "SQL", "SELECT COUNT(*) FROM orders");
     JsonNode result = executeToolCall(toolCall);
 
     assertThat(result.has("content")).isTrue();
     JsonNode content = result.get("content");
@@ -460,7 +479,7 @@
     arguments.put("Authorization", McpTestUtils.createAuthorizationHeader("test-token"));
     Map<String, Object> toolCall = McpTestUtils.createToolCallRequest("create_metric", arguments);
 
     JsonNode result = executeToolCall(toolCall);
     assertThat(result.has("isError")).isTrue();
     assertThat(result.get("isError").asBoolean()).isTrue();
   }
@@ -480,7 +499,7 @@
 
     Map<String, Object> searchActive =
         McpTestUtils.createSearchMetadataToolCall(deletionTestTableName, 5, Entity.TABLE);
     JsonNode activeResult = executeToolCall(searchActive);
     validateDeletedFieldPresence(activeResult, false);
 
     delete("tables/" + deletionTestTable.getId());
@@ -509,7 +528,7 @@
               Map<String, Object> toolCall =
                   McpTestUtils.createSearchMetadataToolCall(
                       createdTestCaseName, 10, Entity.TEST_CASE);
               JsonNode result = executeToolCall(toolCall);
               JsonNode response =
                   OBJECT_MAPPER.readTree(result.get("content").get(0).get("text").asText());
 
@@ -538,7 +557,7 @@
             () -> {
               Map<String, Object> toolCall =
                   McpTestUtils.createSearchMetadataToolCall("mcp_val_table", 10, Entity.TEST_SUITE);
               JsonNode result = executeToolCall(toolCall);
               JsonNode response =
                   OBJECT_MAPPER.readTree(result.get("content").get(0).get("text").asText());
 

openmetadata-mcp/src/main/java/org/openmetadata/mcp/tools/TestDefinitionsTool.java

@@ -92,9 +92,7 @@ private static String stringParam(Map<String, Object> params, String key, String
 
   private static ListFilter buildFilter(String entityType, String testPlatform) {
     ListFilter filter = new ListFilter(Include.NON_DELETED);
-    if (entityType != null) {
-      filter.addQueryParam("entityType", entityType);
-    }
+    TestDefinitionRepository.addEntityTypeFilter(filter, entityType);
     if (testPlatform != null) {
       filter.addQueryParam("testPlatform", testPlatform);
     }

openmetadata-mcp/src/main/resources/json/data/mcp/tools.json

@@ -768,8 +768,10 @@
         "properties": {
           "entityType": {
             "type": "string",
-            "description": "Entity Type can be 'TABLE' for table asset/entity or 'COLUMN' for column level tests. Default is TABLE."
-          },
+            "description": "Entity Type (case-insensitive). Use 'TABLE' for table asset/entity or 'COLUMN' for column level tests. Default is TABLE.",
+            "default": "TABLE",
+            "examples": ["TABLE", "COLUMN"]
+          }
           "testPlatform": {
             "type": "string",
             "description": "Default value can be 'OpenMetadata'. Other Platform can be 'OpenMetadata','GreatExpectations', 'DBT', 'Deequ', 'Soda', 'Other' if the user specifically gives the platform name."

openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/TestDefinitionRepository.java

@@ -12,6 +12,7 @@
 import org.openmetadata.schema.type.Include;
 import org.openmetadata.schema.type.ProviderType;
 import org.openmetadata.schema.type.Relationship;
+import org.openmetadata.schema.type.TestDefinitionEntityType;
 import org.openmetadata.schema.type.change.ChangeSource;
 import org.openmetadata.service.Entity;
 import org.openmetadata.service.exception.CatalogExceptionMessage;
@@ -21,6 +22,10 @@
 
 @Slf4j
 public class TestDefinitionRepository extends EntityRepository<TestDefinition> {
+  private static final String ENTITY_TYPE_PARAM = "entityType";
+  private static final List<TestDefinitionEntityType> ENTITY_TYPES =
+      List.of(TestDefinitionEntityType.values());
+
   public TestDefinitionRepository() {
     super(
         TestDefinitionResource.COLLECTION_PATH,
@@ -146,6 +151,36 @@ private void requireNoDependentTestCases(UUID testDefinitionId) {
     }
   }
 
+  /**
+   * Canonicalizes the {@code entityType} listing filter for every door into {@link
+   * CollectionDAO.TestDefinitionDAO}. The DAO compares the value against the {@code
+   * test_definition.entityType} generated column with {@code =}, which PostgreSQL evaluates
+   * case-sensitively under the deterministic collations it ships with, so an un-normalized {@code
+   * Column} silently matched nothing while MySQL's case-insensitive collation matched it — see issue
+   * #29542. Canonicalizing here keeps both engines and both callers (the REST resource and the MCP
+   * tool) identical, and turns an unknown value into a {@code 400} instead of an empty page. A blank
+   * value stays an absent filter so that clients serializing an unset filter are not rejected.
+   */
+  public static void addEntityTypeFilter(ListFilter filter, String entityType) {
+    String value = CommonUtil.nullOrEmpty(entityType) ? "" : entityType.trim();
+    if (!value.isEmpty()) {
+      filter.addQueryParam(ENTITY_TYPE_PARAM, parseEntityType(value).value());
+    }
+  }
+
+  private static TestDefinitionEntityType parseEntityType(String entityType) {
+    return ENTITY_TYPES.stream()
+        .filter(candidate -> candidate.value().equalsIgnoreCase(entityType))
+        .findFirst()
+        .orElseThrow(
+            () ->
+                new IllegalArgumentException(
+                    String.format(
+                        "Invalid entityType '%s'. Must be one of %s",
+                        entityType,
+                        ENTITY_TYPES.stream().map(TestDefinitionEntityType::value).toList())));
+  }
+
   @Override
   public EntityRepository<TestDefinition>.EntityUpdater getUpdater(
       TestDefinition original,

openmetadata-service/src/main/java/org/openmetadata/service/resources/dqtests/TestDefinitionResource.java

@@ -101,7 +101,10 @@ public static class TestDefinitionList extends ResultList<TestDefinition> {
                 @Content(
                     mediaType = "application/json",
                     schema =
-                        @Schema(implementation = TestDefinitionResource.TestDefinitionList.class)))
+                        @Schema(implementation = TestDefinitionResource.TestDefinitionList.class))),
+        @ApiResponse(
+            responseCode = "400",
+            description = "entityType is not one of the TestDefinitionEntityType values")
       })
   public ResultList<TestDefinition> list(
       @Context UriInfo uriInfo,
@@ -163,9 +166,7 @@ public ResultList<TestDefinition> list(
           @QueryParam("enabled")
           Boolean enabledParam) {
     ListFilter filter = new ListFilter(include);
-    if (entityType != null) {
-      filter.addQueryParam("entityType", entityType);
-    }
+    TestDefinitionRepository.addEntityTypeFilter(filter, entityType);
     if (testPlatformParam != null) {
       filter.addQueryParam("testPlatform", testPlatformParam);
     }