You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by mi...@apache.org on 2025/02/07 14:44:34 UTC

(kafka) branch trunk updated: KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)

This is an automated email from the ASF dual-hosted git repository.

mimaison pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/trunk by this push:
     new b22c7d5b5c4 KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)
b22c7d5b5c4 is described below

commit b22c7d5b5c439b1900dcb49c3ef47b816b1a4699
Author: PoAn Yang <pa...@apache.org>
AuthorDate: Fri Feb 7 22:44:27 2025 +0800

    KAFKA-17833: Convert DescribeAuthorizedOperationsTest to use KRaft (#18252)
    
    
    Reviewers: Mickael Maison <mi...@gmail.com>
---
 checkstyle/import-control-core.xml                 |   1 +
 .../admin/DescribeAuthorizedOperationsTest.java    | 252 +++++++++++++++++++++
 .../api/DescribeAuthorizedOperationsTest.scala     | 211 -----------------
 3 files changed, 253 insertions(+), 211 deletions(-)

diff --git a/checkstyle/import-control-core.xml b/checkstyle/import-control-core.xml
index 309bafae838..43fd2d3ff2f 100644
--- a/checkstyle/import-control-core.xml
+++ b/checkstyle/import-control-core.xml
@@ -135,6 +135,7 @@
     <allow pkg="kafka.security.authorizer"/>
     <allow pkg="kafka.server"/>
     <allow pkg="kafka.zk"/>
+    <allow pkg="org.apache.kafka.clients"/>
     <allow pkg="org.apache.kafka.clients.admin"/>
     <allow pkg="org.apache.kafka.coordinator.group"/>
     <allow pkg="org.apache.kafka.metadata"/>
diff --git a/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java b/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java
new file mode 100644
index 00000000000..d58f1d9ec6e
--- /dev/null
+++ b/core/src/test/java/kafka/admin/DescribeAuthorizedOperationsTest.java
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package kafka.admin;
+
+import org.apache.kafka.clients.CommonClientConfigs;
+import org.apache.kafka.clients.admin.Admin;
+import org.apache.kafka.clients.admin.ConsumerGroupDescription;
+import org.apache.kafka.clients.admin.DescribeClusterOptions;
+import org.apache.kafka.clients.admin.DescribeConsumerGroupsOptions;
+import org.apache.kafka.clients.admin.DescribeConsumerGroupsResult;
+import org.apache.kafka.clients.admin.DescribeTopicsOptions;
+import org.apache.kafka.clients.admin.NewTopic;
+import org.apache.kafka.clients.admin.TopicDescription;
+import org.apache.kafka.clients.consumer.OffsetAndMetadata;
+import org.apache.kafka.common.TopicPartition;
+import org.apache.kafka.common.acl.AccessControlEntry;
+import org.apache.kafka.common.acl.AclBinding;
+import org.apache.kafka.common.acl.AclBindingFilter;
+import org.apache.kafka.common.acl.AclOperation;
+import org.apache.kafka.common.config.SaslConfigs;
+import org.apache.kafka.common.resource.PatternType;
+import org.apache.kafka.common.resource.Resource;
+import org.apache.kafka.common.resource.ResourcePattern;
+import org.apache.kafka.common.resource.ResourceType;
+import org.apache.kafka.common.security.auth.KafkaPrincipal;
+import org.apache.kafka.common.security.auth.SecurityProtocol;
+import org.apache.kafka.common.test.ClusterInstance;
+import org.apache.kafka.common.test.JaasUtils;
+import org.apache.kafka.common.test.api.ClusterConfig;
+import org.apache.kafka.common.test.api.ClusterTemplate;
+import org.apache.kafka.common.test.api.Type;
+import org.apache.kafka.common.test.junit.ClusterTestExtensions;
+import org.apache.kafka.coordinator.group.GroupCoordinatorConfig;
+import org.apache.kafka.security.authorizer.AclEntry;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+import static org.apache.kafka.common.acl.AccessControlEntryFilter.ANY;
+import static org.apache.kafka.common.acl.AclOperation.ALL;
+import static org.apache.kafka.common.acl.AclOperation.ALTER;
+import static org.apache.kafka.common.acl.AclOperation.DELETE;
+import static org.apache.kafka.common.acl.AclOperation.DESCRIBE;
+import static org.apache.kafka.common.acl.AclPermissionType.ALLOW;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+@ExtendWith(ClusterTestExtensions.class)
+public class DescribeAuthorizedOperationsTest {
+    private static final String GROUP1 = "group1";
+    private static final String GROUP2 = "group2";
+    private static final String GROUP3 = "group3";
+    private static final ResourcePattern GROUP1_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP1, PatternType.LITERAL);
+    private static final ResourcePattern GROUP2_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP2, PatternType.LITERAL);
+    private static final ResourcePattern GROUP3_PATTERN = new ResourcePattern(ResourceType.GROUP, GROUP3, PatternType.LITERAL);
+    private static final ResourcePattern CLUSTER_PATTERN = new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL);
+    private static final AccessControlEntry ALTER_ENTRY = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALTER);
+    private static final AccessControlEntry DESCRIBE_ENTRY = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DESCRIBE);
+
+    static List<ClusterConfig> generator() {
+        return List.of(
+            ClusterConfig.defaultBuilder()
+                .setTypes(Set.of(Type.KRAFT))
+                .setServerProperties(Map.of(GroupCoordinatorConfig.OFFSETS_TOPIC_PARTITIONS_CONFIG, "1"))
+                .setServerProperties(Map.of(GroupCoordinatorConfig.OFFSETS_TOPIC_REPLICATION_FACTOR_CONFIG, "1"))
+                .setBrokerSecurityProtocol(SecurityProtocol.SASL_PLAINTEXT)
+                .setControllerSecurityProtocol(SecurityProtocol.SASL_PLAINTEXT)
+                .build()
+        );
+    }
+
+    private static AccessControlEntry createAccessControlEntry(String username, AclOperation operation) {
+        return new AccessControlEntry(
+            new KafkaPrincipal(KafkaPrincipal.USER_TYPE, username).toString(),
+            AclEntry.WILDCARD_HOST,
+            operation,
+            ALLOW
+        );
+    }
+
+    private Map<String, Object> createAdminConfig(String username, String password) {
+        Map<String, Object> configs = new HashMap<>();
+        configs.put(CommonClientConfigs.SECURITY_PROTOCOL_CONFIG, SecurityProtocol.SASL_PLAINTEXT.name);
+        configs.put(SaslConfigs.SASL_MECHANISM, "PLAIN");
+        configs.put(SaslConfigs.SASL_JAAS_CONFIG,
+            String.format("org.apache.kafka.common.security.plain.PlainLoginModule required username=\"%s\" password=\"%s\";", username, password));
+        return configs;
+    }
+
+    private void setupSecurity(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+            ResourcePattern topicResource = new ResourcePattern(ResourceType.TOPIC, AclEntry.WILDCARD_RESOURCE, PatternType.LITERAL);
+
+            admin.createAcls(List.of(
+                new AclBinding(CLUSTER_PATTERN, ALTER_ENTRY),
+                new AclBinding(topicResource, DESCRIBE_ENTRY)
+            )).all().get();
+
+            clusterInstance.waitAcls(new AclBindingFilter(CLUSTER_PATTERN.toFilter(), ANY), Set.of(ALTER_ENTRY));
+            clusterInstance.waitAcls(new AclBindingFilter(topicResource.toFilter(), ANY), Set.of(DESCRIBE_ENTRY));
+        }
+    }
+
+    @ClusterTemplate("generator")
+    public void testConsumerGroupAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+        setupSecurity(clusterInstance);
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD));
+             Admin user1 = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD));
+        ) {
+            admin.createTopics(List.of(new NewTopic("topic1", 1, (short) 1)));
+            clusterInstance.waitForTopic("topic1", 1);
+
+            // create consumers to avoid group not found error
+            TopicPartition tp = new TopicPartition("topic1", 0);
+            OffsetAndMetadata offsetAndMetadata = new OffsetAndMetadata(0);
+            admin.alterConsumerGroupOffsets(GROUP1, Map.of(tp, offsetAndMetadata)).all().get();
+            admin.alterConsumerGroupOffsets(GROUP2, Map.of(tp, offsetAndMetadata)).all().get();
+            admin.alterConsumerGroupOffsets(GROUP3, Map.of(tp, offsetAndMetadata)).all().get();
+
+            AccessControlEntry allOperationsEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+            AccessControlEntry describeEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DESCRIBE);
+            AccessControlEntry deleteEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DELETE);
+            user1.createAcls(List.of(
+                new AclBinding(GROUP1_PATTERN, allOperationsEntry),
+                new AclBinding(GROUP2_PATTERN, describeEntry),
+                new AclBinding(GROUP3_PATTERN, deleteEntry)
+            )).all();
+            clusterInstance.waitAcls(new AclBindingFilter(GROUP1_PATTERN.toFilter(), ANY), Set.of(allOperationsEntry));
+            clusterInstance.waitAcls(new AclBindingFilter(GROUP2_PATTERN.toFilter(), ANY), Set.of(describeEntry));
+            clusterInstance.waitAcls(new AclBindingFilter(GROUP3_PATTERN.toFilter(), ANY), Set.of(deleteEntry));
+
+            DescribeConsumerGroupsResult describeConsumerGroupsResult = user1.describeConsumerGroups(
+                List.of(GROUP1, GROUP2, GROUP3), new DescribeConsumerGroupsOptions().includeAuthorizedOperations(true));
+            assertEquals(3, describeConsumerGroupsResult.describedGroups().size());
+
+            ConsumerGroupDescription group1Description = describeConsumerGroupsResult.describedGroups().get(GROUP1).get();
+            assertEquals(AclEntry.supportedOperations(ResourceType.GROUP), group1Description.authorizedOperations());
+
+            ConsumerGroupDescription group2Description = describeConsumerGroupsResult.describedGroups().get(GROUP2).get();
+            assertEquals(Set.of(DESCRIBE), group2Description.authorizedOperations());
+
+            ConsumerGroupDescription group3Description = describeConsumerGroupsResult.describedGroups().get(GROUP3).get();
+            assertEquals(Set.of(DESCRIBE, DELETE), group3Description.authorizedOperations());
+        }
+    }
+
+    @ClusterTemplate("generator")
+    public void testClusterAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+        setupSecurity(clusterInstance);
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+            // test without includeAuthorizedOperations flag
+            Set<AclOperation> authorizedOperations = admin.describeCluster().authorizedOperations().get();
+            assertNull(authorizedOperations);
+
+            // test with includeAuthorizedOperations flag
+            authorizedOperations = admin.describeCluster(new DescribeClusterOptions().includeAuthorizedOperations(true)).authorizedOperations().get();
+            assertEquals(Set.of(DESCRIBE, ALTER), authorizedOperations);
+        }
+
+        // enable all operations for cluster resource
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+            AccessControlEntry allOperationEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+            admin.createAcls(List.of(new AclBinding(CLUSTER_PATTERN, allOperationEntry))).all().get();
+            clusterInstance.waitAcls(
+                new AclBindingFilter(CLUSTER_PATTERN.toFilter(), ANY),
+                Set.of(allOperationEntry, ALTER_ENTRY)
+            );
+        }
+
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+            Set<AclOperation> authorizedOperations = admin.describeCluster(new DescribeClusterOptions().includeAuthorizedOperations(true)).authorizedOperations().get();
+            assertEquals(AclEntry.supportedOperations(ResourceType.CLUSTER), authorizedOperations);
+        }
+    }
+
+    @ClusterTemplate("generator")
+    public void testTopicAuthorizedOperations(ClusterInstance clusterInstance) throws ExecutionException, InterruptedException {
+        String topic1 = "topic1";
+        String topic2 = "topic2";
+        setupSecurity(clusterInstance);
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+            admin.createTopics(List.of(
+                new NewTopic(topic1, 1, (short) 1),
+                new NewTopic(topic2, 1, (short) 1)
+            ));
+            clusterInstance.waitForTopic(topic1, 1);
+            clusterInstance.waitForTopic(topic2, 1);
+        }
+
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+            // test without includeAuthorizedOperations flag
+            Map<String, TopicDescription> topicDescriptions = admin.describeTopics(List.of(topic1, topic2)).allTopicNames().get();
+            assertNull(topicDescriptions.get(topic1).authorizedOperations());
+            assertNull(topicDescriptions.get(topic2).authorizedOperations());
+
+            // test with includeAuthorizedOperations flag
+            topicDescriptions = admin.describeTopics(
+                List.of(topic1, topic2),
+                new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames().get();
+            assertEquals(Set.of(DESCRIBE), topicDescriptions.get(topic1).authorizedOperations());
+            assertEquals(Set.of(DESCRIBE), topicDescriptions.get(topic2).authorizedOperations());
+        }
+
+        // add few permissions
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_ADMIN, JaasUtils.KAFKA_PLAIN_ADMIN_PASSWORD))) {
+            ResourcePattern topic1Resource = new ResourcePattern(ResourceType.TOPIC, topic1, PatternType.LITERAL);
+            ResourcePattern topic2Resource = new ResourcePattern(ResourceType.TOPIC, topic2, PatternType.LITERAL);
+            AccessControlEntry allOperationEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, ALL);
+            AccessControlEntry deleteEntry = createAccessControlEntry(JaasUtils.KAFKA_PLAIN_USER1, DELETE);
+            admin.createAcls(List.of(
+                new AclBinding(topic1Resource, allOperationEntry),
+                new AclBinding(topic2Resource, deleteEntry)
+            )).all().get();
+            clusterInstance.waitAcls(
+                new AclBindingFilter(topic1Resource.toFilter(), ANY),
+                Set.of(allOperationEntry)
+            );
+            clusterInstance.waitAcls(
+                new AclBindingFilter(topic2Resource.toFilter(), ANY),
+                Set.of(deleteEntry)
+            );
+        }
+
+        try (Admin admin = clusterInstance.admin(createAdminConfig(JaasUtils.KAFKA_PLAIN_USER1, JaasUtils.KAFKA_PLAIN_USER1_PASSWORD))) {
+            Map<String, TopicDescription> topicDescriptions = admin.describeTopics(
+                List.of(topic1, topic2),
+                new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames().get();
+            assertEquals(AclEntry.supportedOperations(ResourceType.TOPIC), topicDescriptions.get(topic1).authorizedOperations());
+            assertEquals(Set.of(DESCRIBE, DELETE), topicDescriptions.get(topic2).authorizedOperations());
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala b/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala
deleted file mode 100644
index c7426c0d78e..00000000000
--- a/core/src/test/scala/integration/kafka/api/DescribeAuthorizedOperationsTest.scala
+++ /dev/null
@@ -1,211 +0,0 @@
-/**
-  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE
-  * file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
-  * to You under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
-  * License. You may obtain a copy of the License at
-  *
-  * http://www.apache.org/licenses/LICENSE-2.0
-  *
-  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
-  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
-  * specific language governing permissions and limitations under the License.
-  */
-package kafka.api
-
-import kafka.security.JaasTestUtils
-
-import java.util
-import java.util.Properties
-import kafka.utils.{CoreUtils, TestUtils}
-import org.apache.kafka.clients.admin._
-import org.apache.kafka.common.acl.AclOperation.{ALL, ALTER, CLUSTER_ACTION, DELETE, DESCRIBE}
-import org.apache.kafka.common.acl.AclPermissionType.ALLOW
-import org.apache.kafka.common.acl._
-import org.apache.kafka.common.resource.{PatternType, Resource, ResourcePattern, ResourceType}
-import org.apache.kafka.common.security.auth.{KafkaPrincipal, SecurityProtocol}
-import org.apache.kafka.common.utils.Utils
-import org.apache.kafka.metadata.authorizer.StandardAuthorizer
-import org.apache.kafka.security.authorizer.AclEntry
-import org.apache.kafka.server.authorizer.Authorizer
-import org.apache.kafka.server.config.ServerConfigs
-import org.junit.jupiter.api.Assertions.{assertEquals, assertFalse, assertNull}
-import org.junit.jupiter.api.{AfterEach, BeforeEach, Disabled, Test, TestInfo}
-
-import scala.jdk.CollectionConverters._
-import scala.jdk.javaapi.OptionConverters
-
-object DescribeAuthorizedOperationsTest {
-  val Group1 = "group1"
-  val Group2 = "group2"
-  val Group3 = "group3"
-  val Topic1 = "topic1"
-  val Topic2 = "topic2"
-
-  val Group1Acl = new AclBinding(
-    new ResourcePattern(ResourceType.GROUP, Group1, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
-  val Group2Acl = new AclBinding(
-    new ResourcePattern(ResourceType.GROUP, Group2, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DESCRIBE))
-
-  val Group3Acl = new AclBinding(
-    new ResourcePattern(ResourceType.GROUP, Group3, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DELETE))
-
-  val ClusterAllAcl = new AclBinding(
-    new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
-  val Topic1Acl = new AclBinding(
-    new ResourcePattern(ResourceType.TOPIC, Topic1, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALL))
-
-  val Topic2All = new AclBinding(
-    new ResourcePattern(ResourceType.TOPIC, Topic2, PatternType.LITERAL),
-    accessControlEntry(JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DELETE))
-
-  private def accessControlEntry(
-    userName: String,
-    operation: AclOperation
-  ): AccessControlEntry = {
-    new AccessControlEntry(new KafkaPrincipal(KafkaPrincipal.USER_TYPE, userName).toString,
-      AclEntry.WILDCARD_HOST, operation, ALLOW)
-  }
-}
-
-@Disabled("KAFKA-17833: change to use kraft")
-class DescribeAuthorizedOperationsTest extends IntegrationTestHarness with SaslSetup {
-  import DescribeAuthorizedOperationsTest._
-
-  override val brokerCount = 1
-  this.serverConfig.setProperty(ServerConfigs.AUTHORIZER_CLASS_NAME_CONFIG, classOf[StandardAuthorizer].getName)
-
-  var client: Admin = _
-
-  override protected def securityProtocol = SecurityProtocol.SASL_SSL
-
-  override protected lazy val trustStoreFile = Some(TestUtils.tempFile("truststore", ".jks"))
-
-  override def configureSecurityBeforeServersStart(testInfo: TestInfo): Unit = {
-    val authorizer = CoreUtils.createObject[Authorizer](classOf[StandardAuthorizer].getName)
-    val clusterResource = new ResourcePattern(ResourceType.CLUSTER, Resource.CLUSTER_NAME, PatternType.LITERAL)
-    val topicResource = new ResourcePattern(ResourceType.TOPIC, AclEntry.WILDCARD_RESOURCE, PatternType.LITERAL)
-
-    try {
-      authorizer.configure(this.configs.head.originals())
-      val result = authorizer.createAcls(null, List(
-        new AclBinding(clusterResource, accessControlEntry(
-          JaasTestUtils.KAFKA_SERVER_PRINCIPAL_UNQUALIFIED_NAME, CLUSTER_ACTION)),
-        new AclBinding(clusterResource, accessControlEntry(
-          JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, ALTER)),
-        new AclBinding(topicResource, accessControlEntry(
-          JaasTestUtils.KAFKA_CLIENT_PRINCIPAL_UNQUALIFIED_NAME_2, DESCRIBE))
-      ).asJava)
-      result.asScala.map(_.toCompletableFuture.get).foreach(result => assertFalse(result.exception.isPresent))
-    } finally {
-      authorizer.close()
-    }
-  }
-
-  @BeforeEach
-  override def setUp(testInfo: TestInfo): Unit = {
-    startSasl(jaasSections(Seq("GSSAPI"), Some("GSSAPI"), JaasTestUtils.KAFKA_SERVER_CONTEXT_NAME))
-    super.setUp(testInfo)
-    TestUtils.waitUntilBrokerMetadataIsPropagated(servers)
-    client = Admin.create(createConfig())
-  }
-
-  @AfterEach
-  override def tearDown(): Unit = {
-    Utils.closeQuietly(client, "AdminClient")
-    super.tearDown()
-    closeSasl()
-  }
-
-  private def createConfig(): Properties = {
-    val adminClientConfig = new Properties()
-    adminClientConfig.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers())
-    adminClientConfig.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, "20000")
-    val securityProps: util.Map[Object, Object] =
-      JaasTestUtils.adminClientSecurityConfigs(securityProtocol, OptionConverters.toJava(trustStoreFile), OptionConverters.toJava(clientSaslProperties))
-    adminClientConfig.putAll(securityProps)
-    adminClientConfig
-  }
-
-  @Test
-  def testConsumerGroupAuthorizedOperations(): Unit = {
-    val results = client.createAcls(List(Group1Acl, Group2Acl, Group3Acl).asJava)
-    assertEquals(Set(Group1Acl, Group2Acl, Group3Acl), results.values.keySet.asScala)
-    results.all.get
-
-    val describeConsumerGroupsResult = client.describeConsumerGroups(Seq(Group1, Group2, Group3).asJava,
-      new DescribeConsumerGroupsOptions().includeAuthorizedOperations(true))
-    assertEquals(3, describeConsumerGroupsResult.describedGroups().size())
-    val expectedOperations = AclEntry.supportedOperations(ResourceType.GROUP)
-
-    val group1Description = describeConsumerGroupsResult.describedGroups().get(Group1).get
-    assertEquals(expectedOperations, group1Description.authorizedOperations())
-
-    val group2Description = describeConsumerGroupsResult.describedGroups().get(Group2).get
-    assertEquals(Set(AclOperation.DESCRIBE), group2Description.authorizedOperations().asScala.toSet)
-
-    val group3Description = describeConsumerGroupsResult.describedGroups().get(Group3).get
-    assertEquals(Set(AclOperation.DESCRIBE, AclOperation.DELETE), group3Description.authorizedOperations().asScala.toSet)
-  }
-
-  @Test
-  def testClusterAuthorizedOperations(): Unit = {
-    // test without includeAuthorizedOperations flag
-    var clusterDescribeResult = client.describeCluster()
-    assertNull(clusterDescribeResult.authorizedOperations.get())
-
-    // test with includeAuthorizedOperations flag, we have give Alter permission
-    // in configureSecurityBeforeServersStart()
-    clusterDescribeResult = client.describeCluster(new DescribeClusterOptions().
-      includeAuthorizedOperations(true))
-    assertEquals(Set(AclOperation.DESCRIBE, AclOperation.ALTER),
-      clusterDescribeResult.authorizedOperations().get().asScala.toSet)
-
-    // enable all operations for cluster resource
-    val results = client.createAcls(List(ClusterAllAcl).asJava)
-    assertEquals(Set(ClusterAllAcl), results.values.keySet.asScala)
-    results.all.get
-
-    val expectedOperations = AclEntry.supportedOperations(ResourceType.CLUSTER)
-
-    clusterDescribeResult = client.describeCluster(new DescribeClusterOptions().
-      includeAuthorizedOperations(true))
-    assertEquals(expectedOperations, clusterDescribeResult.authorizedOperations().get())
-  }
-
-  @Test
-  def testTopicAuthorizedOperations(): Unit = {
-    createTopic(Topic1)
-    createTopic(Topic2)
-
-    // test without includeAuthorizedOperations flag
-    var describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava).allTopicNames.get()
-    assertNull(describeTopicsResult.get(Topic1).authorizedOperations)
-    assertNull(describeTopicsResult.get(Topic2).authorizedOperations)
-
-    // test with includeAuthorizedOperations flag
-    describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava,
-      new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames.get()
-    assertEquals(Set(AclOperation.DESCRIBE), describeTopicsResult.get(Topic1).authorizedOperations().asScala.toSet)
-    assertEquals(Set(AclOperation.DESCRIBE), describeTopicsResult.get(Topic2).authorizedOperations().asScala.toSet)
-
-    // add few permissions
-    val results = client.createAcls(List(Topic1Acl, Topic2All).asJava)
-    assertEquals(Set(Topic1Acl, Topic2All), results.values.keySet.asScala)
-    results.all.get
-
-    val expectedOperations = AclEntry.supportedOperations(ResourceType.TOPIC)
-
-    describeTopicsResult = client.describeTopics(Set(Topic1, Topic2).asJava,
-      new DescribeTopicsOptions().includeAuthorizedOperations(true)).allTopicNames.get()
-    assertEquals(expectedOperations, describeTopicsResult.get(Topic1).authorizedOperations())
-    assertEquals(Set(AclOperation.DESCRIBE, AclOperation.DELETE),
-      describeTopicsResult.get(Topic2).authorizedOperations().asScala.toSet)
-  }
-}