From 9d59fbac9daaee1627fb0504f85cdded215c6ee2 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Fri, 14 Jun 2024 17:52:46 +0800 Subject: [PATCH 01/18] first upload,remain RunWith --- .../connect/runtime/AbstractHerderTest.java | 64 ++-- .../runtime/AbstractWorkerSourceTaskTest.java | 56 +-- .../connect/runtime/ConnectMetricsTest.java | 33 +- .../connect/runtime/ConnectorConfigTest.java | 29 +- .../runtime/ErrorHandlingTaskTest.java | 31 +- .../ExactlyOnceWorkerSourceTaskTest.java | 81 +++-- .../runtime/InternalSinkRecordTest.java | 18 +- .../kafka/connect/runtime/LoggersTest.java | 38 ++- .../connect/runtime/MockConnectMetrics.java | 7 +- .../connect/runtime/RestartPlanTest.java | 13 +- .../connect/runtime/RestartRequestTest.java | 9 +- .../runtime/SampleHeaderConverter.java | 5 +- .../connect/runtime/SamplePredicate.java | 3 +- .../connect/runtime/SampleSinkConnector.java | 5 +- .../runtime/SampleSourceConnector.java | 5 +- .../connect/runtime/SampleTransformation.java | 3 +- .../runtime/SourceConnectorConfigTest.java | 13 +- .../SourceTaskOffsetCommitterTest.java | 38 ++- .../connect/runtime/StateTrackerTest.java | 14 +- .../connect/runtime/SubmittedRecordsTest.java | 66 ++-- .../runtime/TransformationConfigTest.java | 5 +- .../runtime/TransformationStageTest.java | 13 +- .../connect/runtime/WorkerConfigTest.java | 25 +- .../runtime/WorkerConfigTransformerTest.java | 26 +- .../connect/runtime/WorkerConnectorTest.java | 28 +- .../runtime/WorkerMetricsGroupTest.java | 18 +- .../connect/runtime/WorkerSinkTaskTest.java | 74 ++-- .../runtime/WorkerSinkTaskThreadedTest.java | 58 ++-- .../connect/runtime/WorkerSourceTaskTest.java | 69 ++-- .../kafka/connect/runtime/WorkerTaskTest.java | 40 +-- .../kafka/connect/runtime/WorkerTest.java | 81 +++-- .../connect/runtime/WorkerTestUtils.java | 37 +- .../runtime/WorkerTransactionContextTest.java | 8 +- .../ConnectProtocolCompatibilityTest.java | 9 +- .../distributed/DistributedConfigTest.java | 33 +- .../distributed/DistributedHerderTest.java | 122 +++---- .../IncrementalCooperativeAssignorTest.java | 319 +++++++++--------- .../WorkerCoordinatorIncrementalTest.java | 35 +- .../distributed/WorkerCoordinatorTest.java | 41 ++- .../distributed/WorkerGroupMemberTest.java | 32 +- .../runtime/errors/ErrorReporterTest.java | 28 +- .../RetryWithToleranceOperatorTest.java | 36 +- .../WorkerErrantRecordReporterTest.java | 20 +- .../health/ConnectClusterStateImplTest.java | 26 +- .../isolation/DelegatingClassLoaderTest.java | 18 +- .../runtime/isolation/PluginDescTest.java | 11 +- .../runtime/isolation/PluginScannerTest.java | 174 +++++----- .../runtime/isolation/PluginUtilsTest.java | 67 ++-- .../runtime/isolation/PluginsTest.java | 22 +- .../isolation/SynchronizationTest.java | 277 +++++++-------- .../runtime/isolation/TestPlugins.java | 7 +- .../runtime/rest/ConnectRestServerTest.java | 92 ++--- .../rest/InternalRequestSignatureTest.java | 23 +- .../connect/runtime/rest/RestClientTest.java | 43 +-- .../runtime/rest/RestServerConfigTest.java | 7 +- .../rest/entities/ConnectorOffsetsTest.java | 3 +- .../rest/entities/ConnectorTypeTest.java | 2 +- .../entities/CreateConnectorRequestTest.java | 5 +- .../runtime/rest/entities/PluginInfoTest.java | 2 +- .../ConnectorPluginsResourceTest.java | 52 +-- .../resources/ConnectorsResourceTest.java | 67 ++-- .../InternalConnectResourceTest.java | 34 +- .../rest/resources/LoggingResourceTest.java | 26 +- .../rest/resources/RootResourceTest.java | 15 +- .../runtime/rest/util/SSLUtilsTest.java | 93 ++--- .../standalone/StandaloneConfigTest.java | 9 +- .../standalone/StandaloneHerderTest.java | 48 +-- 67 files changed, 1416 insertions(+), 1395 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index da8fed5b66d34..736bdb5c6b5cf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -16,6 +16,21 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.producer.ProducerConfig; import org.apache.kafka.common.config.ConfigDef; @@ -56,35 +71,21 @@ import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.apache.kafka.connect.runtime.AbstractHerder.keysWithVariableValues; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; @@ -98,7 +99,8 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractHerderTest { private static final String CONN1 = "sourceA"; @@ -1050,16 +1052,16 @@ private void testConnectorPluginConfig( verify(plugins).withClassLoader(newPluginInstance.get().getClass().getClassLoader()); } - @Test(expected = NotFoundException.class) + @Test public void testGetConnectorConfigDefWithBadName() throws Exception { String connName = "AnotherPlugin"; AbstractHerder herder = testHerder(); when(worker.getPlugins()).thenReturn(plugins); when(plugins.pluginClass(anyString())).thenThrow(new ClassNotFoundException()); - herder.connectorPluginConfig(connName); + assertThrows(NotFoundException.class, () -> herder.connectorPluginConfig(connName)); } - @Test(expected = BadRequestException.class) + @Test @SuppressWarnings({"rawtypes", "unchecked"}) public void testGetConnectorConfigDefWithInvalidPluginType() throws Exception { String connName = "AnotherPlugin"; @@ -1067,7 +1069,7 @@ public void testGetConnectorConfigDefWithInvalidPluginType() throws Exception { when(worker.getPlugins()).thenReturn(plugins); when(plugins.pluginClass(anyString())).thenReturn((Class) Object.class); when(plugins.newPlugin(anyString())).thenReturn(new DirectoryConfigProvider()); - herder.connectorPluginConfig(connName); + assertThrows(BadRequestException.class, () -> herder.connectorPluginConfig(connName)); } @Test @@ -1228,7 +1230,7 @@ private void testConfigProviderRegex(String rawConnConfig) { private void testConfigProviderRegex(String rawConnConfig, boolean expected) { Set keys = keysWithVariableValues(Collections.singletonMap("key", rawConnConfig), ConfigTransformer.DEFAULT_PATTERN); boolean actual = keys != null && !keys.isEmpty() && keys.contains("key"); - assertEquals(String.format("%s should have matched regex", rawConnConfig), expected, actual); + assertEquals(expected, actual, String.format("%s should have matched regex", rawConnConfig)); } private AbstractHerder createConfigValidationHerder(Class connectorClass, diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index 62cac0d37877f..b00db2c817c51 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.TimeoutException; +import java.util.function.Supplier; +import java.util.stream.Collectors; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.admin.TopicDescription; import org.apache.kafka.clients.producer.Callback; @@ -55,29 +67,18 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.nio.ByteBuffer; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.TimeoutException; -import java.util.function.Supplier; -import java.util.stream.Collectors; - import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; @@ -90,12 +91,12 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; @@ -107,7 +108,8 @@ import static org.mockito.Mockito.when; @SuppressWarnings("unchecked") -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractWorkerSourceTaskTest { private static final String TOPIC = "topic"; @@ -151,7 +153,7 @@ public class AbstractWorkerSourceTaskTest { private AbstractWorkerSourceTask workerTask; - @Before + @BeforeEach public void setup() { Map workerProps = workerProps(); plugins = new Plugins(workerProps); @@ -187,7 +189,7 @@ private Map sourceConnectorPropsWithGroups() { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); verifyNoMoreInteractions(statusListener); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java index 11de95284044e..d1a51c6c0d35b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java @@ -16,6 +16,9 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.Sensor; @@ -24,21 +27,17 @@ import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroup; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroupId; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class ConnectMetricsTest { @@ -51,12 +50,12 @@ public class ConnectMetricsTest { private ConnectMetrics metrics; - @Before + @BeforeEach public void setUp() { metrics = new ConnectMetrics("worker1", new WorkerConfig(WorkerConfig.baseConfigDef(), DEFAULT_WORKER_CONFIG), new MockTime(), "cluster-1"); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java index 6fa2808c19ea3..4bd9181c85daf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java @@ -16,6 +16,11 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.ConfigException; import org.apache.kafka.connect.components.Versioned; @@ -26,20 +31,14 @@ import org.apache.kafka.connect.sink.SinkRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.Test; - -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; public class ConnectorConfigTest> { @@ -469,8 +468,8 @@ public void testEnrichedConfigDef() { private static void assertEnrichedConfigDef(ConfigDef def, String prefix, String keyName, ConfigDef.Type expectedType) { assertNull(def.configKeys().get(keyName)); ConfigDef.ConfigKey configKey = def.configKeys().get(prefix + keyName); - assertNotNull(prefix + keyName + "' config must be present", configKey); - assertEquals(prefix + keyName + "' config should be a " + expectedType, expectedType, configKey.type); + assertNotNull(configKey, prefix + keyName + "' config must be present"); + assertEquals(expectedType, configKey.type, prefix + keyName + "' config should be a " + expectedType); } public static class HasDuplicateConfigTransformation> implements Transformation, Versioned { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index 3aeecc1d757c3..1468aefac9097 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -16,6 +16,15 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; @@ -61,10 +70,10 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; @@ -74,16 +83,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.IOException; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - import static java.util.Collections.emptyMap; import static java.util.Collections.singletonList; import static org.apache.kafka.common.utils.Time.SYSTEM; @@ -98,7 +97,7 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.any; import static org.mockito.Mockito.doReturn; @@ -190,7 +189,7 @@ public ErrorHandlingTaskTest(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; } - @Before + @BeforeEach public void setup() { time = new MockTime(0, 0, 0); metrics = new MockConnectMetrics(); @@ -220,7 +219,7 @@ private Map sourceConnectorProps(String topic) { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) { metrics.stop(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index 6d5e6350357ed..2c1388744b650 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -16,6 +16,23 @@ */ package org.apache.kafka.connect.runtime; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.stream.Collectors; import org.apache.kafka.clients.producer.Producer; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.KafkaException; @@ -54,10 +71,10 @@ import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; @@ -66,24 +83,6 @@ import org.mockito.stubbing.OngoingStubbing; import org.mockito.verification.VerificationMode; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Consumer; -import java.util.stream.Collectors; - import static java.util.Collections.emptySet; import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; @@ -99,11 +98,11 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.atLeast; @@ -189,7 +188,7 @@ public ExactlyOnceWorkerSourceTaskTest(boolean enableTopicCreation) { this.taskStarted = false; } - @Before + @BeforeEach public void setup() throws Exception { Map workerProps = workerProps(); plugins = new Plugins(workerProps); @@ -209,7 +208,7 @@ public void setup() throws Exception { }); } - @After + @AfterEach public void teardown() throws Exception { // In most tests, we don't really care about how many times the task got polled, // how many times we prepared to write offsets, etc. @@ -607,15 +606,15 @@ public void testIntervalBasedCommit() throws Exception { startTaskThread(); awaitPolls(2); - assertEquals("No flushes should have taken place before offset commit interval has elapsed", 0, flushCount()); + assertEquals(0, flushCount(), "No flushes should have taken place before offset commit interval has elapsed"); time.sleep(commitInterval); awaitPolls(2); - assertEquals("One flush should have taken place after offset commit interval has elapsed", 1, flushCount()); + assertEquals(1, flushCount(), "One flush should have taken place after offset commit interval has elapsed"); time.sleep(commitInterval * 2); awaitPolls(2); - assertEquals("Two flushes should have taken place after offset commit interval has elapsed again", 2, flushCount()); + assertEquals(2, flushCount(), "Two flushes should have taken place after offset commit interval has elapsed again"); awaitShutdown(); @@ -664,22 +663,22 @@ private void testConnectorBasedCommit(Consumer requestCommit startTaskThread(); awaitPolls(3); - assertEquals("No flushes should have taken place without connector requesting transaction commit", - 0, flushCount()); + assertEquals(0, flushCount(), + "No flushes should have taken place without connector requesting transaction commit"); requestCommit.accept(transactionContext); awaitPolls(3); - assertEquals("One flush should have taken place after transaction commit/abort was requested", - 1, flushCount()); + assertEquals(1, flushCount(), + "One flush should have taken place after transaction commit/abort was requested"); awaitPolls(3); - assertEquals("Only one flush should still have taken place without connector re-requesting commit/abort, even on identical records", - 1, flushCount()); + assertEquals(1, flushCount(), + "Only one flush should still have taken place without connector re-requesting commit/abort, even on identical records"); awaitShutdown(); - assertEquals("Task should have flushed offsets once based on connector-defined boundaries, and skipped final end-of-life offset commit", - 1, flushCount()); + assertEquals(1, flushCount(), + "Task should have flushed offsets once based on connector-defined boundaries, and skipped final end-of-life offset commit"); // We begin a new transaction after connector-requested aborts so that we can still write offsets for the source records that were aborted verify(producer, times(abort ? 3 : 2)).beginTransaction(); verifySends(); @@ -1205,8 +1204,8 @@ private void assertTransactionMetrics(int minimumMaxSizeExpected) { if (actualMax - actualMin <= 0.000001d) { assertEquals(actualMax, actualAvg, 0.000002d); } else { - assertTrue("Average transaction size should be greater than minimum transaction size", actualAvg > actualMin); - assertTrue("Average transaction size should be less than maximum transaction size", actualAvg < actualMax); + assertTrue(actualAvg > actualMin, "Average transaction size should be greater than minimum transaction size"); + assertTrue(actualAvg < actualMax, "Average transaction size should be less than maximum transaction size"); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java index 28ffcfd8d0848..7b9005394baff 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java @@ -16,21 +16,23 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.connect.header.Header; import org.apache.kafka.connect.runtime.errors.ProcessingContext; import org.apache.kafka.connect.sink.SinkRecord; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.Collections; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class InternalSinkRecordTest { private static final String TOPIC = "test-topic"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java index 184724ef25503..c5e5c8cd78815 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java @@ -16,17 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.common.utils.MockTime; -import org.apache.kafka.common.utils.Time; -import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; -import org.apache.log4j.Hierarchy; -import org.apache.log4j.Level; -import org.apache.log4j.Logger; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; - import java.util.Arrays; import java.util.Collections; import java.util.Enumeration; @@ -37,18 +26,31 @@ import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; - -@RunWith(MockitoJUnitRunner.StrictStubs.class) +import org.apache.kafka.common.utils.MockTime; +import org.apache.kafka.common.utils.Time; +import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; +import org.apache.log4j.Hierarchy; +import org.apache.log4j.Level; +import org.apache.log4j.Logger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class LoggersTest { private static final long INITIAL_TIME = 1696951712135L; private Time time; - @Before + @BeforeEach public void setup() { time = new MockTime(0, INITIAL_TIME, 0); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java index c5f9f8314d9ef..24c2efba4551f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java @@ -16,6 +16,9 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.KafkaMetric; @@ -23,10 +26,6 @@ import org.apache.kafka.common.metrics.MetricsReporter; import org.apache.kafka.common.utils.MockTime; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - /** * A specialization of {@link ConnectMetrics} that uses a custom {@link MetricsReporter} to capture the metrics * that were created, and makes those metrics available even after the metrics were removed from the diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java index 480ba2bae9ebd..28214bd5f331d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java @@ -16,17 +16,16 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.List; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo.TaskState; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; -import org.junit.Test; - -import java.util.ArrayList; -import java.util.List; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class RestartPlanTest { private static final String CONNECTOR_NAME = "foo"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java index c4be5ca88f60e..1a28e425c8085 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java @@ -16,15 +16,14 @@ */ package org.apache.kafka.connect.runtime; -import org.junit.Test; - import java.util.Arrays; import java.util.Collections; import java.util.List; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class RestartRequestTest { private static final String CONNECTOR_NAME = "foo"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java index 3491fde3988c0..f273e05ef8663 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java @@ -16,6 +16,8 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; @@ -23,9 +25,6 @@ import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.storage.HeaderConverter; -import java.io.IOException; -import java.util.Map; - public class SampleHeaderConverter implements HeaderConverter, Versioned { @Override public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java index 4d72df35ca3e3..f573381d1e533 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java @@ -16,14 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.predicates.Predicate; -import java.util.Map; - public class SamplePredicate implements Predicate, Versioned { private boolean testResult; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java index da8fb231edc7a..578f0a758f27e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java @@ -16,13 +16,12 @@ */ package org.apache.kafka.connect.runtime; +import java.util.List; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.sink.SinkConnector; -import java.util.List; -import java.util.Map; - public class SampleSinkConnector extends SinkConnector { public static final String VERSION = "some great version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java index cb91530439f3d..02aefae0bfd78 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java @@ -16,15 +16,14 @@ */ package org.apache.kafka.connect.runtime; +import java.util.List; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; -import java.util.List; -import java.util.Map; - public class SampleSourceConnector extends SourceConnector { public static final String VERSION = "an entirely different version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java index 443b488ef3b46..d7ea0ea776db6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java @@ -16,14 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; import org.apache.kafka.connect.transforms.Transformation; -import java.util.Map; - public class SampleTransformation> implements Transformation, Versioned { boolean closed = false; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java index 251bb72fbe2d9..a867a094b63b2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java @@ -17,14 +17,13 @@ package org.apache.kafka.connect.runtime; -import org.apache.kafka.common.config.ConfigException; -import org.junit.Test; - import java.util.HashMap; import java.util.Map; import java.util.Objects; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; +import org.apache.kafka.common.config.ConfigException; +import org.junit.jupiter.api.Test; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_COMPACT; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_CONFIG; @@ -40,10 +39,10 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class SourceConnectorConfigTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java index ef962cf5b445e..c2e7c0b96fbea 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.common.utils.LogCaptureAppender; -import org.apache.kafka.common.utils.ThreadUtils; -import org.apache.kafka.connect.errors.ConnectException; -import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; -import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - import java.util.HashMap; import java.util.Map; import java.util.concurrent.CancellationException; @@ -36,17 +24,31 @@ import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; +import org.apache.kafka.common.utils.LogCaptureAppender; +import org.apache.kafka.common.utils.ThreadUtils; +import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; +import org.apache.kafka.connect.util.ConnectorTaskId; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Collections.singletonMap; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +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 static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class SourceTaskOffsetCommitterTest { private final ConcurrentHashMap> committers = new ConcurrentHashMap<>(); @@ -66,7 +68,7 @@ public class SourceTaskOffsetCommitterTest { private static final long DEFAULT_OFFSET_COMMIT_INTERVAL_MS = 1000; - @Before + @BeforeEach public void setup() { Map workerProps = new HashMap<>(); workerProps.put("key.converter", "org.apache.kafka.connect.json.JsonConverter"); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java index 507d196d42982..349230e696476 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java @@ -16,13 +16,13 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.runtime.AbstractStatus.State; import org.apache.kafka.common.utils.MockTime; -import org.junit.Before; -import org.junit.Test; +import org.apache.kafka.connect.runtime.AbstractStatus.State; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; public class StateTrackerTest { @@ -31,7 +31,7 @@ public class StateTrackerTest { private StateTracker tracker; private MockTime time; - @Before + @BeforeEach public void setUp() { time = new MockTime(); time.sleep(1000L); @@ -100,4 +100,4 @@ public void calculateDurations() { } -} \ No newline at end of file +} diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java index 39d680a7d46be..17ba8f5abdcf9 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java @@ -16,10 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; -import org.junit.Before; -import org.junit.Test; - import java.util.Arrays; import java.util.Collections; import java.util.HashMap; @@ -28,11 +24,14 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; +import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.SubmittedRecords.CommittableOffsets; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class SubmittedRecordsTest { @@ -44,7 +43,7 @@ public class SubmittedRecordsTest { SubmittedRecords submittedRecords; - @Before + @BeforeEach public void setup() { submittedRecords = new SubmittedRecords(); offset = new AtomicInteger(); @@ -178,8 +177,8 @@ public void testRemoveLastSubmittedRecord() { assertEquals(Collections.emptyMap(), committableOffsets.offsets()); assertMetadata(committableOffsets, 0, 1, 1, 1, PARTITION1); - assertTrue("First attempt to remove record from submitted queue should succeed", submittedRecord.drop()); - assertFalse("Attempt to remove already-removed record from submitted queue should fail", submittedRecord.drop()); + assertTrue(submittedRecord.drop(), "First attempt to remove record from submitted queue should succeed"); + assertFalse(submittedRecord.drop(), "Attempt to remove already-removed record from submitted queue should fail"); committableOffsets = submittedRecords.committableOffsets(); // Even if SubmittedRecords::remove is broken, we haven't ack'd anything yet, so there should be no committable offsets @@ -203,7 +202,7 @@ public void testRemoveNotLastSubmittedRecord() { assertMetadata(committableOffsets, 0, 2, 2, 1, PARTITION1, PARTITION2); assertNoEmptyDeques(); - assertTrue("First attempt to remove record from submitted queue should succeed", recordToRemove.drop()); + assertTrue(recordToRemove.drop(), "First attempt to remove record from submitted queue should succeed"); committableOffsets = submittedRecords.committableOffsets(); // Even if SubmittedRecords::remove is broken, we haven't ack'd anything yet, so there should be no committable offsets @@ -265,27 +264,24 @@ public void testAwaitMessagesAfterAllRemoved() { SubmittedRecord recordToRemove1 = submittedRecords.submit(PARTITION1, newOffset()); SubmittedRecord recordToRemove2 = submittedRecords.submit(PARTITION1, newOffset()); assertFalse( - "Await should fail since neither of the in-flight records has been removed so far", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) - ); + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should fail since neither of the in-flight records has been removed so far"); recordToRemove1.drop(); assertFalse( - "Await should fail since only one of the two submitted records has been removed so far", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) - ); + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should fail since only one of the two submitted records has been removed so far"); recordToRemove1.drop(); assertFalse( + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), "Await should fail since only one of the two submitted records has been removed so far, " - + "even though that record has been removed twice", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) - ); + + "even though that record has been removed twice"); recordToRemove2.drop(); assertTrue( - "Await should succeed since both submitted records have now been removed", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should succeed since both submitted records have now been removed" ); } @@ -308,48 +304,48 @@ public void testAwaitMessagesReturnsAfterAsynchronousAck() throws Exception { }).start(); assertTrue( - "Should not have finished awaiting message delivery before either in-flight record was acknowledged", - awaitComplete.getCount() > 0 + awaitComplete.getCount() > 0, + "Should not have finished awaiting message delivery before either in-flight record was acknowledged" ); inFlightRecord1.ack(); assertTrue( - "Should not have finished awaiting message delivery before one in-flight record was acknowledged", - awaitComplete.getCount() > 0 + awaitComplete.getCount() > 0, + "Should not have finished awaiting message delivery before one in-flight record was acknowledged" ); inFlightRecord1.ack(); assertTrue( + awaitComplete.getCount() > 0, "Should not have finished awaiting message delivery before one in-flight record was acknowledged, " - + "even though the other record has been acknowledged twice", - awaitComplete.getCount() > 0 + + "even though the other record has been acknowledged twice" ); inFlightRecord2.ack(); assertTrue( - "Should have finished awaiting message delivery after both in-flight records were acknowledged", - awaitComplete.await(1, TimeUnit.SECONDS) + awaitComplete.await(1, TimeUnit.SECONDS), + "Should have finished awaiting message delivery after both in-flight records were acknowledged" ); assertTrue( - "Await of in-flight messages should have succeeded", - awaitResult.get() + awaitResult.get(), + "Await of in-flight messages should have succeeded" ); } private void assertNoRemainingDeques() { - assertEquals("Internal records map should be completely empty", Collections.emptyMap(), submittedRecords.records); + assertEquals(Collections.emptyMap(), submittedRecords.records, "Internal records map should be completely empty"); } @SafeVarargs private final void assertRemovedDeques(Map... partitions) { for (Map partition : partitions) { - assertFalse("Deque for partition " + partition + " should have been cleaned up from internal records map", submittedRecords.records.containsKey(partition)); + assertFalse(submittedRecords.records.containsKey(partition), "Deque for partition " + partition + " should have been cleaned up from internal records map"); } } private void assertNoEmptyDeques() { submittedRecords.records.forEach((partition, deque) -> - assertFalse("Empty deque for partition " + partition + " should have been cleaned up from internal records map", deque.isEmpty()) + assertFalse(deque.isEmpty(), "Empty deque for partition " + partition + " should have been cleaned up from internal records map") ); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java index 1d63d7db55f34..88fdf6d2d7713 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java @@ -16,6 +16,7 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.tools.MockConnector; import org.apache.kafka.connect.transforms.Cast; @@ -30,9 +31,7 @@ import org.apache.kafka.connect.transforms.TimestampConverter; import org.apache.kafka.connect.transforms.TimestampRouter; import org.apache.kafka.connect.transforms.ValueToKey; -import org.junit.Test; - -import java.util.HashMap; +import org.junit.jupiter.api.Test; /** * Tests that transformations' configs can be composed with ConnectorConfig during its construction, ensuring no diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index 6d6b8dcaa814f..67a47c0039591 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -19,18 +19,21 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Collections.singletonMap; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class TransformationStageTest { private final SourceRecord initial = new SourceRecord(singletonMap("initial", 1), null, null, null, null); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java index dbb25cdafac15..7d1429d66a37a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java @@ -16,24 +16,23 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.MockAdminClient; import org.apache.kafka.common.Node; import org.apache.kafka.connect.errors.ConnectException; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.MockedStatic; import org.mockito.internal.stubbing.answers.CallsRealMethods; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; -import java.util.List; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mockStatic; import static org.mockito.Mockito.times; @@ -43,13 +42,13 @@ public class WorkerConfigTest { private static final String CLUSTER_ID = "cluster-id"; private MockedStatic workerConfigMockedStatic; - @Before + @BeforeEach public void setup() { workerConfigMockedStatic = mockStatic(WorkerConfig.class, new CallsRealMethods()); workerConfigMockedStatic.when(() -> WorkerConfig.lookupKafkaClusterId(any(WorkerConfig.class))).thenReturn(CLUSTER_ID); } - @After + @AfterEach public void teardown() { workerConfigMockedStatic.close(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java index 4af49c0ea1600..2857aeb4763a0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java @@ -16,30 +16,32 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.common.config.ConfigData; -import org.apache.kafka.common.config.provider.ConfigProvider; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Set; +import org.apache.kafka.common.config.ConfigData; +import org.apache.kafka.common.config.provider.ConfigProvider; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_NONE; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.notNull; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerConfigTransformerTest { public static final String MY_KEY = "myKey"; @@ -60,7 +62,7 @@ public class WorkerConfigTransformerTest { private HerderRequest requestId; private WorkerConfigTransformer configTransformer; - @Before + @BeforeEach public void setup() { configTransformer = new WorkerConfigTransformer(worker, Collections.singletonMap("test", new TestConfigProvider())); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index ab8cdb65a0cb8..f895c5541ace7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -16,6 +16,10 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.health.ConnectorType; @@ -28,16 +32,10 @@ import org.apache.kafka.connect.storage.CloseableOffsetStorageReader; import org.apache.kafka.connect.storage.ConnectorOffsetBackingStore; import org.apache.kafka.connect.util.Callback; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; - - -import java.util.Arrays; -import java.util.Collection; -import java.util.HashMap; -import java.util.Map; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.ArgumentCaptor; @@ -47,11 +45,11 @@ import org.mockito.junit.MockitoRule; import org.mockito.quality.Strictness; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.isNull; @@ -113,13 +111,13 @@ public WorkerConnectorTest(ConnectorType connectorType) { } } - @Before + @BeforeEach public void setup() { connectorConfig = new ConnectorConfig(plugins, CONFIG); metrics = new MockConnectMetrics(); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index 9d17b638d5c2e..fc5294c0358a6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -16,19 +16,20 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.MetricNameTemplate; import org.apache.kafka.common.metrics.CompoundStat; import org.apache.kafka.common.metrics.Sensor; import org.apache.kafka.common.metrics.stats.CumulativeSum; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.HashMap; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyDouble; @@ -38,7 +39,8 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerMetricsGroupTest { private final String connector = "org.FakeConnector"; private final ConnectorTaskId task = new ConnectorTaskId(connector, 0); @@ -62,7 +64,7 @@ public class WorkerMetricsGroupTest { @Mock private ConnectMetrics.MetricGroup metricGroup; @Mock private MetricName metricName; - @Before + @BeforeEach public void setup() { // We don't expect metricGroup.metricName to be invoked with null in practice, // but it's easier to test this way, and should have no impact diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java index 75f942a6871d8..103e48b00a64c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java @@ -16,27 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import static java.util.Arrays.asList; -import static java.util.Collections.singleton; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.ArgumentMatchers.anyMap; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; @@ -95,21 +74,44 @@ import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; import org.mockito.stubbing.OngoingStubbing; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +import static java.util.Arrays.asList; +import static java.util.Collections.singleton; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSinkTaskTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values // with mix of integer/string in Connect @@ -176,7 +178,7 @@ public class WorkerSinkTaskTest { private long recordsReturnedTp1; private long recordsReturnedTp3; - @Before + @BeforeEach public void setUp() { time = new MockTime(); Map workerProps = new HashMap<>(); @@ -207,7 +209,7 @@ private void createTask(TargetState initialState, Converter keyConverter, Conver retryWithToleranceOperator, null, statusBackingStore, errorReportersSupplier); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } @@ -920,10 +922,10 @@ public void testRequestCommit() { // is the normal commit time less the two sleeps since it started each // of those sleeps were 10 seconds. // KAFKA-8229 - assertEquals("Should have only advanced by 40 seconds", - previousCommitValue + + assertEquals(previousCommitValue + (WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT - 10000L * 2), - workerTask.getNextCommit()); + workerTask.getNextCommit(), + "Should have only advanced by 40 seconds"); assertSinkMetricValue("partition-count", 2); assertSinkMetricValue("sink-record-read-total", 1.0); @@ -1110,7 +1112,7 @@ public void testLongRunningCommitWithoutTimeout() { workerTask.iteration(); // iter 3 -- commit in progress // Make sure the "committing" flag didn't immediately get flipped back to false due to an incorrect timeout - assertTrue("Expected worker to be in the process of committing offsets", workerTask.isCommitting()); + assertTrue(workerTask.isCommitting(), "Expected worker to be in the process of committing offsets"); // Delay the result of trying to commit offsets to Kafka via the consumer.commitAsync method. ArgumentCaptor offsetCommitCallbackArgumentCaptor = @@ -1196,8 +1198,8 @@ public void testSuppressCloseErrors() { workerTask.initializeAndStart(); RuntimeException thrownException = assertThrows(ConnectException.class, () -> workerTask.execute()); - assertEquals("Exception from put should be the cause", putException, thrownException.getCause()); - assertTrue("Exception from close should be suppressed", thrownException.getSuppressed().length > 0); + assertEquals(putException, thrownException.getCause(), "Exception from put should be the cause"); + assertTrue(thrownException.getSuppressed().length > 0, "Exception from close should be suppressed"); assertEquals(closeException, thrownException.getSuppressed()[0]); } @@ -1889,4 +1891,4 @@ private void assertTaskMetricValue(String name, String expected) { String measured = metrics.currentMetricValueAsString(taskGroup, name); assertEquals(expected, measured); } -} \ No newline at end of file +} diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index facdf9da72a1c..4be63978830a5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -25,53 +37,42 @@ import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.header.internals.RecordHeaders; import org.apache.kafka.common.record.TimestampType; +import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.errors.ProcessingContext; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperatorTest; -import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkRecord; import org.apache.kafka.connect.sink.SinkTask; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.common.utils.MockTime; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.invocation.InvocationOnMock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.io.IOException; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.function.Function; - import static java.util.Collections.singletonList; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyString; @@ -84,7 +85,8 @@ import static org.mockito.Mockito.when; @SuppressWarnings("unchecked") -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSinkTaskThreadedTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values @@ -161,7 +163,7 @@ public class WorkerSinkTaskThreadedTest { return offsetsToCommit; }; - @Before + @BeforeEach public void setup() { time = new MockTime(); metrics = new MockConnectMetrics(); @@ -178,7 +180,7 @@ public void setup() { recordsReturned = 0; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 00cc7b7bb6382..d5c34016c69cc 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -16,32 +16,52 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Supplier; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.producer.Callback; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.KafkaException; +import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.errors.InvalidTopicException; import org.apache.kafka.common.errors.TopicAuthorizationException; -import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.header.Headers; import org.apache.kafka.common.header.internals.RecordHeaders; +import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.integration.MonitorableSourceConnector; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroup; -import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperator; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperatorTest; -import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; import org.apache.kafka.connect.source.SourceTaskContext; import org.apache.kafka.connect.storage.CloseableOffsetStorageReader; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.ConnectorOffsetBackingStore; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; @@ -53,10 +73,9 @@ import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.apache.kafka.common.utils.LogCaptureAppender; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.AdditionalAnswers; @@ -67,26 +86,6 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Supplier; - import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; @@ -99,12 +98,12 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyString; @@ -201,7 +200,7 @@ public WorkerSourceTaskTest(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; } - @Before + @BeforeEach public void setup() { Map workerProps = workerProps(); plugins = new Plugins(workerProps); @@ -237,7 +236,7 @@ private Map sourceConnectorPropsWithGroups(String topic) { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); verifyNoMoreInteractions(statusListener); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java index 859ec64f656a7..84bbf4b5e64b7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java @@ -16,6 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.function.Supplier; +import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.runtime.TaskStatus.Listener; @@ -27,30 +34,25 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.common.utils.MockTime; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CountDownLatch; -import java.util.function.Supplier; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerTaskTest { private static final Map TASK_PROPS = new HashMap<>(); @@ -68,12 +70,12 @@ public class WorkerTaskTest { @Mock private TransformationChain transformationChain; @Mock private Supplier>> errorReportersSupplier; - @Before + @BeforeEach public void setup() { metrics = new MockConnectMetrics(); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 4c5a04533e226..b63c0451bf21b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -16,6 +16,26 @@ */ package org.apache.kafka.connect.runtime; +import javax.management.MBeanServer; +import javax.management.ObjectName; +import java.lang.management.ManagementFactory; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.Admin; import org.apache.kafka.clients.admin.AlterConsumerGroupOffsetsOptions; @@ -88,9 +108,9 @@ import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.SinkUtils; import org.apache.kafka.connect.util.TopicAdmin; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.AdditionalAnswers; @@ -103,27 +123,6 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.quality.Strictness; -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.lang.management.ManagementFactory; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; - import static org.apache.kafka.clients.admin.AdminClientConfig.RETRY_BACKOFF_MS_CONFIG; import static org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_CONFIG; import static org.apache.kafka.clients.producer.ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG; @@ -148,14 +147,14 @@ import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyCollection; import static org.mockito.ArgumentMatchers.anyLong; @@ -254,7 +253,7 @@ public WorkerTest(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; } - @Before + @BeforeEach public void setup() { // Use strict mode to detect unused mocks mockitoSession = Mockito.mockitoSession() @@ -315,7 +314,7 @@ public void setup() { WorkerTest::workerTaskConstructor); } - @After + @AfterEach public void teardown() { // Critical to always close MockedStatics // Ideal would be to use try-with-resources in an individual test, but it introduced a rather large level of @@ -1845,9 +1844,9 @@ public void testZombieFencing() { assertEquals(expectedZombieFenceFuture, actualZombieFenceFuture); assertNotNull(adminConfig.get()); - assertEquals("Admin should be configured with user-specified overrides", - "4761", - adminConfig.get().get(RETRY_BACKOFF_MS_CONFIG) + assertEquals("4761", + adminConfig.get().get(RETRY_BACKOFF_MS_CONFIG), + "Admin should be configured with user-specified overrides" ); verifyKafkaClusterId(); @@ -2751,11 +2750,9 @@ private void testStartTaskWithTooManyTaskConfigs(boolean enforced) { ArgumentCaptor failureCaptor = ArgumentCaptor.forClass(Throwable.class); verify(taskStatusListener, times(1)).onFailure(eq(TASK_ID), failureCaptor.capture()); - assertTrue( + assertInstanceOf(TooManyTasksException.class, failureCaptor.getValue(), "Expected task start exception to be TooManyTasksException, but was " - + failureCaptor.getValue().getClass() + " instead", - failureCaptor.getValue() instanceof TooManyTasksException - ); + + failureCaptor.getValue().getClass() + " instead"); tasksMaxExceededMessage = failureCaptor.getValue().getMessage(); } else { @@ -2788,10 +2785,10 @@ private void assertTasksMaxExceededMessage(String connector, int numTasks, int m + numTasks + " tasks, which is greater than " + maxTasks; assertTrue( + message.startsWith(expectedPrefix), "Warning/exception message '" + message + "' did not start with the expected prefix '" - + expectedPrefix + "'", - message.startsWith(expectedPrefix) + + expectedPrefix + "'" ); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java index 6101dc48c6b11..844eb7f21ed78 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java @@ -16,12 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; -import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; -import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; -import org.apache.kafka.connect.util.ConnectorTaskId; - import java.util.AbstractMap.SimpleEntry; import java.util.Collections; import java.util.HashMap; @@ -29,12 +23,17 @@ import java.util.Map; import java.util.stream.Collectors; import java.util.stream.IntStream; +import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; +import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectorTaskId; import static org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.WorkerLoad; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; public class WorkerTestUtils { @@ -176,29 +175,29 @@ public static void assertAssignment(boolean expectFailed, int expectedRevokedTaskNum, int expectedDelay, ExtendedAssignment assignment) { - assertNotNull("Assignment can't be null", assignment); + assertNotNull(assignment, "Assignment can't be null"); - assertEquals("Wrong status in " + assignment, expectFailed, assignment.failed()); + assertEquals(expectFailed, assignment.failed(), "Wrong status in " + assignment); - assertEquals("Wrong leader in " + assignment, expectedLeader, assignment.leader()); + assertEquals(expectedLeader, assignment.leader(), "Wrong leader in " + assignment); - assertEquals("Wrong leaderUrl in " + assignment, expectedLeaderUrl(expectedLeader), - assignment.leaderUrl()); + assertEquals(expectedLeaderUrl(expectedLeader), + assignment.leaderUrl(), "Wrong leaderUrl in " + assignment); - assertEquals("Wrong offset in " + assignment, expectedOffset, assignment.offset()); + assertEquals(expectedOffset, assignment.offset(), "Wrong offset in " + assignment); assertThat("Wrong set of assigned connectors in " + assignment, assignment.connectors(), is(expectedAssignedConnectors)); - assertEquals("Wrong number of assigned tasks in " + assignment, - expectedAssignedTaskNum, assignment.tasks().size()); + assertEquals(expectedAssignedTaskNum, assignment.tasks().size(), + "Wrong number of assigned tasks in " + assignment); assertThat("Wrong set of revoked connectors in " + assignment, assignment.revokedConnectors(), is(expectedRevokedConnectors)); - assertEquals("Wrong number of revoked tasks in " + assignment, - expectedRevokedTaskNum, assignment.revokedTasks().size()); + assertEquals(expectedRevokedTaskNum, assignment.revokedTasks().size(), + "Wrong number of revoked tasks in " + assignment); - assertEquals("Wrong rebalance delay in " + assignment, expectedDelay, assignment.delay()); + assertEquals(expectedDelay, assignment.delay(), "Wrong rebalance delay in " + assignment); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java index 3bc2b2155d1f1..6906afa47012c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java @@ -17,11 +17,11 @@ package org.apache.kafka.connect.runtime; import org.apache.kafka.connect.source.SourceRecord; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class WorkerTransactionContextTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java index 38084383e2951..d36b387206c5b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java @@ -16,17 +16,16 @@ */ package org.apache.kafka.connect.runtime.distributed; -import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Test; - import java.nio.ByteBuffer; import java.util.Arrays; import java.util.Collections; +import org.apache.kafka.connect.util.ConnectorTaskId; +import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; public class ConnectProtocolCompatibilityTest { private static final String LEADER = "leader"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java index c7fc0d8299a11..59af7b9282720 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java @@ -17,13 +17,6 @@ package org.apache.kafka.connect.runtime.distributed; -import org.apache.kafka.clients.CommonClientConfigs; -import org.apache.kafka.common.config.ConfigException; -import org.apache.kafka.common.security.auth.SecurityProtocol; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; - import javax.crypto.KeyGenerator; import javax.crypto.Mac; import java.security.InvalidParameterException; @@ -37,24 +30,33 @@ import java.util.Locale; import java.util.Map; import java.util.Set; +import org.apache.kafka.clients.CommonClientConfigs; +import org.apache.kafka.common.config.ConfigException; +import org.apache.kafka.common.security.auth.SecurityProtocol; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.EXACTLY_ONCE_SOURCE_SUPPORT_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.GROUP_ID_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_KEY_GENERATION_ALGORITHM_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_SIGNATURE_ALGORITHM_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_VERIFICATION_ALGORITHMS_CONFIG; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +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 static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class DistributedConfigTest { public Map configs() { @@ -148,7 +150,8 @@ private void testSupportedAlgorithms(String type, String... expectedAlgorithms) Set supportedAlgorithms = DistributedConfig.supportedAlgorithms(type); Set unsupportedAlgorithms = new HashSet<>(Arrays.asList(expectedAlgorithms)); unsupportedAlgorithms.removeAll(supportedAlgorithms); - assertEquals(type + " algorithms were found that should be supported by this JVM but are not", Collections.emptySet(), unsupportedAlgorithms); + assertEquals(Collections.emptySet(), unsupportedAlgorithms, + type + " algorithms were found that should be supported by this JVM but are not"); } @Test diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java index 028e5202bf529..851764b73b4af 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java @@ -16,6 +16,32 @@ */ package org.apache.kafka.connect.runtime.distributed; +import javax.crypto.SecretKey; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.AbstractExecutorService; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.KafkaException; import org.apache.kafka.common.KafkaFuture; @@ -72,42 +98,17 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; import org.apache.kafka.connect.util.Stage; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import javax.crypto.SecretKey; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.AbstractExecutorService; -import java.util.concurrent.Callable; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.RejectedExecutionException; -import java.util.concurrent.ThreadPoolExecutor; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; -import java.util.stream.IntStream; - import static java.util.Collections.singletonList; import static javax.ws.rs.core.Response.Status.FORBIDDEN; import static javax.ws.rs.core.Response.Status.SERVICE_UNAVAILABLE; @@ -122,12 +123,12 @@ import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V2; import static org.apache.kafka.connect.source.SourceTask.TransactionBoundary.CONNECTOR; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.AdditionalMatchers.leq; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyLong; @@ -147,7 +148,8 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) @SuppressWarnings("unchecked") public class DistributedHerderTest { private static final Map HERDER_CONFIG = new HashMap<>(); @@ -301,7 +303,7 @@ public class DistributedHerderTest { private final SampleConnectorClientConfigOverridePolicy noneConnectorClientConfigOverridePolicy = new SampleConnectorClientConfigOverridePolicy(); - @Before + @BeforeEach public void setUp() throws Exception { time = new MockTime(); metrics = new MockConnectMetrics(time); @@ -323,7 +325,7 @@ public void setUp() throws Exception { when(herder.connectorType(anyMap())).thenReturn(ConnectorType.SOURCE); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); if (herderExecutor != null) { @@ -1813,7 +1815,7 @@ public void testStopConnector() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue("Callback should already have been invoked by herder", cb.isDone()); + assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); cb.get(0, TimeUnit.MILLISECONDS); verifyNoMoreInteractions(worker, member, configBackingStore, statusBackingStore); @@ -1840,11 +1842,11 @@ public void testStopConnectorNotLeader() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue("Callback should already have been invoked by herder", cb.isDone()); + assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); ExecutionException e = assertThrows( - "Should not be able to handle request to stop connector when not leader", ExecutionException.class, - () -> cb.get(0, TimeUnit.SECONDS) + () -> cb.get(0, TimeUnit.SECONDS), + "Should not be able to handle request to stop connector when not leader" ); assertInstanceOf(NotLeaderException.class, e.getCause()); @@ -1880,11 +1882,11 @@ public void testStopConnectorFailToWriteTaskConfigs() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue("Callback should already have been invoked by herder", cb.isDone()); + assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); ExecutionException e = assertThrows( - "Should not be able to handle request to stop connector when not leader", ExecutionException.class, - () -> cb.get(0, TimeUnit.SECONDS) + () -> cb.get(0, TimeUnit.SECONDS), + "Should not be able to handle request to stop connector when not leader" ); assertEquals(e.getCause(), taskConfigsWriteException); @@ -3615,8 +3617,8 @@ public void testExactlyOnceSourceSupportValidationOnUnknownConnector() { List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains("The connector does not implement the API required for preflight validation of exactly-once source support.")); + errors.get(0).contains("The connector does not implement the API required for preflight validation of exactly-once source support."), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -3636,8 +3638,8 @@ public void testExactlyOnceSourceSupportValidationHandlesConnectorErrorsGraceful List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains(errorMessage)); + errors.get(0).contains(errorMessage), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -3672,8 +3674,8 @@ public void testExactlyOnceSourceSupportValidationHandlesInvalidValuesGracefully List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains("String must be one of (case insensitive): ")); + errors.get(0).contains("String must be one of (case insensitive): "), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -3710,8 +3712,8 @@ public void testConnectorTransactionBoundaryValidationOnUnsupportedConnector() { List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains("The connector does not support connector-defined transaction boundaries with the given configuration.")); + errors.get(0).contains("The connector does not support connector-defined transaction boundaries with the given configuration."), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -3731,8 +3733,8 @@ public void testConnectorTransactionBoundaryValidationHandlesConnectorErrorsGrac List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains(errorMessage)); + errors.get(0).contains(errorMessage), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -3750,8 +3752,8 @@ public void testConnectorTransactionBoundaryValidationHandlesInvalidValuesGracef List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - "Error message did not contain expected text: " + errors.get(0), - errors.get(0).contains("String must be one of (case insensitive): ")); + errors.get(0).contains("String must be one of (case insensitive): "), + "Error message did not contain expected text: " + errors.get(0)); assertEquals(1, errors.size()); } @@ -4209,7 +4211,7 @@ private void startBackgroundHerder() { private void stopBackgroundHerder() throws Exception { herder.stop(); herderExecutor.shutdown(); - assertTrue("herder thread did not finish in time", herderExecutor.awaitTermination(10, TimeUnit.SECONDS)); + assertTrue(herderExecutor.awaitTermination(10, TimeUnit.SECONDS), "herder thread did not finish in time"); herderFuture.get(); assertTrue(noneConnectorClientConfigOverridePolicy.isClosed()); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java index 48b7973fdc22e..5aacc89f20b78 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java @@ -16,22 +16,6 @@ */ package org.apache.kafka.connect.runtime.distributed; -import org.apache.kafka.clients.consumer.internals.RequestFuture; -import org.apache.kafka.common.message.JoinGroupResponseData; -import org.apache.kafka.common.utils.LogContext; -import org.apache.kafka.common.utils.MockTime; -import org.apache.kafka.common.utils.Time; -import org.apache.kafka.connect.runtime.TargetState; -import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.util.ConnectUtils; -import org.apache.kafka.connect.storage.ClusterConfigState; -import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; - import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.Arrays; @@ -45,20 +29,38 @@ import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.IntStream; +import org.apache.kafka.clients.consumer.internals.RequestFuture; +import org.apache.kafka.common.message.JoinGroupResponseData; +import org.apache.kafka.common.utils.LogContext; +import org.apache.kafka.common.utils.MockTime; +import org.apache.kafka.common.utils.Time; +import org.apache.kafka.connect.runtime.TargetState; +import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectUtils; +import org.apache.kafka.connect.util.ConnectorTaskId; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeAssignor.ClusterAssignment; import static org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.WorkerLoad; import static org.apache.kafka.connect.util.ConnectUtils.transformValues; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.notNull; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class IncrementalCooperativeAssignorTest { // Offset isn't used in most tests but is required for creating a config snapshot object, @@ -73,7 +75,7 @@ public class IncrementalCooperativeAssignorTest { private ClusterAssignment returnedAssignments; private Map memberAssignments; - @Before + @BeforeEach public void setup() { generationId = 1000; time = Time.SYSTEM; @@ -730,9 +732,9 @@ public void testLostAssignmentHandlingWhenWorkerBounces() { new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); @@ -747,9 +749,9 @@ public void testLostAssignmentHandlingWhenWorkerBounces() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -762,9 +764,9 @@ public void testLostAssignmentHandlingWhenWorkerBounces() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.singleton(flakyWorker), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.singleton(flakyWorker), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -775,17 +777,17 @@ public void testLostAssignmentHandlingWhenWorkerBounces() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertTrue("Wrong assignment of lost connectors", - configuredAssignment.getOrDefault(flakyWorker, new WorkerLoad.Builder(flakyWorker).build()) - .connectors() - .containsAll(lostAssignments.connectors())); - assertTrue("Wrong assignment of lost tasks", - configuredAssignment.getOrDefault(flakyWorker, new WorkerLoad.Builder(flakyWorker).build()) - .tasks() - .containsAll(lostAssignments.tasks())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertTrue(configuredAssignment.getOrDefault(flakyWorker, new WorkerLoad.Builder(flakyWorker).build()) + .connectors() + .containsAll(lostAssignments.connectors()), + "Wrong assignment of lost connectors"); + assertTrue(configuredAssignment.getOrDefault(flakyWorker, new WorkerLoad.Builder(flakyWorker).build()) + .tasks() + .containsAll(lostAssignments.tasks()), + "Wrong assignment of lost tasks"); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); } @@ -810,9 +812,9 @@ public void testLostAssignmentHandlingWhenWorkerLeavesPermanently() { new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); @@ -827,9 +829,9 @@ public void testLostAssignmentHandlingWhenWorkerLeavesPermanently() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -841,9 +843,9 @@ public void testLostAssignmentHandlingWhenWorkerLeavesPermanently() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -853,13 +855,13 @@ public void testLostAssignmentHandlingWhenWorkerLeavesPermanently() { assignor.handleLostAssignments(lostAssignments, lostAssignmentsToReassign, new ArrayList<>(configuredAssignment.values())); - assertTrue("Wrong assignment of lost connectors", - lostAssignmentsToReassign.build().connectors().containsAll(lostAssignments.connectors())); - assertTrue("Wrong assignment of lost tasks", - lostAssignmentsToReassign.build().tasks().containsAll(lostAssignments.tasks())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertTrue(lostAssignmentsToReassign.build().connectors().containsAll(lostAssignments.connectors()), + "Wrong assignment of lost connectors"); + assertTrue(lostAssignmentsToReassign.build().tasks().containsAll(lostAssignments.tasks()), + "Wrong assignment of lost tasks"); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); } @@ -884,9 +886,9 @@ public void testLostAssignmentHandlingWithMoreThanOneCandidates() { new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); @@ -904,9 +906,9 @@ public void testLostAssignmentHandlingWithMoreThanOneCandidates() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.singleton(newWorker), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.singleton(newWorker), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -921,9 +923,9 @@ public void testLostAssignmentHandlingWithMoreThanOneCandidates() { Set expectedWorkers = new HashSet<>(); expectedWorkers.addAll(Arrays.asList(newWorker, flakyWorker)); - assertEquals("Wrong set of workers for reassignments", - expectedWorkers, - assignor.candidateWorkersForReassignment); + assertEquals(expectedWorkers, + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -949,13 +951,13 @@ public void testLostAssignmentHandlingWithMoreThanOneCandidates() { .tasks()); listOfTasksInLast2Workers.addAll(configuredAssignment.getOrDefault(flakyWorker, new WorkerLoad.Builder(flakyWorker).build()) .tasks()); - assertTrue("Wrong assignment of lost connectors", - listOfConnectorsInLast2Workers.containsAll(lostAssignments.connectors())); - assertTrue("Wrong assignment of lost tasks", - listOfTasksInLast2Workers.containsAll(lostAssignments.tasks())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertTrue(listOfConnectorsInLast2Workers.containsAll(lostAssignments.connectors()), + "Wrong assignment of lost connectors"); + assertTrue(listOfTasksInLast2Workers.containsAll(lostAssignments.tasks()), + "Wrong assignment of lost tasks"); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); } @@ -980,9 +982,9 @@ public void testLostAssignmentHandlingWhenWorkerBouncesBackButFinallyLeaves() { new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); @@ -997,9 +999,9 @@ public void testLostAssignmentHandlingWhenWorkerBouncesBackButFinallyLeaves() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -1012,9 +1014,9 @@ public void testLostAssignmentHandlingWhenWorkerBouncesBackButFinallyLeaves() { assignor.handleLostAssignments(lostAssignments, new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.singleton(veryFlakyWorker), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.singleton(veryFlakyWorker), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(time.milliseconds() + rebalanceDelay, assignor.scheduledRebalance); assertEquals(rebalanceDelay, assignor.delay); @@ -1027,13 +1029,13 @@ public void testLostAssignmentHandlingWhenWorkerBouncesBackButFinallyLeaves() { assignor.handleLostAssignments(lostAssignments, lostAssignmentsToReassign, new ArrayList<>(configuredAssignment.values())); - assertTrue("Wrong assignment of lost connectors", - lostAssignmentsToReassign.build().connectors().containsAll(lostAssignments.connectors())); - assertTrue("Wrong assignment of lost tasks", - lostAssignmentsToReassign.build().tasks().containsAll(lostAssignments.tasks())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertTrue(lostAssignmentsToReassign.build().connectors().containsAll(lostAssignments.connectors()), + "Wrong assignment of lost connectors"); + assertTrue(lostAssignmentsToReassign.build().tasks().containsAll(lostAssignments.tasks()), + "Wrong assignment of lost tasks"); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); } @@ -1059,9 +1061,9 @@ public void testLostAssignmentHandlingWhenScheduledDelayIsDisabled() { new ConnectorsAndTasks.Builder(), new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); @@ -1077,15 +1079,15 @@ public void testLostAssignmentHandlingWhenScheduledDelayIsDisabled() { assignor.handleLostAssignments(lostAssignments, lostAssignmentsToReassign, new ArrayList<>(configuredAssignment.values())); - assertEquals("Wrong set of workers for reassignments", - Collections.emptySet(), - assignor.candidateWorkersForReassignment); + assertEquals(Collections.emptySet(), + assignor.candidateWorkersForReassignment, + "Wrong set of workers for reassignments"); assertEquals(0, assignor.scheduledRebalance); assertEquals(0, assignor.delay); - assertEquals("Wrong assignment of lost connectors", - lostAssignments.connectors(), lostAssignmentsToReassign.build().connectors()); - assertEquals("Wrong assignment of lost tasks", - lostAssignments.tasks(), lostAssignmentsToReassign.build().tasks()); + assertEquals(lostAssignments.connectors(), + lostAssignmentsToReassign.build().connectors(), "Wrong assignment of lost connectors"); + assertEquals(lostAssignments.tasks(), + lostAssignmentsToReassign.build().tasks(), "Wrong assignment of lost tasks"); } @Test @@ -1240,9 +1242,9 @@ public void testProtocolV1() { serializedAssignments.forEach((worker, serializedAssignment) -> { ExtendedAssignment assignment = IncrementalCooperativeConnectProtocol.deserializeAssignment(serializedAssignment); assertEquals( - "Incorrect protocol version in assignment for worker " + worker, IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1, - assignment.version() + assignment.version(), + "Incorrect protocol version in assignment for worker " + worker ); }); } @@ -1281,9 +1283,9 @@ public void testProtocolV2() { serializedAssignments.forEach((worker, serializedAssignment) -> { ExtendedAssignment assignment = IncrementalCooperativeConnectProtocol.deserializeAssignment(serializedAssignment); assertEquals( - "Incorrect protocol version in assignment for worker " + worker, IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V2, - assignment.version() + assignment.version(), + "Incorrect protocol version in assignment for worker " + worker ); }); } @@ -1332,16 +1334,16 @@ private void addNewEmptyWorkers(String... workers) { private void addNewWorker(String worker, List connectors, List tasks) { ConnectorsAndTasks assignment = new ConnectorsAndTasks.Builder().with(connectors, tasks).build(); assertNull( - "Worker " + worker + " already exists", - memberAssignments.put(worker, assignment) + memberAssignments.put(worker, assignment), + "Worker " + worker + " already exists" ); } private void removeWorkers(String... workers) { for (String worker : workers) { assertNotNull( - "Worker " + worker + " does not exist", - memberAssignments.remove(worker) + memberAssignments.remove(worker), + "Worker " + worker + " does not exist" ); } } @@ -1375,15 +1377,15 @@ private static List newTasks(String connectorName, int start, i private void addNewConnector(String connector, int taskCount) { assertNull( - "Connector " + connector + " already exists", - connectors.put(connector, taskCount) + connectors.put(connector, taskCount), + "Connector " + connector + " already exists" ); } private void removeConnector(String connector) { assertNotNull( - "Connector " + connector + " does not exist", - connectors.remove(connector) + connectors.remove(connector), + "Connector " + connector + " does not exist" ); } @@ -1418,7 +1420,8 @@ private ClusterConfigState configState() { private void applyAssignments() { returnedAssignments.allWorkers().forEach(worker -> { - ConnectorsAndTasks workerAssignment = memberAssignments.computeIfAbsent(worker, ignored -> new ConnectorsAndTasks.Builder().build()); + ConnectorsAndTasks workerAssignment = memberAssignments.computeIfAbsent(worker, + ignored -> new ConnectorsAndTasks.Builder().build()); workerAssignment.connectors().removeAll(returnedAssignments.newlyRevokedConnectors(worker)); workerAssignment.connectors().addAll(returnedAssignments.newlyAssignedConnectors(worker)); @@ -1426,49 +1429,44 @@ private void applyAssignments() { workerAssignment.tasks().addAll(returnedAssignments.newlyAssignedTasks(worker)); assertEquals( - "Complete connector assignment for worker " + worker + " does not match expectations " + - "based on prior assignment and new revocations and assignments", new HashSet<>(workerAssignment.connectors()), - new HashSet<>(returnedAssignments.allAssignedConnectors().get(worker)) + new HashSet<>(returnedAssignments.allAssignedConnectors().get(worker)), + "Complete connector assignment for worker " + worker + " does not match expectations " + + "based on prior assignment and new revocations and assignments" ); assertEquals( - "Complete task assignment for worker " + worker + " does not match expectations " + - "based on prior assignment and new revocations and assignments", new HashSet<>(workerAssignment.tasks()), - new HashSet<>(returnedAssignments.allAssignedTasks().get(worker)) + new HashSet<>(returnedAssignments.allAssignedTasks().get(worker)), + "Complete task assignment for worker " + worker + " does not match expectations " + + "based on prior assignment and new revocations and assignments" ); }); } private void assertEmptyAssignment() { assertEquals( - "No connectors should have been newly assigned during this round", Collections.emptyList(), - ConnectUtils.combineCollections(returnedAssignments.newlyAssignedConnectors().values()) - ); + ConnectUtils.combineCollections(returnedAssignments.newlyAssignedConnectors().values()), + "No connectors should have been newly assigned during this round"); assertEquals( - "No tasks should have been newly assigned during this round", Collections.emptyList(), - ConnectUtils.combineCollections(returnedAssignments.newlyAssignedTasks().values()) - ); + ConnectUtils.combineCollections(returnedAssignments.newlyAssignedTasks().values()), + "No tasks should have been newly assigned during this round"); assertEquals( - "No connectors should have been revoked during this round", Collections.emptyList(), - ConnectUtils.combineCollections(returnedAssignments.newlyRevokedConnectors().values()) - ); + ConnectUtils.combineCollections(returnedAssignments.newlyRevokedConnectors().values()), + "No connectors should have been revoked during this round"); assertEquals( - "No tasks should have been revoked during this round", Collections.emptyList(), - ConnectUtils.combineCollections(returnedAssignments.newlyRevokedTasks().values()) - ); + ConnectUtils.combineCollections(returnedAssignments.newlyRevokedTasks().values()), + "No tasks should have been revoked during this round"); } private void assertWorkers(String... workers) { assertEquals( - "Wrong set of workers", new HashSet<>(Arrays.asList(workers)), - returnedAssignments.allWorkers() - ); + returnedAssignments.allWorkers(), + "Wrong set of workers"); } /** @@ -1498,9 +1496,9 @@ private void assertAllocations(String allocated, Function actualAllocations = allocations(allocation); assertEquals( - "Allocation of assigned " + allocated + " across cluster does not match expected counts", expectedAllocations, - actualAllocations + actualAllocations, + "Allocation of assigned " + allocated + " across cluster does not match expected counts" ); } @@ -1515,25 +1513,23 @@ private List allocations(Function assertEquals( - "Expected no revocations to take place during this round, but connector revocations were issued for worker " + worker, Collections.emptySet(), - new HashSet<>(revocations) - ) + new HashSet<>(revocations), + "Expected no revocations to take place during this round, but connector revocations were issued for worker " + worker) ); returnedAssignments.newlyRevokedTasks().forEach((worker, revocations) -> assertEquals( - "Expected no revocations to take place during this round, but task revocations were issued for worker " + worker, Collections.emptySet(), - new HashSet<>(revocations) - ) + new HashSet<>(revocations), + "Expected no revocations to take place during this round, but task revocations were issued for worker " + worker) ); } private void assertDelay(int expectedDelay) { assertEquals( - "Wrong rebalance delay", expectedDelay, - assignor.delay + assignor.delay, + "Wrong rebalance delay" ); } @@ -1557,13 +1553,13 @@ private void assertNoRedundantAssignments() { ); existingConnectors.retainAll(newConnectors); - assertEquals("Found connectors in new assignment that already exist in current assignment", - Collections.emptyList(), - existingConnectors); + assertEquals(Collections.emptyList(), + existingConnectors, + "Found connectors in new assignment that already exist in current assignment"); existingTasks.retainAll(newTasks); - assertEquals("Found tasks in new assignment that already exist in current assignment", - Collections.emptyList(), - existingConnectors); + assertEquals(Collections.emptyList(), + existingConnectors, + "Found tasks in new assignment that already exist in current assignment"); } private void assertBalancedAndCompleteAllocation() { @@ -1582,22 +1578,19 @@ private void assertBalancedAllocation() { int maxTasks = taskCounts.get(taskCounts.size() - 1); assertTrue( - "Assignments are imbalanced. The spread of connectors across each worker is: " + connectorCounts, - maxConnectors - minConnectors <= 1 - ); + maxConnectors - minConnectors <= 1, + "Assignments are imbalanced. The spread of connectors across each worker is: " + connectorCounts); assertTrue( - "Assignments are imbalanced. The spread of tasks across each worker is: " + taskCounts, - maxTasks - minTasks <= 1 - ); + maxTasks - minTasks <= 1, + "Assignments are imbalanced. The spread of tasks across each worker is: " + taskCounts); } private void assertCompleteAllocation() { List allAssignedConnectors = ConnectUtils.combineCollections(memberAssignments.values(), ConnectorsAndTasks::connectors); assertEquals( - "The set of connectors assigned across the cluster does not match the set of connectors in the config topic", connectors.keySet(), - new HashSet<>(allAssignedConnectors) - ); + new HashSet<>(allAssignedConnectors), + "The set of connectors assigned across the cluster does not match the set of connectors in the config topic"); Map> allAssignedTasks = ConnectUtils.combineCollections(memberAssignments.values(), ConnectorsAndTasks::tasks) .stream() @@ -1608,18 +1601,18 @@ private void assertCompleteAllocation() { .mapToObj(i -> new ConnectorTaskId(connector, i)) .collect(Collectors.toSet()); assertEquals( - "The set of tasks assigned across the cluster for connector " + connector + " does not match the set of tasks in the config topic", expectedTasks, - new HashSet<>(allAssignedTasks.get(connector)) + new HashSet<>(allAssignedTasks.get(connector)), + "The set of tasks assigned across the cluster for connector " + connector + " does not match the set of tasks in the config topic" ); }); } private static void assertNoDuplicates(List collection, String assertionMessage) { assertEquals( - assertionMessage, new HashSet<>(collection).size(), - collection.size() + collection.size(), + assertionMessage ); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java index ca5c3bdc6f833..6b877ac04e138 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java @@ -16,6 +16,15 @@ */ package org.apache.kafka.connect.runtime.distributed; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; import org.apache.kafka.clients.GroupRebalanceConfig; import org.apache.kafka.clients.Metadata; import org.apache.kafka.clients.MockClient; @@ -29,10 +38,10 @@ import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.KafkaConfigBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; @@ -40,16 +49,6 @@ import org.mockito.junit.MockitoRule; import org.mockito.quality.Strictness; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; - import static org.apache.kafka.common.message.JoinGroupRequestData.JoinGroupRequestProtocol; import static org.apache.kafka.common.message.JoinGroupRequestData.JoinGroupRequestProtocolCollection; import static org.apache.kafka.common.message.JoinGroupResponseData.JoinGroupResponseMember; @@ -60,9 +59,9 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.SESSIONED; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.times; @@ -127,7 +126,7 @@ public static Iterable mode() { @Parameter(1) public int expectedMetadataSize; - @Before + @BeforeEach public void setup() { LogContext loggerFactory = new LogContext(); @@ -175,7 +174,7 @@ public void setup() { configState1 = clusterConfigState(offset, 2, 4); } - @After + @AfterEach public void teardown() { this.metrics.close(); verifyNoMoreInteractions(configStorage); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java index 1911eb10b1303..74e6e2ea84b8b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java @@ -16,6 +16,17 @@ */ package org.apache.kafka.connect.runtime.distributed; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.stream.Collectors; import org.apache.kafka.clients.GroupRebalanceConfig; import org.apache.kafka.clients.Metadata; import org.apache.kafka.clients.MockClient; @@ -41,10 +52,10 @@ import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.KafkaConfigBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; @@ -52,24 +63,12 @@ import org.mockito.junit.MockitoRule; import org.mockito.quality.Strictness; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.stream.Collectors; - import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.COMPATIBLE; import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.mock; @@ -131,7 +130,7 @@ public static Iterable mode() { @Parameter(1) public int expectedMetadataSize; - @Before + @BeforeEach public void setup() { LogContext logContext = new LogContext(); @@ -241,7 +240,7 @@ public void setup() { ); } - @After + @AfterEach public void teardown() { this.metrics.close(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java index 77d70d8fd9a7b..411c2a297d739 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java @@ -16,6 +16,11 @@ */ package org.apache.kafka.connect.runtime.distributed; +import javax.management.MBeanServer; +import javax.management.ObjectName; +import java.lang.management.ManagementFactory; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.JmxReporter; @@ -26,26 +31,23 @@ import org.apache.kafka.connect.runtime.MockConnectMetrics; import org.apache.kafka.connect.runtime.WorkerConfig; import org.apache.kafka.connect.storage.ConfigBackingStore; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.lang.management.ManagementFactory; -import java.util.HashMap; -import java.util.Map; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerGroupMemberTest { @Mock private ConfigBackingStore configBackingStore; @@ -83,8 +85,8 @@ public void testMetrics() throws Exception { foundJmxReporter = true; } } - assertTrue("Failed to find MockMetricsReporter", foundMockReporter); - assertTrue("Failed to find JmxReporter", foundJmxReporter); + assertTrue(foundMockReporter, "Failed to find MockMetricsReporter"); + assertTrue(foundJmxReporter, "Failed to find JmxReporter"); MetricName name = member.metrics().metricName("test.avg", "grp1"); member.metrics().addMetric(name, new Avg()); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java index e0018a13e9544..9506a94993df5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java @@ -16,6 +16,10 @@ */ package org.apache.kafka.connect.runtime.errors; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Future; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; @@ -31,17 +35,14 @@ import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; @@ -67,7 +68,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class ErrorReporterTest { private static final String TOPIC = "test-topic"; @@ -86,13 +88,13 @@ public class ErrorReporterTest { private ErrorHandlingMetrics errorHandlingMetrics; private MockConnectMetrics metrics; - @Before + @BeforeEach public void setup() { metrics = new MockConnectMetrics(); errorHandlingMetrics = new ErrorHandlingMetrics(new ConnectorTaskId("connector-", 1), metrics); } - @After + @AfterEach public void tearDown() { if (metrics != null) { metrics.stop(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java index 66d2e335599e2..dfa6173e043e3 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime.errors; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import java.util.stream.IntStream; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.producer.RecordMetadata; @@ -35,25 +47,14 @@ import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.OngoingStubbing; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; -import java.util.stream.IntStream; - import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; import static org.apache.kafka.common.utils.Time.SYSTEM; @@ -80,7 +81,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class RetryWithToleranceOperatorTest { private static final Map PROPERTIES = new HashMap() {{ diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java index e84c832f6442b..07d941380bba0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java @@ -17,6 +17,10 @@ package org.apache.kafka.connect.runtime.errors; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.utils.Time; @@ -25,15 +29,12 @@ import org.apache.kafka.connect.runtime.InternalSinkRecord; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.concurrent.CompletableFuture; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; @@ -42,7 +43,8 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerErrantRecordReporterTest { private WorkerErrantRecordReporter reporter; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java index 16c7f42831180..24fdb41db5c2c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java @@ -16,22 +16,23 @@ */ package org.apache.kafka.connect.runtime.health; -import org.apache.kafka.connect.errors.ConnectException; -import org.apache.kafka.connect.runtime.Herder; -import org.apache.kafka.connect.util.Callback; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; +import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.Herder; +import org.apache.kafka.connect.util.Callback; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotSame; @@ -39,7 +40,8 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doAnswer; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class ConnectClusterStateImplTest { protected static final String KAFKA_CLUSTER_ID = "franzwashere"; @@ -49,7 +51,7 @@ public class ConnectClusterStateImplTest { protected long herderRequestTimeoutMs = TimeUnit.SECONDS.toMillis(10); protected Collection expectedConnectors; - @Before + @BeforeEach public void setUp() { expectedConnectors = Arrays.asList("sink1", "source1", "source2"); connectClusterState = new ConnectClusterStateImpl( diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java index 70303e552af96..9d14f7adea6d5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java @@ -16,24 +16,26 @@ */ package org.apache.kafka.connect.runtime.isolation; -import org.apache.kafka.connect.sink.SinkConnector; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; - import java.net.MalformedURLException; import java.net.URL; import java.util.Collections; import java.util.SortedSet; import java.util.TreeSet; +import org.apache.kafka.connect.sink.SinkConnector; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class DelegatingClassLoaderTest { public PluginClassLoader parent; @@ -55,7 +57,7 @@ public class DelegatingClassLoaderTest { } } - @Before + @BeforeEach @SuppressWarnings({"unchecked"}) public void setUp() { parent = mock(PluginClassLoader.class); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java index 12eac8c94de06..f05193b2b4492 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java @@ -17,6 +17,8 @@ package org.apache.kafka.connect.runtime.isolation; +import java.net.URL; +import java.nio.file.Paths; import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.config.provider.FileConfigProvider; import org.apache.kafka.connect.json.JsonConverter; @@ -26,11 +28,8 @@ import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.Before; -import org.junit.Test; - -import java.net.URL; -import java.nio.file.Paths; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; @@ -48,7 +47,7 @@ public class PluginDescTest { private PluginClassLoader pluginLoader; private PluginClassLoader otherPluginLoader; - @Before + @BeforeEach public void setUp() throws Exception { // Fairly simple use case, thus no need to create a random directory here yet. URL location = Paths.get("/tmp").toUri().toURL(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java index 4f20ccdeaae7e..20245ff425c53 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java @@ -17,135 +17,128 @@ package org.apache.kafka.connect.runtime.isolation; -import org.junit.BeforeClass; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; - +import java.io.File; import java.nio.file.Files; import java.nio.file.Path; -import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; +import java.util.HashMap; import java.util.HashSet; -import java.util.List; +import java.util.Map; import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.io.TempDir; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertFalse; -@RunWith(Parameterized.class) public class PluginScannerTest { private enum ScannerType { Reflection, ServiceLoader } - @Rule - public TemporaryFolder pluginDir = new TemporaryFolder(); - - private final PluginScanner scanner; - - @Parameterized.Parameters - public static Collection parameters() { - List values = new ArrayList<>(); - for (ScannerType type : ScannerType.values()) { - values.add(new Object[]{type}); - } - return values; + + @TempDir + File pluginDir; + + private Map scannerMap; + + @BeforeEach + public void setScanner() { + scannerMap = new HashMap<>(); + scannerMap.put(ScannerType.Reflection, new ReflectionScanner()); + scannerMap.put(ScannerType.ServiceLoader, new ServiceLoaderScanner()); } - public PluginScannerTest(ScannerType scannerType) { - switch (scannerType) { - case Reflection: - this.scanner = new ReflectionScanner(); - break; - case ServiceLoader: - this.scanner = new ServiceLoaderScanner(); - break; - default: - throw new IllegalArgumentException("Unknown type " + scannerType); - } + static Stream parameters() { + return Stream.of(ScannerType.values()); } - - @BeforeClass + + @BeforeAll public static void setUp() { // Work around a circular-dependency in TestPlugins. TestPlugins.pluginPath(); } - @Test - public void testScanningEmptyPluginPath() { - PluginScanResult result = scan( - Collections.emptySet() - ); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningEmptyPluginPath(ScannerType scannerType) { + PluginScanResult result = scan(scannerType, Collections.emptySet()); assertTrue(result.isEmpty()); } - @Test - public void testScanningPluginClasses() { - PluginScanResult result = scan( - TestPlugins.pluginPath() - ); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningPluginClasses(ScannerType scannerType) { + PluginScanResult result = scan(scannerType, TestPlugins.pluginPath()); Set classes = new HashSet<>(); result.forEach(pluginDesc -> classes.add(pluginDesc.className())); Set expectedClasses = new HashSet<>(TestPlugins.pluginClasses()); assertEquals(expectedClasses, classes); } - @Test - public void testScanningInvalidUberJar() throws Exception { - pluginDir.newFile("invalid.jar"); - - PluginScanResult result = scan( - Collections.singleton(pluginDir.getRoot().toPath().toAbsolutePath()) - ); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningInvalidUberJar(ScannerType scannerType) throws Exception { + File newFile = new File(pluginDir, "invalid.jar"); + newFile.createNewFile(); + PluginScanResult result = scan(scannerType, Collections.singleton(pluginDir.toPath())); assertTrue(result.isEmpty()); } - @Test - public void testScanningPluginDirContainsInvalidJarsOnly() throws Exception { - pluginDir.newFolder("my-plugin"); - pluginDir.newFile("my-plugin/invalid.jar"); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningPluginDirContainsInvalidJarsOnly(ScannerType scannerType) throws Exception { + File newFile = new File(pluginDir, "my-plugin"); + newFile.mkdir(); + newFile = new File(newFile, "invalid.jar"); + newFile.createNewFile(); - PluginScanResult result = scan( - Collections.singleton(pluginDir.getRoot().toPath().toAbsolutePath()) - ); + PluginScanResult result = scan(scannerType, Collections.singleton(pluginDir.toPath())); assertTrue(result.isEmpty()); } - @Test - public void testScanningNoPlugins() { - PluginScanResult result = scan( - Collections.singleton(pluginDir.getRoot().toPath().toAbsolutePath()) + @ParameterizedTest + @MethodSource("parameters") + public void testScanningNoPlugins(ScannerType scannerType) { + PluginScanResult result = scan(scannerType, + Collections.singleton(pluginDir.toPath()) ); assertTrue(result.isEmpty()); } - @Test - public void testScanningPluginDirEmpty() throws Exception { - pluginDir.newFolder("my-plugin"); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningPluginDirEmpty(ScannerType scannerType) throws Exception { + File newFile = new File(pluginDir, "my-plugin"); + newFile.mkdir(); - PluginScanResult result = scan( - Collections.singleton(pluginDir.getRoot().toPath().toAbsolutePath()) + PluginScanResult result = scan(scannerType, + Collections.singleton(pluginDir.toPath()) ); assertTrue(result.isEmpty()); } - @Test - public void testScanningMixOfValidAndInvalidPlugins() throws Exception { - pluginDir.newFile("invalid.jar"); - pluginDir.newFolder("my-plugin"); - pluginDir.newFile("my-plugin/invalid.jar"); - Path pluginPath = this.pluginDir.getRoot().toPath(); + @ParameterizedTest + @MethodSource("parameters") + public void testScanningMixOfValidAndInvalidPlugins(ScannerType scannerType) throws Exception { + new File(pluginDir, "invalid.jar").createNewFile(); + File newFile = new File(pluginDir, "my-plugin"); + newFile.mkdir(); + newFile = new File(newFile, "invalid.jar"); + newFile.createNewFile(); + Path pluginPath = this.pluginDir.toPath(); for (Path source : TestPlugins.pluginPath()) { Files.copy(source, pluginPath.resolve(source.getFileName())); } - PluginScanResult result = scan( - Collections.singleton(pluginDir.getRoot().toPath().toAbsolutePath()) + PluginScanResult result = scan(scannerType, + Collections.singleton(pluginDir.toPath()) ); Set classes = new HashSet<>(); result.forEach(pluginDesc -> classes.add(pluginDesc.className())); @@ -153,25 +146,30 @@ public void testScanningMixOfValidAndInvalidPlugins() throws Exception { assertEquals(expectedClasses, classes); } - @Test - public void testNonVersionedPluginHasUndefinedVersion() { - PluginScanResult unversionedPluginsResult = scan(TestPlugins.pluginPath(TestPlugins.TestPlugin.SAMPLING_HEADER_CONVERTER)); + @ParameterizedTest + @MethodSource("parameters") + public void testNonVersionedPluginHasUndefinedVersion(ScannerType scannerType) { + PluginScanResult unversionedPluginsResult = scan(scannerType, + TestPlugins.pluginPath(TestPlugins.TestPlugin.SAMPLING_HEADER_CONVERTER)); assertFalse(unversionedPluginsResult.isEmpty()); unversionedPluginsResult.forEach(pluginDesc -> assertEquals(PluginDesc.UNDEFINED_VERSION, pluginDesc.version())); } - @Test - public void testVersionedPluginsHasVersion() { - PluginScanResult versionedPluginResult = scan(TestPlugins.pluginPath(TestPlugins.TestPlugin.READ_VERSION_FROM_RESOURCE_V1)); + @ParameterizedTest + @MethodSource("parameters") + public void testVersionedPluginsHasVersion(ScannerType scannerType) { + PluginScanResult versionedPluginResult = scan(scannerType, + TestPlugins.pluginPath(TestPlugins.TestPlugin.READ_VERSION_FROM_RESOURCE_V1)); assertFalse(versionedPluginResult.isEmpty()); versionedPluginResult.forEach(pluginDesc -> assertEquals("1.0.0", pluginDesc.version())); } - private PluginScanResult scan(Set pluginLocations) { + private PluginScanResult scan(ScannerType scannerType, Set pluginLocations) { ClassLoaderFactory factory = new ClassLoaderFactory(); Set pluginSources = PluginUtils.pluginSources(pluginLocations, PluginScannerTest.class.getClassLoader(), factory); - return scanner.discoverPlugins(pluginSources); + return this.scannerMap.get(scannerType).discoverPlugins(pluginSources); } + } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java index f5dc83e6a8917..a0aa90a4cbb30 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime.isolation; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.SortedSet; +import java.util.TreeSet; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; @@ -28,34 +40,21 @@ import org.apache.kafka.connect.tools.MockSinkConnector; import org.apache.kafka.connect.tools.MockSourceConnector; import org.apache.kafka.connect.transforms.Transformation; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.rules.TemporaryFolder; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.SortedSet; -import java.util.TreeSet; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class PluginUtilsTest { @Rule public TemporaryFolder rootDir = new TemporaryFolder(); private Path pluginPath; - @Before + @BeforeEach public void setUp() throws Exception { pluginPath = rootDir.newFolder("plugins").toPath().toRealPath(); } @@ -191,9 +190,9 @@ public void testConnectApiClasses() { // Classes in the API should never be loaded in isolation. for (String clazz : apiClasses) { assertFalse( - clazz + " from 'api' is loaded in isolation but should not be", - PluginUtils.shouldLoadInIsolation(clazz) - ); + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'api' is loaded in isolation but should not be" + ); } } @@ -222,8 +221,8 @@ public void testConnectRuntimeClasses() { ); for (String clazz : runtimeClasses) { assertFalse( - clazz + " from 'runtime' is loaded in isolation but should not be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'runtime' is loaded in isolation but should not be" ); } } @@ -251,8 +250,8 @@ public void testAllowedRuntimeClasses() { ); for (String clazz : jsonConverterClasses) { assertTrue( - clazz + " from 'runtime' is not loaded in isolation but should be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'runtime' is not loaded in isolation but should be" ); } } @@ -306,8 +305,8 @@ public void testTransformsClasses() { ); for (String clazz : transformsClasses) { assertTrue( - clazz + " from 'transforms' is not loaded in isolation but should be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'transforms' is not loaded in isolation but should be" ); } } @@ -325,8 +324,8 @@ public void testAllowedJsonConverterClasses() { ); for (String clazz : jsonConverterClasses) { assertTrue( - clazz + " from 'json' is not loaded in isolation but should be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'json' is not loaded in isolation but should be" ); } } @@ -342,8 +341,8 @@ public void testAllowedFileConnectors() { ); for (String clazz : jsonConverterClasses) { assertTrue( - clazz + " from 'file' is not loaded in isolation but should be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'file' is not loaded in isolation but should be" ); } } @@ -357,8 +356,8 @@ public void testAllowedBasicAuthExtensionClasses() { ); for (String clazz : basicAuthExtensionClasses) { assertTrue( - clazz + " from 'basic-auth-extension' is not loaded in isolation but should be", - PluginUtils.shouldLoadInIsolation(clazz) + PluginUtils.shouldLoadInIsolation(clazz), + clazz + " from 'basic-auth-extension' is not loaded in isolation but should be" ); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java index 8a637beee5ec0..3b7d6592d57d7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java @@ -24,8 +24,13 @@ import java.nio.file.Path; import java.util.Arrays; import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Map.Entry; - +import java.util.Set; +import java.util.SortedSet; +import java.util.stream.Collectors; import org.apache.kafka.common.Configurable; import org.apache.kafka.common.config.AbstractConfig; import org.apache.kafka.common.config.ConfigDef; @@ -33,10 +38,10 @@ import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.components.Versioned; +import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.connector.policy.AllConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.converters.ByteArrayConverter; -import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; @@ -54,15 +59,8 @@ import org.apache.kafka.connect.storage.ConverterType; import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.storage.SimpleHeaderConverter; -import org.junit.Before; -import org.junit.Test; - -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.SortedSet; -import java.util.stream.Collectors; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -85,7 +83,7 @@ public class PluginsTest { private PluginScanResult empty; private String missingPluginClass; - @Before + @BeforeEach public void setup() { Map pluginProps = new HashMap<>(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java index e8ba9153bc09b..bbf8746178538 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java @@ -17,8 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import static org.junit.Assert.fail; - import java.lang.management.LockInfo; import java.lang.management.ManagementFactory; import java.lang.management.MonitorInfo; @@ -26,6 +24,7 @@ import java.net.URL; import java.security.AccessController; import java.security.PrivilegedAction; +import java.time.Duration; import java.util.Arrays; import java.util.Collections; import java.util.Map; @@ -45,15 +44,18 @@ import org.apache.kafka.common.config.ConfigDef.Importance; import org.apache.kafka.common.config.ConfigDef.Type; import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.After; -import org.junit.Before; import org.junit.Rule; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.junit.rules.TestName; import org.mockito.Mockito; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; + public class SynchronizationTest { public static final Logger log = LoggerFactory.getLogger(SynchronizationTest.class); @@ -67,7 +69,7 @@ public class SynchronizationTest { private Breakpoint dclBreakpoint; private Breakpoint pclBreakpoint; - @Before + @BeforeEach public void setup() { Map pluginProps = Collections.singletonMap( WorkerConfig.PLUGIN_PATH_CONFIG, @@ -89,7 +91,7 @@ public void setup() { } - @After + @AfterEach public void tearDown() throws InterruptedException { dclBreakpoint.clear(); pclBreakpoint.clear(); @@ -221,141 +223,144 @@ protected Object getClassLoadingLock(String className) { } } - // If the test times out, then there's a deadlock in the test but not necessarily the code - @Test(timeout = 15000L) + @Test public void testSimultaneousUpwardAndDownwardDelegating() throws Exception { - String t1Class = TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(); - // Grab a reference to the target PluginClassLoader before activating breakpoints - ClassLoader connectorLoader = plugins.connectorLoader(t1Class); - - // THREAD 1: loads a class by delegating downward starting from the DelegatingClassLoader - // DelegatingClassLoader breakpoint will only trigger on this thread - dclBreakpoint.set(t1Class::equals); - Runnable thread1 = () -> { - // Use the DelegatingClassLoader as the current context loader - try (LoaderSwap loaderSwap = plugins.withClassLoader(plugins.delegatingLoader())) { - - // Load an isolated plugin from the delegating classloader, which will - // 1. Enter the DelegatingClassLoader - // 2. Wait on dclBreakpoint for test to continue - // 3. Enter the PluginClassLoader - // 4. Load the isolated plugin class and return - new AbstractConfig( - new ConfigDef().define("a.class", Type.CLASS, Importance.HIGH, ""), - Collections.singletonMap("a.class", t1Class)); - } - }; - - // THREAD 2: loads a class by delegating upward starting from the PluginClassLoader - // Use any non-plugin class that no plugins depend on, so that the class isn't loaded during plugin discovery - String t2Class = Mockito.class.getName(); - // PluginClassLoader breakpoint will only trigger on this thread - pclBreakpoint.set(t2Class::equals); - Runnable thread2 = () -> { - // Use the PluginClassLoader as the current context loader - try (LoaderSwap loaderSwap = plugins.withClassLoader(connectorLoader)) { - // Load a non-isolated class from the plugin classloader, which will - // 1. Enter the PluginClassLoader - // 2. Wait for the test to continue - // 3. Enter the DelegatingClassLoader - // 4. Load the non-isolated class and return - new AbstractConfig(new ConfigDef().define("a.class", Type.CLASS, Importance.HIGH, ""), - Collections.singletonMap("a.class", t2Class)); - } - }; - - // STEP 1: Have T1 enter the DelegatingClassLoader and pause - exec.submit(thread1); - // T1 enters ConfigDef::parseType - // T1 enters DelegatingClassLoader::loadClass - dclBreakpoint.testAwait(); - dclBreakpoint.testAwait(); - // T1 exits DelegatingClassLoader::loadClass - // T1 enters Class::forName - // T1 enters DelegatingClassLoader::loadClass - dclBreakpoint.testAwait(); - // T1 waits in the delegating classloader while we set up the other thread - dumpThreads("step 1, T1 waiting in DelegatingClassLoader"); - - // STEP 2: Have T2 enter PluginClassLoader, delegate upward to the Delegating classloader - exec.submit(thread2); - // T2 enters PluginClassLoader::loadClass - pclBreakpoint.testAwait(); - // T2 falls through to ClassLoader::loadClass - pclBreakpoint.testAwait(); - // T2 delegates upwards to DelegatingClassLoader::loadClass - // T2 enters ClassLoader::loadClass and loads the class from the parent (CLASSPATH) - dumpThreads("step 2, T2 entered DelegatingClassLoader and is loading class from parent"); - - // STEP 3: Resume T1 and have it enter the PluginClassLoader - dclBreakpoint.testAwait(); - // T1 enters PluginClassLoader::loadClass - dumpThreads("step 3, T1 entered PluginClassLoader and is/was loading class from isolated jar"); - - // If the DelegatingClassLoader and PluginClassLoader are both not parallel capable, then this test will deadlock - // Otherwise, T1 should be able to complete it's load from the PluginClassLoader concurrently with T2, - // before releasing the DelegatingClassLoader and allowing T2 to complete. - // As the DelegatingClassLoader is not parallel capable, it must be the case that PluginClassLoader is. - assertNoDeadlocks(); + // If the test times out, then there's a deadlock in the test but not necessarily the code + assertTimeoutPreemptively(Duration.ofSeconds(15), () -> { + String t1Class = TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(); + // Grab a reference to the target PluginClassLoader before activating breakpoints + ClassLoader connectorLoader = plugins.connectorLoader(t1Class); + + // THREAD 1: loads a class by delegating downward starting from the DelegatingClassLoader + // DelegatingClassLoader breakpoint will only trigger on this thread + dclBreakpoint.set(t1Class::equals); + Runnable thread1 = () -> { + // Use the DelegatingClassLoader as the current context loader + try (LoaderSwap loaderSwap = plugins.withClassLoader(plugins.delegatingLoader())) { + + // Load an isolated plugin from the delegating classloader, which will + // 1. Enter the DelegatingClassLoader + // 2. Wait on dclBreakpoint for test to continue + // 3. Enter the PluginClassLoader + // 4. Load the isolated plugin class and return + new AbstractConfig( + new ConfigDef().define("a.class", Type.CLASS, Importance.HIGH, ""), + Collections.singletonMap("a.class", t1Class)); + } + }; + + // THREAD 2: loads a class by delegating upward starting from the PluginClassLoader + // Use any non-plugin class that no plugins depend on, so that the class isn't loaded during plugin discovery + String t2Class = Mockito.class.getName(); + // PluginClassLoader breakpoint will only trigger on this thread + pclBreakpoint.set(t2Class::equals); + Runnable thread2 = () -> { + // Use the PluginClassLoader as the current context loader + try (LoaderSwap loaderSwap = plugins.withClassLoader(connectorLoader)) { + // Load a non-isolated class from the plugin classloader, which will + // 1. Enter the PluginClassLoader + // 2. Wait for the test to continue + // 3. Enter the DelegatingClassLoader + // 4. Load the non-isolated class and return + new AbstractConfig(new ConfigDef().define("a.class", Type.CLASS, Importance.HIGH, ""), + Collections.singletonMap("a.class", t2Class)); + } + }; + + // STEP 1: Have T1 enter the DelegatingClassLoader and pause + exec.submit(thread1); + // T1 enters ConfigDef::parseType + // T1 enters DelegatingClassLoader::loadClass + dclBreakpoint.testAwait(); + dclBreakpoint.testAwait(); + // T1 exits DelegatingClassLoader::loadClass + // T1 enters Class::forName + // T1 enters DelegatingClassLoader::loadClass + dclBreakpoint.testAwait(); + // T1 waits in the delegating classloader while we set up the other thread + dumpThreads("step 1, T1 waiting in DelegatingClassLoader"); + + // STEP 2: Have T2 enter PluginClassLoader, delegate upward to the Delegating classloader + exec.submit(thread2); + // T2 enters PluginClassLoader::loadClass + pclBreakpoint.testAwait(); + // T2 falls through to ClassLoader::loadClass + pclBreakpoint.testAwait(); + // T2 delegates upwards to DelegatingClassLoader::loadClass + // T2 enters ClassLoader::loadClass and loads the class from the parent (CLASSPATH) + dumpThreads("step 2, T2 entered DelegatingClassLoader and is loading class from parent"); + + // STEP 3: Resume T1 and have it enter the PluginClassLoader + dclBreakpoint.testAwait(); + // T1 enters PluginClassLoader::loadClass + dumpThreads("step 3, T1 entered PluginClassLoader and is/was loading class from isolated jar"); + + // If the DelegatingClassLoader and PluginClassLoader are both not parallel capable, then this test will deadlock + // Otherwise, T1 should be able to complete it's load from the PluginClassLoader concurrently with T2, + // before releasing the DelegatingClassLoader and allowing T2 to complete. + // As the DelegatingClassLoader is not parallel capable, it must be the case that PluginClassLoader is. + assertNoDeadlocks(); + }); } - // If the test times out, then there's a deadlock in the test but not necessarily the code - @Test(timeout = 15000L) - // Ensure the PluginClassLoader is parallel capable and not synchronized on its monitor lock - public void testPluginClassLoaderDoesntHoldMonitorLock() - throws InterruptedException, TimeoutException, BrokenBarrierException { - String t1Class = TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(); - ClassLoader connectorLoader = plugins.connectorLoader(t1Class); - - Object externalTestLock = new Object(); - Breakpoint testBreakpoint = new Breakpoint<>(); - Breakpoint progress = new Breakpoint<>(); - - // THREAD 1: hold the PluginClassLoader's monitor lock, and attempt to grab the external lock - testBreakpoint.set(null); - Runnable thread1 = () -> { - synchronized (connectorLoader) { - testBreakpoint.await(null); - testBreakpoint.await(null); - synchronized (externalTestLock) { + @Test + public void testPluginClassLoaderDoesntHoldMonitorLock() { + // If the test times out, then there's a deadlock in the test but not necessarily the code + // Ensure the PluginClassLoader is parallel capable and not synchronized on its monitor lock + assertTimeoutPreemptively(Duration.ofSeconds(15), () -> { + String t1Class = TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(); + ClassLoader connectorLoader = plugins.connectorLoader(t1Class); + + Object externalTestLock = new Object(); + Breakpoint testBreakpoint = new Breakpoint<>(); + Breakpoint progress = new Breakpoint<>(); + + // THREAD 1: hold the PluginClassLoader's monitor lock, and attempt to grab the external lock + testBreakpoint.set(null); + Runnable thread1 = () -> { + synchronized (connectorLoader) { + testBreakpoint.await(null); + testBreakpoint.await(null); + synchronized (externalTestLock) { + } } - } - }; + }; - // THREAD 2: load a class via forName while holding some external lock - progress.set(null); - Runnable thread2 = () -> { - synchronized (externalTestLock) { - try { - progress.await(null); - Class.forName(TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(), true, connectorLoader); - } catch (ClassNotFoundException e) { - throw new RuntimeException("Failed to load test plugin", e); + // THREAD 2: load a class via forName while holding some external lock + progress.set(null); + Runnable thread2 = () -> { + synchronized (externalTestLock) { + try { + progress.await(null); + Class.forName(TestPlugins.TestPlugin.SAMPLING_CONVERTER.className(), true, connectorLoader); + } catch (ClassNotFoundException e) { + throw new RuntimeException("Failed to load test plugin", e); + } } - } - }; - - // STEP 1: Have T1 hold the PluginClassLoader's monitor lock - exec.submit(thread1); - // LOCK the classloader monitor lock - testBreakpoint.testAwait(); - dumpThreads("step 1, T1 holding classloader monitor lock"); - - // STEP 2: Have T2 hold the external lock, and proceed to perform classloading - exec.submit(thread2); - // LOCK the external lock - progress.testAwait(); - // perform class loading - dumpThreads("step 2, T2 holding external lock"); - - // STEP 3: Have T1 grab the external lock, and then release both locks - testBreakpoint.testAwait(); - // LOCK the external lock - dumpThreads("step 3, T1 grabbed external lock"); - - // If the PluginClassLoader was not parallel capable, then these threads should deadlock - // Otherwise, classloading should proceed without grabbing the monitor lock, and complete before T1 grabs the external lock from T2. - assertNoDeadlocks(); + }; + + // STEP 1: Have T1 hold the PluginClassLoader's monitor lock + exec.submit(thread1); + // LOCK the classloader monitor lock + testBreakpoint.testAwait(); + dumpThreads("step 1, T1 holding classloader monitor lock"); + + // STEP 2: Have T2 hold the external lock, and proceed to perform classloading + exec.submit(thread2); + // LOCK the external lock + progress.testAwait(); + // perform class loading + dumpThreads("step 2, T2 holding external lock"); + + // STEP 3: Have T1 grab the external lock, and then release both locks + testBreakpoint.testAwait(); + // LOCK the external lock + dumpThreads("step 3, T1 grabbed external lock"); + + // If the PluginClassLoader was not parallel capable, then these threads should deadlock + // Otherwise, classloading should proceed without grabbing the monitor lock, and complete before T1 grabs the external lock from T2. + assertNoDeadlocks(); + }); } private boolean threadFromCurrentTest(ThreadInfo threadInfo) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java index 2bc03b2b7c25f..e3dbc23cb751d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java @@ -17,6 +17,9 @@ package org.apache.kafka.connect.runtime.isolation; +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; @@ -40,10 +43,6 @@ import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.stream.Collectors; -import javax.tools.JavaCompiler; -import javax.tools.StandardJavaFileManager; -import javax.tools.ToolProvider; - import org.apache.kafka.connect.components.Versioned; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java index 0494d00272668..96ecee8ac840c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java @@ -16,6 +16,17 @@ */ package org.apache.kafka.connect.runtime.rest; +import javax.ws.rs.core.MediaType; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.net.URI; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.http.HttpHost; @@ -35,36 +46,27 @@ import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.slf4j.LoggerFactory; -import javax.ws.rs.core.MediaType; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doReturn; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class ConnectRestServerTest { @Mock private RestClient restClient; @@ -76,12 +78,12 @@ public class ConnectRestServerTest { protected static final String KAFKA_CLUSTER_ID = "Xbafgnagvar"; - @Before + @BeforeEach public void setUp() { httpClient = HttpClients.createMinimal(); } - @After + @AfterEach public void tearDown() throws IOException { for (CloseableHttpResponse response: responses) { response.close(); @@ -117,7 +119,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.LISTENERS_CONFIG, "http://localhost:8080,https://localhost:8443"); server = new ConnectRestServer(null, restClient, configMap); - Assert.assertEquals("http://localhost:8080/", server.advertisedUrl().toString()); + assertEquals("http://localhost:8080/", server.advertisedUrl().toString()); server.stop(); // Advertised URI from listeners with protocol @@ -126,7 +128,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_LISTENER_CONFIG, "https"); server = new ConnectRestServer(null, restClient, configMap); - Assert.assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); + assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); server.stop(); // Advertised URI from listeners with only SSL available @@ -134,7 +136,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.LISTENERS_CONFIG, "https://localhost:8443"); server = new ConnectRestServer(null, restClient, configMap); - Assert.assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); + assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); server.stop(); // Listener is overridden by advertised values @@ -145,7 +147,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_PORT_CONFIG, "10000"); server = new ConnectRestServer(null, restClient, configMap); - Assert.assertEquals("http://somehost:10000/", server.advertisedUrl().toString()); + assertEquals("http://somehost:10000/", server.advertisedUrl().toString()); server.stop(); // correct listener is chosen when https listener is configured before http listener and advertised listener is http @@ -154,7 +156,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_LISTENER_CONFIG, "http"); server = new ConnectRestServer(null, restClient, configMap); - Assert.assertEquals("http://plaintext-localhost:4761/", server.advertisedUrl().toString()); + assertEquals("http://plaintext-localhost:4761/", server.advertisedUrl().toString()); server.stop(); } @@ -173,10 +175,10 @@ public void testOptionsDoesNotIncludeWadlOutput() throws IOException { HttpOptions request = new HttpOptions("/connectors"); request.addHeader("Content-Type", MediaType.WILDCARD); HttpResponse response = executeRequest(server.advertisedUrl(), request); - Assert.assertEquals(MediaType.TEXT_PLAIN, response.getEntity().getContentType().getValue()); + assertEquals(MediaType.TEXT_PLAIN, response.getEntity().getContentType().getValue()); ByteArrayOutputStream baos = new ByteArrayOutputStream(); response.getEntity().writeTo(baos); - Assert.assertArrayEquals( + assertArrayEquals( request.getAllowedMethods(response).toArray(), new String(baos.toByteArray(), StandardCharsets.UTF_8).split(", ") ); @@ -203,10 +205,10 @@ public void checkCORSRequest(String corsDomain, String origin, String expectedHe request.addHeader("Origin", origin); HttpResponse response = executeRequest(serverUrl, request); - Assert.assertEquals(200, response.getStatusLine().getStatusCode()); + assertEquals(200, response.getStatusLine().getStatusCode()); if (expectedHeader != null) { - Assert.assertEquals(expectedHeader, + assertEquals(expectedHeader, response.getFirstHeader("Access-Control-Allow-Origin").getValue()); } @@ -215,13 +217,13 @@ public void checkCORSRequest(String corsDomain, String origin, String expectedHe request.addHeader("Origin", origin); request.addHeader("Access-Control-Request-Method", method); response = executeRequest(serverUrl, request); - Assert.assertEquals(404, response.getStatusLine().getStatusCode()); + assertEquals(404, response.getStatusLine().getStatusCode()); if (expectedHeader != null) { - Assert.assertEquals(expectedHeader, + assertEquals(expectedHeader, response.getFirstHeader("Access-Control-Allow-Origin").getValue()); } if (method != null) { - Assert.assertEquals(method, + assertEquals(method, response.getFirstHeader("Access-Control-Allow-Methods").getValue()); } } @@ -242,7 +244,7 @@ public void testStandaloneConfig() throws IOException { HttpRequest request = new HttpGet("/connectors"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - Assert.assertEquals(200, response.getStatusLine().getStatusCode()); + assertEquals(200, response.getStatusLine().getStatusCode()); } @Test @@ -304,7 +306,7 @@ public void testIndependentAdminEndpoint() throws IOException { HttpRequest request = new HttpGet("/admin/loggers"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - Assert.assertEquals(404, response.getStatusLine().getStatusCode()); + assertEquals(404, response.getStatusLine().getStatusCode()); } @Test @@ -324,7 +326,7 @@ public void testDisableAdminEndpoint() throws IOException { HttpRequest request = new HttpGet("/admin/loggers"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - Assert.assertEquals(404, response.getStatusLine().getStatusCode()); + assertEquals(404, response.getStatusLine().getStatusCode()); } @Test @@ -386,12 +388,12 @@ private void checkCustomizedHttpResponseHeaders(String headerConfig, Map - Assert.assertEquals(response.getFirstHeader(k).getValue(), v)); + assertEquals(response.getFirstHeader(k).getValue(), v)); } else { - Assert.assertNull(response.getFirstHeader("X-Frame-Options")); + assertNull(response.getFirstHeader("X-Frame-Options")); } } @@ -399,7 +401,7 @@ private String executeGet(URI serverUrl, String endpoint) throws IOException { HttpRequest request = new HttpGet(endpoint); HttpResponse response = executeRequest(serverUrl, request); - Assert.assertEquals(200, response.getStatusLine().getStatusCode()); + assertEquals(200, response.getStatusLine().getStatusCode()); return new BasicResponseHandler().handleResponse(response); } @@ -410,7 +412,7 @@ private String executePut(URI serverUrl, String endpoint, String jsonBody) throw request.setEntity(entity); HttpResponse response = executeRequest(serverUrl, request); - Assert.assertEquals(200, response.getStatusLine().getStatusCode()); + assertEquals(200, response.getStatusLine().getStatusCode()); return new BasicResponseHandler().handleResponse(response); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java index 82fab1313067e..1b6c5a9a57ddc 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java @@ -17,22 +17,22 @@ package org.apache.kafka.connect.runtime.rest; -import org.apache.kafka.connect.errors.ConnectException; -import org.apache.kafka.connect.runtime.distributed.Crypto; -import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; -import org.eclipse.jetty.client.api.Request; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.ArgumentCaptor; -import org.mockito.junit.MockitoJUnitRunner; - import javax.crypto.Mac; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.ws.rs.core.HttpHeaders; - import java.security.NoSuchAlgorithmException; import java.util.Base64; +import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.distributed.Crypto; +import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; +import org.eclipse.jetty.client.api.Request; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -45,7 +45,8 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class InternalRequestSignatureTest { private static final byte[] REQUEST_BODY = diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java index 3c104e0e9307d..c134a7bd6b182 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java @@ -17,6 +17,14 @@ package org.apache.kafka.connect.runtime.rest; +import javax.crypto.SecretKey; +import javax.ws.rs.core.Response; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collection; +import java.util.Objects; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeoutException; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.JsonProcessingException; @@ -28,35 +36,29 @@ import org.eclipse.jetty.client.api.ContentResponse; import org.eclipse.jetty.client.api.Request; import org.junit.Rule; -import org.junit.Test; import org.junit.experimental.runners.Enclosed; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import javax.crypto.SecretKey; -import javax.ws.rs.core.Response; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collection; -import java.util.Objects; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeoutException; - import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; @@ -106,8 +108,9 @@ private static RestClient.HttpResponse httpRequest( } + @Nested @RunWith(Parameterized.class) - public static class RequestFailureParameterizedTest { + class RequestFailureParameterizedTest { @Rule public MockitoRule initRule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); @@ -119,7 +122,7 @@ public static class RequestFailureParameterizedTest { public Throwable requestException; @Parameterized.Parameters - public static Collection requestExceptions() { + public Collection requestExceptions() { return Arrays.asList(new Object[][]{ {new InterruptedException()}, {new ExecutionException(null)}, @@ -127,7 +130,7 @@ public static Collection requestExceptions() { }); } - private static Request buildThrowingMockRequest(Throwable t) throws ExecutionException, InterruptedException, TimeoutException { + private Request buildThrowingMockRequest(Throwable t) throws ExecutionException, InterruptedException, TimeoutException { Request req = mock(Request.class); when(req.header(anyString(), anyString())).thenReturn(req); when(req.send()).thenThrow(t); @@ -147,12 +150,14 @@ public void testFailureDuringRequestCausesInternalServerError() throws Exception } - @RunWith(MockitoJUnitRunner.StrictStubs.class) - public static class Tests { + @Nested + @ExtendWith(MockitoExtension.class) + @MockitoSettings(strictness = Strictness.STRICT_STUBS) + class Tests { @Mock private HttpClient httpClient; - private static String toJsonString(Object obj) { + private String toJsonString(Object obj) { try { return OBJECT_MAPPER.writeValueAsString(obj); } catch (JsonProcessingException e) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java index 4930c1a3ef221..80a58223df5fa 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java @@ -16,15 +16,14 @@ */ package org.apache.kafka.connect.runtime.rest; -import org.apache.kafka.common.config.ConfigException; -import org.apache.kafka.common.config.internals.BrokerSecurityConfigs; -import org.junit.Test; - import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import org.apache.kafka.common.config.ConfigException; +import org.apache.kafka.common.config.internals.BrokerSecurityConfigs; +import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.rest.RestServerConfig.LISTENERS_DEFAULT; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java index 726915d2e3a1f..92b2e6da8ee32 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java @@ -16,11 +16,10 @@ */ package org.apache.kafka.connect.runtime.rest.entities; -import org.junit.Test; - import java.util.Arrays; import java.util.HashMap; import java.util.Map; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java index cd07bd8557326..50d1265d20d41 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java @@ -16,7 +16,7 @@ */ package org.apache.kafka.connect.runtime.rest.entities; -import org.junit.Test; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java index 1d32479f82c22..0d7c48ecd4827 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java @@ -16,10 +16,9 @@ */ package org.apache.kafka.connect.runtime.rest.entities; -import org.apache.kafka.connect.runtime.TargetState; -import org.junit.Test; - import java.util.Collections; +import org.apache.kafka.connect.runtime.TargetState; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java index 34e28ee47f6bb..c18fa20db71ee 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java @@ -17,7 +17,7 @@ package org.apache.kafka.connect.runtime.rest.entities; import org.apache.kafka.connect.runtime.isolation.PluginDesc; -import org.junit.Test; +import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java index 589dfb29bd0f5..60b8a83fcb3e5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java @@ -16,6 +16,22 @@ */ package org.apache.kafka.connect.runtime.rest.resources; +import javax.ws.rs.BadRequestException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.TreeSet; +import java.util.stream.Collectors; +import java.util.stream.Stream; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.kafka.common.config.Config; import org.apache.kafka.common.config.ConfigDef; @@ -45,8 +61,8 @@ import org.apache.kafka.connect.runtime.rest.entities.ConfigInfos; import org.apache.kafka.connect.runtime.rest.entities.ConfigKeyInfo; import org.apache.kafka.connect.runtime.rest.entities.ConfigValueInfo; -import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.tools.MockSinkConnector; @@ -59,28 +75,13 @@ import org.apache.kafka.connect.transforms.predicates.HasHeaderKey; import org.apache.kafka.connect.transforms.predicates.RecordIsTombstone; import org.apache.kafka.connect.util.Callback; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; -import org.mockito.junit.MockitoJUnitRunner; - -import javax.ws.rs.BadRequestException; -import java.net.URL; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.TreeSet; -import java.util.stream.Collectors; -import java.util.stream.Stream; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Arrays.asList; import static org.junit.Assert.assertEquals; @@ -88,16 +89,17 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class ConnectorPluginsResourceTest { private static final Map PROPS; @@ -201,7 +203,7 @@ public class ConnectorPluginsResourceTest { private final Plugins plugins = mock(Plugins.class); private ConnectorPluginsResource connectorPluginsResource; - @Before + @BeforeEach public void setUp() throws Exception { doReturn(plugins).when(herder).plugins(); doReturn(SINK_CONNECTOR_PLUGINS).when(plugins).sinkConnectors(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java index 2386b2558e176..2eaf97fde4300 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java @@ -16,6 +16,22 @@ */ package org.apache.kafka.connect.runtime.rest.resources; +import javax.ws.rs.BadRequestException; +import javax.ws.rs.core.HttpHeaders; +import javax.ws.rs.core.MultivaluedHashMap; +import javax.ws.rs.core.MultivaluedMap; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.UriInfo; +import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.kafka.connect.errors.AlreadyExistsException; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.AbstractStatus; @@ -42,36 +58,20 @@ import org.apache.kafka.connect.runtime.rest.errors.ConnectRestException; import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Stubber; -import javax.ws.rs.BadRequestException; -import javax.ws.rs.core.HttpHeaders; -import javax.ws.rs.core.MultivaluedHashMap; -import javax.ws.rs.core.MultivaluedMap; -import javax.ws.rs.core.Response; -import javax.ws.rs.core.UriInfo; -import java.net.URI; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.any; import static org.mockito.Mockito.doAnswer; @@ -83,7 +83,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) @SuppressWarnings("unchecked") public class ConnectorsResourceTest { // Note trailing / and that we do *not* use LEADER_URL to construct our reference values. This checks that we handle @@ -166,7 +167,7 @@ public class ConnectorsResourceTest { @Mock private RestServerConfig serverConfig; - @Before + @BeforeEach public void setUp() throws NoSuchMethodException { when(serverConfig.topicTrackingEnabled()).thenReturn(true); when(serverConfig.topicTrackingResetEnabled()).thenReturn(true); @@ -177,7 +178,7 @@ public void setUp() throws NoSuchMethodException { when(forward.getQueryParameters()).thenReturn(queryParams); } - @After + @AfterEach public void teardown() { verifyNoMoreInteractions(herder); } @@ -539,7 +540,7 @@ public void testCreateConnectorWithSpecialCharsInName() throws Throwable { String rspLocation = connectorsResource.createConnector(FORWARD, NULL_HEADERS, body).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - Assert.assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); + assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); } @Test @@ -554,7 +555,7 @@ public void testCreateConnectorWithControlSequenceInName() throws Throwable { String rspLocation = connectorsResource.createConnector(FORWARD, NULL_HEADERS, body).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - Assert.assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); + assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); } @Test @@ -567,7 +568,7 @@ public void testPutConnectorConfigWithSpecialCharsInName() throws Throwable { String rspLocation = connectorsResource.putConnectorConfig(CONNECTOR_NAME_SPECIAL_CHARS, NULL_HEADERS, FORWARD, CONNECTOR_CONFIG_SPECIAL_CHARS).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - Assert.assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); + assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); } @Test @@ -580,7 +581,7 @@ public void testPutConnectorConfigWithControlSequenceInName() throws Throwable { String rspLocation = connectorsResource.putConnectorConfig(CONNECTOR_NAME_CONTROL_SEQUENCES1, NULL_HEADERS, FORWARD, CONNECTOR_CONFIG_CONTROL_SEQUENCES).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - Assert.assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); + assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); } @Test diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java index c48b60fbd96ff..393ad4463a203 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java @@ -16,6 +16,15 @@ */ package org.apache.kafka.connect.runtime.rest.resources; +import javax.crypto.Mac; +import javax.ws.rs.core.HttpHeaders; +import javax.ws.rs.core.UriInfo; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Base64; +import java.util.Collections; +import java.util.List; +import java.util.Map; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.Herder; @@ -23,24 +32,16 @@ import org.apache.kafka.connect.runtime.rest.RestClient; import org.apache.kafka.connect.runtime.rest.RestServer; import org.apache.kafka.connect.util.Callback; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Stubber; -import javax.crypto.Mac; -import javax.ws.rs.core.HttpHeaders; -import javax.ws.rs.core.UriInfo; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Base64; -import java.util.Collections; -import java.util.List; -import java.util.Map; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.any; @@ -50,7 +51,8 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class InternalConnectResourceTest { private static final Boolean FORWARD = true; @@ -73,7 +75,7 @@ public class InternalConnectResourceTest { private InternalConnectResource internalResource; - @Before + @BeforeEach public void setup() { internalResource = new InternalConnectResource(herder, restClient, () -> RestServer.DEFAULT_REST_REQUEST_TIMEOUT_MS); internalResource.uriInfo = uriInfo; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java index 3b3df99351167..ea5f89cc62372 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java @@ -16,30 +16,32 @@ */ package org.apache.kafka.connect.runtime.rest.resources; +import javax.ws.rs.core.Response; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.slf4j.event.Level; -import javax.ws.rs.core.Response; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class LoggingResourceTest { private LoggingResource loggingResource; @@ -47,7 +49,7 @@ public class LoggingResourceTest { @Mock private Herder herder; - @Before + @BeforeEach public void setup() { loggingResource = new LoggingResource(herder); } @@ -162,4 +164,4 @@ public void testSetLevelClusterScope() { verify(herder).setClusterLoggerLevel(logger, level); } -} \ No newline at end of file +} diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java index 976484392451b..e22dc1c396c7f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java @@ -20,23 +20,26 @@ import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.rest.entities.ServerInfo; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class RootResourceTest { @Mock private Herder herder; private RootResource rootResource; - @Before + @BeforeEach public void setUp() { rootResource = new RootResource(herder); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java index 8f5c3235e7e6a..35dff2a8eb49c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java @@ -16,15 +16,18 @@ */ package org.apache.kafka.connect.runtime.rest.util; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.common.config.SslConfigs; import org.apache.kafka.connect.runtime.rest.RestServerConfig; import org.eclipse.jetty.util.ssl.SslContextFactory; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class SSLUtilsTest { @@ -37,8 +40,8 @@ public void testGetOrDefault() { Map map = new HashMap<>(); map.put("exists", "value"); - Assert.assertEquals(SSLUtils.getOrDefault(map, existingKey, defaultValue), value); - Assert.assertEquals(SSLUtils.getOrDefault(map, missingKey, defaultValue), defaultValue); + assertEquals(SSLUtils.getOrDefault(map, existingKey, defaultValue), value); + assertEquals(SSLUtils.getOrDefault(map, missingKey, defaultValue), defaultValue); } @Test @@ -64,19 +67,19 @@ public void testCreateServerSideSslContextFactory() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Server ssl = SSLUtils.createServerSideSslContextFactory(config); - Assert.assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); - Assert.assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); - Assert.assertEquals("SunJSSE", ssl.getProvider()); - Assert.assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); - Assert.assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); - Assert.assertTrue(ssl.getNeedClientAuth()); - Assert.assertFalse(ssl.getWantClientAuth()); - Assert.assertEquals("JKS", ssl.getKeyStoreType()); - Assert.assertEquals("JKS", ssl.getTrustStoreType()); - Assert.assertEquals("TLS", ssl.getProtocol()); - Assert.assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); - Assert.assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); - Assert.assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); + assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); + assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); + assertEquals("SunJSSE", ssl.getProvider()); + assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); + assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); + assertTrue(ssl.getNeedClientAuth()); + assertFalse(ssl.getWantClientAuth()); + assertEquals("JKS", ssl.getKeyStoreType()); + assertEquals("JKS", ssl.getTrustStoreType()); + assertEquals("TLS", ssl.getProtocol()); + assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); + assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); + assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); } @Test @@ -102,17 +105,17 @@ public void testCreateClientSideSslContextFactory() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Client ssl = SSLUtils.createClientSideSslContextFactory(config); - Assert.assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); - Assert.assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); - Assert.assertEquals("SunJSSE", ssl.getProvider()); - Assert.assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); - Assert.assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); - Assert.assertEquals("JKS", ssl.getKeyStoreType()); - Assert.assertEquals("JKS", ssl.getTrustStoreType()); - Assert.assertEquals("TLS", ssl.getProtocol()); - Assert.assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); - Assert.assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); - Assert.assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); + assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); + assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); + assertEquals("SunJSSE", ssl.getProvider()); + assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); + assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); + assertEquals("JKS", ssl.getKeyStoreType()); + assertEquals("JKS", ssl.getTrustStoreType()); + assertEquals("TLS", ssl.getProtocol()); + assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); + assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); + assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); } @Test @@ -130,14 +133,14 @@ public void testCreateServerSideSslContextFactoryDefaultValues() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Server ssl = SSLUtils.createServerSideSslContextFactory(config); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); - Assert.assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); - Assert.assertFalse(ssl.getNeedClientAuth()); - Assert.assertFalse(ssl.getWantClientAuth()); + assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); + assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); + assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); + assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); + assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); + assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); + assertFalse(ssl.getNeedClientAuth()); + assertFalse(ssl.getWantClientAuth()); } @Test @@ -155,11 +158,11 @@ public void testCreateClientSideSslContextFactoryDefaultValues() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Client ssl = SSLUtils.createClientSideSslContextFactory(config); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); - Assert.assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); - Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); + assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); + assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); + assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); + assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); + assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); + assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java index e2e886f7925f7..44da4ba3a6bbf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java @@ -16,15 +16,14 @@ */ package org.apache.kafka.connect.runtime.standalone; +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Collectors; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.SslConfigs; import org.apache.kafka.common.config.types.Password; import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.Test; - -import java.util.HashMap; -import java.util.Map; -import java.util.stream.Collectors; +import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 959e498931096..8907501b55c25 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -16,6 +16,17 @@ */ package org.apache.kafka.connect.runtime.standalone; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; import org.apache.kafka.common.config.Config; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.ConfigValue; @@ -41,44 +52,34 @@ import org.apache.kafka.connect.runtime.WorkerConfigTransformer; import org.apache.kafka.connect.runtime.distributed.SampleConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.runtime.isolation.LoaderSwap; -import org.apache.kafka.connect.runtime.rest.entities.Message; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.ConnectorInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.Message; import org.apache.kafka.connect.runtime.rest.entities.TaskInfo; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceTask; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.MemoryConfigBackingStore; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Collections.emptyList; import static java.util.Collections.singleton; @@ -110,7 +111,8 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) @SuppressWarnings("unchecked") public class StandaloneHerderTest { private static final String CONNECTOR_NAME = "test"; @@ -141,7 +143,7 @@ private enum SourceSink { private final SampleConnectorClientConfigOverridePolicy noneConnectorClientConfigOverridePolicy = new SampleConnectorClientConfigOverridePolicy(); - @Before + @BeforeEach public void setup() throws ExecutionException, InterruptedException { herder = mock(StandaloneHerder.class, withSettings() .useConstructor(worker, WORKER_ID, KAFKA_CLUSTER_ID, statusBackingStore, new MemoryConfigBackingStore(transformer), noneConnectorClientConfigOverridePolicy, new MockTime()) @@ -151,7 +153,7 @@ public void setup() throws ExecutionException, InterruptedException { when(transformer.transform(eq(CONNECTOR_NAME), configCapture.capture())).thenAnswer(invocation -> configCapture.getValue()); } - @After + @AfterEach public void tearDown() { verifyNoMoreInteractions(worker, statusBackingStore); herder.stop(); From b923a28e793a153fab42a5cdb9e35db48641948e Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sat, 15 Jun 2024 14:28:31 +0800 Subject: [PATCH 02/18] upgrade all junit 4 to junit5 in connect:runtime --- .../connect/runtime/AbstractHerderTest.java | 33 +- .../runtime/AbstractWorkerSourceTaskTest.java | 31 +- .../connect/runtime/ConnectMetricsTest.java | 24 +- .../connect/runtime/ConnectorConfigTest.java | 18 +- .../runtime/ErrorHandlingTaskTest.java | 51 ++- .../ExactlyOnceWorkerSourceTaskTest.java | 246 ++++++----- .../runtime/InternalSinkRecordTest.java | 15 +- .../kafka/connect/runtime/LoggersTest.java | 21 +- .../connect/runtime/RestartPlanTest.java | 8 +- .../connect/runtime/RestartRequestTest.java | 8 +- .../runtime/SampleConverterWithHeaders.java | 5 +- .../runtime/SourceConnectorConfigTest.java | 10 +- .../SourceTaskOffsetCommitterTest.java | 23 +- .../connect/runtime/StateTrackerTest.java | 14 +- .../connect/runtime/SubmittedRecordsTest.java | 60 +-- .../runtime/TransformationConfigTest.java | 2 +- .../runtime/TransformationStageTest.java | 10 +- .../connect/runtime/WorkerConfigTest.java | 18 +- .../runtime/WorkerConfigTransformerTest.java | 19 +- .../connect/runtime/WorkerConnectorTest.java | 145 ++++--- .../runtime/WorkerMetricsGroupTest.java | 15 +- .../connect/runtime/WorkerSinkTaskTest.java | 116 +++-- .../runtime/WorkerSinkTaskThreadedTest.java | 33 +- .../connect/runtime/WorkerSourceTaskTest.java | 152 ++++--- .../kafka/connect/runtime/WorkerTaskTest.java | 27 +- .../kafka/connect/runtime/WorkerTest.java | 408 +++++++++++------- .../connect/runtime/WorkerTestUtils.java | 31 +- .../runtime/WorkerTransactionContextTest.java | 8 +- .../IncrementalCooperativeAssignorTest.java | 2 +- .../distributed/WorkerCoordinatorTest.java | 2 +- .../runtime/isolation/PluginScannerTest.java | 2 +- .../runtime/isolation/PluginsTest.java | 19 +- .../isolation/SynchronizationTest.java | 29 +- .../runtime/isolation/TestPlugins.java | 14 +- .../rest/InternalRequestSignatureTest.java | 1 - .../connect/runtime/rest/RestClientTest.java | 4 +- .../ConnectorPluginsResourceTest.java | 4 +- .../standalone/StandaloneHerderTest.java | 6 +- 38 files changed, 932 insertions(+), 702 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index da8fed5b66d34..0c0318ced8435 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -56,11 +56,13 @@ import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.ArrayList; import java.util.Arrays; @@ -79,12 +81,12 @@ import java.util.stream.Collectors; import static org.apache.kafka.connect.runtime.AbstractHerder.keysWithVariableValues; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +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.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; @@ -98,7 +100,8 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractHerderTest { private static final String CONN1 = "sourceA"; @@ -1050,16 +1053,16 @@ private void testConnectorPluginConfig( verify(plugins).withClassLoader(newPluginInstance.get().getClass().getClassLoader()); } - @Test(expected = NotFoundException.class) + @Test public void testGetConnectorConfigDefWithBadName() throws Exception { String connName = "AnotherPlugin"; AbstractHerder herder = testHerder(); when(worker.getPlugins()).thenReturn(plugins); when(plugins.pluginClass(anyString())).thenThrow(new ClassNotFoundException()); - herder.connectorPluginConfig(connName); + assertThrows(NotFoundException.class, () -> herder.connectorPluginConfig(connName)); } - @Test(expected = BadRequestException.class) + @Test @SuppressWarnings({"rawtypes", "unchecked"}) public void testGetConnectorConfigDefWithInvalidPluginType() throws Exception { String connName = "AnotherPlugin"; @@ -1067,7 +1070,7 @@ public void testGetConnectorConfigDefWithInvalidPluginType() throws Exception { when(worker.getPlugins()).thenReturn(plugins); when(plugins.pluginClass(anyString())).thenReturn((Class) Object.class); when(plugins.newPlugin(anyString())).thenReturn(new DirectoryConfigProvider()); - herder.connectorPluginConfig(connName); + assertThrows(BadRequestException.class, () -> herder.connectorPluginConfig(connName)); } @Test @@ -1228,7 +1231,7 @@ private void testConfigProviderRegex(String rawConnConfig) { private void testConfigProviderRegex(String rawConnConfig, boolean expected) { Set keys = keysWithVariableValues(Collections.singletonMap("key", rawConnConfig), ConfigTransformer.DEFAULT_PATTERN); boolean actual = keys != null && !keys.isEmpty() && keys.contains("key"); - assertEquals(String.format("%s should have matched regex", rawConnConfig), expected, actual); + assertEquals(expected, actual, String.format("%s should have matched regex", rawConnConfig)); } private AbstractHerder createConfigValidationHerder(Class connectorClass, diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index 62cac0d37877f..139f0f290d648 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -55,14 +55,16 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; import java.nio.ByteBuffer; @@ -90,12 +92,12 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; @@ -107,7 +109,8 @@ import static org.mockito.Mockito.when; @SuppressWarnings("unchecked") -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractWorkerSourceTaskTest { private static final String TOPIC = "topic"; @@ -151,7 +154,7 @@ public class AbstractWorkerSourceTaskTest { private AbstractWorkerSourceTask workerTask; - @Before + @BeforeEach public void setup() { Map workerProps = workerProps(); plugins = new Plugins(workerProps); @@ -187,7 +190,7 @@ private Map sourceConnectorPropsWithGroups() { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); verifyNoMoreInteractions(statusListener); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java index 11de95284044e..449a2a2eae3fd 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java @@ -24,21 +24,21 @@ import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroup; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroupId; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.util.Collections; import java.util.HashMap; import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNotSame; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class ConnectMetricsTest { @@ -51,12 +51,12 @@ public class ConnectMetricsTest { private ConnectMetrics metrics; - @Before + @BeforeEach public void setUp() { metrics = new ConnectMetrics("worker1", new WorkerConfig(WorkerConfig.baseConfigDef(), DEFAULT_WORKER_CONFIG), new MockTime(), "cluster-1"); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java index 6fa2808c19ea3..45b1624da13c9 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java @@ -26,7 +26,7 @@ import org.apache.kafka.connect.sink.SinkRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.Collections; import java.util.HashMap; @@ -34,12 +34,12 @@ import java.util.Map; import java.util.Set; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; public class ConnectorConfigTest> { @@ -469,8 +469,8 @@ public void testEnrichedConfigDef() { private static void assertEnrichedConfigDef(ConfigDef def, String prefix, String keyName, ConfigDef.Type expectedType) { assertNull(def.configKeys().get(keyName)); ConfigDef.ConfigKey configKey = def.configKeys().get(prefix + keyName); - assertNotNull(prefix + keyName + "' config must be present", configKey); - assertEquals(prefix + keyName + "' config should be a " + expectedType, expectedType, configKey.type); + assertNotNull(configKey, prefix + keyName + "' config must be present"); + assertEquals(expectedType, configKey.type, prefix + keyName + "' config should be a " + expectedType); } public static class HasDuplicateConfigTransformation> implements Transformation, Versioned { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index 3aeecc1d757c3..996bd5c93f5c0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -61,15 +61,13 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -98,7 +96,7 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.any; import static org.mockito.Mockito.doReturn; @@ -108,10 +106,9 @@ import static org.mockito.Mockito.when; -@RunWith(Parameterized.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class ErrorHandlingTaskTest { - @Rule - public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); private static final String TOPIC = "test"; private static final int PARTITION1 = 12; @@ -179,19 +176,15 @@ public class ErrorHandlingTaskTest { private ErrorHandlingMetrics errorHandlingMetrics; - private final boolean enableTopicCreation; + private boolean enableTopicCreation; - @Parameterized.Parameters public static Collection parameters() { return Arrays.asList(false, true); } - public ErrorHandlingTaskTest(boolean enableTopicCreation) { - this.enableTopicCreation = enableTopicCreation; - } - @Before - public void setup() { + public void setup(boolean enableTopicCreation) { + this.enableTopicCreation = enableTopicCreation; time = new MockTime(0, 0, 0); metrics = new MockConnectMetrics(); Map workerProps = new HashMap<>(); @@ -220,15 +213,17 @@ private Map sourceConnectorProps(String topic) { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) { metrics.stop(); } } - @Test - public void testErrorHandlingInSinkTasks() { + @ParameterizedTest + @MethodSource("parameters") + public void testErrorHandlingInSinkTasks(boolean enableTopicCreation) { + setup(enableTopicCreation); Map reportProps = new HashMap<>(); reportProps.put(ConnectorConfig.ERRORS_LOG_ENABLE_CONFIG, "true"); reportProps.put(ConnectorConfig.ERRORS_LOG_INCLUDE_MESSAGES_CONFIG, "true"); @@ -277,8 +272,10 @@ private RetryWithToleranceOperator operator() { SYSTEM, errorHandlingMetrics); } - @Test - public void testErrorHandlingInSourceTasks() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testErrorHandlingInSourceTasks(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Map reportProps = new HashMap<>(); reportProps.put(ConnectorConfig.ERRORS_LOG_ENABLE_CONFIG, "true"); reportProps.put(ConnectorConfig.ERRORS_LOG_INCLUDE_MESSAGES_CONFIG, "true"); @@ -337,8 +334,10 @@ private ConnectorConfig connConfig(Map connProps) { return new ConnectorConfig(plugins, props); } - @Test - public void testErrorHandlingInSourceTasksWithBadConverter() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testErrorHandlingInSourceTasksWithBadConverter(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Map reportProps = new HashMap<>(); reportProps.put(ConnectorConfig.ERRORS_LOG_ENABLE_CONFIG, "true"); reportProps.put(ConnectorConfig.ERRORS_LOG_INCLUDE_MESSAGES_CONFIG, "true"); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index 6d5e6350357ed..997e3f27e652c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -51,24 +51,21 @@ import org.apache.kafka.connect.test.util.MockitoUtils; import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.OngoingStubbing; import org.mockito.verification.VerificationMode; import java.time.Duration; import java.util.Arrays; -import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; @@ -83,6 +80,7 @@ import java.util.concurrent.atomic.AtomicReference; import java.util.function.Consumer; import java.util.stream.Collectors; +import java.util.stream.Stream; import static java.util.Collections.emptySet; import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; @@ -99,11 +97,11 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.atLeast; @@ -115,7 +113,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(Parameterized.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.WARN) public class ExactlyOnceWorkerSourceTaskTest { private static final String TOPIC = "topic"; private static final Map PARTITION = Collections.singletonMap("key", "partition".getBytes()); @@ -157,8 +156,6 @@ public class ExactlyOnceWorkerSourceTaskTest { @Mock private Runnable preProducerCheck; @Mock private Runnable postProducerCheck; - @Rule public MockitoRule rule = MockitoJUnit.rule(); - private static final Map TASK_PROPS = new HashMap<>(); static { TASK_PROPS.put(TaskConfig.TASK_CLASS_CONFIG, TestSourceTask.class.getName()); @@ -174,23 +171,20 @@ public class ExactlyOnceWorkerSourceTaskTest { private final AtomicReference pollLatch = new AtomicReference<>(new CountDownLatch(0)); private final AtomicReference> pollRecords = new AtomicReference<>(RECORDS); - private final boolean enableTopicCreation; + private boolean enableTopicCreation; private boolean taskStarted; private Future workerTaskFuture; - @ParameterizedTest.Parameters - public static Collection parameters() { - return Arrays.asList(false, true); + + public static Stream parameters() { + return Stream.of(false, true); } - public ExactlyOnceWorkerSourceTaskTest(boolean enableTopicCreation) { + + public void setup(boolean enableTopicCreation) throws Exception { this.enableTopicCreation = enableTopicCreation; this.taskStarted = false; - } - - @Before - public void setup() throws Exception { Map workerProps = workerProps(); plugins = new Plugins(workerProps); config = new StandaloneConfig(workerProps); @@ -209,7 +203,7 @@ public void setup() throws Exception { }); } - @After + @AfterEach public void teardown() throws Exception { // In most tests, we don't really care about how many times the task got polled, // how many times we prepared to write offsets, etc. @@ -293,8 +287,10 @@ private void createWorkerTask(TargetState initialState, Converter keyConverter, sourceConfig, Runnable::run, preProducerCheck, postProducerCheck, Collections::emptyList); } - @Test - public void testRemoveMetrics() { + @ParameterizedTest + @MethodSource("parameters") + public void testRemoveMetrics(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); workerTask.removeMetrics(); @@ -310,8 +306,10 @@ private Set filterToTaskMetrics(Set metricNames) { .collect(Collectors.toSet()); } - @Test - public void testStartPaused() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testStartPaused(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(TargetState.PAUSED); final CountDownLatch pauseLatch = new CountDownLatch(1); @@ -333,8 +331,10 @@ public void testStartPaused() throws Exception { assertPollMetrics(0); } - @Test - public void testPause() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPause(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); expectSuccessfulSends(); @@ -372,8 +372,10 @@ public void testPause() throws Exception { verifyCleanShutdown(); } - @Test - public void testFailureInPreProducerCheck() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPreProducerCheck(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); Exception exception = new ConnectException("Failed to perform zombie fencing"); @@ -386,8 +388,10 @@ public void testFailureInPreProducerCheck() throws Exception { verifyShutdown(true, false); } - @Test - public void testFailureInProducerInitialization() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInProducerInitialization(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); Exception exception = new ConnectException("You can't do that!"); @@ -401,8 +405,10 @@ public void testFailureInProducerInitialization() throws Exception { verifyShutdown(true, false); } - @Test - public void testFailureInPostProducerCheck() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPostProducerCheck(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); Exception exception = new ConnectException("New task configs for the connector have already been generated"); @@ -417,8 +423,10 @@ public void testFailureInPostProducerCheck() throws Exception { verifyShutdown(true, false); } - @Test - public void testFailureInOffsetStoreStart() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInOffsetStoreStart(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); Exception exception = new ConnectException("No soup for you!"); @@ -434,8 +442,10 @@ public void testFailureInOffsetStoreStart() throws Exception { verifyShutdown(true, false); } - @Test - public void testPollsInBackground() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPollsInBackground(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); expectSuccessfulSends(); @@ -459,8 +469,10 @@ public void testPollsInBackground() throws Exception { assertTransactionMetrics(RECORDS.size()); } - @Test - public void testFailureInPoll() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPoll(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -482,8 +494,10 @@ public void testFailureInPoll() throws Exception { assertPollMetrics(0); } - @Test - public void testFailureInPollAfterCancel() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -508,8 +522,10 @@ public void testFailureInPollAfterCancel() throws Exception { assertPollMetrics(0); } - @Test - public void testFailureInPollAfterStop() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -537,8 +553,10 @@ public void testFailureInPollAfterStop() throws Exception { assertPollMetrics(0); } - @Test - public void testPollReturnsNoRecords() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // Test that the task handles an empty list of records createWorkerTask(); @@ -562,8 +580,10 @@ public void testPollReturnsNoRecords() throws Exception { assertPollMetrics(0); } - @Test - public void testPollBasedCommit() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPollBasedCommit(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.POLL); sourceConfig = new SourceConnectorConfig(plugins, connectorProps, enableTopicCreation); @@ -590,8 +610,10 @@ public void testPollBasedCommit() throws Exception { assertTransactionMetrics(RECORDS.size()); } - @Test - public void testIntervalBasedCommit() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testIntervalBasedCommit(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); long commitInterval = 618; Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.INTERVAL); connectorProps.put(TRANSACTION_BOUNDARY_INTERVAL_CONFIG, Long.toString(commitInterval)); @@ -607,15 +629,16 @@ public void testIntervalBasedCommit() throws Exception { startTaskThread(); awaitPolls(2); - assertEquals("No flushes should have taken place before offset commit interval has elapsed", 0, flushCount()); + assertEquals(0, flushCount(), "No flushes should have taken place before offset commit interval has elapsed"); time.sleep(commitInterval); awaitPolls(2); - assertEquals("One flush should have taken place after offset commit interval has elapsed", 1, flushCount()); + assertEquals(1, flushCount(), "One flush should have taken place after offset commit interval has elapsed"); time.sleep(commitInterval * 2); awaitPolls(2); - assertEquals("Two flushes should have taken place after offset commit interval has elapsed again", 2, flushCount()); + assertEquals(2, flushCount(), + "Two flushes should have taken place after offset commit interval has elapsed again"); awaitShutdown(); @@ -631,27 +654,36 @@ public void testIntervalBasedCommit() throws Exception { assertTransactionMetrics(RECORDS.size() * 2); } - @Test - public void testConnectorCommitOnBatch() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorCommitOnBatch(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorBasedCommit(TransactionContext::commitTransaction, false); } - @Test - public void testConnectorCommitOnRecord() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorCommitOnRecord(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorBasedCommit(ctx -> ctx.commitTransaction(SOURCE_RECORD_2), false); } - @Test - public void testConnectorAbortOnBatch() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorAbortOnBatch(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorBasedCommit(TransactionContext::abortTransaction, true); } - @Test - public void testConnectorAbortOnRecord() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorAbortOnRecord(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorBasedCommit(ctx -> ctx.abortTransaction(SOURCE_RECORD_2), true); } private void testConnectorBasedCommit(Consumer requestCommit, boolean abort) throws Exception { + setup(enableTopicCreation); Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.CONNECTOR); sourceConfig = new SourceConnectorConfig(plugins, connectorProps, enableTopicCreation); createWorkerTask(); @@ -664,22 +696,22 @@ private void testConnectorBasedCommit(Consumer requestCommit startTaskThread(); awaitPolls(3); - assertEquals("No flushes should have taken place without connector requesting transaction commit", - 0, flushCount()); + assertEquals(0, flushCount(), + "No flushes should have taken place without connector requesting transaction commit"); requestCommit.accept(transactionContext); awaitPolls(3); - assertEquals("One flush should have taken place after transaction commit/abort was requested", - 1, flushCount()); + assertEquals(1, flushCount(), + "One flush should have taken place after transaction commit/abort was requested"); awaitPolls(3); - assertEquals("Only one flush should still have taken place without connector re-requesting commit/abort, even on identical records", - 1, flushCount()); + assertEquals(1, flushCount(), + "Only one flush should still have taken place without connector re-requesting commit/abort, even on identical records"); awaitShutdown(); - assertEquals("Task should have flushed offsets once based on connector-defined boundaries, and skipped final end-of-life offset commit", - 1, flushCount()); + assertEquals(1, flushCount(), + "Task should have flushed offsets once based on connector-defined boundaries, and skipped final end-of-life offset commit"); // We begin a new transaction after connector-requested aborts so that we can still write offsets for the source records that were aborted verify(producer, times(abort ? 3 : 2)).beginTransaction(); verifySends(); @@ -696,8 +728,10 @@ private void testConnectorBasedCommit(Consumer requestCommit assertTransactionMetrics(abort ? 0 : (3 * RECORDS.size())); } - @Test - public void testConnectorAbortsEmptyTransaction() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorAbortsEmptyTransaction(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.CONNECTOR); sourceConfig = new SourceConnectorConfig(plugins, connectorProps, enableTopicCreation); createWorkerTask(); @@ -741,8 +775,10 @@ public void testConnectorAbortsEmptyTransaction() throws Exception { verifyPossibleTopicCreation(); } - @Test - public void testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // We fail tasks that try to abort and commit a transaction for the same record or same batch // But we don't fail if they try to commit the last record of a batch and abort the entire batch // Instead, we give precedence to the record-based operation @@ -779,8 +815,10 @@ public void testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch() th verifyPossibleTopicCreation(); } - @Test - public void testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // We fail tasks that try to abort and commit a transaction for the same record or same batch // But we don't fail if they try to abort the last record of a batch and commit the entire batch // Instead, we give precedence to the record-based operation @@ -822,8 +860,10 @@ public void testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch() th verifyPossibleTopicCreation(); } - @Test - public void testCommitFlushSyncCallbackFailure() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testCommitFlushSyncCallbackFailure(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); when(offsetWriter.beginFlush()).thenReturn(true); when(offsetWriter.doFlush(any())).thenAnswer(invocation -> { @@ -834,8 +874,10 @@ public void testCommitFlushSyncCallbackFailure() throws Exception { testCommitFailure(failure, false); } - @Test - public void testCommitFlushAsyncCallbackFailure() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testCommitFlushAsyncCallbackFailure(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); when(offsetWriter.beginFlush()).thenReturn(true); // doFlush delegates its callback to the producer, @@ -852,8 +894,10 @@ public void testCommitFlushAsyncCallbackFailure() throws Exception { testCommitFailure(failure, true); } - @Test - public void testCommitTransactionFailure() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testCommitTransactionFailure(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); when(offsetWriter.beginFlush()).thenReturn(true); doThrow(failure).when(producer).commitTransaction(); @@ -894,8 +938,10 @@ private void testCommitFailure(Exception commitException, boolean executeCommit) verifyShutdown(true, false); } - @Test - public void testSendRecordsRetries() { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsRetries(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); // Differentiate only by Kafka partition so we can reuse conversion expectations @@ -938,8 +984,10 @@ public void testSendRecordsRetries() { verify(offsetWriter).offset(PARTITION, offset(3)); } - @Test - public void testSendRecordsProducerSendFailsImmediately() { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); SourceRecord record1 = new SourceRecord(PARTITION, OFFSET, TOPIC, 1, KEY_SCHEMA, KEY, RECORD_SCHEMA, VALUE_1); @@ -961,8 +1009,10 @@ public void testSendRecordsProducerSendFailsImmediately() { verifyPossibleTopicCreation(); } - @Test - public void testSlowTaskStart() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); final CountDownLatch startupLatch = new CountDownLatch(1); final CountDownLatch finishStartupLatch = new CountDownLatch(1); @@ -995,8 +1045,10 @@ public void testSlowTaskStart() throws Exception { verifyCleanShutdown(); } - @Test - public void testCancel() { + @ParameterizedTest + @MethodSource("parameters") + public void testCancel(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); // workerTask said something dumb on twitter @@ -1205,8 +1257,8 @@ private void assertTransactionMetrics(int minimumMaxSizeExpected) { if (actualMax - actualMin <= 0.000001d) { assertEquals(actualMax, actualAvg, 0.000002d); } else { - assertTrue("Average transaction size should be greater than minimum transaction size", actualAvg > actualMin); - assertTrue("Average transaction size should be less than maximum transaction size", actualAvg < actualMax); + assertTrue(actualAvg > actualMin, "Average transaction size should be greater than minimum transaction size"); + assertTrue(actualAvg < actualMax, "Average transaction size should be less than maximum transaction size"); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java index 28ffcfd8d0848..80174b3307dae 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java @@ -20,17 +20,20 @@ import org.apache.kafka.connect.header.Header; import org.apache.kafka.connect.runtime.errors.ProcessingContext; import org.apache.kafka.connect.sink.SinkRecord; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.Collections; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class InternalSinkRecordTest { private static final String TOPIC = "test-topic"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java index 184724ef25503..64262b47d3e99 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java @@ -22,10 +22,12 @@ import org.apache.log4j.Hierarchy; import org.apache.log4j.Level; import org.apache.log4j.Logger; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.Arrays; import java.util.Collections; @@ -38,17 +40,18 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class LoggersTest { private static final long INITIAL_TIME = 1696951712135L; private Time time; - @Before + @BeforeEach public void setup() { time = new MockTime(0, INITIAL_TIME, 0); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java index 480ba2bae9ebd..4c695b90b5a69 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java @@ -19,14 +19,14 @@ import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo.TaskState; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.List; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class RestartPlanTest { private static final String CONNECTOR_NAME = "foo"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java index c4be5ca88f60e..734bfbe440808 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java @@ -16,15 +16,15 @@ */ package org.apache.kafka.connect.runtime; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Collections; import java.util.List; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class RestartRequestTest { private static final String CONNECTOR_NAME = "foo"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java index 562507425589c..19320736dc95c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java @@ -16,8 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.UnsupportedEncodingException; -import java.util.Map; import org.apache.kafka.common.header.Header; import org.apache.kafka.common.header.Headers; import org.apache.kafka.common.utils.AppInfoParser; @@ -27,6 +25,9 @@ import org.apache.kafka.connect.errors.DataException; import org.apache.kafka.connect.storage.Converter; +import java.io.UnsupportedEncodingException; +import java.util.Map; + /** * This is a simple Converter implementation that uses "encoding" header to encode/decode strings via provided charset name */ diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java index 251bb72fbe2d9..d4592dec6c23b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java @@ -18,7 +18,7 @@ package org.apache.kafka.connect.runtime; import org.apache.kafka.common.config.ConfigException; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.HashMap; import java.util.Map; @@ -40,10 +40,10 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class SourceConnectorConfigTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java index ef962cf5b445e..a80e904a3e5a6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java @@ -21,12 +21,14 @@ import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.HashMap; import java.util.Map; @@ -38,15 +40,16 @@ import java.util.concurrent.TimeUnit; import static java.util.Collections.singletonMap; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +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 static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class SourceTaskOffsetCommitterTest { private final ConcurrentHashMap> committers = new ConcurrentHashMap<>(); @@ -66,7 +69,7 @@ public class SourceTaskOffsetCommitterTest { private static final long DEFAULT_OFFSET_COMMIT_INTERVAL_MS = 1000; - @Before + @BeforeEach public void setup() { Map workerProps = new HashMap<>(); workerProps.put("key.converter", "org.apache.kafka.connect.json.JsonConverter"); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java index 507d196d42982..349230e696476 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java @@ -16,13 +16,13 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.runtime.AbstractStatus.State; import org.apache.kafka.common.utils.MockTime; -import org.junit.Before; -import org.junit.Test; +import org.apache.kafka.connect.runtime.AbstractStatus.State; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; public class StateTrackerTest { @@ -31,7 +31,7 @@ public class StateTrackerTest { private StateTracker tracker; private MockTime time; - @Before + @BeforeEach public void setUp() { time = new MockTime(); time.sleep(1000L); @@ -100,4 +100,4 @@ public void calculateDurations() { } -} \ No newline at end of file +} diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java index 39d680a7d46be..2d6e3ecea5b3b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java @@ -17,8 +17,8 @@ package org.apache.kafka.connect.runtime; import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import java.util.Arrays; import java.util.Collections; @@ -30,9 +30,9 @@ import java.util.concurrent.atomic.AtomicInteger; import static org.apache.kafka.connect.runtime.SubmittedRecords.CommittableOffsets; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class SubmittedRecordsTest { @@ -44,7 +44,7 @@ public class SubmittedRecordsTest { SubmittedRecords submittedRecords; - @Before + @BeforeEach public void setup() { submittedRecords = new SubmittedRecords(); offset = new AtomicInteger(); @@ -178,8 +178,8 @@ public void testRemoveLastSubmittedRecord() { assertEquals(Collections.emptyMap(), committableOffsets.offsets()); assertMetadata(committableOffsets, 0, 1, 1, 1, PARTITION1); - assertTrue("First attempt to remove record from submitted queue should succeed", submittedRecord.drop()); - assertFalse("Attempt to remove already-removed record from submitted queue should fail", submittedRecord.drop()); + assertTrue(submittedRecord.drop(), "First attempt to remove record from submitted queue should succeed"); + assertFalse(submittedRecord.drop(), "Attempt to remove already-removed record from submitted queue should fail"); committableOffsets = submittedRecords.committableOffsets(); // Even if SubmittedRecords::remove is broken, we haven't ack'd anything yet, so there should be no committable offsets @@ -203,7 +203,7 @@ public void testRemoveNotLastSubmittedRecord() { assertMetadata(committableOffsets, 0, 2, 2, 1, PARTITION1, PARTITION2); assertNoEmptyDeques(); - assertTrue("First attempt to remove record from submitted queue should succeed", recordToRemove.drop()); + assertTrue(recordToRemove.drop(), "First attempt to remove record from submitted queue should succeed"); committableOffsets = submittedRecords.committableOffsets(); // Even if SubmittedRecords::remove is broken, we haven't ack'd anything yet, so there should be no committable offsets @@ -265,27 +265,27 @@ public void testAwaitMessagesAfterAllRemoved() { SubmittedRecord recordToRemove1 = submittedRecords.submit(PARTITION1, newOffset()); SubmittedRecord recordToRemove2 = submittedRecords.submit(PARTITION1, newOffset()); assertFalse( - "Await should fail since neither of the in-flight records has been removed so far", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should fail since neither of the in-flight records has been removed so far" ); recordToRemove1.drop(); assertFalse( - "Await should fail since only one of the two submitted records has been removed so far", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should fail since only one of the two submitted records has been removed so far" ); recordToRemove1.drop(); assertFalse( + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), "Await should fail since only one of the two submitted records has been removed so far, " - + "even though that record has been removed twice", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) + + "even though that record has been removed twice" ); recordToRemove2.drop(); assertTrue( - "Await should succeed since both submitted records have now been removed", - submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS) + submittedRecords.awaitAllMessages(0, TimeUnit.MILLISECONDS), + "Await should succeed since both submitted records have now been removed" ); } @@ -308,48 +308,48 @@ public void testAwaitMessagesReturnsAfterAsynchronousAck() throws Exception { }).start(); assertTrue( - "Should not have finished awaiting message delivery before either in-flight record was acknowledged", - awaitComplete.getCount() > 0 + awaitComplete.getCount() > 0, + "Should not have finished awaiting message delivery before either in-flight record was acknowledged" ); inFlightRecord1.ack(); assertTrue( - "Should not have finished awaiting message delivery before one in-flight record was acknowledged", - awaitComplete.getCount() > 0 + awaitComplete.getCount() > 0, + "Should not have finished awaiting message delivery before one in-flight record was acknowledged" ); inFlightRecord1.ack(); assertTrue( + awaitComplete.getCount() > 0, "Should not have finished awaiting message delivery before one in-flight record was acknowledged, " - + "even though the other record has been acknowledged twice", - awaitComplete.getCount() > 0 + + "even though the other record has been acknowledged twice" ); inFlightRecord2.ack(); assertTrue( - "Should have finished awaiting message delivery after both in-flight records were acknowledged", - awaitComplete.await(1, TimeUnit.SECONDS) + awaitComplete.await(1, TimeUnit.SECONDS), + "Should have finished awaiting message delivery after both in-flight records were acknowledged" ); assertTrue( - "Await of in-flight messages should have succeeded", - awaitResult.get() + awaitResult.get(), + "Await of in-flight messages should have succeeded" ); } private void assertNoRemainingDeques() { - assertEquals("Internal records map should be completely empty", Collections.emptyMap(), submittedRecords.records); + assertEquals(Collections.emptyMap(), submittedRecords.records, "Internal records map should be completely empty"); } @SafeVarargs private final void assertRemovedDeques(Map... partitions) { for (Map partition : partitions) { - assertFalse("Deque for partition " + partition + " should have been cleaned up from internal records map", submittedRecords.records.containsKey(partition)); + assertFalse(submittedRecords.records.containsKey(partition), "Deque for partition " + partition + " should have been cleaned up from internal records map"); } } private void assertNoEmptyDeques() { submittedRecords.records.forEach((partition, deque) -> - assertFalse("Empty deque for partition " + partition + " should have been cleaned up from internal records map", deque.isEmpty()) + assertFalse(deque.isEmpty(), "Empty deque for partition " + partition + " should have been cleaned up from internal records map") ); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java index 1d63d7db55f34..1aae5bc842d25 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java @@ -30,7 +30,7 @@ import org.apache.kafka.connect.transforms.TimestampConverter; import org.apache.kafka.connect.transforms.TimestampRouter; import org.apache.kafka.connect.transforms.ValueToKey; -import org.junit.Test; +import org.junit.jupiter.api.Test; import java.util.HashMap; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index 6d6b8dcaa814f..8ccb190050d44 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -19,18 +19,18 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.Test; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import static java.util.Collections.singletonMap; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class TransformationStageTest { private final SourceRecord initial = new SourceRecord(singletonMap("initial", 1), null, null, null, null); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java index dbb25cdafac15..b95f4145e1291 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java @@ -20,20 +20,20 @@ import org.apache.kafka.clients.admin.MockAdminClient; import org.apache.kafka.common.Node; import org.apache.kafka.connect.errors.ConnectException; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.MockedStatic; import org.mockito.internal.stubbing.answers.CallsRealMethods; import java.util.Arrays; import java.util.HashMap; -import java.util.Map; import java.util.List; +import java.util.Map; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mockStatic; import static org.mockito.Mockito.times; @@ -43,13 +43,13 @@ public class WorkerConfigTest { private static final String CLUSTER_ID = "cluster-id"; private MockedStatic workerConfigMockedStatic; - @Before + @BeforeEach public void setup() { workerConfigMockedStatic = mockStatic(WorkerConfig.class, new CallsRealMethods()); workerConfigMockedStatic.when(() -> WorkerConfig.lookupKafkaClusterId(any(WorkerConfig.class))).thenReturn(CLUSTER_ID); } - @After + @AfterEach public void teardown() { workerConfigMockedStatic.close(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java index 4af49c0ea1600..d81d9f8179508 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java @@ -18,11 +18,13 @@ import org.apache.kafka.common.config.ConfigData; import org.apache.kafka.common.config.provider.ConfigProvider; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.Collections; import java.util.HashMap; @@ -31,15 +33,16 @@ import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_NONE; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.notNull; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerConfigTransformerTest { public static final String MY_KEY = "myKey"; @@ -60,7 +63,7 @@ public class WorkerConfigTransformerTest { private HerderRequest requestId; private WorkerConfigTransformer configTransformer; - @Before + @BeforeEach public void setup() { configTransformer = new WorkerConfigTransformer(worker, Collections.singletonMap("test", new TestConfigProvider())); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index ab8cdb65a0cb8..46438a78e07f8 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -28,30 +28,27 @@ import org.apache.kafka.connect.storage.CloseableOffsetStorageReader; import org.apache.kafka.connect.storage.ConnectorOffsetBackingStore; import org.apache.kafka.connect.util.Callback; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; - +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.ArgumentCaptor; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.Map; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.mockito.ArgumentCaptor; -import org.mockito.InOrder; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; -import org.mockito.quality.Strictness; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.isNull; @@ -63,7 +60,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(Parameterized.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerConnectorTest { private static final String VERSION = "1.1"; @@ -77,25 +75,22 @@ public class WorkerConnectorTest { public ConnectorConfig connectorConfig; public MockConnectMetrics metrics; - @Rule - public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); @Mock private Plugins plugins; @Mock private CloseableConnectorContext ctx; @Mock private ConnectorStatus.Listener listener; @Mock private ClassLoader classLoader; - private final ConnectorType connectorType; - private final Connector connector; - private final CloseableOffsetStorageReader offsetStorageReader; - private final ConnectorOffsetBackingStore offsetStore; + private ConnectorType connectorType; + private Connector connector; + private CloseableOffsetStorageReader offsetStorageReader; + private ConnectorOffsetBackingStore offsetStore; - @Parameterized.Parameters public static Collection parameters() { return Arrays.asList(ConnectorType.SOURCE, ConnectorType.SINK); } - public WorkerConnectorTest(ConnectorType connectorType) { + private void setConnector(ConnectorType connectorType) { this.connectorType = connectorType; switch (connectorType) { case SINK: @@ -112,20 +107,22 @@ public WorkerConnectorTest(ConnectorType connectorType) { throw new IllegalStateException("Unexpected connector type: " + connectorType); } } - - @Before - public void setup() { + + public void setup(ConnectorType connectorType) { + setConnector(connectorType); connectorConfig = new ConnectorConfig(plugins, CONFIG); metrics = new MockConnectMetrics(); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } - @Test - public void testInitializeFailure() { + @ParameterizedTest + @MethodSource("parameters") + public void testInitializeFailure(ConnectorType connectorType) { + setup(connectorType); RuntimeException exception = new RuntimeException(); when(connector.version()).thenReturn(VERSION); @@ -144,8 +141,10 @@ public void testInitializeFailure() { verifyCleanShutdown(false); } - @Test - public void testFailureIsFinalState() { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureIsFinalState(ConnectorType connectorType) { + setup(connectorType); RuntimeException exception = new RuntimeException(); when(connector.version()).thenReturn(VERSION); @@ -171,8 +170,10 @@ public void testFailureIsFinalState() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupAndShutdown() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupAndShutdown(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -195,8 +196,10 @@ public void testStartupAndShutdown() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupAndPause() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupAndPause(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -224,8 +227,10 @@ public void testStartupAndPause() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupAndStop() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupAndStop(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -254,8 +259,10 @@ public void testStartupAndStop() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testOnResume() { + @ParameterizedTest + @MethodSource("parameters") + public void testOnResume(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -284,8 +291,10 @@ public void testOnResume() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupPaused() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupPaused(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -308,8 +317,10 @@ public void testStartupPaused() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupStopped() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupStopped(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -332,8 +343,10 @@ public void testStartupStopped() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStartupFailure() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartupFailure(ConnectorType connectorType) { + setup(connectorType); RuntimeException exception = new RuntimeException(); when(connector.version()).thenReturn(VERSION); @@ -359,8 +372,10 @@ public void testStartupFailure() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testStopFailure() { + @ParameterizedTest + @MethodSource("parameters") + public void testStopFailure(ConnectorType connectorType) { + setup(connectorType); RuntimeException exception = new RuntimeException(); when(connector.version()).thenReturn(VERSION); @@ -401,8 +416,10 @@ public void testStopFailure() { verifyNoMoreInteractions(listener); } - @Test - public void testShutdownFailure() { + @ParameterizedTest + @MethodSource("parameters") + public void testShutdownFailure(ConnectorType connectorType) { + setup(connectorType); RuntimeException exception = new RuntimeException(); when(connector.version()).thenReturn(VERSION); @@ -429,8 +446,10 @@ public void testShutdownFailure() { verifyShutdown(false, true); } - @Test - public void testTransitionStartedToStarted() { + @ParameterizedTest + @MethodSource("parameters") + public void testTransitionStartedToStarted(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -456,8 +475,10 @@ public void testTransitionStartedToStarted() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testTransitionPausedToPaused() { + @ParameterizedTest + @MethodSource("parameters") + public void testTransitionPausedToPaused(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -487,8 +508,10 @@ public void testTransitionPausedToPaused() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testTransitionStoppedToStopped() { + @ParameterizedTest + @MethodSource("parameters") + public void testTransitionStoppedToStopped(ConnectorType connectorType) { + setup(connectorType); when(connector.version()).thenReturn(VERSION); Callback onStateChange = mockCallback(); @@ -518,8 +541,10 @@ public void testTransitionStoppedToStopped() { verifyNoMoreInteractions(onStateChange); } - @Test - public void testFailConnectorThatIsNeitherSourceNorSink() { + @ParameterizedTest + @MethodSource("parameters") + public void testFailConnectorThatIsNeitherSourceNorSink(ConnectorType connectorType) { + setup(connectorType); Connector badConnector = mock(Connector.class); when(badConnector.version()).thenReturn(VERSION); WorkerConnector workerConnector = new WorkerConnector(CONNECTOR, badConnector, connectorConfig, ctx, metrics, listener, offsetStorageReader, offsetStore, classLoader); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index 9d17b638d5c2e..a909b79fb133e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -22,11 +22,13 @@ import org.apache.kafka.common.metrics.Sensor; import org.apache.kafka.common.metrics.stats.CumulativeSum; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.HashMap; @@ -38,7 +40,8 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerMetricsGroupTest { private final String connector = "org.FakeConnector"; private final ConnectorTaskId task = new ConnectorTaskId(connector, 0); @@ -62,7 +65,7 @@ public class WorkerMetricsGroupTest { @Mock private ConnectMetrics.MetricGroup metricGroup; @Mock private MetricName metricName; - @Before + @BeforeEach public void setup() { // We don't expect metricGroup.metricName to be invoked with null in practice, // but it's easier to test this way, and should have no impact diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java index 75f942a6871d8..c0e4c4dfa7697 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java @@ -16,45 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import static java.util.Arrays.asList; -import static java.util.Collections.singleton; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotEquals; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.ArgumentMatchers.anyMap; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.atLeastOnce; -import static org.mockito.Mockito.doAnswer; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.time.Duration; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.regex.Pattern; -import java.util.stream.Collectors; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -95,21 +56,60 @@ import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoJUnitRunner; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; import org.mockito.stubbing.OngoingStubbing; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +import static java.util.Arrays.asList; +import static java.util.Collections.singleton; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.atLeastOnce; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSinkTaskTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values // with mix of integer/string in Connect @@ -170,13 +170,11 @@ public class WorkerSinkTaskTest { @Mock private ErrorHandlingMetrics errorHandlingMetrics; private final ArgumentCaptor rebalanceListener = ArgumentCaptor.forClass(ConsumerRebalanceListener.class); - @Rule - public final MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); private long recordsReturnedTp1; private long recordsReturnedTp3; - @Before + @BeforeEach public void setUp() { time = new MockTime(); Map workerProps = new HashMap<>(); @@ -207,7 +205,7 @@ private void createTask(TargetState initialState, Converter keyConverter, Conver retryWithToleranceOperator, null, statusBackingStore, errorReportersSupplier); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } @@ -920,10 +918,10 @@ public void testRequestCommit() { // is the normal commit time less the two sleeps since it started each // of those sleeps were 10 seconds. // KAFKA-8229 - assertEquals("Should have only advanced by 40 seconds", - previousCommitValue + + assertEquals(previousCommitValue + (WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT - 10000L * 2), - workerTask.getNextCommit()); + workerTask.getNextCommit(), + "Should have only advanced by 40 seconds"); assertSinkMetricValue("partition-count", 2); assertSinkMetricValue("sink-record-read-total", 1.0); @@ -1110,7 +1108,7 @@ public void testLongRunningCommitWithoutTimeout() { workerTask.iteration(); // iter 3 -- commit in progress // Make sure the "committing" flag didn't immediately get flipped back to false due to an incorrect timeout - assertTrue("Expected worker to be in the process of committing offsets", workerTask.isCommitting()); + assertTrue(workerTask.isCommitting(), "Expected worker to be in the process of committing offsets"); // Delay the result of trying to commit offsets to Kafka via the consumer.commitAsync method. ArgumentCaptor offsetCommitCallbackArgumentCaptor = @@ -1196,8 +1194,8 @@ public void testSuppressCloseErrors() { workerTask.initializeAndStart(); RuntimeException thrownException = assertThrows(ConnectException.class, () -> workerTask.execute()); - assertEquals("Exception from put should be the cause", putException, thrownException.getCause()); - assertTrue("Exception from close should be suppressed", thrownException.getSuppressed().length > 0); + assertEquals(putException, thrownException.getCause(), "Exception from put should be the cause"); + assertTrue(thrownException.getSuppressed().length > 0, "Exception from close should be suppressed"); assertEquals(closeException, thrownException.getSuppressed()[0]); } @@ -1889,4 +1887,4 @@ private void assertTaskMetricValue(String name, String expected) { String measured = metrics.currentMetricValueAsString(taskGroup, name); assertEquals(expected, measured); } -} \ No newline at end of file +} diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index facdf9da72a1c..54a3dea59eece 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -25,33 +25,35 @@ import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.header.internals.RecordHeaders; import org.apache.kafka.common.record.TimestampType; +import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.errors.ProcessingContext; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperatorTest; -import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkRecord; import org.apache.kafka.connect.sink.SinkTask; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.common.utils.MockTime; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import org.mockito.invocation.InvocationOnMock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; import java.io.IOException; @@ -68,10 +70,10 @@ import java.util.function.Function; import static java.util.Collections.singletonList; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyString; @@ -84,7 +86,8 @@ import static org.mockito.Mockito.when; @SuppressWarnings("unchecked") -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSinkTaskThreadedTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values @@ -161,7 +164,7 @@ public class WorkerSinkTaskThreadedTest { return offsetsToCommit; }; - @Before + @BeforeEach public void setup() { time = new MockTime(); metrics = new MockConnectMetrics(); @@ -178,7 +181,7 @@ public void setup() { recordsReturned = 0; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 00cc7b7bb6382..16204dee9ec68 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -22,26 +22,27 @@ import org.apache.kafka.clients.producer.ProducerRecord; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.KafkaException; +import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.errors.InvalidTopicException; import org.apache.kafka.common.errors.TopicAuthorizationException; -import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.header.Headers; import org.apache.kafka.common.header.internals.RecordHeaders; +import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.integration.MonitorableSourceConnector; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroup; -import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperator; import org.apache.kafka.connect.runtime.errors.RetryWithToleranceOperatorTest; -import org.apache.kafka.connect.runtime.errors.ErrorHandlingMetrics; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; import org.apache.kafka.connect.source.SourceTaskContext; import org.apache.kafka.connect.storage.CloseableOffsetStorageReader; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.ConnectorOffsetBackingStore; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; @@ -50,20 +51,17 @@ import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.test.util.ConcurrencyUtils; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; -import org.apache.kafka.common.utils.LogCaptureAppender; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnit; -import org.mockito.junit.MockitoRule; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; @@ -71,7 +69,6 @@ import java.nio.charset.StandardCharsets; import java.time.Duration; import java.util.Arrays; -import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; @@ -86,6 +83,7 @@ import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Supplier; +import java.util.stream.Stream; import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; @@ -99,12 +97,12 @@ import static org.apache.kafka.connect.runtime.TopicCreationConfig.PARTITIONS_CONFIG; import static org.apache.kafka.connect.runtime.TopicCreationConfig.REPLICATION_FACTOR_CONFIG; import static org.apache.kafka.connect.runtime.WorkerConfig.TOPIC_CREATION_ENABLE_CONFIG; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.anyString; @@ -121,12 +119,11 @@ import static org.mockito.Mockito.when; @SuppressWarnings({"unchecked"}) -@RunWith(Parameterized.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSourceTaskTest { public static final String POLL_TIMEOUT_MSG = "Timeout waiting for poll"; - @org.junit.Rule - public MockitoRule rule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); private static final String TOPIC = "topic"; private static final Map PARTITION = Collections.singletonMap("key", "partition".getBytes()); @@ -190,19 +187,14 @@ public class WorkerSourceTaskTest { new SourceRecord(PARTITION, OFFSET, "topic", null, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD) ); - private final boolean enableTopicCreation; + private boolean enableTopicCreation; - @ParameterizedTest.Parameters - public static Collection parameters() { - return Arrays.asList(false, true); + public static Stream parameters() { + return Stream.of(false, true); } - public WorkerSourceTaskTest(boolean enableTopicCreation) { + public void setup(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; - } - - @Before - public void setup() { Map workerProps = workerProps(); plugins = new Plugins(workerProps); config = new StandaloneConfig(workerProps); @@ -237,7 +229,7 @@ private Map sourceConnectorPropsWithGroups(String topic) { return props; } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); verifyNoMoreInteractions(statusListener); @@ -267,8 +259,10 @@ private void createWorkerTask(TargetState initialState, Converter keyConverter, retryWithToleranceOperator, statusBackingStore, Runnable::run, Collections::emptyList); } - @Test - public void testStartPaused() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testStartPaused(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); final CountDownLatch pauseLatch = new CountDownLatch(1); createWorkerTask(TargetState.PAUSED); @@ -291,8 +285,10 @@ public void testStartPaused() throws Exception { verifyClose(); } - @Test - public void testPause() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPause(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); AtomicInteger count = new AtomicInteger(0); @@ -330,8 +326,10 @@ public void testPause() throws Exception { verifyClose(); } - @Test - public void testPollsInBackground() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPollsInBackground(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = expectPolls(10); @@ -355,8 +353,10 @@ public void testPollsInBackground() throws Exception { verifyClose(); } - @Test - public void testFailureInPoll() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPoll(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -386,8 +386,10 @@ public void testFailureInPoll() throws Exception { verifyClose(); } - @Test - public void testFailureInPollAfterCancel() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -425,8 +427,10 @@ public void testFailureInPollAfterCancel() throws Exception { } } - @Test - public void testFailureInPollAfterStop() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); final CountDownLatch pollLatch = new CountDownLatch(1); @@ -458,8 +462,10 @@ public void testFailureInPollAfterStop() throws Exception { verifyClose(); } - @Test - public void testPollReturnsNoRecords() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // Test that the task handles an empty list of records createWorkerTask(); @@ -488,8 +494,10 @@ public void testPollReturnsNoRecords() throws Exception { verifyClose(); } - @Test - public void testCommit() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testCommit(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // Test that the task commits properly when prompted createWorkerTask(); @@ -522,8 +530,10 @@ public void testCommit() throws Exception { verifyClose(); } - @Test - public void testCommitFailure() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testCommitFailure(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); // Test that the task commits properly when prompted createWorkerTask(); @@ -556,8 +566,10 @@ public void testCommitFailure() throws Exception { verifyClose(); } - @Test - public void testSendRecordsRetries() { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsRetries(boolean enableTopicCreation) { + setup(enableTopicCreation); createWorkerTask(); // Differentiate only by Kafka partition, so we can reuse conversion expectations @@ -589,8 +601,10 @@ public void testSendRecordsRetries() { assertNull(workerTask.toSend); } - @Test - public void testSendRecordsProducerCallbackFail() { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsProducerCallbackFail(boolean enableTopicCreation) { + setup(enableTopicCreation); createWorkerTask(); SourceRecord record1 = new SourceRecord(PARTITION, OFFSET, "topic", 1, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD); @@ -608,8 +622,10 @@ public void testSendRecordsProducerCallbackFail() { verify(valueConverter, times(2)).fromConnectData(anyString(), any(Headers.class), eq(RECORD_SCHEMA), eq(RECORD)); } - @Test - public void testSendRecordsProducerSendFailsImmediately() { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreation) { + setup(enableTopicCreation); createWorkerTask(); SourceRecord record1 = new SourceRecord(PARTITION, OFFSET, TOPIC, 1, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD); @@ -625,8 +641,10 @@ public void testSendRecordsProducerSendFailsImmediately() { assertThrows(ConnectException.class, () -> workerTask.sendRecords()); } - @Test - public void testSendRecordsTaskCommitRecordFail() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testSendRecordsTaskCommitRecordFail(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTask(); // Differentiate only by Kafka partition, so we can reuse conversion expectations @@ -648,8 +666,10 @@ public void testSendRecordsTaskCommitRecordFail() throws Exception { assertNull(workerTask.toSend); } - @Test - public void testSourceTaskIgnoresProducerException() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testSourceTaskIgnoresProducerException(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); createWorkerTaskWithErrorToleration(); expectTopicCreation(TOPIC); @@ -686,8 +706,10 @@ public void testSourceTaskIgnoresProducerException() throws Exception { assertEquals(0, workerTask.submittedRecords.records.size()); } - @Test - public void testSlowTaskStart() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); final CountDownLatch startupLatch = new CountDownLatch(1); final CountDownLatch finishStartupLatch = new CountDownLatch(1); @@ -722,8 +744,10 @@ public void testSlowTaskStart() throws Exception { verifyClose(); } - @Test - public void testCancel() { + @ParameterizedTest + @MethodSource("parameters") + public void testCancel(boolean enableTopicCreation) { + setup(enableTopicCreation); createWorkerTask(); workerTask.cancel(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java index 859ec64f656a7..665fbf65f72b4 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java @@ -16,6 +16,7 @@ */ package org.apache.kafka.connect.runtime; +import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.runtime.TaskStatus.Listener; @@ -27,13 +28,14 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.apache.kafka.common.utils.MockTime; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.junit.jupiter.MockitoExtension; +import org.mockito.junit.jupiter.MockitoSettings; +import org.mockito.quality.Strictness; import java.util.ArrayList; import java.util.HashMap; @@ -42,15 +44,16 @@ import java.util.concurrent.CountDownLatch; import java.util.function.Supplier; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(MockitoJUnitRunner.StrictStubs.class) +@ExtendWith(MockitoExtension.class) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerTaskTest { private static final Map TASK_PROPS = new HashMap<>(); @@ -68,12 +71,12 @@ public class WorkerTaskTest { @Mock private TransformationChain transformationChain; @Mock private Supplier>> errorReportersSupplier; - @Before + @BeforeEach public void setup() { metrics = new MockConnectMetrics(); } - @After + @AfterEach public void tearDown() { if (metrics != null) metrics.stop(); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 4c5a04533e226..11964af9bd74d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -85,14 +85,11 @@ import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; -import org.apache.kafka.connect.util.ParameterizedTest; import org.apache.kafka.connect.util.SinkUtils; import org.apache.kafka.connect.util.TopicAdmin; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; @@ -148,14 +145,14 @@ import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyCollection; import static org.mockito.ArgumentMatchers.anyLong; @@ -176,7 +173,6 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@RunWith(Parameterized.class) public class WorkerTest { private static final String CONNECTOR_ID = "test-connector"; @@ -238,24 +234,17 @@ public class WorkerTest { private String mockFileProviderTestId; private Map connectorProps; - private final boolean enableTopicCreation; private MockedConstruction sourceTaskMockedConstruction; private MockedConstruction eosSourceTaskMockedConstruction; private MockedConstruction sinkTaskMockedConstruction; private MockitoSession mockitoSession; - @ParameterizedTest.Parameters public static Collection parameters() { return Arrays.asList(false, true); } - public WorkerTest(boolean enableTopicCreation) { - this.enableTopicCreation = enableTopicCreation; - } - - @Before - public void setup() { + public void setup(boolean enableTopicCreation) { // Use strict mode to detect unused mocks mockitoSession = Mockito.mockitoSession() .initMocks(this) @@ -315,7 +304,7 @@ public void setup() { WorkerTest::workerTaskConstructor); } - @After + @AfterEach public void teardown() { // Critical to always close MockedStatics // Ideal would be to use try-with-resources in an individual test, but it introduced a rather large level of @@ -327,8 +316,10 @@ public void teardown() { mockitoSession.finishMocking(); } - @Test - public void testStartAndStopConnector() throws Throwable { + @ParameterizedTest + @MethodSource("parameters") + public void testStartAndStopConnector(boolean enableTopicCreation) throws Throwable { + setup(enableTopicCreation); final String connectorClass = SampleSourceConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -394,8 +385,10 @@ private void mockFileConfigProvider() { .thenReturn(mockFileConfigProvider); } - @Test - public void testStartConnectorFailure() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testStartConnectorFailure(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); final String nonConnectorClass = "java.util.HashMap"; connectorProps.put(CONNECTOR_CLASS_CONFIG, nonConnectorClass); // Bad connector class name @@ -434,8 +427,10 @@ public void testStartConnectorFailure() throws Exception { verify(connectorStatusListener).onFailure(eq(CONNECTOR_ID), any(ConnectException.class)); } - @Test - public void testAddConnectorByAlias() throws Throwable { + @ParameterizedTest + @MethodSource("parameters") + public void testAddConnectorByAlias(boolean enableTopicCreation) throws Throwable { + setup(enableTopicCreation); final String connectorAlias = "SampleSourceConnector"; mockKafkaClusterId(); mockConnectorIsolation(connectorAlias, sinkConnector); @@ -477,8 +472,10 @@ public void testAddConnectorByAlias() throws Throwable { verify(ctx).close(); } - @Test - public void testAddConnectorByShortAlias() throws Throwable { + @ParameterizedTest + @MethodSource("parameters") + public void testAddConnectorByShortAlias(boolean enableTopicCreation) throws Throwable { + setup(enableTopicCreation); final String shortConnectorAlias = "WorkerTest"; mockKafkaClusterId(); @@ -519,8 +516,10 @@ public void testAddConnectorByShortAlias() throws Throwable { verifyExecutorSubmit(); } - @Test - public void testStopInvalidConnector() { + @ParameterizedTest + @MethodSource("parameters") + public void testStopInvalidConnector(boolean enableTopicCreation) { + setup(enableTopicCreation); mockKafkaClusterId(); worker = new Worker(WORKER_ID, new MockTime(), plugins, config, offsetBackingStore, noneConnectorClientConfigOverridePolicy); worker.herder = herder; @@ -532,8 +531,10 @@ public void testStopInvalidConnector() { verifyConverters(); } - @Test - public void testReconfigureConnectorTasks() throws Throwable { + @ParameterizedTest + @MethodSource("parameters") + public void testReconfigureConnectorTasks(boolean enableTopicCreation) throws Throwable { + setup(enableTopicCreation); final String connectorClass = SampleSourceConnector.class.getName(); mockKafkaClusterId(); @@ -606,8 +607,10 @@ public void testReconfigureConnectorTasks() throws Throwable { verify(ctx).close(); } - @Test - public void testAddRemoveSourceTask() { + @ParameterizedTest + @MethodSource("parameters") + public void testAddRemoveSourceTask(boolean enableTopicCreation) { + setup(enableTopicCreation); mockKafkaClusterId(); mockTaskIsolation(SampleSourceConnector.class, TestSourceTask.class, task); mockTaskConverter(ClassLoaderUsage.CURRENT_CLASSLOADER, WorkerConfig.KEY_CONVERTER_CLASS_CONFIG, taskKeyConverter); @@ -658,8 +661,10 @@ public void testAddRemoveSourceTask() { verifyExecutorSubmit(); } - @Test - public void testAddRemoveSinkTask() { + @ParameterizedTest + @MethodSource("parameters") + public void testAddRemoveSinkTask(boolean enableTopicCreation) { + setup(enableTopicCreation); // Most of the other cases use source tasks; we make sure to get code coverage for sink tasks here as well SinkTask task = mock(TestSinkTask.class); mockKafkaClusterId(); @@ -713,8 +718,10 @@ public void testAddRemoveSinkTask() { verifyExecutorSubmit(); } - @Test - public void testAddRemoveExactlyOnceSourceTask() { + @ParameterizedTest + @MethodSource("parameters") + public void testAddRemoveExactlyOnceSourceTask(boolean enableTopicCreation) { + setup(enableTopicCreation); Map workerProps = new HashMap<>(); workerProps.put("key.converter", "org.apache.kafka.connect.json.JsonConverter"); workerProps.put("value.converter", "org.apache.kafka.connect.json.JsonConverter"); @@ -785,8 +792,10 @@ public void testAddRemoveExactlyOnceSourceTask() { verifyExecutorSubmit(); } - @Test - public void testTaskStatusMetricsStatuses() { + @ParameterizedTest + @MethodSource("parameters") + public void testTaskStatusMetricsStatuses(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockStorage(); mockFileConfigProvider(); @@ -867,8 +876,10 @@ public void testTaskStatusMetricsStatuses() { verifyTaskHeaderConverter(); } - @Test - public void testConnectorStatusMetricsGroup_taskStatusCounter() { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorStatusMetricsGroup_taskStatusCounter(boolean enableTopicCreation) { + setup(enableTopicCreation); ConcurrentMap> tasks = new ConcurrentHashMap<>(); tasks.put(new ConnectorTaskId("c1", 0), mock(WorkerSourceTask.class)); tasks.put(new ConnectorTaskId("c1", 1), mock(WorkerSourceTask.class)); @@ -896,8 +907,10 @@ public void testConnectorStatusMetricsGroup_taskStatusCounter() { verifyKafkaClusterId(); } - @Test - public void testStartTaskFailure() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartTaskFailure(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockFileConfigProvider(); @@ -924,8 +937,10 @@ public void testStartTaskFailure() { verifyGenericIsolation(); } - @Test - public void testCleanupTasksOnStop() { + @ParameterizedTest + @MethodSource("parameters") + public void testCleanupTasksOnStop(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockStorage(); mockFileConfigProvider(); @@ -969,8 +984,10 @@ public void testCleanupTasksOnStop() { verifyExecutorSubmit(); } - @Test - public void testConverterOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testConverterOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockStorage(); mockFileConfigProvider(); @@ -1023,8 +1040,10 @@ public void testConverterOverrides() { verifyStorage(); } - @Test - public void testProducerConfigsWithoutOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testProducerConfigsWithoutOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); when(connectorConfig.originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX)).thenReturn(new HashMap<>()); Map expectedConfigs = new HashMap<>(defaultProducerConfigs); expectedConfigs.put("client.id", "connector-producer-job-0"); @@ -1034,8 +1053,10 @@ public void testProducerConfigsWithoutOverrides() { verify(connectorConfig).originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX); } - @Test - public void testProducerConfigsWithOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testProducerConfigsWithOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("producer.acks", "-1"); props.put("producer.linger.ms", "1000"); @@ -1055,8 +1076,10 @@ public void testProducerConfigsWithOverrides() { verify(connectorConfig).originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX); } - @Test - public void testProducerConfigsWithClientOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testProducerConfigsWithClientOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("producer.acks", "-1"); props.put("producer.linger.ms", "1000"); @@ -1081,8 +1104,10 @@ public void testProducerConfigsWithClientOverrides() { verify(connectorConfig).originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX); } - @Test - public void testConsumerConfigsWithoutOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testConsumerConfigsWithoutOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); Map expectedConfigs = new HashMap<>(defaultConsumerConfigs); expectedConfigs.put("group.id", "connect-test-connector"); expectedConfigs.put("client.id", "connector-consumer-job-0"); @@ -1094,8 +1119,10 @@ public void testConsumerConfigsWithoutOverrides() { null, noneConnectorClientConfigOverridePolicy, CLUSTER_ID, ConnectorType.SINK)); } - @Test - public void testConsumerConfigsWithOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testConsumerConfigsWithOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("consumer.group.id", "connect-test"); props.put("consumer.auto.offset.reset", "latest"); @@ -1117,8 +1144,10 @@ public void testConsumerConfigsWithOverrides() { verify(connectorConfig).originalsWithPrefix(ConnectorConfig.CONNECTOR_CLIENT_CONSUMER_OVERRIDES_PREFIX); } - @Test - public void testConsumerConfigsWithClientOverrides() { + @ParameterizedTest + @MethodSource("parameters") + public void testConsumerConfigsWithClientOverrides(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("consumer.auto.offset.reset", "latest"); props.put("consumer.max.poll.records", "5000"); @@ -1143,8 +1172,10 @@ public void testConsumerConfigsWithClientOverrides() { verify(connectorConfig).originalsWithPrefix(ConnectorConfig.CONNECTOR_CLIENT_CONSUMER_OVERRIDES_PREFIX); } - @Test - public void testConsumerConfigsClientOverridesWithNonePolicy() { + @ParameterizedTest + @MethodSource("parameters") + public void testConsumerConfigsClientOverridesWithNonePolicy(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("consumer.auto.offset.reset", "latest"); props.put("consumer.max.poll.records", "5000"); @@ -1160,8 +1191,10 @@ public void testConsumerConfigsClientOverridesWithNonePolicy() { verify(connectorConfig).originalsWithPrefix(ConnectorConfig.CONNECTOR_CLIENT_CONSUMER_OVERRIDES_PREFIX); } - @Test - public void testAdminConfigsClientOverridesWithAllPolicy() { + @ParameterizedTest + @MethodSource("parameters") + public void testAdminConfigsClientOverridesWithAllPolicy(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("admin.client.id", "testid"); props.put("admin.metadata.max.age.ms", "5000"); @@ -1186,8 +1219,10 @@ public void testAdminConfigsClientOverridesWithAllPolicy() { verify(connectorConfig).originalsWithPrefix(CONNECTOR_CLIENT_ADMIN_OVERRIDES_PREFIX); } - @Test - public void testAdminConfigsClientOverridesWithNonePolicy() { + @ParameterizedTest + @MethodSource("parameters") + public void testAdminConfigsClientOverridesWithNonePolicy(boolean enableTopicCreation) { + setup(enableTopicCreation); Map props = new HashMap<>(workerProps); props.put("admin.client.id", "testid"); props.put("admin.metadata.max.age.ms", "5000"); @@ -1201,8 +1236,10 @@ public void testAdminConfigsClientOverridesWithNonePolicy() { verify(connectorConfig).originalsWithPrefix(CONNECTOR_CLIENT_ADMIN_OVERRIDES_PREFIX); } - @Test - public void testRegularSourceOffsetsConsumerConfigs() { + @ParameterizedTest + @MethodSource("parameters") + public void testRegularSourceOffsetsConsumerConfigs(boolean enableTopicCreation) { + setup(enableTopicCreation); final Map connectorConsumerOverrides = new HashMap<>(); when(connectorConfig.originalsWithPrefix(ConnectorConfig.CONNECTOR_CLIENT_CONSUMER_OVERRIDES_PREFIX)).thenReturn(connectorConsumerOverrides); @@ -1240,8 +1277,10 @@ public void testRegularSourceOffsetsConsumerConfigs() { assertEquals("read_uncommitted", consumerConfigs.get(ISOLATION_LEVEL_CONFIG)); } - @Test - public void testExactlyOnceSourceOffsetsConsumerConfigs() { + @ParameterizedTest + @MethodSource("parameters") + public void testExactlyOnceSourceOffsetsConsumerConfigs(boolean enableTopicCreation) { + setup(enableTopicCreation); final Map connectorConsumerOverrides = new HashMap<>(); when(connectorConfig.originalsWithPrefix(ConnectorConfig.CONNECTOR_CLIENT_CONSUMER_OVERRIDES_PREFIX)).thenReturn(connectorConsumerOverrides); @@ -1279,8 +1318,10 @@ public void testExactlyOnceSourceOffsetsConsumerConfigs() { assertEquals("read_committed", consumerConfigs.get(ISOLATION_LEVEL_CONFIG)); } - @Test - public void testExactlyOnceSourceTaskProducerConfigs() { + @ParameterizedTest + @MethodSource("parameters") + public void testExactlyOnceSourceTaskProducerConfigs(boolean enableTopicCreation) { + setup(enableTopicCreation); final Map connectorProducerOverrides = new HashMap<>(); when(connectorConfig.originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX)).thenReturn(connectorProducerOverrides); @@ -1335,8 +1376,10 @@ public void testExactlyOnceSourceTaskProducerConfigs() { assertEquals(transactionalId, producerConfigs.get(TRANSACTIONAL_ID_CONFIG)); } - @Test - public void testOffsetStoreForRegularSourceConnector() { + @ParameterizedTest + @MethodSource("parameters") + public void testOffsetStoreForRegularSourceConnector(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockFileConfigProvider(); @@ -1422,8 +1465,10 @@ public void testOffsetStoreForRegularSourceConnector() { verifyKafkaClusterId(); } - @Test - public void testOffsetStoreForExactlyOnceSourceConnector() { + @ParameterizedTest + @MethodSource("parameters") + public void testOffsetStoreForExactlyOnceSourceConnector(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockFileConfigProvider(); @@ -1509,8 +1554,10 @@ public void testOffsetStoreForExactlyOnceSourceConnector() { verifyKafkaClusterId(); } - @Test - public void testOffsetStoreForRegularSourceTask() { + @ParameterizedTest + @MethodSource("parameters") + public void testOffsetStoreForRegularSourceTask(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockFileConfigProvider(); @@ -1625,8 +1672,10 @@ public void testOffsetStoreForRegularSourceTask() { verifyKafkaClusterId(); } - @Test - public void testOffsetStoreForExactlyOnceSourceTask() { + @ParameterizedTest + @MethodSource("parameters") + public void testOffsetStoreForExactlyOnceSourceTask(boolean enableTopicCreation) { + setup(enableTopicCreation); mockInternalConverters(); mockFileConfigProvider(); @@ -1718,8 +1767,10 @@ public void testOffsetStoreForExactlyOnceSourceTask() { verifyKafkaClusterId(); } - @Test - public void testWorkerMetrics() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testWorkerMetrics(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); mockInternalConverters(); mockFileConfigProvider(); @@ -1749,8 +1800,10 @@ public void testWorkerMetrics() throws Exception { verifyKafkaClusterId(); } - @Test - public void testExecutorServiceShutdown() throws InterruptedException { + @ParameterizedTest + @MethodSource("parameters") + public void testExecutorServiceShutdown(boolean enableTopicCreation) throws InterruptedException { + setup(enableTopicCreation); mockKafkaClusterId(); ExecutorService executorService = mock(ExecutorService.class); doNothing().when(executorService).shutdown(); @@ -1770,8 +1823,10 @@ public void testExecutorServiceShutdown() throws InterruptedException { } - @Test - public void testExecutorServiceShutdownWhenTerminationFails() throws InterruptedException { + @ParameterizedTest + @MethodSource("parameters") + public void testExecutorServiceShutdownWhenTerminationFails(boolean enableTopicCreation) throws InterruptedException { + setup(enableTopicCreation); mockKafkaClusterId(); ExecutorService executorService = mock(ExecutorService.class); doNothing().when(executorService).shutdown(); @@ -1791,8 +1846,10 @@ public void testExecutorServiceShutdownWhenTerminationFails() throws Interrupted } - @Test - public void testExecutorServiceShutdownWhenTerminationThrowsException() throws InterruptedException { + @ParameterizedTest + @MethodSource("parameters") + public void testExecutorServiceShutdownWhenTerminationThrowsException(boolean enableTopicCreation) throws InterruptedException { + setup(enableTopicCreation); mockKafkaClusterId(); ExecutorService executorService = mock(ExecutorService.class); doNothing().when(executorService).shutdown(); @@ -1813,9 +1870,11 @@ public void testExecutorServiceShutdownWhenTerminationThrowsException() throws I verifyNoMoreInteractions(executorService); } - @Test + @ParameterizedTest + @MethodSource("parameters") @SuppressWarnings("unchecked") - public void testZombieFencing() { + public void testZombieFencing(boolean enableTopicCreation) { + setup(enableTopicCreation); Admin admin = mock(Admin.class); AtomicReference> adminConfig = new AtomicReference<>(); Function, Admin> mockAdminConstructor = actualAdminConfig -> { @@ -1845,17 +1904,19 @@ public void testZombieFencing() { assertEquals(expectedZombieFenceFuture, actualZombieFenceFuture); assertNotNull(adminConfig.get()); - assertEquals("Admin should be configured with user-specified overrides", - "4761", - adminConfig.get().get(RETRY_BACKOFF_MS_CONFIG) + assertEquals("4761", + adminConfig.get().get(RETRY_BACKOFF_MS_CONFIG), + "Admin should be configured with user-specified overrides" ); verifyKafkaClusterId(); verifyGenericIsolation(); } - @Test - public void testGetSinkConnectorOffsets() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testGetSinkConnectorOffsets(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); @@ -1881,8 +1942,10 @@ public void testGetSinkConnectorOffsets() throws Exception { verifyKafkaClusterId(); } - @Test - public void testGetSinkConnectorOffsetsAdminClientSynchronousError() { + @ParameterizedTest + @MethodSource("parameters") + public void testGetSinkConnectorOffsetsAdminClientSynchronousError(boolean enableTopicCreation) { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); @@ -1905,8 +1968,10 @@ public void testGetSinkConnectorOffsetsAdminClientSynchronousError() { verifyKafkaClusterId(); } - @Test - public void testGetSinkConnectorOffsetsAdminClientAsynchronousError() { + @ParameterizedTest + @MethodSource("parameters") + public void testGetSinkConnectorOffsetsAdminClientAsynchronousError(boolean enableTopicCreation) { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); @@ -1950,8 +2015,10 @@ private void mockAdminListConsumerGroupOffsets(Admin admin, Map, Map> offsets = Collections.singletonMap( Collections.singletonMap("filename", "/path/to/filename"), Collections.singletonMap("position", 20) @@ -2144,8 +2221,10 @@ public void testNormalizeSourceConnectorOffsets() throws Exception { assertInstanceOf(Long.class, normalizedOffsets.values().iterator().next().get("position")); } - @Test - public void testAlterOffsetsSinkConnectorNoDeletes() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetsSinkConnectorNoDeletes(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); @SuppressWarnings("unchecked") ArgumentCaptor> alterOffsetsMapCapture = ArgumentCaptor.forClass(Map.class); Map, Map> partitionOffsets = new HashMap<>(); @@ -2166,8 +2245,10 @@ public void testAlterOffsetsSinkConnectorNoDeletes() throws Exception { assertEquals(100, alterOffsetsMapCapture.getValue().get(new TopicPartition("test_topic", 20)).offset()); } - @Test - public void testAlterOffsetSinkConnectorOnlyDeletes() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetSinkConnectorOnlyDeletes(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); @SuppressWarnings("unchecked") ArgumentCaptor> deleteOffsetsSetCapture = ArgumentCaptor.forClass(Set.class); Map, Map> partitionOffsets = new HashMap<>(); @@ -2191,8 +2272,10 @@ public void testAlterOffsetSinkConnectorOnlyDeletes() throws Exception { assertEquals(expectedTopicPartitionsForOffsetDelete, deleteOffsetsSetCapture.getValue()); } - @Test - public void testAlterOffsetsSinkConnectorAltersAndDeletes() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetsSinkConnectorAltersAndDeletes(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); @SuppressWarnings("unchecked") ArgumentCaptor> alterOffsetsMapCapture = ArgumentCaptor.forClass(Map.class); @SuppressWarnings("unchecked") @@ -2260,8 +2343,10 @@ private void alterOffsetsSinkConnector(Map, Map> parti verifyKafkaClusterId(); } - @Test - public void testAlterOffsetsSinkConnectorAlterOffsetsError() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetsSinkConnectorAlterOffsetsError(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2299,8 +2384,10 @@ public void testAlterOffsetsSinkConnectorAlterOffsetsError() throws Exception { verifyKafkaClusterId(); } - @Test - public void testAlterOffsetsSinkConnectorDeleteOffsetsError() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetsSinkConnectorDeleteOffsetsError(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2348,8 +2435,10 @@ public void testAlterOffsetsSinkConnectorDeleteOffsetsError() throws Exception { verifyKafkaClusterId(); } - @Test - public void testAlterOffsetsSinkConnectorSynchronousError() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testAlterOffsetsSinkConnectorSynchronousError(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2383,9 +2472,11 @@ public void testAlterOffsetsSinkConnectorSynchronousError() throws Exception { verifyKafkaClusterId(); } - @Test + @ParameterizedTest + @MethodSource("parameters") @SuppressWarnings("unchecked") - public void testResetOffsetsSourceConnectorExactlyOnceSupportEnabled() throws Exception { + public void testResetOffsetsSourceConnectorExactlyOnceSupportEnabled(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); Map workerProps = new HashMap<>(this.workerProps); workerProps.put("exactly.once.source.support", "enabled"); workerProps.put("bootstrap.servers", "localhost:9092"); @@ -2432,8 +2523,10 @@ public void testResetOffsetsSourceConnectorExactlyOnceSupportEnabled() throws Ex verifyKafkaClusterId(); } - @Test - public void testResetOffsetsSinkConnector() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testResetOffsetsSinkConnector(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2473,8 +2566,10 @@ public void testResetOffsetsSinkConnector() throws Exception { verifyKafkaClusterId(); } - @Test - public void testResetOffsetsSinkConnectorDeleteConsumerGroupError() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testResetOffsetsSinkConnectorDeleteConsumerGroupError(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2507,9 +2602,11 @@ public void testResetOffsetsSinkConnectorDeleteConsumerGroupError() throws Excep verifyKafkaClusterId(); } - @Test + @ParameterizedTest + @MethodSource("parameters") @SuppressWarnings("unchecked") - public void testModifySourceConnectorOffsetsTimeout() throws Exception { + public void testModifySourceConnectorOffsetsTimeout(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); Time time = new MockTime(); mockInternalConverters(); @@ -2542,8 +2639,10 @@ public void testModifySourceConnectorOffsetsTimeout() throws Exception { verifyKafkaClusterId(); } - @Test - public void testModifyOffsetsSinkConnectorTimeout() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testModifyOffsetsSinkConnectorTimeout(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); mockKafkaClusterId(); String connectorClass = SampleSinkConnector.class.getName(); connectorProps.put(CONNECTOR_CLASS_CONFIG, connectorClass); @@ -2572,13 +2671,17 @@ public void testModifyOffsetsSinkConnectorTimeout() throws Exception { verifyKafkaClusterId(); } - @Test - public void testConnectorGeneratesTooManyTasksButMaxNotEnforced() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorGeneratesTooManyTasksButMaxNotEnforced(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorGeneratesTooManyTasks(false); } - @Test - public void testConnectorGeneratesTooManyTasksAndMaxEnforced() throws Exception { + @ParameterizedTest + @MethodSource("parameters") + public void testConnectorGeneratesTooManyTasksAndMaxEnforced(boolean enableTopicCreation) throws Exception { + setup(enableTopicCreation); testConnectorGeneratesTooManyTasks(true); } @@ -2689,13 +2792,17 @@ private void testConnectorGeneratesTooManyTasks(boolean enforced) throws Excepti worker.stop(); } - @Test - public void testStartTaskWithTooManyTaskConfigsButMaxNotEnforced() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartTaskWithTooManyTaskConfigsButMaxNotEnforced(boolean enableTopicCreation) { + setup(enableTopicCreation); testStartTaskWithTooManyTaskConfigs(false); } - @Test - public void testStartTaskWithTooManyTaskConfigsAndMaxEnforced() { + @ParameterizedTest + @MethodSource("parameters") + public void testStartTaskWithTooManyTaskConfigsAndMaxEnforced(boolean enableTopicCreation) { + setup(enableTopicCreation); testStartTaskWithTooManyTaskConfigs(true); } @@ -2751,11 +2858,8 @@ private void testStartTaskWithTooManyTaskConfigs(boolean enforced) { ArgumentCaptor failureCaptor = ArgumentCaptor.forClass(Throwable.class); verify(taskStatusListener, times(1)).onFailure(eq(TASK_ID), failureCaptor.capture()); - assertTrue( - "Expected task start exception to be TooManyTasksException, but was " - + failureCaptor.getValue().getClass() + " instead", - failureCaptor.getValue() instanceof TooManyTasksException - ); + assertInstanceOf(TooManyTasksException.class, failureCaptor.getValue(), + "Expected task start exception to be TooManyTasksException, but was " + failureCaptor.getValue().getClass() + " instead"); tasksMaxExceededMessage = failureCaptor.getValue().getMessage(); } else { @@ -2788,10 +2892,10 @@ private void assertTasksMaxExceededMessage(String connector, int numTasks, int m + numTasks + " tasks, which is greater than " + maxTasks; assertTrue( + message.startsWith(expectedPrefix), "Warning/exception message '" - + message + "' did not start with the expected prefix '" - + expectedPrefix + "'", - message.startsWith(expectedPrefix) + + message + "' did not start with the expected prefix '" + + expectedPrefix + "'" ); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java index 6101dc48c6b11..f85e7e9bb0b04 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java @@ -16,10 +16,10 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.util.ConnectorTaskId; import java.util.AbstractMap.SimpleEntry; @@ -33,8 +33,8 @@ import static org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.WorkerLoad; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; public class WorkerTestUtils { @@ -176,29 +176,30 @@ public static void assertAssignment(boolean expectFailed, int expectedRevokedTaskNum, int expectedDelay, ExtendedAssignment assignment) { - assertNotNull("Assignment can't be null", assignment); + assertNotNull(assignment, "Assignment can't be null"); - assertEquals("Wrong status in " + assignment, expectFailed, assignment.failed()); + assertEquals(expectFailed, assignment.failed(), "Wrong status in " + assignment); - assertEquals("Wrong leader in " + assignment, expectedLeader, assignment.leader()); + assertEquals(expectedLeader, assignment.leader(), "Wrong leader in " + assignment); - assertEquals("Wrong leaderUrl in " + assignment, expectedLeaderUrl(expectedLeader), - assignment.leaderUrl()); + assertEquals(expectedLeaderUrl(expectedLeader), + assignment.leaderUrl(), "Wrong leaderUrl in " + assignment); - assertEquals("Wrong offset in " + assignment, expectedOffset, assignment.offset()); + assertEquals(expectedOffset, assignment.offset(), "Wrong offset in " + assignment); assertThat("Wrong set of assigned connectors in " + assignment, assignment.connectors(), is(expectedAssignedConnectors)); - assertEquals("Wrong number of assigned tasks in " + assignment, - expectedAssignedTaskNum, assignment.tasks().size()); + assertEquals(expectedAssignedTaskNum, assignment.tasks().size(), + "Wrong number of assigned tasks in " + assignment); assertThat("Wrong set of revoked connectors in " + assignment, assignment.revokedConnectors(), is(expectedRevokedConnectors)); - assertEquals("Wrong number of revoked tasks in " + assignment, - expectedRevokedTaskNum, assignment.revokedTasks().size()); + assertEquals(expectedRevokedTaskNum, assignment.revokedTasks().size(), + "Wrong number of revoked tasks in " + assignment); - assertEquals("Wrong rebalance delay in " + assignment, expectedDelay, assignment.delay()); + assertEquals(expectedDelay, assignment.delay(), + "Wrong rebalance delay in " + assignment); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java index 3bc2b2155d1f1..6906afa47012c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java @@ -17,11 +17,11 @@ package org.apache.kafka.connect.runtime; import org.apache.kafka.connect.source.SourceRecord; -import org.junit.Test; +import org.junit.jupiter.api.Test; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; public class WorkerTransactionContextTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java index 48b7973fdc22e..751846ce462b9 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java @@ -24,8 +24,8 @@ import org.apache.kafka.connect.runtime.TargetState; import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.util.ConnectUtils; import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectUtils; import org.apache.kafka.connect.util.ConnectorTaskId; import org.junit.Before; import org.junit.Test; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java index 1911eb10b1303..5d728a62032e2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java @@ -68,8 +68,8 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java index 4f20ccdeaae7e..9126b2ae996af 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java @@ -34,8 +34,8 @@ import java.util.Set; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; @RunWith(Parameterized.class) public class PluginScannerTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java index 8a637beee5ec0..c08c597f38636 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java @@ -17,15 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.nio.file.Path; -import java.util.Arrays; -import java.util.Collections; -import java.util.Map.Entry; - import org.apache.kafka.common.Configurable; import org.apache.kafka.common.config.AbstractConfig; import org.apache.kafka.common.config.ConfigDef; @@ -33,10 +24,10 @@ import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.components.Versioned; +import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.connector.policy.AllConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.converters.ByteArrayConverter; -import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; @@ -57,9 +48,17 @@ import org.junit.Before; import org.junit.Test; +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.stream.Collectors; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java index e8ba9153bc09b..cbf1be866a20e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java @@ -17,7 +17,19 @@ package org.apache.kafka.connect.runtime.isolation; -import static org.junit.Assert.fail; +import org.apache.kafka.common.config.AbstractConfig; +import org.apache.kafka.common.config.ConfigDef; +import org.apache.kafka.common.config.ConfigDef.Importance; +import org.apache.kafka.common.config.ConfigDef.Type; +import org.apache.kafka.connect.runtime.WorkerConfig; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import java.lang.management.LockInfo; import java.lang.management.ManagementFactory; @@ -40,19 +52,8 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; import java.util.stream.Collectors; -import org.apache.kafka.common.config.AbstractConfig; -import org.apache.kafka.common.config.ConfigDef; -import org.apache.kafka.common.config.ConfigDef.Importance; -import org.apache.kafka.common.config.ConfigDef.Type; -import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.mockito.Mockito; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; + +import static org.junit.Assert.fail; public class SynchronizationTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java index 2bc03b2b7c25f..75e4c82f489bc 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java @@ -17,6 +17,13 @@ package org.apache.kafka.connect.runtime.isolation; +import org.apache.kafka.connect.components.Versioned; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; @@ -40,13 +47,6 @@ import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.stream.Collectors; -import javax.tools.JavaCompiler; -import javax.tools.StandardJavaFileManager; -import javax.tools.ToolProvider; - -import org.apache.kafka.connect.components.Versioned; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * Utility class for constructing test plugins for Connect. diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java index 82fab1313067e..e15d06cc31d29 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java @@ -30,7 +30,6 @@ import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.ws.rs.core.HttpHeaders; - import java.security.NoSuchAlgorithmException; import java.util.Base64; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java index 3c104e0e9307d..d611243a3b10f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java @@ -49,14 +49,14 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java index 589dfb29bd0f5..091d32bfb1214 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java @@ -45,8 +45,8 @@ import org.apache.kafka.connect.runtime.rest.entities.ConfigInfos; import org.apache.kafka.connect.runtime.rest.entities.ConfigKeyInfo; import org.apache.kafka.connect.runtime.rest.entities.ConfigValueInfo; -import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.tools.MockSinkConnector; @@ -88,10 +88,10 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 959e498931096..602d0c5a8521d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -41,20 +41,20 @@ import org.apache.kafka.connect.runtime.WorkerConfigTransformer; import org.apache.kafka.connect.runtime.distributed.SampleConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.runtime.isolation.LoaderSwap; -import org.apache.kafka.connect.runtime.rest.entities.Message; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.ConnectorInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.Message; import org.apache.kafka.connect.runtime.rest.entities.TaskInfo; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceTask; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.MemoryConfigBackingStore; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.Callback; From ffdc6456b9fa9153b9f827ce06cac0c38e5acd77 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sat, 15 Jun 2024 15:03:23 +0800 Subject: [PATCH 03/18] upgrade all junit 4 to junit5 in connect:runtime --- .../org/apache/kafka/connect/runtime/AbstractHerderTest.java | 2 +- .../apache/kafka/connect/runtime/TransformationStageTest.java | 2 +- .../apache/kafka/connect/runtime/WorkerMetricsGroupTest.java | 2 +- .../kafka/connect/runtime/WorkerSinkTaskThreadedTest.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index 0c0318ced8435..8bbab4444a866 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -101,7 +101,7 @@ import static org.mockito.Mockito.withSettings; @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@MockitoSettings(strictness = Strictness.LENIENT) public class AbstractHerderTest { private static final String CONN1 = "sourceA"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index 8ccb190050d44..d6d7c6ec22bac 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -30,7 +30,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@MockitoSettings(strictness = Strictness.LENIENT) public class TransformationStageTest { private final SourceRecord initial = new SourceRecord(singletonMap("initial", 1), null, null, null, null); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index a909b79fb133e..7ad7ae422973b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -41,7 +41,7 @@ import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@MockitoSettings(strictness = Strictness.WARN) public class WorkerMetricsGroupTest { private final String connector = "org.FakeConnector"; private final ConnectorTaskId task = new ConnectorTaskId(connector, 0); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index 54a3dea59eece..8742ecd34ddc6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -87,7 +87,7 @@ @SuppressWarnings("unchecked") @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@MockitoSettings(strictness = Strictness.WARN) public class WorkerSinkTaskThreadedTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values From f85e837fd920971de4e64c44453adad3e88c3644 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sat, 15 Jun 2024 15:07:52 +0800 Subject: [PATCH 04/18] revert other dir --- .../ConnectProtocolCompatibilityTest.java | 9 +- .../distributed/DistributedConfigTest.java | 33 +++-- .../distributed/DistributedHerderTest.java | 122 +++++++++--------- .../IncrementalCooperativeAssignorTest.java | 2 +- .../WorkerCoordinatorIncrementalTest.java | 35 ++--- .../distributed/WorkerCoordinatorTest.java | 2 +- .../distributed/WorkerGroupMemberTest.java | 32 +++-- .../runtime/errors/ErrorReporterTest.java | 28 ++-- .../RetryWithToleranceOperatorTest.java | 36 +++--- .../WorkerErrantRecordReporterTest.java | 20 ++- .../health/ConnectClusterStateImplTest.java | 26 ++-- .../isolation/DelegatingClassLoaderTest.java | 18 ++- .../runtime/isolation/PluginDescTest.java | 11 +- .../runtime/isolation/PluginScannerTest.java | 2 +- .../runtime/isolation/PluginUtilsTest.java | 67 +++++----- .../runtime/isolation/PluginsTest.java | 19 +-- .../isolation/SynchronizationTest.java | 29 ++--- .../runtime/isolation/TestPlugins.java | 14 +- .../runtime/rest/ConnectRestServerTest.java | 92 +++++++------ .../rest/InternalRequestSignatureTest.java | 23 ++-- .../connect/runtime/rest/RestClientTest.java | 43 +++--- .../runtime/rest/RestServerConfigTest.java | 7 +- .../rest/entities/ConnectorOffsetsTest.java | 3 +- .../rest/entities/ConnectorTypeTest.java | 2 +- .../entities/CreateConnectorRequestTest.java | 5 +- .../runtime/rest/entities/PluginInfoTest.java | 2 +- .../ConnectorPluginsResourceTest.java | 52 ++++---- .../resources/ConnectorsResourceTest.java | 67 +++++----- .../InternalConnectResourceTest.java | 34 +++-- .../rest/resources/LoggingResourceTest.java | 26 ++-- .../rest/resources/RootResourceTest.java | 15 +-- .../runtime/rest/util/SSLUtilsTest.java | 93 +++++++------ .../standalone/StandaloneConfigTest.java | 9 +- .../standalone/StandaloneHerderTest.java | 48 ++++--- 34 files changed, 497 insertions(+), 529 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java index d36b387206c5b..38084383e2951 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/ConnectProtocolCompatibilityTest.java @@ -16,16 +16,17 @@ */ package org.apache.kafka.connect.runtime.distributed; +import org.apache.kafka.connect.util.ConnectorTaskId; +import org.junit.Test; + import java.nio.ByteBuffer; import java.util.Arrays; import java.util.Collections; -import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V2; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; public class ConnectProtocolCompatibilityTest { private static final String LEADER = "leader"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java index 59af7b9282720..c7fc0d8299a11 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedConfigTest.java @@ -17,6 +17,13 @@ package org.apache.kafka.connect.runtime.distributed; +import org.apache.kafka.clients.CommonClientConfigs; +import org.apache.kafka.common.config.ConfigException; +import org.apache.kafka.common.security.auth.SecurityProtocol; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; + import javax.crypto.KeyGenerator; import javax.crypto.Mac; import java.security.InvalidParameterException; @@ -30,33 +37,24 @@ import java.util.Locale; import java.util.Map; import java.util.Set; -import org.apache.kafka.clients.CommonClientConfigs; -import org.apache.kafka.common.config.ConfigException; -import org.apache.kafka.common.security.auth.SecurityProtocol; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.EXACTLY_ONCE_SOURCE_SUPPORT_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.GROUP_ID_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_KEY_GENERATION_ALGORITHM_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_SIGNATURE_ALGORITHM_CONFIG; import static org.apache.kafka.connect.runtime.distributed.DistributedConfig.INTER_WORKER_VERIFICATION_ALGORITHMS_CONFIG; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -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 static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class DistributedConfigTest { public Map configs() { @@ -150,8 +148,7 @@ private void testSupportedAlgorithms(String type, String... expectedAlgorithms) Set supportedAlgorithms = DistributedConfig.supportedAlgorithms(type); Set unsupportedAlgorithms = new HashSet<>(Arrays.asList(expectedAlgorithms)); unsupportedAlgorithms.removeAll(supportedAlgorithms); - assertEquals(Collections.emptySet(), unsupportedAlgorithms, - type + " algorithms were found that should be supported by this JVM but are not"); + assertEquals(type + " algorithms were found that should be supported by this JVM but are not", Collections.emptySet(), unsupportedAlgorithms); } @Test diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java index 851764b73b4af..028e5202bf529 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java @@ -16,32 +16,6 @@ */ package org.apache.kafka.connect.runtime.distributed; -import javax.crypto.SecretKey; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.AbstractExecutorService; -import java.util.concurrent.Callable; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.RejectedExecutionException; -import java.util.concurrent.ThreadPoolExecutor; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; -import java.util.stream.IntStream; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.KafkaException; import org.apache.kafka.common.KafkaFuture; @@ -98,17 +72,42 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; import org.apache.kafka.connect.util.Stage; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.mockito.stubbing.Answer; +import javax.crypto.SecretKey; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.AbstractExecutorService; +import java.util.concurrent.Callable; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + import static java.util.Collections.singletonList; import static javax.ws.rs.core.Response.Status.FORBIDDEN; import static javax.ws.rs.core.Response.Status.SERVICE_UNAVAILABLE; @@ -123,12 +122,12 @@ import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V2; import static org.apache.kafka.connect.source.SourceTask.TransactionBoundary.CONNECTOR; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.junit.jupiter.api.Assertions.assertInstanceOf; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.junit.jupiter.api.Assertions.fail; import static org.mockito.AdditionalMatchers.leq; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyLong; @@ -148,8 +147,7 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) @SuppressWarnings("unchecked") public class DistributedHerderTest { private static final Map HERDER_CONFIG = new HashMap<>(); @@ -303,7 +301,7 @@ public class DistributedHerderTest { private final SampleConnectorClientConfigOverridePolicy noneConnectorClientConfigOverridePolicy = new SampleConnectorClientConfigOverridePolicy(); - @BeforeEach + @Before public void setUp() throws Exception { time = new MockTime(); metrics = new MockConnectMetrics(time); @@ -325,7 +323,7 @@ public void setUp() throws Exception { when(herder.connectorType(anyMap())).thenReturn(ConnectorType.SOURCE); } - @AfterEach + @After public void tearDown() { if (metrics != null) metrics.stop(); if (herderExecutor != null) { @@ -1815,7 +1813,7 @@ public void testStopConnector() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); + assertTrue("Callback should already have been invoked by herder", cb.isDone()); cb.get(0, TimeUnit.MILLISECONDS); verifyNoMoreInteractions(worker, member, configBackingStore, statusBackingStore); @@ -1842,11 +1840,11 @@ public void testStopConnectorNotLeader() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); + assertTrue("Callback should already have been invoked by herder", cb.isDone()); ExecutionException e = assertThrows( + "Should not be able to handle request to stop connector when not leader", ExecutionException.class, - () -> cb.get(0, TimeUnit.SECONDS), - "Should not be able to handle request to stop connector when not leader" + () -> cb.get(0, TimeUnit.SECONDS) ); assertInstanceOf(NotLeaderException.class, e.getCause()); @@ -1882,11 +1880,11 @@ public void testStopConnectorFailToWriteTaskConfigs() throws Exception { herder.stopConnector(CONN1, cb); // external request herder.tick(); // continue - assertTrue(cb.isDone(), "Callback should already have been invoked by herder"); + assertTrue("Callback should already have been invoked by herder", cb.isDone()); ExecutionException e = assertThrows( + "Should not be able to handle request to stop connector when not leader", ExecutionException.class, - () -> cb.get(0, TimeUnit.SECONDS), - "Should not be able to handle request to stop connector when not leader" + () -> cb.get(0, TimeUnit.SECONDS) ); assertEquals(e.getCause(), taskConfigsWriteException); @@ -3617,8 +3615,8 @@ public void testExactlyOnceSourceSupportValidationOnUnknownConnector() { List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains("The connector does not implement the API required for preflight validation of exactly-once source support."), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains("The connector does not implement the API required for preflight validation of exactly-once source support.")); assertEquals(1, errors.size()); } @@ -3638,8 +3636,8 @@ public void testExactlyOnceSourceSupportValidationHandlesConnectorErrorsGraceful List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains(errorMessage), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains(errorMessage)); assertEquals(1, errors.size()); } @@ -3674,8 +3672,8 @@ public void testExactlyOnceSourceSupportValidationHandlesInvalidValuesGracefully List errors = validatedConfigs.get(SourceConnectorConfig.EXACTLY_ONCE_SUPPORT_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains("String must be one of (case insensitive): "), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains("String must be one of (case insensitive): ")); assertEquals(1, errors.size()); } @@ -3712,8 +3710,8 @@ public void testConnectorTransactionBoundaryValidationOnUnsupportedConnector() { List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains("The connector does not support connector-defined transaction boundaries with the given configuration."), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains("The connector does not support connector-defined transaction boundaries with the given configuration.")); assertEquals(1, errors.size()); } @@ -3733,8 +3731,8 @@ public void testConnectorTransactionBoundaryValidationHandlesConnectorErrorsGrac List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains(errorMessage), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains(errorMessage)); assertEquals(1, errors.size()); } @@ -3752,8 +3750,8 @@ public void testConnectorTransactionBoundaryValidationHandlesInvalidValuesGracef List errors = validatedConfigs.get(SourceConnectorConfig.TRANSACTION_BOUNDARY_CONFIG).errorMessages(); assertFalse(errors.isEmpty()); assertTrue( - errors.get(0).contains("String must be one of (case insensitive): "), - "Error message did not contain expected text: " + errors.get(0)); + "Error message did not contain expected text: " + errors.get(0), + errors.get(0).contains("String must be one of (case insensitive): ")); assertEquals(1, errors.size()); } @@ -4211,7 +4209,7 @@ private void startBackgroundHerder() { private void stopBackgroundHerder() throws Exception { herder.stop(); herderExecutor.shutdown(); - assertTrue(herderExecutor.awaitTermination(10, TimeUnit.SECONDS), "herder thread did not finish in time"); + assertTrue("herder thread did not finish in time", herderExecutor.awaitTermination(10, TimeUnit.SECONDS)); herderFuture.get(); assertTrue(noneConnectorClientConfigOverridePolicy.isClosed()); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java index 751846ce462b9..48b7973fdc22e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java @@ -24,8 +24,8 @@ import org.apache.kafka.connect.runtime.TargetState; import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.util.ConnectUtils; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.util.ConnectorTaskId; import org.junit.Before; import org.junit.Test; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java index 6b877ac04e138..ca5c3bdc6f833 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorIncrementalTest.java @@ -16,15 +16,6 @@ */ package org.apache.kafka.connect.runtime.distributed; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; import org.apache.kafka.clients.GroupRebalanceConfig; import org.apache.kafka.clients.Metadata; import org.apache.kafka.clients.MockClient; @@ -38,10 +29,10 @@ import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.KafkaConfigBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; +import org.junit.After; +import org.junit.Before; import org.junit.Rule; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; @@ -49,6 +40,16 @@ import org.mockito.junit.MockitoRule; import org.mockito.quality.Strictness; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; + import static org.apache.kafka.common.message.JoinGroupRequestData.JoinGroupRequestProtocol; import static org.apache.kafka.common.message.JoinGroupRequestData.JoinGroupRequestProtocolCollection; import static org.apache.kafka.common.message.JoinGroupResponseData.JoinGroupResponseMember; @@ -59,9 +60,9 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.SESSIONED; import static org.apache.kafka.connect.runtime.distributed.IncrementalCooperativeConnectProtocol.CONNECT_PROTOCOL_V1; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertTrue; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.times; @@ -126,7 +127,7 @@ public static Iterable mode() { @Parameter(1) public int expectedMetadataSize; - @BeforeEach + @Before public void setup() { LogContext loggerFactory = new LogContext(); @@ -174,7 +175,7 @@ public void setup() { configState1 = clusterConfigState(offset, 2, 4); } - @AfterEach + @After public void teardown() { this.metrics.close(); verifyNoMoreInteractions(configStorage); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java index 5d728a62032e2..1911eb10b1303 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java @@ -68,8 +68,8 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java index 411c2a297d739..77d70d8fd9a7b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerGroupMemberTest.java @@ -16,11 +16,6 @@ */ package org.apache.kafka.connect.runtime.distributed; -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.lang.management.ManagementFactory; -import java.util.HashMap; -import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.JmxReporter; @@ -31,23 +26,26 @@ import org.apache.kafka.connect.runtime.MockConnectMetrics; import org.apache.kafka.connect.runtime.WorkerConfig; import org.apache.kafka.connect.storage.ConfigBackingStore; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; + +import javax.management.MBeanServer; +import javax.management.ObjectName; +import java.lang.management.ManagementFactory; +import java.util.HashMap; +import java.util.Map; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class WorkerGroupMemberTest { @Mock private ConfigBackingStore configBackingStore; @@ -85,8 +83,8 @@ public void testMetrics() throws Exception { foundJmxReporter = true; } } - assertTrue(foundMockReporter, "Failed to find MockMetricsReporter"); - assertTrue(foundJmxReporter, "Failed to find JmxReporter"); + assertTrue("Failed to find MockMetricsReporter", foundMockReporter); + assertTrue("Failed to find JmxReporter", foundJmxReporter); MetricName name = member.metrics().metricName("test.avg", "grp1"); member.metrics().addMetric(name, new Avg()); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java index 9506a94993df5..e0018a13e9544 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/ErrorReporterTest.java @@ -16,10 +16,6 @@ */ package org.apache.kafka.connect.runtime.errors; -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.Future; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; @@ -35,14 +31,17 @@ import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Future; import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; @@ -68,8 +67,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ErrorReporterTest { private static final String TOPIC = "test-topic"; @@ -88,13 +86,13 @@ public class ErrorReporterTest { private ErrorHandlingMetrics errorHandlingMetrics; private MockConnectMetrics metrics; - @BeforeEach + @Before public void setup() { metrics = new MockConnectMetrics(); errorHandlingMetrics = new ErrorHandlingMetrics(new ConnectorTaskId("connector-", 1), metrics); } - @AfterEach + @After public void tearDown() { if (metrics != null) { metrics.stop(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java index dfa6173e043e3..66d2e335599e2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/RetryWithToleranceOperatorTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime.errors; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.stream.Collectors; -import java.util.stream.IntStream; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.producer.RecordMetadata; @@ -47,14 +35,25 @@ import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.mockito.stubbing.OngoingStubbing; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + import static java.util.Collections.emptyMap; import static java.util.Collections.singletonMap; import static org.apache.kafka.common.utils.Time.SYSTEM; @@ -81,8 +80,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class RetryWithToleranceOperatorTest { private static final Map PROPERTIES = new HashMap() {{ diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java index 07d941380bba0..e84c832f6442b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/errors/WorkerErrantRecordReporterTest.java @@ -17,10 +17,6 @@ package org.apache.kafka.connect.runtime.errors; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.concurrent.CompletableFuture; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.common.TopicPartition; import org.apache.kafka.common.utils.Time; @@ -29,12 +25,15 @@ import org.apache.kafka.connect.runtime.InternalSinkRecord; import org.apache.kafka.connect.storage.Converter; import org.apache.kafka.connect.storage.HeaderConverter; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; @@ -43,8 +42,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class WorkerErrantRecordReporterTest { private WorkerErrantRecordReporter reporter; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java index 24fdb41db5c2c..16c7f42831180 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/health/ConnectClusterStateImplTest.java @@ -16,23 +16,22 @@ */ package org.apache.kafka.connect.runtime.health; +import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.Herder; +import org.apache.kafka.connect.util.Callback; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; + import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; -import org.apache.kafka.connect.errors.ConnectException; -import org.apache.kafka.connect.runtime.Herder; -import org.apache.kafka.connect.util.Callback; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotSame; @@ -40,8 +39,7 @@ import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doAnswer; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ConnectClusterStateImplTest { protected static final String KAFKA_CLUSTER_ID = "franzwashere"; @@ -51,7 +49,7 @@ public class ConnectClusterStateImplTest { protected long herderRequestTimeoutMs = TimeUnit.SECONDS.toMillis(10); protected Collection expectedConnectors; - @BeforeEach + @Before public void setUp() { expectedConnectors = Arrays.asList("sink1", "source1", "source2"); connectClusterState = new ConnectClusterStateImpl( diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java index 9d14f7adea6d5..70303e552af96 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/DelegatingClassLoaderTest.java @@ -16,26 +16,24 @@ */ package org.apache.kafka.connect.runtime.isolation; +import org.apache.kafka.connect.sink.SinkConnector; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.junit.MockitoJUnitRunner; + import java.net.MalformedURLException; import java.net.URL; import java.util.Collections; import java.util.SortedSet; import java.util.TreeSet; -import org.apache.kafka.connect.sink.SinkConnector; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class DelegatingClassLoaderTest { public PluginClassLoader parent; @@ -57,7 +55,7 @@ public class DelegatingClassLoaderTest { } } - @BeforeEach + @Before @SuppressWarnings({"unchecked"}) public void setUp() { parent = mock(PluginClassLoader.class); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java index f05193b2b4492..12eac8c94de06 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginDescTest.java @@ -17,8 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import java.net.URL; -import java.nio.file.Paths; import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.config.provider.FileConfigProvider; import org.apache.kafka.connect.json.JsonConverter; @@ -28,8 +26,11 @@ import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.Before; +import org.junit.Test; + +import java.net.URL; +import java.nio.file.Paths; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; @@ -47,7 +48,7 @@ public class PluginDescTest { private PluginClassLoader pluginLoader; private PluginClassLoader otherPluginLoader; - @BeforeEach + @Before public void setUp() throws Exception { // Fairly simple use case, thus no need to create a random directory here yet. URL location = Paths.get("/tmp").toUri().toURL(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java index 9126b2ae996af..4f20ccdeaae7e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java @@ -34,8 +34,8 @@ import java.util.Set; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; @RunWith(Parameterized.class) public class PluginScannerTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java index a0aa90a4cbb30..f5dc83e6a8917 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginUtilsTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime.isolation; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.SortedSet; -import java.util.TreeSet; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; @@ -40,21 +28,34 @@ import org.apache.kafka.connect.tools.MockSinkConnector; import org.apache.kafka.connect.tools.MockSourceConnector; import org.apache.kafka.connect.transforms.Transformation; +import org.junit.Before; import org.junit.Rule; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; +import org.junit.Test; import org.junit.rules.TemporaryFolder; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.SortedSet; +import java.util.TreeSet; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; public class PluginUtilsTest { @Rule public TemporaryFolder rootDir = new TemporaryFolder(); private Path pluginPath; - @BeforeEach + @Before public void setUp() throws Exception { pluginPath = rootDir.newFolder("plugins").toPath().toRealPath(); } @@ -190,9 +191,9 @@ public void testConnectApiClasses() { // Classes in the API should never be loaded in isolation. for (String clazz : apiClasses) { assertFalse( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'api' is loaded in isolation but should not be" - ); + clazz + " from 'api' is loaded in isolation but should not be", + PluginUtils.shouldLoadInIsolation(clazz) + ); } } @@ -221,8 +222,8 @@ public void testConnectRuntimeClasses() { ); for (String clazz : runtimeClasses) { assertFalse( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'runtime' is loaded in isolation but should not be" + clazz + " from 'runtime' is loaded in isolation but should not be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } @@ -250,8 +251,8 @@ public void testAllowedRuntimeClasses() { ); for (String clazz : jsonConverterClasses) { assertTrue( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'runtime' is not loaded in isolation but should be" + clazz + " from 'runtime' is not loaded in isolation but should be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } @@ -305,8 +306,8 @@ public void testTransformsClasses() { ); for (String clazz : transformsClasses) { assertTrue( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'transforms' is not loaded in isolation but should be" + clazz + " from 'transforms' is not loaded in isolation but should be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } @@ -324,8 +325,8 @@ public void testAllowedJsonConverterClasses() { ); for (String clazz : jsonConverterClasses) { assertTrue( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'json' is not loaded in isolation but should be" + clazz + " from 'json' is not loaded in isolation but should be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } @@ -341,8 +342,8 @@ public void testAllowedFileConnectors() { ); for (String clazz : jsonConverterClasses) { assertTrue( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'file' is not loaded in isolation but should be" + clazz + " from 'file' is not loaded in isolation but should be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } @@ -356,8 +357,8 @@ public void testAllowedBasicAuthExtensionClasses() { ); for (String clazz : basicAuthExtensionClasses) { assertTrue( - PluginUtils.shouldLoadInIsolation(clazz), - clazz + " from 'basic-auth-extension' is not loaded in isolation but should be" + clazz + " from 'basic-auth-extension' is not loaded in isolation but should be", + PluginUtils.shouldLoadInIsolation(clazz) ); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java index c08c597f38636..8a637beee5ec0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java @@ -17,6 +17,15 @@ package org.apache.kafka.connect.runtime.isolation; +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; +import java.util.Map.Entry; + import org.apache.kafka.common.Configurable; import org.apache.kafka.common.config.AbstractConfig; import org.apache.kafka.common.config.ConfigDef; @@ -24,10 +33,10 @@ import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.components.Versioned; -import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.connector.policy.AllConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.converters.ByteArrayConverter; +import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; @@ -48,17 +57,9 @@ import org.junit.Before; import org.junit.Test; -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.nio.file.Path; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.stream.Collectors; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java index cbf1be866a20e..e8ba9153bc09b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java @@ -17,19 +17,7 @@ package org.apache.kafka.connect.runtime.isolation; -import org.apache.kafka.common.config.AbstractConfig; -import org.apache.kafka.common.config.ConfigDef; -import org.apache.kafka.common.config.ConfigDef.Importance; -import org.apache.kafka.common.config.ConfigDef.Type; -import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.mockito.Mockito; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import static org.junit.Assert.fail; import java.lang.management.LockInfo; import java.lang.management.ManagementFactory; @@ -52,8 +40,19 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; import java.util.stream.Collectors; - -import static org.junit.Assert.fail; +import org.apache.kafka.common.config.AbstractConfig; +import org.apache.kafka.common.config.ConfigDef; +import org.apache.kafka.common.config.ConfigDef.Importance; +import org.apache.kafka.common.config.ConfigDef.Type; +import org.apache.kafka.connect.runtime.WorkerConfig; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class SynchronizationTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java index 75e4c82f489bc..2bc03b2b7c25f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java @@ -17,13 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import org.apache.kafka.connect.components.Versioned; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import javax.tools.JavaCompiler; -import javax.tools.StandardJavaFileManager; -import javax.tools.ToolProvider; import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; @@ -47,6 +40,13 @@ import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.stream.Collectors; +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; + +import org.apache.kafka.connect.components.Versioned; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Utility class for constructing test plugins for Connect. diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java index 96ecee8ac840c..0494d00272668 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/ConnectRestServerTest.java @@ -16,17 +16,6 @@ */ package org.apache.kafka.connect.runtime.rest; -import javax.ws.rs.core.MediaType; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.http.HttpHost; @@ -46,27 +35,36 @@ import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.slf4j.LoggerFactory; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertNotEquals; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; +import javax.ws.rs.core.MediaType; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.net.URI; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doReturn; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ConnectRestServerTest { @Mock private RestClient restClient; @@ -78,12 +76,12 @@ public class ConnectRestServerTest { protected static final String KAFKA_CLUSTER_ID = "Xbafgnagvar"; - @BeforeEach + @Before public void setUp() { httpClient = HttpClients.createMinimal(); } - @AfterEach + @After public void tearDown() throws IOException { for (CloseableHttpResponse response: responses) { response.close(); @@ -119,7 +117,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.LISTENERS_CONFIG, "http://localhost:8080,https://localhost:8443"); server = new ConnectRestServer(null, restClient, configMap); - assertEquals("http://localhost:8080/", server.advertisedUrl().toString()); + Assert.assertEquals("http://localhost:8080/", server.advertisedUrl().toString()); server.stop(); // Advertised URI from listeners with protocol @@ -128,7 +126,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_LISTENER_CONFIG, "https"); server = new ConnectRestServer(null, restClient, configMap); - assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); + Assert.assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); server.stop(); // Advertised URI from listeners with only SSL available @@ -136,7 +134,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.LISTENERS_CONFIG, "https://localhost:8443"); server = new ConnectRestServer(null, restClient, configMap); - assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); + Assert.assertEquals("https://localhost:8443/", server.advertisedUrl().toString()); server.stop(); // Listener is overridden by advertised values @@ -147,7 +145,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_PORT_CONFIG, "10000"); server = new ConnectRestServer(null, restClient, configMap); - assertEquals("http://somehost:10000/", server.advertisedUrl().toString()); + Assert.assertEquals("http://somehost:10000/", server.advertisedUrl().toString()); server.stop(); // correct listener is chosen when https listener is configured before http listener and advertised listener is http @@ -156,7 +154,7 @@ public void testAdvertisedUri() { configMap.put(RestServerConfig.REST_ADVERTISED_LISTENER_CONFIG, "http"); server = new ConnectRestServer(null, restClient, configMap); - assertEquals("http://plaintext-localhost:4761/", server.advertisedUrl().toString()); + Assert.assertEquals("http://plaintext-localhost:4761/", server.advertisedUrl().toString()); server.stop(); } @@ -175,10 +173,10 @@ public void testOptionsDoesNotIncludeWadlOutput() throws IOException { HttpOptions request = new HttpOptions("/connectors"); request.addHeader("Content-Type", MediaType.WILDCARD); HttpResponse response = executeRequest(server.advertisedUrl(), request); - assertEquals(MediaType.TEXT_PLAIN, response.getEntity().getContentType().getValue()); + Assert.assertEquals(MediaType.TEXT_PLAIN, response.getEntity().getContentType().getValue()); ByteArrayOutputStream baos = new ByteArrayOutputStream(); response.getEntity().writeTo(baos); - assertArrayEquals( + Assert.assertArrayEquals( request.getAllowedMethods(response).toArray(), new String(baos.toByteArray(), StandardCharsets.UTF_8).split(", ") ); @@ -205,10 +203,10 @@ public void checkCORSRequest(String corsDomain, String origin, String expectedHe request.addHeader("Origin", origin); HttpResponse response = executeRequest(serverUrl, request); - assertEquals(200, response.getStatusLine().getStatusCode()); + Assert.assertEquals(200, response.getStatusLine().getStatusCode()); if (expectedHeader != null) { - assertEquals(expectedHeader, + Assert.assertEquals(expectedHeader, response.getFirstHeader("Access-Control-Allow-Origin").getValue()); } @@ -217,13 +215,13 @@ public void checkCORSRequest(String corsDomain, String origin, String expectedHe request.addHeader("Origin", origin); request.addHeader("Access-Control-Request-Method", method); response = executeRequest(serverUrl, request); - assertEquals(404, response.getStatusLine().getStatusCode()); + Assert.assertEquals(404, response.getStatusLine().getStatusCode()); if (expectedHeader != null) { - assertEquals(expectedHeader, + Assert.assertEquals(expectedHeader, response.getFirstHeader("Access-Control-Allow-Origin").getValue()); } if (method != null) { - assertEquals(method, + Assert.assertEquals(method, response.getFirstHeader("Access-Control-Allow-Methods").getValue()); } } @@ -244,7 +242,7 @@ public void testStandaloneConfig() throws IOException { HttpRequest request = new HttpGet("/connectors"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - assertEquals(200, response.getStatusLine().getStatusCode()); + Assert.assertEquals(200, response.getStatusLine().getStatusCode()); } @Test @@ -306,7 +304,7 @@ public void testIndependentAdminEndpoint() throws IOException { HttpRequest request = new HttpGet("/admin/loggers"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - assertEquals(404, response.getStatusLine().getStatusCode()); + Assert.assertEquals(404, response.getStatusLine().getStatusCode()); } @Test @@ -326,7 +324,7 @@ public void testDisableAdminEndpoint() throws IOException { HttpRequest request = new HttpGet("/admin/loggers"); HttpResponse response = executeRequest(server.advertisedUrl(), request); - assertEquals(404, response.getStatusLine().getStatusCode()); + Assert.assertEquals(404, response.getStatusLine().getStatusCode()); } @Test @@ -388,12 +386,12 @@ private void checkCustomizedHttpResponseHeaders(String headerConfig, Map - assertEquals(response.getFirstHeader(k).getValue(), v)); + Assert.assertEquals(response.getFirstHeader(k).getValue(), v)); } else { - assertNull(response.getFirstHeader("X-Frame-Options")); + Assert.assertNull(response.getFirstHeader("X-Frame-Options")); } } @@ -401,7 +399,7 @@ private String executeGet(URI serverUrl, String endpoint) throws IOException { HttpRequest request = new HttpGet(endpoint); HttpResponse response = executeRequest(serverUrl, request); - assertEquals(200, response.getStatusLine().getStatusCode()); + Assert.assertEquals(200, response.getStatusLine().getStatusCode()); return new BasicResponseHandler().handleResponse(response); } @@ -412,7 +410,7 @@ private String executePut(URI serverUrl, String endpoint, String jsonBody) throw request.setEntity(entity); HttpResponse response = executeRequest(serverUrl, request); - assertEquals(200, response.getStatusLine().getStatusCode()); + Assert.assertEquals(200, response.getStatusLine().getStatusCode()); return new BasicResponseHandler().handleResponse(response); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java index 1b6c5a9a57ddc..82fab1313067e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java @@ -17,22 +17,22 @@ package org.apache.kafka.connect.runtime.rest; +import org.apache.kafka.connect.errors.ConnectException; +import org.apache.kafka.connect.runtime.distributed.Crypto; +import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; +import org.eclipse.jetty.client.api.Request; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.junit.MockitoJUnitRunner; + import javax.crypto.Mac; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.ws.rs.core.HttpHeaders; + import java.security.NoSuchAlgorithmException; import java.util.Base64; -import org.apache.kafka.connect.errors.ConnectException; -import org.apache.kafka.connect.runtime.distributed.Crypto; -import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; -import org.eclipse.jetty.client.api.Request; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -45,8 +45,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class InternalRequestSignatureTest { private static final byte[] REQUEST_BODY = diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java index c134a7bd6b182..3c104e0e9307d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java @@ -17,14 +17,6 @@ package org.apache.kafka.connect.runtime.rest; -import javax.crypto.SecretKey; -import javax.ws.rs.core.Response; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collection; -import java.util.Objects; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeoutException; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.JsonProcessingException; @@ -36,29 +28,35 @@ import org.eclipse.jetty.client.api.ContentResponse; import org.eclipse.jetty.client.api.Request; import org.junit.Rule; +import org.junit.Test; import org.junit.experimental.runners.Enclosed; -import org.junit.jupiter.api.Nested; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.MockitoRule; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import javax.crypto.SecretKey; +import javax.ws.rs.core.Response; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collection; +import java.util.Objects; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeoutException; + import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; @@ -108,9 +106,8 @@ private static RestClient.HttpResponse httpRequest( } - @Nested @RunWith(Parameterized.class) - class RequestFailureParameterizedTest { + public static class RequestFailureParameterizedTest { @Rule public MockitoRule initRule = MockitoJUnit.rule().strictness(Strictness.STRICT_STUBS); @@ -122,7 +119,7 @@ class RequestFailureParameterizedTest { public Throwable requestException; @Parameterized.Parameters - public Collection requestExceptions() { + public static Collection requestExceptions() { return Arrays.asList(new Object[][]{ {new InterruptedException()}, {new ExecutionException(null)}, @@ -130,7 +127,7 @@ public Collection requestExceptions() { }); } - private Request buildThrowingMockRequest(Throwable t) throws ExecutionException, InterruptedException, TimeoutException { + private static Request buildThrowingMockRequest(Throwable t) throws ExecutionException, InterruptedException, TimeoutException { Request req = mock(Request.class); when(req.header(anyString(), anyString())).thenReturn(req); when(req.send()).thenThrow(t); @@ -150,14 +147,12 @@ public void testFailureDuringRequestCausesInternalServerError() throws Exception } - @Nested - @ExtendWith(MockitoExtension.class) - @MockitoSettings(strictness = Strictness.STRICT_STUBS) - class Tests { + @RunWith(MockitoJUnitRunner.StrictStubs.class) + public static class Tests { @Mock private HttpClient httpClient; - private String toJsonString(Object obj) { + private static String toJsonString(Object obj) { try { return OBJECT_MAPPER.writeValueAsString(obj); } catch (JsonProcessingException e) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java index 80a58223df5fa..4930c1a3ef221 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestServerConfigTest.java @@ -16,14 +16,15 @@ */ package org.apache.kafka.connect.runtime.rest; +import org.apache.kafka.common.config.ConfigException; +import org.apache.kafka.common.config.internals.BrokerSecurityConfigs; +import org.junit.Test; + import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import org.apache.kafka.common.config.ConfigException; -import org.apache.kafka.common.config.internals.BrokerSecurityConfigs; -import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.rest.RestServerConfig.LISTENERS_DEFAULT; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java index 92b2e6da8ee32..726915d2e3a1f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorOffsetsTest.java @@ -16,10 +16,11 @@ */ package org.apache.kafka.connect.runtime.rest.entities; +import org.junit.Test; + import java.util.Arrays; import java.util.HashMap; import java.util.Map; -import org.junit.jupiter.api.Test; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java index 50d1265d20d41..cd07bd8557326 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/ConnectorTypeTest.java @@ -16,7 +16,7 @@ */ package org.apache.kafka.connect.runtime.rest.entities; -import org.junit.jupiter.api.Test; +import org.junit.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java index 0d7c48ecd4827..1d32479f82c22 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/CreateConnectorRequestTest.java @@ -16,9 +16,10 @@ */ package org.apache.kafka.connect.runtime.rest.entities; -import java.util.Collections; import org.apache.kafka.connect.runtime.TargetState; -import org.junit.jupiter.api.Test; +import org.junit.Test; + +import java.util.Collections; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java index c18fa20db71ee..34e28ee47f6bb 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/entities/PluginInfoTest.java @@ -17,7 +17,7 @@ package org.apache.kafka.connect.runtime.rest.entities; import org.apache.kafka.connect.runtime.isolation.PluginDesc; -import org.junit.jupiter.api.Test; +import org.junit.Test; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java index 60b8a83fcb3e5..589dfb29bd0f5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java @@ -16,22 +16,6 @@ */ package org.apache.kafka.connect.runtime.rest.resources; -import javax.ws.rs.BadRequestException; -import java.net.URL; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.TreeSet; -import java.util.stream.Collectors; -import java.util.stream.Stream; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.kafka.common.config.Config; import org.apache.kafka.common.config.ConfigDef; @@ -61,8 +45,8 @@ import org.apache.kafka.connect.runtime.rest.entities.ConfigInfos; import org.apache.kafka.connect.runtime.rest.entities.ConfigKeyInfo; import org.apache.kafka.connect.runtime.rest.entities.ConfigValueInfo; -import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; +import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.tools.MockSinkConnector; @@ -75,13 +59,28 @@ import org.apache.kafka.connect.transforms.predicates.HasHeaderKey; import org.apache.kafka.connect.transforms.predicates.RecordIsTombstone; import org.apache.kafka.connect.util.Callback; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; + +import javax.ws.rs.BadRequestException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.TreeSet; +import java.util.stream.Collectors; +import java.util.stream.Stream; import static java.util.Arrays.asList; import static org.junit.Assert.assertEquals; @@ -89,17 +88,16 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ConnectorPluginsResourceTest { private static final Map PROPS; @@ -203,7 +201,7 @@ public class ConnectorPluginsResourceTest { private final Plugins plugins = mock(Plugins.class); private ConnectorPluginsResource connectorPluginsResource; - @BeforeEach + @Before public void setUp() throws Exception { doReturn(plugins).when(herder).plugins(); doReturn(SINK_CONNECTOR_PLUGINS).when(plugins).sinkConnectors(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java index 2eaf97fde4300..2386b2558e176 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorsResourceTest.java @@ -16,22 +16,6 @@ */ package org.apache.kafka.connect.runtime.rest.resources; -import javax.ws.rs.BadRequestException; -import javax.ws.rs.core.HttpHeaders; -import javax.ws.rs.core.MultivaluedHashMap; -import javax.ws.rs.core.MultivaluedMap; -import javax.ws.rs.core.Response; -import javax.ws.rs.core.UriInfo; -import java.net.URI; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; import org.apache.kafka.connect.errors.AlreadyExistsException; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.AbstractStatus; @@ -58,20 +42,36 @@ import org.apache.kafka.connect.runtime.rest.errors.ConnectRestException; import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.mockito.stubbing.Stubber; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import javax.ws.rs.BadRequestException; +import javax.ws.rs.core.HttpHeaders; +import javax.ws.rs.core.MultivaluedHashMap; +import javax.ws.rs.core.MultivaluedMap; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.UriInfo; +import java.net.URI; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.any; import static org.mockito.Mockito.doAnswer; @@ -83,8 +83,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) @SuppressWarnings("unchecked") public class ConnectorsResourceTest { // Note trailing / and that we do *not* use LEADER_URL to construct our reference values. This checks that we handle @@ -167,7 +166,7 @@ public class ConnectorsResourceTest { @Mock private RestServerConfig serverConfig; - @BeforeEach + @Before public void setUp() throws NoSuchMethodException { when(serverConfig.topicTrackingEnabled()).thenReturn(true); when(serverConfig.topicTrackingResetEnabled()).thenReturn(true); @@ -178,7 +177,7 @@ public void setUp() throws NoSuchMethodException { when(forward.getQueryParameters()).thenReturn(queryParams); } - @AfterEach + @After public void teardown() { verifyNoMoreInteractions(herder); } @@ -540,7 +539,7 @@ public void testCreateConnectorWithSpecialCharsInName() throws Throwable { String rspLocation = connectorsResource.createConnector(FORWARD, NULL_HEADERS, body).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); + Assert.assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); } @Test @@ -555,7 +554,7 @@ public void testCreateConnectorWithControlSequenceInName() throws Throwable { String rspLocation = connectorsResource.createConnector(FORWARD, NULL_HEADERS, body).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); + Assert.assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); } @Test @@ -568,7 +567,7 @@ public void testPutConnectorConfigWithSpecialCharsInName() throws Throwable { String rspLocation = connectorsResource.putConnectorConfig(CONNECTOR_NAME_SPECIAL_CHARS, NULL_HEADERS, FORWARD, CONNECTOR_CONFIG_SPECIAL_CHARS).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); + Assert.assertEquals("/connectors/" + CONNECTOR_NAME_SPECIAL_CHARS, decoded); } @Test @@ -581,7 +580,7 @@ public void testPutConnectorConfigWithControlSequenceInName() throws Throwable { String rspLocation = connectorsResource.putConnectorConfig(CONNECTOR_NAME_CONTROL_SEQUENCES1, NULL_HEADERS, FORWARD, CONNECTOR_CONFIG_CONTROL_SEQUENCES).getLocation().toString(); String decoded = new URI(rspLocation).getPath(); - assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); + Assert.assertEquals("/connectors/" + CONNECTOR_NAME_CONTROL_SEQUENCES1, decoded); } @Test diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java index 393ad4463a203..c48b60fbd96ff 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/InternalConnectResourceTest.java @@ -16,15 +16,6 @@ */ package org.apache.kafka.connect.runtime.rest.resources; -import javax.crypto.Mac; -import javax.ws.rs.core.HttpHeaders; -import javax.ws.rs.core.UriInfo; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Base64; -import java.util.Collections; -import java.util.List; -import java.util.Map; import com.fasterxml.jackson.databind.ObjectMapper; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.Herder; @@ -32,16 +23,24 @@ import org.apache.kafka.connect.runtime.rest.RestClient; import org.apache.kafka.connect.runtime.rest.RestServer; import org.apache.kafka.connect.util.Callback; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.mockito.stubbing.Stubber; +import javax.crypto.Mac; +import javax.ws.rs.core.HttpHeaders; +import javax.ws.rs.core.UriInfo; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Base64; +import java.util.Collections; +import java.util.List; +import java.util.Map; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.any; @@ -51,8 +50,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class InternalConnectResourceTest { private static final Boolean FORWARD = true; @@ -75,7 +73,7 @@ public class InternalConnectResourceTest { private InternalConnectResource internalResource; - @BeforeEach + @Before public void setup() { internalResource = new InternalConnectResource(herder, restClient, () -> RestServer.DEFAULT_REST_REQUEST_TIMEOUT_MS); internalResource.uriInfo = uriInfo; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java index ea5f89cc62372..3b3df99351167 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/LoggingResourceTest.java @@ -16,32 +16,30 @@ */ package org.apache.kafka.connect.runtime.rest.resources; -import javax.ws.rs.core.Response; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.errors.NotFoundException; import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import org.slf4j.event.Level; +import javax.ws.rs.core.Response; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertThrows; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class LoggingResourceTest { private LoggingResource loggingResource; @@ -49,7 +47,7 @@ public class LoggingResourceTest { @Mock private Herder herder; - @BeforeEach + @Before public void setup() { loggingResource = new LoggingResource(herder); } @@ -164,4 +162,4 @@ public void testSetLevelClusterScope() { verify(herder).setClusterLoggerLevel(logger, level); } -} +} \ No newline at end of file diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java index e22dc1c396c7f..976484392451b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/RootResourceTest.java @@ -20,26 +20,23 @@ import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.runtime.Herder; import org.apache.kafka.connect.runtime.rest.entities.ServerInfo; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class RootResourceTest { @Mock private Herder herder; private RootResource rootResource; - @BeforeEach + @Before public void setUp() { rootResource = new RootResource(herder); } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java index 35dff2a8eb49c..8f5c3235e7e6a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/util/SSLUtilsTest.java @@ -16,18 +16,15 @@ */ package org.apache.kafka.connect.runtime.rest.util; -import java.util.Arrays; -import java.util.HashMap; -import java.util.Map; import org.apache.kafka.common.config.SslConfigs; import org.apache.kafka.connect.runtime.rest.RestServerConfig; import org.eclipse.jetty.util.ssl.SslContextFactory; -import org.junit.jupiter.api.Test; +import org.junit.Assert; +import org.junit.Test; -import static org.junit.jupiter.api.Assertions.assertArrayEquals; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; public class SSLUtilsTest { @@ -40,8 +37,8 @@ public void testGetOrDefault() { Map map = new HashMap<>(); map.put("exists", "value"); - assertEquals(SSLUtils.getOrDefault(map, existingKey, defaultValue), value); - assertEquals(SSLUtils.getOrDefault(map, missingKey, defaultValue), defaultValue); + Assert.assertEquals(SSLUtils.getOrDefault(map, existingKey, defaultValue), value); + Assert.assertEquals(SSLUtils.getOrDefault(map, missingKey, defaultValue), defaultValue); } @Test @@ -67,19 +64,19 @@ public void testCreateServerSideSslContextFactory() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Server ssl = SSLUtils.createServerSideSslContextFactory(config); - assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); - assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); - assertEquals("SunJSSE", ssl.getProvider()); - assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); - assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); - assertTrue(ssl.getNeedClientAuth()); - assertFalse(ssl.getWantClientAuth()); - assertEquals("JKS", ssl.getKeyStoreType()); - assertEquals("JKS", ssl.getTrustStoreType()); - assertEquals("TLS", ssl.getProtocol()); - assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); - assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); - assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); + Assert.assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); + Assert.assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); + Assert.assertEquals("SunJSSE", ssl.getProvider()); + Assert.assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); + Assert.assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); + Assert.assertTrue(ssl.getNeedClientAuth()); + Assert.assertFalse(ssl.getWantClientAuth()); + Assert.assertEquals("JKS", ssl.getKeyStoreType()); + Assert.assertEquals("JKS", ssl.getTrustStoreType()); + Assert.assertEquals("TLS", ssl.getProtocol()); + Assert.assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); + Assert.assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); + Assert.assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); } @Test @@ -105,17 +102,17 @@ public void testCreateClientSideSslContextFactory() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Client ssl = SSLUtils.createClientSideSslContextFactory(config); - assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); - assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); - assertEquals("SunJSSE", ssl.getProvider()); - assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); - assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); - assertEquals("JKS", ssl.getKeyStoreType()); - assertEquals("JKS", ssl.getTrustStoreType()); - assertEquals("TLS", ssl.getProtocol()); - assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); - assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); - assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); + Assert.assertEquals("file:///path/to/keystore", ssl.getKeyStorePath()); + Assert.assertEquals("file:///path/to/truststore", ssl.getTrustStorePath()); + Assert.assertEquals("SunJSSE", ssl.getProvider()); + Assert.assertArrayEquals(new String[] {"SSL_RSA_WITH_RC4_128_SHA", "SSL_RSA_WITH_RC4_128_MD5"}, ssl.getIncludeCipherSuites()); + Assert.assertEquals("SHA1PRNG", ssl.getSecureRandomAlgorithm()); + Assert.assertEquals("JKS", ssl.getKeyStoreType()); + Assert.assertEquals("JKS", ssl.getTrustStoreType()); + Assert.assertEquals("TLS", ssl.getProtocol()); + Assert.assertArrayEquals(new String[] {"TLSv1.2", "TLSv1.1", "TLSv1"}, ssl.getIncludeProtocols()); + Assert.assertEquals("SunX509", ssl.getKeyManagerFactoryAlgorithm()); + Assert.assertEquals("PKIX", ssl.getTrustManagerFactoryAlgorithm()); } @Test @@ -133,14 +130,14 @@ public void testCreateServerSideSslContextFactoryDefaultValues() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Server ssl = SSLUtils.createServerSideSslContextFactory(config); - assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); - assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); - assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); - assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); - assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); - assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); - assertFalse(ssl.getNeedClientAuth()); - assertFalse(ssl.getWantClientAuth()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); + Assert.assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); + Assert.assertFalse(ssl.getNeedClientAuth()); + Assert.assertFalse(ssl.getWantClientAuth()); } @Test @@ -158,11 +155,11 @@ public void testCreateClientSideSslContextFactoryDefaultValues() { RestServerConfig config = RestServerConfig.forPublic(null, configMap); SslContextFactory.Client ssl = SSLUtils.createClientSideSslContextFactory(config); - assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); - assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); - assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); - assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); - assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); - assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYSTORE_TYPE, ssl.getKeyStoreType()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTSTORE_TYPE, ssl.getTrustStoreType()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_PROTOCOL, ssl.getProtocol()); + Assert.assertArrayEquals(Arrays.asList(SslConfigs.DEFAULT_SSL_ENABLED_PROTOCOLS.split("\\s*,\\s*")).toArray(), ssl.getIncludeProtocols()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_KEYMANGER_ALGORITHM, ssl.getKeyManagerFactoryAlgorithm()); + Assert.assertEquals(SslConfigs.DEFAULT_SSL_TRUSTMANAGER_ALGORITHM, ssl.getTrustManagerFactoryAlgorithm()); } } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java index 44da4ba3a6bbf..e2e886f7925f7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneConfigTest.java @@ -16,14 +16,15 @@ */ package org.apache.kafka.connect.runtime.standalone; -import java.util.HashMap; -import java.util.Map; -import java.util.stream.Collectors; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.SslConfigs; import org.apache.kafka.common.config.types.Password; import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.jupiter.api.Test; +import org.junit.Test; + +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Collectors; import static org.junit.Assert.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 8907501b55c25..959e498931096 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -16,17 +16,6 @@ */ package org.apache.kafka.connect.runtime.standalone; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; import org.apache.kafka.common.config.Config; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.ConfigValue; @@ -52,34 +41,44 @@ import org.apache.kafka.connect.runtime.WorkerConfigTransformer; import org.apache.kafka.connect.runtime.distributed.SampleConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.runtime.isolation.LoaderSwap; +import org.apache.kafka.connect.runtime.rest.entities.Message; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.ConnectorInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; -import org.apache.kafka.connect.runtime.rest.entities.Message; import org.apache.kafka.connect.runtime.rest.entities.TaskInfo; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceTask; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.MemoryConfigBackingStore; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.mockito.junit.jupiter.MockitoSettings; -import org.mockito.quality.Strictness; +import org.mockito.junit.MockitoJUnitRunner; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; import static java.util.Collections.emptyList; import static java.util.Collections.singleton; @@ -111,8 +110,7 @@ import static org.mockito.Mockito.when; import static org.mockito.Mockito.withSettings; -@ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@RunWith(MockitoJUnitRunner.StrictStubs.class) @SuppressWarnings("unchecked") public class StandaloneHerderTest { private static final String CONNECTOR_NAME = "test"; @@ -143,7 +141,7 @@ private enum SourceSink { private final SampleConnectorClientConfigOverridePolicy noneConnectorClientConfigOverridePolicy = new SampleConnectorClientConfigOverridePolicy(); - @BeforeEach + @Before public void setup() throws ExecutionException, InterruptedException { herder = mock(StandaloneHerder.class, withSettings() .useConstructor(worker, WORKER_ID, KAFKA_CLUSTER_ID, statusBackingStore, new MemoryConfigBackingStore(transformer), noneConnectorClientConfigOverridePolicy, new MockTime()) @@ -153,7 +151,7 @@ public void setup() throws ExecutionException, InterruptedException { when(transformer.transform(eq(CONNECTOR_NAME), configCapture.capture())).thenAnswer(invocation -> configCapture.getValue()); } - @AfterEach + @After public void tearDown() { verifyNoMoreInteractions(worker, statusBackingStore); herder.stop(); From 6a08838a2b26296a197c2f2bb795a3597fda8a6e Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sat, 15 Jun 2024 15:16:37 +0800 Subject: [PATCH 05/18] update mokito strictness --- .../kafka/connect/runtime/AbstractWorkerSourceTaskTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index b00db2c817c51..e5961c5f3683a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -109,7 +109,7 @@ @SuppressWarnings("unchecked") @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.STRICT_STUBS) +@MockitoSettings(strictness = Strictness.WARN) public class AbstractWorkerSourceTaskTest { private static final String TOPIC = "topic"; From ace892cc998f3b882e0af53aa7575a6e041d46a5 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sat, 15 Jun 2024 15:21:48 +0800 Subject: [PATCH 06/18] revert mockito strictness --- .../org/apache/kafka/connect/runtime/AbstractHerderTest.java | 2 +- .../kafka/connect/runtime/AbstractWorkerSourceTaskTest.java | 2 +- .../apache/kafka/connect/runtime/TransformationStageTest.java | 2 +- .../apache/kafka/connect/runtime/WorkerMetricsGroupTest.java | 2 +- .../kafka/connect/runtime/WorkerSinkTaskThreadedTest.java | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index 8bbab4444a866..0c0318ced8435 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -101,7 +101,7 @@ import static org.mockito.Mockito.withSettings; @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.LENIENT) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractHerderTest { private static final String CONN1 = "sourceA"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index e5961c5f3683a..b00db2c817c51 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -109,7 +109,7 @@ @SuppressWarnings("unchecked") @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.WARN) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class AbstractWorkerSourceTaskTest { private static final String TOPIC = "topic"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index d6d7c6ec22bac..8ccb190050d44 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -30,7 +30,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -@MockitoSettings(strictness = Strictness.LENIENT) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class TransformationStageTest { private final SourceRecord initial = new SourceRecord(singletonMap("initial", 1), null, null, null, null); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index 7ad7ae422973b..a909b79fb133e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -41,7 +41,7 @@ import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.WARN) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerMetricsGroupTest { private final String connector = "org.FakeConnector"; private final ConnectorTaskId task = new ConnectorTaskId(connector, 0); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index 8742ecd34ddc6..54a3dea59eece 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -87,7 +87,7 @@ @SuppressWarnings("unchecked") @ExtendWith(MockitoExtension.class) -@MockitoSettings(strictness = Strictness.WARN) +@MockitoSettings(strictness = Strictness.STRICT_STUBS) public class WorkerSinkTaskThreadedTest { // These are fixed to keep this code simpler. In this example we assume byte[] raw values From d44c98909ba1205c4deb32e81e8cae752d4ba86a Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sun, 16 Jun 2024 13:06:02 +0800 Subject: [PATCH 07/18] update @MethodSource("parameters") to ValueSource and EnumSource --- .../runtime/ErrorHandlingTaskTest.java | 6 +- .../ExactlyOnceWorkerSourceTaskTest.java | 57 ++++----- .../connect/runtime/WorkerConnectorTest.java | 31 ++--- .../connect/runtime/WorkerSourceTaskTest.java | 32 ++--- .../kafka/connect/runtime/WorkerTest.java | 118 +++++++++--------- 5 files changed, 123 insertions(+), 121 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index 996bd5c93f5c0..8d90e71442e1e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -221,7 +221,7 @@ public void tearDown() { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testErrorHandlingInSinkTasks(boolean enableTopicCreation) { setup(enableTopicCreation); Map reportProps = new HashMap<>(); @@ -273,7 +273,7 @@ private RetryWithToleranceOperator operator() { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testErrorHandlingInSourceTasks(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Map reportProps = new HashMap<>(); @@ -335,7 +335,7 @@ private ConnectorConfig connConfig(Map connProps) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testErrorHandlingInSourceTasksWithBadConverter(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Map reportProps = new HashMap<>(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index 997e3f27e652c..c441707fd6292 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -57,6 +57,7 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoSettings; @@ -288,7 +289,7 @@ private void createWorkerTask(TargetState initialState, Converter keyConverter, } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testRemoveMetrics(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -307,7 +308,7 @@ private Set filterToTaskMetrics(Set metricNames) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartPaused(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(TargetState.PAUSED); @@ -332,7 +333,7 @@ public void testStartPaused(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPause(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -373,7 +374,7 @@ public void testPause(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPreProducerCheck(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -389,7 +390,7 @@ public void testFailureInPreProducerCheck(boolean enableTopicCreation) throws Ex } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInProducerInitialization(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -406,7 +407,7 @@ public void testFailureInProducerInitialization(boolean enableTopicCreation) thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPostProducerCheck(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -424,7 +425,7 @@ public void testFailureInPostProducerCheck(boolean enableTopicCreation) throws E } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInOffsetStoreStart(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -443,7 +444,7 @@ public void testFailureInOffsetStoreStart(boolean enableTopicCreation) throws Ex } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPollsInBackground(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -470,7 +471,7 @@ public void testPollsInBackground(boolean enableTopicCreation) throws Exception } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPoll(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -495,7 +496,7 @@ public void testFailureInPoll(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -523,7 +524,7 @@ public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exc } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -554,7 +555,7 @@ public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Excep } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // Test that the task handles an empty list of records @@ -581,7 +582,7 @@ public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Excepti } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPollBasedCommit(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.POLL); @@ -611,7 +612,7 @@ public void testPollBasedCommit(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testIntervalBasedCommit(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); long commitInterval = 618; @@ -655,28 +656,28 @@ public void testIntervalBasedCommit(boolean enableTopicCreation) throws Exceptio } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorCommitOnBatch(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorBasedCommit(TransactionContext::commitTransaction, false); } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorCommitOnRecord(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorBasedCommit(ctx -> ctx.commitTransaction(SOURCE_RECORD_2), false); } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorAbortOnBatch(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorBasedCommit(TransactionContext::abortTransaction, true); } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorAbortOnRecord(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorBasedCommit(ctx -> ctx.abortTransaction(SOURCE_RECORD_2), true); @@ -729,7 +730,7 @@ private void testConnectorBasedCommit(Consumer requestCommit } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorAbortsEmptyTransaction(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Map connectorProps = sourceConnectorProps(SourceTask.TransactionBoundary.CONNECTOR); @@ -776,7 +777,7 @@ public void testConnectorAbortsEmptyTransaction(boolean enableTopicCreation) thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // We fail tasks that try to abort and commit a transaction for the same record or same batch @@ -816,7 +817,7 @@ public void testMixedConnectorTransactionBoundaryCommitLastRecordAbortBatch(bool } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // We fail tasks that try to abort and commit a transaction for the same record or same batch @@ -861,7 +862,7 @@ public void testMixedConnectorTransactionBoundaryAbortLastRecordCommitBatch(bool } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCommitFlushSyncCallbackFailure(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); @@ -875,7 +876,7 @@ public void testCommitFlushSyncCallbackFailure(boolean enableTopicCreation) thro } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCommitFlushAsyncCallbackFailure(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); @@ -895,7 +896,7 @@ public void testCommitFlushAsyncCallbackFailure(boolean enableTopicCreation) thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCommitTransactionFailure(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); Exception failure = new RecordTooLargeException(); @@ -939,7 +940,7 @@ private void testCommitFailure(Exception commitException, boolean executeCommit) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsRetries(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -985,7 +986,7 @@ public void testSendRecordsRetries(boolean enableTopicCreation) throws Exception } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -1010,7 +1011,7 @@ public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreat } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); final CountDownLatch startupLatch = new CountDownLatch(1); @@ -1046,7 +1047,7 @@ public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCancel(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index 46438a78e07f8..895effef54ac8 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -31,6 +31,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; @@ -120,7 +121,7 @@ public void tearDown() { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testInitializeFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -142,7 +143,7 @@ public void testInitializeFailure(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testFailureIsFinalState(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -171,7 +172,7 @@ public void testFailureIsFinalState(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndShutdown(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -197,7 +198,7 @@ public void testStartupAndShutdown(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndPause(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -228,7 +229,7 @@ public void testStartupAndPause(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndStop(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -260,7 +261,7 @@ public void testStartupAndStop(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testOnResume(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -292,7 +293,7 @@ public void testOnResume(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupPaused(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -318,7 +319,7 @@ public void testStartupPaused(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupStopped(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -344,7 +345,7 @@ public void testStartupStopped(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -373,7 +374,7 @@ public void testStartupFailure(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStopFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -417,7 +418,7 @@ public void testStopFailure(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testShutdownFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -447,7 +448,7 @@ public void testShutdownFailure(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionStartedToStarted(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -476,7 +477,7 @@ public void testTransitionStartedToStarted(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionPausedToPaused(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -509,7 +510,7 @@ public void testTransitionPausedToPaused(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionStoppedToStopped(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -542,7 +543,7 @@ public void testTransitionStoppedToStopped(ConnectorType connectorType) { } @ParameterizedTest - @MethodSource("parameters") + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testFailConnectorThatIsNeitherSourceNorSink(ConnectorType connectorType) { setup(connectorType); Connector badConnector = mock(Connector.class); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 16204dee9ec68..071136e62ce40 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -260,7 +260,7 @@ private void createWorkerTask(TargetState initialState, Converter keyConverter, } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartPaused(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); final CountDownLatch pauseLatch = new CountDownLatch(1); @@ -286,7 +286,7 @@ public void testStartPaused(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPause(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -327,7 +327,7 @@ public void testPause(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPollsInBackground(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -354,7 +354,7 @@ public void testPollsInBackground(boolean enableTopicCreation) throws Exception } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPoll(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -387,7 +387,7 @@ public void testFailureInPoll(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -428,7 +428,7 @@ public void testFailureInPollAfterCancel(boolean enableTopicCreation) throws Exc } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -463,7 +463,7 @@ public void testFailureInPollAfterStop(boolean enableTopicCreation) throws Excep } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // Test that the task handles an empty list of records @@ -495,7 +495,7 @@ public void testPollReturnsNoRecords(boolean enableTopicCreation) throws Excepti } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCommit(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // Test that the task commits properly when prompted @@ -531,7 +531,7 @@ public void testCommit(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCommitFailure(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); // Test that the task commits properly when prompted @@ -567,7 +567,7 @@ public void testCommitFailure(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsRetries(boolean enableTopicCreation) { setup(enableTopicCreation); createWorkerTask(); @@ -602,7 +602,7 @@ public void testSendRecordsRetries(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsProducerCallbackFail(boolean enableTopicCreation) { setup(enableTopicCreation); createWorkerTask(); @@ -623,7 +623,7 @@ public void testSendRecordsProducerCallbackFail(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreation) { setup(enableTopicCreation); createWorkerTask(); @@ -642,7 +642,7 @@ public void testSendRecordsProducerSendFailsImmediately(boolean enableTopicCreat } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSendRecordsTaskCommitRecordFail(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTask(); @@ -667,7 +667,7 @@ public void testSendRecordsTaskCommitRecordFail(boolean enableTopicCreation) thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSourceTaskIgnoresProducerException(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); createWorkerTaskWithErrorToleration(); @@ -707,7 +707,7 @@ public void testSourceTaskIgnoresProducerException(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); final CountDownLatch startupLatch = new CountDownLatch(1); @@ -745,7 +745,7 @@ public void testSlowTaskStart(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCancel(boolean enableTopicCreation) { setup(enableTopicCreation); createWorkerTask(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 11964af9bd74d..3de1548a9a547 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -317,7 +317,7 @@ public void teardown() { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartAndStopConnector(boolean enableTopicCreation) throws Throwable { setup(enableTopicCreation); final String connectorClass = SampleSourceConnector.class.getName(); @@ -386,7 +386,7 @@ private void mockFileConfigProvider() { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartConnectorFailure(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); final String nonConnectorClass = "java.util.HashMap"; @@ -428,7 +428,7 @@ public void testStartConnectorFailure(boolean enableTopicCreation) throws Except } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAddConnectorByAlias(boolean enableTopicCreation) throws Throwable { setup(enableTopicCreation); final String connectorAlias = "SampleSourceConnector"; @@ -473,7 +473,7 @@ public void testAddConnectorByAlias(boolean enableTopicCreation) throws Throwabl } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAddConnectorByShortAlias(boolean enableTopicCreation) throws Throwable { setup(enableTopicCreation); final String shortConnectorAlias = "WorkerTest"; @@ -517,7 +517,7 @@ public void testAddConnectorByShortAlias(boolean enableTopicCreation) throws Thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStopInvalidConnector(boolean enableTopicCreation) { setup(enableTopicCreation); mockKafkaClusterId(); @@ -532,7 +532,7 @@ public void testStopInvalidConnector(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testReconfigureConnectorTasks(boolean enableTopicCreation) throws Throwable { setup(enableTopicCreation); final String connectorClass = SampleSourceConnector.class.getName(); @@ -608,7 +608,7 @@ public void testReconfigureConnectorTasks(boolean enableTopicCreation) throws Th } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAddRemoveSourceTask(boolean enableTopicCreation) { setup(enableTopicCreation); mockKafkaClusterId(); @@ -662,7 +662,7 @@ public void testAddRemoveSourceTask(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAddRemoveSinkTask(boolean enableTopicCreation) { setup(enableTopicCreation); // Most of the other cases use source tasks; we make sure to get code coverage for sink tasks here as well @@ -719,7 +719,7 @@ public void testAddRemoveSinkTask(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAddRemoveExactlyOnceSourceTask(boolean enableTopicCreation) { setup(enableTopicCreation); Map workerProps = new HashMap<>(); @@ -793,7 +793,7 @@ public void testAddRemoveExactlyOnceSourceTask(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testTaskStatusMetricsStatuses(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -877,7 +877,7 @@ public void testTaskStatusMetricsStatuses(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorStatusMetricsGroup_taskStatusCounter(boolean enableTopicCreation) { setup(enableTopicCreation); ConcurrentMap> tasks = new ConcurrentHashMap<>(); @@ -908,7 +908,7 @@ public void testConnectorStatusMetricsGroup_taskStatusCounter(boolean enableTopi } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartTaskFailure(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -938,7 +938,7 @@ public void testStartTaskFailure(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testCleanupTasksOnStop(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -985,7 +985,7 @@ public void testCleanupTasksOnStop(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConverterOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -1041,7 +1041,7 @@ public void testConverterOverrides(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testProducerConfigsWithoutOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); when(connectorConfig.originalsWithPrefix(CONNECTOR_CLIENT_PRODUCER_OVERRIDES_PREFIX)).thenReturn(new HashMap<>()); @@ -1054,7 +1054,7 @@ public void testProducerConfigsWithoutOverrides(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testProducerConfigsWithOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1077,7 +1077,7 @@ public void testProducerConfigsWithOverrides(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testProducerConfigsWithClientOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1105,7 +1105,7 @@ public void testProducerConfigsWithClientOverrides(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConsumerConfigsWithoutOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); Map expectedConfigs = new HashMap<>(defaultConsumerConfigs); @@ -1120,7 +1120,7 @@ public void testConsumerConfigsWithoutOverrides(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConsumerConfigsWithOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1145,7 +1145,7 @@ public void testConsumerConfigsWithOverrides(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConsumerConfigsWithClientOverrides(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1173,7 +1173,7 @@ public void testConsumerConfigsWithClientOverrides(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConsumerConfigsClientOverridesWithNonePolicy(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1192,7 +1192,7 @@ public void testConsumerConfigsClientOverridesWithNonePolicy(boolean enableTopic } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAdminConfigsClientOverridesWithAllPolicy(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1220,7 +1220,7 @@ public void testAdminConfigsClientOverridesWithAllPolicy(boolean enableTopicCrea } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAdminConfigsClientOverridesWithNonePolicy(boolean enableTopicCreation) { setup(enableTopicCreation); Map props = new HashMap<>(workerProps); @@ -1237,7 +1237,7 @@ public void testAdminConfigsClientOverridesWithNonePolicy(boolean enableTopicCre } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testRegularSourceOffsetsConsumerConfigs(boolean enableTopicCreation) { setup(enableTopicCreation); final Map connectorConsumerOverrides = new HashMap<>(); @@ -1278,7 +1278,7 @@ public void testRegularSourceOffsetsConsumerConfigs(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testExactlyOnceSourceOffsetsConsumerConfigs(boolean enableTopicCreation) { setup(enableTopicCreation); final Map connectorConsumerOverrides = new HashMap<>(); @@ -1319,7 +1319,7 @@ public void testExactlyOnceSourceOffsetsConsumerConfigs(boolean enableTopicCreat } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testExactlyOnceSourceTaskProducerConfigs(boolean enableTopicCreation) { setup(enableTopicCreation); final Map connectorProducerOverrides = new HashMap<>(); @@ -1377,7 +1377,7 @@ public void testExactlyOnceSourceTaskProducerConfigs(boolean enableTopicCreation } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testOffsetStoreForRegularSourceConnector(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -1466,7 +1466,7 @@ public void testOffsetStoreForRegularSourceConnector(boolean enableTopicCreation } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testOffsetStoreForExactlyOnceSourceConnector(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -1555,7 +1555,7 @@ public void testOffsetStoreForExactlyOnceSourceConnector(boolean enableTopicCrea } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testOffsetStoreForRegularSourceTask(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -1673,7 +1673,7 @@ public void testOffsetStoreForRegularSourceTask(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testOffsetStoreForExactlyOnceSourceTask(boolean enableTopicCreation) { setup(enableTopicCreation); mockInternalConverters(); @@ -1768,7 +1768,7 @@ public void testOffsetStoreForExactlyOnceSourceTask(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testWorkerMetrics(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1801,7 +1801,7 @@ public void testWorkerMetrics(boolean enableTopicCreation) throws Exception { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testExecutorServiceShutdown(boolean enableTopicCreation) throws InterruptedException { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1824,7 +1824,7 @@ public void testExecutorServiceShutdown(boolean enableTopicCreation) throws Inte } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testExecutorServiceShutdownWhenTerminationFails(boolean enableTopicCreation) throws InterruptedException { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1847,7 +1847,7 @@ public void testExecutorServiceShutdownWhenTerminationFails(boolean enableTopicC } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testExecutorServiceShutdownWhenTerminationThrowsException(boolean enableTopicCreation) throws InterruptedException { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1871,7 +1871,7 @@ public void testExecutorServiceShutdownWhenTerminationThrowsException(boolean en } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) @SuppressWarnings("unchecked") public void testZombieFencing(boolean enableTopicCreation) { setup(enableTopicCreation); @@ -1914,7 +1914,7 @@ public void testZombieFencing(boolean enableTopicCreation) { } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testGetSinkConnectorOffsets(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1943,7 +1943,7 @@ public void testGetSinkConnectorOffsets(boolean enableTopicCreation) throws Exce } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testGetSinkConnectorOffsetsAdminClientSynchronousError(boolean enableTopicCreation) { setup(enableTopicCreation); mockKafkaClusterId(); @@ -1969,7 +1969,7 @@ public void testGetSinkConnectorOffsetsAdminClientSynchronousError(boolean enabl } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testGetSinkConnectorOffsetsAdminClientAsynchronousError(boolean enableTopicCreation) { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2016,7 +2016,7 @@ private void mockAdminListConsumerGroupOffsets(Admin admin, Map, Map> offsets = Collections.singletonMap( @@ -2222,7 +2222,7 @@ public void testNormalizeSourceConnectorOffsets(boolean enableTopicCreation) thr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetsSinkConnectorNoDeletes(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); @SuppressWarnings("unchecked") @@ -2246,7 +2246,7 @@ public void testAlterOffsetsSinkConnectorNoDeletes(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetSinkConnectorOnlyDeletes(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); @SuppressWarnings("unchecked") @@ -2273,7 +2273,7 @@ public void testAlterOffsetSinkConnectorOnlyDeletes(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetsSinkConnectorAltersAndDeletes(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); @SuppressWarnings("unchecked") @@ -2344,7 +2344,7 @@ private void alterOffsetsSinkConnector(Map, Map> parti } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetsSinkConnectorAlterOffsetsError(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2385,7 +2385,7 @@ public void testAlterOffsetsSinkConnectorAlterOffsetsError(boolean enableTopicCr } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetsSinkConnectorDeleteOffsetsError(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2436,7 +2436,7 @@ public void testAlterOffsetsSinkConnectorDeleteOffsetsError(boolean enableTopicC } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testAlterOffsetsSinkConnectorSynchronousError(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2473,7 +2473,7 @@ public void testAlterOffsetsSinkConnectorSynchronousError(boolean enableTopicCre } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) @SuppressWarnings("unchecked") public void testResetOffsetsSourceConnectorExactlyOnceSupportEnabled(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); @@ -2524,7 +2524,7 @@ public void testResetOffsetsSourceConnectorExactlyOnceSupportEnabled(boolean ena } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testResetOffsetsSinkConnector(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2567,7 +2567,7 @@ public void testResetOffsetsSinkConnector(boolean enableTopicCreation) throws Ex } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testResetOffsetsSinkConnectorDeleteConsumerGroupError(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2603,7 +2603,7 @@ public void testResetOffsetsSinkConnectorDeleteConsumerGroupError(boolean enable } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) @SuppressWarnings("unchecked") public void testModifySourceConnectorOffsetsTimeout(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); @@ -2640,7 +2640,7 @@ public void testModifySourceConnectorOffsetsTimeout(boolean enableTopicCreation) } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testModifyOffsetsSinkConnectorTimeout(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); mockKafkaClusterId(); @@ -2672,14 +2672,14 @@ public void testModifyOffsetsSinkConnectorTimeout(boolean enableTopicCreation) t } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorGeneratesTooManyTasksButMaxNotEnforced(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorGeneratesTooManyTasks(false); } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testConnectorGeneratesTooManyTasksAndMaxEnforced(boolean enableTopicCreation) throws Exception { setup(enableTopicCreation); testConnectorGeneratesTooManyTasks(true); @@ -2793,14 +2793,14 @@ private void testConnectorGeneratesTooManyTasks(boolean enforced) throws Excepti } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartTaskWithTooManyTaskConfigsButMaxNotEnforced(boolean enableTopicCreation) { setup(enableTopicCreation); testStartTaskWithTooManyTaskConfigs(false); } @ParameterizedTest - @MethodSource("parameters") + @ValueSource(booleans = {true, false}) public void testStartTaskWithTooManyTaskConfigsAndMaxEnforced(boolean enableTopicCreation) { setup(enableTopicCreation); testStartTaskWithTooManyTaskConfigs(true); From 45256b8c5ac425bbb1f2a2a4f6dfd627d6774b44 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Sun, 16 Jun 2024 13:33:51 +0800 Subject: [PATCH 08/18] update import --- .../runtime/AbstractWorkerSourceTaskTest.java | 25 ++++++++-------- .../runtime/ErrorHandlingTaskTest.java | 2 +- .../ExactlyOnceWorkerSourceTaskTest.java | 1 - .../connect/runtime/MockConnectMetrics.java | 7 +++-- .../runtime/SampleHeaderConverter.java | 5 ++-- .../connect/runtime/SamplePredicate.java | 3 +- .../connect/runtime/SampleSinkConnector.java | 5 ++-- .../runtime/SampleSourceConnector.java | 5 ++-- .../connect/runtime/SampleTransformation.java | 3 +- .../connect/runtime/WorkerConnectorTest.java | 1 - .../connect/runtime/WorkerSourceTaskTest.java | 2 +- .../kafka/connect/runtime/WorkerTest.java | 2 +- .../IncrementalCooperativeAssignorTest.java | 2 +- .../distributed/WorkerCoordinatorTest.java | 2 +- .../runtime/isolation/PluginScannerTest.java | 2 +- .../runtime/isolation/PluginsTest.java | 19 ++++++------ .../isolation/SynchronizationTest.java | 29 ++++++++++--------- .../runtime/isolation/TestPlugins.java | 14 ++++----- .../rest/InternalRequestSignatureTest.java | 1 - .../connect/runtime/rest/RestClientTest.java | 4 +-- .../ConnectorPluginsResourceTest.java | 4 +-- .../standalone/StandaloneHerderTest.java | 6 ++-- 22 files changed, 74 insertions(+), 70 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index b00db2c817c51..139f0f290d648 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.nio.ByteBuffer; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.TimeoutException; -import java.util.function.Supplier; -import java.util.stream.Collectors; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.admin.TopicDescription; import org.apache.kafka.clients.producer.Callback; @@ -79,6 +67,19 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.TimeoutException; +import java.util.function.Supplier; +import java.util.stream.Collectors; + import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index 8d90e71442e1e..a4cb78fab5a2b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -64,7 +64,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoSettings; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index c441707fd6292..fff7d3c188ddb 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -56,7 +56,6 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java index 24c2efba4551f..c5f9f8314d9ef 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java @@ -16,9 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.KafkaMetric; @@ -26,6 +23,10 @@ import org.apache.kafka.common.metrics.MetricsReporter; import org.apache.kafka.common.utils.MockTime; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + /** * A specialization of {@link ConnectMetrics} that uses a custom {@link MetricsReporter} to capture the metrics * that were created, and makes those metrics available even after the metrics were removed from the diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java index f273e05ef8663..3491fde3988c0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java @@ -16,8 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.IOException; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; @@ -25,6 +23,9 @@ import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.storage.HeaderConverter; +import java.io.IOException; +import java.util.Map; + public class SampleHeaderConverter implements HeaderConverter, Versioned { @Override public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java index f573381d1e533..4d72df35ca3e3 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java @@ -16,13 +16,14 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.predicates.Predicate; +import java.util.Map; + public class SamplePredicate implements Predicate, Versioned { private boolean testResult; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java index 578f0a758f27e..da8fb231edc7a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java @@ -16,12 +16,13 @@ */ package org.apache.kafka.connect.runtime; -import java.util.List; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.sink.SinkConnector; +import java.util.List; +import java.util.Map; + public class SampleSinkConnector extends SinkConnector { public static final String VERSION = "some great version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java index 02aefae0bfd78..cb91530439f3d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java @@ -16,14 +16,15 @@ */ package org.apache.kafka.connect.runtime; -import java.util.List; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; +import java.util.List; +import java.util.Map; + public class SampleSourceConnector extends SourceConnector { public static final String VERSION = "an entirely different version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java index d7ea0ea776db6..443b488ef3b46 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java @@ -16,13 +16,14 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; import org.apache.kafka.connect.transforms.Transformation; +import java.util.Map; + public class SampleTransformation> implements Transformation, Versioned { boolean closed = false; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index 895effef54ac8..1c5e1526789b9 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -32,7 +32,6 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; -import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.Mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 071136e62ce40..b84702c05b15f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -56,7 +56,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.Mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 3de1548a9a547..108f4da6efd5a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -89,7 +89,7 @@ import org.apache.kafka.connect.util.TopicAdmin; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; import org.mockito.AdditionalAnswers; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java index 48b7973fdc22e..751846ce462b9 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java @@ -24,8 +24,8 @@ import org.apache.kafka.connect.runtime.TargetState; import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.util.ConnectUtils; import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectUtils; import org.apache.kafka.connect.util.ConnectorTaskId; import org.junit.Before; import org.junit.Test; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java index 1911eb10b1303..5d728a62032e2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java @@ -68,8 +68,8 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertThrows; +import static org.junit.Assert.assertTrue; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java index 4f20ccdeaae7e..9126b2ae996af 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java @@ -34,8 +34,8 @@ import java.util.Set; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; @RunWith(Parameterized.class) public class PluginScannerTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java index 8a637beee5ec0..c08c597f38636 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java @@ -17,15 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.nio.file.Path; -import java.util.Arrays; -import java.util.Collections; -import java.util.Map.Entry; - import org.apache.kafka.common.Configurable; import org.apache.kafka.common.config.AbstractConfig; import org.apache.kafka.common.config.ConfigDef; @@ -33,10 +24,10 @@ import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.components.Versioned; +import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.connector.policy.AllConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.converters.ByteArrayConverter; -import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; @@ -57,9 +48,17 @@ import org.junit.Before; import org.junit.Test; +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.stream.Collectors; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java index e8ba9153bc09b..cbf1be866a20e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java @@ -17,7 +17,19 @@ package org.apache.kafka.connect.runtime.isolation; -import static org.junit.Assert.fail; +import org.apache.kafka.common.config.AbstractConfig; +import org.apache.kafka.common.config.ConfigDef; +import org.apache.kafka.common.config.ConfigDef.Importance; +import org.apache.kafka.common.config.ConfigDef.Type; +import org.apache.kafka.connect.runtime.WorkerConfig; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import java.lang.management.LockInfo; import java.lang.management.ManagementFactory; @@ -40,19 +52,8 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; import java.util.stream.Collectors; -import org.apache.kafka.common.config.AbstractConfig; -import org.apache.kafka.common.config.ConfigDef; -import org.apache.kafka.common.config.ConfigDef.Importance; -import org.apache.kafka.common.config.ConfigDef.Type; -import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.mockito.Mockito; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; + +import static org.junit.Assert.fail; public class SynchronizationTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java index 2bc03b2b7c25f..75e4c82f489bc 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java @@ -17,6 +17,13 @@ package org.apache.kafka.connect.runtime.isolation; +import org.apache.kafka.connect.components.Versioned; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; @@ -40,13 +47,6 @@ import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.stream.Collectors; -import javax.tools.JavaCompiler; -import javax.tools.StandardJavaFileManager; -import javax.tools.ToolProvider; - -import org.apache.kafka.connect.components.Versioned; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * Utility class for constructing test plugins for Connect. diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java index 82fab1313067e..e15d06cc31d29 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java @@ -30,7 +30,6 @@ import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.ws.rs.core.HttpHeaders; - import java.security.NoSuchAlgorithmException; import java.util.Base64; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java index 3c104e0e9307d..d611243a3b10f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java @@ -49,14 +49,14 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java index 589dfb29bd0f5..091d32bfb1214 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java @@ -45,8 +45,8 @@ import org.apache.kafka.connect.runtime.rest.entities.ConfigInfos; import org.apache.kafka.connect.runtime.rest.entities.ConfigKeyInfo; import org.apache.kafka.connect.runtime.rest.entities.ConfigValueInfo; -import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.tools.MockSinkConnector; @@ -88,10 +88,10 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 959e498931096..602d0c5a8521d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -41,20 +41,20 @@ import org.apache.kafka.connect.runtime.WorkerConfigTransformer; import org.apache.kafka.connect.runtime.distributed.SampleConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.runtime.isolation.LoaderSwap; -import org.apache.kafka.connect.runtime.rest.entities.Message; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.ConnectorInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; +import org.apache.kafka.connect.runtime.rest.entities.Message; import org.apache.kafka.connect.runtime.rest.entities.TaskInfo; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceTask; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.MemoryConfigBackingStore; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.Callback; From d0825726855edb33e2cf2fb35c26c581bcb9d208 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 10:06:22 +0800 Subject: [PATCH 09/18] delete redundance --- .../connect/runtime/AbstractHerderTest.java | 31 +++++++------ .../runtime/AbstractWorkerSourceTaskTest.java | 25 +++++------ .../connect/runtime/ConnectMetricsTest.java | 7 ++- .../connect/runtime/ConnectorConfigTest.java | 11 +++-- .../runtime/ErrorHandlingTaskTest.java | 21 +++------ .../ExactlyOnceWorkerSourceTaskTest.java | 39 +++++++--------- .../runtime/InternalSinkRecordTest.java | 3 +- .../kafka/connect/runtime/LoggersTest.java | 21 +++++---- .../connect/runtime/MockConnectMetrics.java | 7 ++- .../connect/runtime/RestartPlanTest.java | 5 +-- .../connect/runtime/RestartRequestTest.java | 3 +- .../runtime/SampleConverterWithHeaders.java | 5 +-- .../runtime/SampleHeaderConverter.java | 5 +-- .../connect/runtime/SamplePredicate.java | 3 +- .../connect/runtime/SampleSinkConnector.java | 5 +-- .../runtime/SampleSourceConnector.java | 5 +-- .../connect/runtime/SampleTransformation.java | 3 +- .../runtime/SourceConnectorConfigTest.java | 5 +-- .../SourceTaskOffsetCommitterTest.java | 17 ++++--- .../connect/runtime/SubmittedRecordsTest.java | 7 ++- .../runtime/TransformationConfigTest.java | 3 +- .../connect/runtime/WorkerConfigTest.java | 9 ++-- .../runtime/WorkerConfigTransformerTest.java | 9 ++-- .../connect/runtime/WorkerConnectorTest.java | 40 +++++++---------- .../runtime/WorkerMetricsGroupTest.java | 3 +- .../connect/runtime/WorkerSinkTaskTest.java | 37 ++++++++-------- .../runtime/WorkerSinkTaskThreadedTest.java | 25 +++++------ .../connect/runtime/WorkerSourceTaskTest.java | 42 ++++++++---------- .../kafka/connect/runtime/WorkerTaskTest.java | 13 +++--- .../kafka/connect/runtime/WorkerTest.java | 44 +++++++++---------- .../connect/runtime/WorkerTestUtils.java | 11 +++-- 31 files changed, 204 insertions(+), 260 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index 0c0318ced8435..736bdb5c6b5cf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -16,6 +16,21 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.producer.ProducerConfig; import org.apache.kafka.common.config.ConfigDef; @@ -64,22 +79,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; - import static org.apache.kafka.connect.runtime.AbstractHerder.keysWithVariableValues; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index 139f0f290d648..b00db2c817c51 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.TimeoutException; +import java.util.function.Supplier; +import java.util.stream.Collectors; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.admin.TopicDescription; import org.apache.kafka.clients.producer.Callback; @@ -67,19 +79,6 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.nio.ByteBuffer; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.TimeoutException; -import java.util.function.Supplier; -import java.util.stream.Collectors; - import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java index 449a2a2eae3fd..d1a51c6c0d35b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java @@ -16,6 +16,9 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.Sensor; @@ -28,10 +31,6 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java index 45b1624da13c9..4bd9181c85daf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java @@ -16,6 +16,11 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.ConfigException; import org.apache.kafka.connect.components.Versioned; @@ -28,12 +33,6 @@ import org.apache.kafka.connect.transforms.predicates.Predicate; import org.junit.jupiter.api.Test; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index a4cb78fab5a2b..70469b46ee2f5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -16,6 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.time.Duration; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; @@ -72,16 +79,6 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.io.IOException; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; - import static java.util.Collections.emptyMap; import static java.util.Collections.singletonList; import static org.apache.kafka.common.utils.Time.SYSTEM; @@ -178,10 +175,6 @@ public class ErrorHandlingTaskTest { private boolean enableTopicCreation; - public static Collection parameters() { - return Arrays.asList(false, true); - } - public void setup(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index fff7d3c188ddb..217a5f208da91 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -16,6 +16,22 @@ */ package org.apache.kafka.connect.runtime; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.stream.Collectors; import org.apache.kafka.clients.producer.Producer; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.KafkaException; @@ -64,24 +80,6 @@ import org.mockito.stubbing.OngoingStubbing; import org.mockito.verification.VerificationMode; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Consumer; -import java.util.stream.Collectors; -import java.util.stream.Stream; - import static java.util.Collections.emptySet; import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; @@ -176,11 +174,6 @@ public class ExactlyOnceWorkerSourceTaskTest { private boolean taskStarted; private Future workerTaskFuture; - - public static Stream parameters() { - return Stream.of(false, true); - } - public void setup(boolean enableTopicCreation) throws Exception { this.enableTopicCreation = enableTopicCreation; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java index 80174b3307dae..7b9005394baff 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java @@ -16,6 +16,7 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.connect.header.Header; import org.apache.kafka.connect.runtime.errors.ProcessingContext; @@ -26,8 +27,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.Collections; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java index 64262b47d3e99..c5e5c8cd78815 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java @@ -16,6 +16,16 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Arrays; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Vector; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; @@ -29,17 +39,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.Arrays; -import java.util.Collections; -import java.util.Enumeration; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Vector; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.Stream; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java index c5f9f8314d9ef..24c2efba4551f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java @@ -16,6 +16,9 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.KafkaMetric; @@ -23,10 +26,6 @@ import org.apache.kafka.common.metrics.MetricsReporter; import org.apache.kafka.common.utils.MockTime; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - /** * A specialization of {@link ConnectMetrics} that uses a custom {@link MetricsReporter} to capture the metrics * that were created, and makes those metrics available even after the metrics were removed from the diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java index 4c695b90b5a69..28214bd5f331d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java @@ -16,14 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.List; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo.TaskState; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; import org.junit.jupiter.api.Test; -import java.util.ArrayList; -import java.util.List; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java index 734bfbe440808..1a28e425c8085 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java @@ -16,11 +16,10 @@ */ package org.apache.kafka.connect.runtime; -import org.junit.jupiter.api.Test; - import java.util.Arrays; import java.util.Collections; import java.util.List; +import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java index 19320736dc95c..562507425589c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java @@ -16,6 +16,8 @@ */ package org.apache.kafka.connect.runtime; +import java.io.UnsupportedEncodingException; +import java.util.Map; import org.apache.kafka.common.header.Header; import org.apache.kafka.common.header.Headers; import org.apache.kafka.common.utils.AppInfoParser; @@ -25,9 +27,6 @@ import org.apache.kafka.connect.errors.DataException; import org.apache.kafka.connect.storage.Converter; -import java.io.UnsupportedEncodingException; -import java.util.Map; - /** * This is a simple Converter implementation that uses "encoding" header to encode/decode strings via provided charset name */ diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java index 3491fde3988c0..f273e05ef8663 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java @@ -16,6 +16,8 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; @@ -23,9 +25,6 @@ import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.storage.HeaderConverter; -import java.io.IOException; -import java.util.Map; - public class SampleHeaderConverter implements HeaderConverter, Versioned { @Override public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java index 4d72df35ca3e3..f573381d1e533 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java @@ -16,14 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.predicates.Predicate; -import java.util.Map; - public class SamplePredicate implements Predicate, Versioned { private boolean testResult; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java index da8fb231edc7a..578f0a758f27e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java @@ -16,13 +16,12 @@ */ package org.apache.kafka.connect.runtime; +import java.util.List; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.sink.SinkConnector; -import java.util.List; -import java.util.Map; - public class SampleSinkConnector extends SinkConnector { public static final String VERSION = "some great version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java index cb91530439f3d..02aefae0bfd78 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java @@ -16,15 +16,14 @@ */ package org.apache.kafka.connect.runtime; +import java.util.List; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; -import java.util.List; -import java.util.Map; - public class SampleSourceConnector extends SourceConnector { public static final String VERSION = "an entirely different version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java index 443b488ef3b46..d7ea0ea776db6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java @@ -16,14 +16,13 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; import org.apache.kafka.connect.transforms.Transformation; -import java.util.Map; - public class SampleTransformation> implements Transformation, Versioned { boolean closed = false; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java index d4592dec6c23b..a867a094b63b2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java @@ -17,14 +17,13 @@ package org.apache.kafka.connect.runtime; -import org.apache.kafka.common.config.ConfigException; -import org.junit.jupiter.api.Test; - import java.util.HashMap; import java.util.Map; import java.util.Objects; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; +import org.apache.kafka.common.config.ConfigException; +import org.junit.jupiter.api.Test; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_COMPACT; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java index a80e904a3e5a6..c2e7c0b96fbea 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java @@ -16,6 +16,14 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CancellationException; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.common.utils.ThreadUtils; import org.apache.kafka.connect.errors.ConnectException; @@ -30,15 +38,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CancellationException; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.ScheduledFuture; -import java.util.concurrent.TimeUnit; - import static java.util.Collections.singletonMap; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java index 2d6e3ecea5b3b..e39fe5cf8c731 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java @@ -16,10 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import java.util.Arrays; import java.util.Collections; import java.util.HashMap; @@ -28,6 +24,9 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; +import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.SubmittedRecords.CommittableOffsets; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java index 1aae5bc842d25..88fdf6d2d7713 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java @@ -16,6 +16,7 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.tools.MockConnector; import org.apache.kafka.connect.transforms.Cast; @@ -32,8 +33,6 @@ import org.apache.kafka.connect.transforms.ValueToKey; import org.junit.jupiter.api.Test; -import java.util.HashMap; - /** * Tests that transformations' configs can be composed with ConnectorConfig during its construction, ensuring no * conflicting fields or other issues. diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java index b95f4145e1291..7d1429d66a37a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java @@ -16,6 +16,10 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.MockAdminClient; import org.apache.kafka.common.Node; @@ -26,11 +30,6 @@ import org.mockito.MockedStatic; import org.mockito.internal.stubbing.answers.CallsRealMethods; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java index d81d9f8179508..2857aeb4763a0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java @@ -16,6 +16,10 @@ */ package org.apache.kafka.connect.runtime; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; import org.apache.kafka.common.config.ConfigData; import org.apache.kafka.common.config.provider.ConfigProvider; import org.junit.jupiter.api.BeforeEach; @@ -26,11 +30,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; - import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_NONE; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index 1c5e1526789b9..465c6e0e006d3 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -16,6 +16,8 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; +import java.util.Map; import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.health.ConnectorType; @@ -39,11 +41,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.Arrays; -import java.util.Collection; -import java.util.HashMap; -import java.util.Map; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; @@ -67,6 +64,7 @@ public class WorkerConnectorTest { private static final String VERSION = "1.1"; public static final String CONNECTOR = "connector"; public static final Map CONFIG = new HashMap<>(); + static { CONFIG.put(ConnectorConfig.CONNECTOR_CLASS_CONFIG, TestConnector.class.getName()); CONFIG.put(ConnectorConfig.NAME_CONFIG, CONNECTOR); @@ -86,10 +84,6 @@ public class WorkerConnectorTest { private CloseableOffsetStorageReader offsetStorageReader; private ConnectorOffsetBackingStore offsetStore; - public static Collection parameters() { - return Arrays.asList(ConnectorType.SOURCE, ConnectorType.SINK); - } - private void setConnector(ConnectorType connectorType) { this.connectorType = connectorType; switch (connectorType) { @@ -120,7 +114,7 @@ public void tearDown() { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testInitializeFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -171,7 +165,7 @@ public void testFailureIsFinalState(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndShutdown(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -197,7 +191,7 @@ public void testStartupAndShutdown(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndPause(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -228,7 +222,7 @@ public void testStartupAndPause(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupAndStop(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -260,7 +254,7 @@ public void testStartupAndStop(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testOnResume(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -292,7 +286,7 @@ public void testOnResume(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupPaused(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -318,7 +312,7 @@ public void testStartupPaused(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupStopped(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -344,7 +338,7 @@ public void testStartupStopped(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStartupFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -373,7 +367,7 @@ public void testStartupFailure(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testStopFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -417,7 +411,7 @@ public void testStopFailure(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testShutdownFailure(ConnectorType connectorType) { setup(connectorType); RuntimeException exception = new RuntimeException(); @@ -447,7 +441,7 @@ public void testShutdownFailure(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionStartedToStarted(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -476,7 +470,7 @@ public void testTransitionStartedToStarted(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionPausedToPaused(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -509,7 +503,7 @@ public void testTransitionPausedToPaused(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testTransitionStoppedToStopped(ConnectorType connectorType) { setup(connectorType); when(connector.version()).thenReturn(VERSION); @@ -542,7 +536,7 @@ public void testTransitionStoppedToStopped(ConnectorType connectorType) { } @ParameterizedTest - @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) + @EnumSource(value = ConnectorType.class, names = {"SOURCE", "SINK"}) public void testFailConnectorThatIsNeitherSourceNorSink(ConnectorType connectorType) { setup(connectorType); Connector badConnector = mock(Connector.class); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index a909b79fb133e..fc5294c0358a6 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -16,6 +16,7 @@ */ package org.apache.kafka.connect.runtime; +import java.util.HashMap; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.MetricNameTemplate; import org.apache.kafka.common.metrics.CompoundStat; @@ -30,8 +31,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.HashMap; - import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyDouble; import static org.mockito.ArgumentMatchers.isNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java index c0e4c4dfa7697..82b8c798e91ed 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java @@ -16,6 +16,24 @@ */ package org.apache.kafka.connect.runtime; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -68,25 +86,6 @@ import org.mockito.stubbing.Answer; import org.mockito.stubbing.OngoingStubbing; -import java.time.Duration; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.regex.Pattern; -import java.util.stream.Collectors; - import static java.util.Arrays.asList; import static java.util.Collections.singleton; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index 54a3dea59eece..4be63978830a5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -16,6 +16,18 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -56,19 +68,6 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.io.IOException; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.function.Function; - import static java.util.Collections.singletonList; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index b84702c05b15f..10a54239c013c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -16,6 +16,24 @@ */ package org.apache.kafka.connect.runtime; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Supplier; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.producer.Callback; import org.apache.kafka.clients.producer.KafkaProducer; @@ -65,26 +83,6 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Supplier; -import java.util.stream.Stream; - import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; @@ -189,10 +187,6 @@ public class WorkerSourceTaskTest { private boolean enableTopicCreation; - public static Stream parameters() { - return Stream.of(false, true); - } - public void setup(boolean enableTopicCreation) { this.enableTopicCreation = enableTopicCreation; Map workerProps = workerProps(); diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java index 665fbf65f72b4..84bbf4b5e64b7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java @@ -16,6 +16,12 @@ */ package org.apache.kafka.connect.runtime; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.function.Supplier; import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.errors.ConnectException; @@ -37,13 +43,6 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CountDownLatch; -import java.util.function.Supplier; - import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.fail; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 108f4da6efd5a..1db34179cd844 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -16,6 +16,26 @@ */ package org.apache.kafka.connect.runtime; +import javax.management.MBeanServer; +import javax.management.ObjectName; +import java.lang.management.ManagementFactory; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.Admin; import org.apache.kafka.clients.admin.AlterConsumerGroupOffsetsOptions; @@ -100,27 +120,6 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.quality.Strictness; -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.lang.management.ManagementFactory; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; - import static org.apache.kafka.clients.admin.AdminClientConfig.RETRY_BACKOFF_MS_CONFIG; import static org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_CONFIG; import static org.apache.kafka.clients.producer.ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG; @@ -240,9 +239,6 @@ public class WorkerTest { private MockedConstruction sinkTaskMockedConstruction; private MockitoSession mockitoSession; - public static Collection parameters() { - return Arrays.asList(false, true); - } public void setup(boolean enableTopicCreation) { // Use strict mode to detect unused mocks diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java index f85e7e9bb0b04..e0a9ea8ce41bc 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java @@ -16,12 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; -import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; -import org.apache.kafka.connect.util.ConnectorTaskId; - import java.util.AbstractMap.SimpleEntry; import java.util.Collections; import java.util.HashMap; @@ -29,6 +23,11 @@ import java.util.Map; import java.util.stream.Collectors; import java.util.stream.IntStream; +import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; +import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectorTaskId; import static org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.WorkerLoad; import static org.hamcrest.CoreMatchers.is; From 9882ebc9b774c3008940dff9afab074ab7541e8b Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 10:10:46 +0800 Subject: [PATCH 10/18] delete redundance --- .../connect/runtime/AbstractHerderTest.java | 32 +++++++------- .../runtime/AbstractWorkerSourceTaskTest.java | 26 +++++------ .../connect/runtime/ConnectMetricsTest.java | 8 ++-- .../connect/runtime/ConnectorConfigTest.java | 12 +++--- .../runtime/ErrorHandlingTaskTest.java | 16 ++++--- .../ExactlyOnceWorkerSourceTaskTest.java | 34 ++++++++------- .../runtime/InternalSinkRecordTest.java | 4 +- .../kafka/connect/runtime/LoggersTest.java | 22 +++++----- .../connect/runtime/MockConnectMetrics.java | 7 +-- .../connect/runtime/RestartPlanTest.java | 6 ++- .../connect/runtime/RestartRequestTest.java | 3 +- .../runtime/SampleConverterWithHeaders.java | 5 ++- .../runtime/SampleHeaderConverter.java | 5 ++- .../connect/runtime/SamplePredicate.java | 3 +- .../connect/runtime/SampleSinkConnector.java | 5 ++- .../runtime/SampleSourceConnector.java | 5 ++- .../connect/runtime/SampleTransformation.java | 3 +- .../runtime/SourceConnectorConfigTest.java | 6 ++- .../SourceTaskOffsetCommitterTest.java | 18 ++++---- .../connect/runtime/StateTrackerTest.java | 1 + .../connect/runtime/SubmittedRecordsTest.java | 8 ++-- .../runtime/TransformationConfigTest.java | 4 +- .../runtime/TransformationStageTest.java | 1 + .../connect/runtime/WorkerConfigTest.java | 10 +++-- .../runtime/WorkerConfigTransformerTest.java | 10 +++-- .../connect/runtime/WorkerConnectorTest.java | 6 ++- .../runtime/WorkerMetricsGroupTest.java | 4 +- .../connect/runtime/WorkerSinkTaskTest.java | 38 ++++++++-------- .../runtime/WorkerSinkTaskThreadedTest.java | 26 +++++------ .../connect/runtime/WorkerSourceTaskTest.java | 38 ++++++++-------- .../kafka/connect/runtime/WorkerTaskTest.java | 14 +++--- .../kafka/connect/runtime/WorkerTest.java | 43 ++++++++++--------- .../connect/runtime/WorkerTestUtils.java | 11 ++--- .../runtime/WorkerTransactionContextTest.java | 1 + 34 files changed, 246 insertions(+), 189 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index 736bdb5c6b5cf..ad131bc8bbe0b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -16,21 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.TimeUnit; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.stream.Collectors; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.producer.ProducerConfig; import org.apache.kafka.common.config.ConfigDef; @@ -71,6 +56,7 @@ import org.apache.kafka.connect.util.Callback; import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.FutureCallback; + import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.ArgumentCaptor; @@ -79,6 +65,22 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.stream.Collectors; + import static org.apache.kafka.connect.runtime.AbstractHerder.keysWithVariableValues; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index b00db2c817c51..2a1460bbfb822 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.nio.ByteBuffer; -import java.nio.charset.StandardCharsets; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.TimeoutException; -import java.util.function.Supplier; -import java.util.stream.Collectors; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.admin.TopicDescription; import org.apache.kafka.clients.producer.Callback; @@ -67,6 +55,7 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -79,6 +68,19 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.TimeoutException; +import java.util.function.Supplier; +import java.util.stream.Collectors; + import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java index d1a51c6c0d35b..b4f53e630125d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectMetricsTest.java @@ -16,9 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.Sensor; @@ -27,10 +24,15 @@ import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroup; import org.apache.kafka.connect.runtime.ConnectMetrics.MetricGroupId; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java index 4bd9181c85daf..6092f8ca7bdc7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ConnectorConfigTest.java @@ -16,11 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.config.ConfigException; import org.apache.kafka.connect.components.Versioned; @@ -31,8 +26,15 @@ import org.apache.kafka.connect.sink.SinkRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; + import org.junit.jupiter.api.Test; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java index 70469b46ee2f5..fbb045d3976fb 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ErrorHandlingTaskTest.java @@ -16,13 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.IOException; -import java.time.Duration; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; @@ -68,6 +61,7 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; @@ -79,6 +73,14 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.IOException; +import java.time.Duration; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + import static java.util.Collections.emptyMap; import static java.util.Collections.singletonList; import static org.apache.kafka.common.utils.Time.SYSTEM; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java index 217a5f208da91..be3dc2401ad69 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/ExactlyOnceWorkerSourceTaskTest.java @@ -16,22 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Consumer; -import java.util.stream.Collectors; import org.apache.kafka.clients.producer.Producer; import org.apache.kafka.clients.producer.RecordMetadata; import org.apache.kafka.common.KafkaException; @@ -69,6 +53,7 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; @@ -80,6 +65,23 @@ import org.mockito.stubbing.OngoingStubbing; import org.mockito.verification.VerificationMode; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; +import java.util.stream.Collectors; + import static java.util.Collections.emptySet; import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java index 7b9005394baff..f76c05a005169 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/InternalSinkRecordTest.java @@ -16,17 +16,19 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Collections; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.connect.header.Header; import org.apache.kafka.connect.runtime.errors.ProcessingContext; import org.apache.kafka.connect.sink.SinkRecord; + import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.Collections; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.mock; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java index c5e5c8cd78815..3dbe688a076a2 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/LoggersTest.java @@ -16,19 +16,10 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Arrays; -import java.util.Collections; -import java.util.Enumeration; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Vector; -import java.util.function.Function; -import java.util.stream.Collectors; -import java.util.stream.Stream; import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.runtime.rest.entities.LoggerLevel; + import org.apache.log4j.Hierarchy; import org.apache.log4j.Level; import org.apache.log4j.Logger; @@ -39,6 +30,17 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.Arrays; +import java.util.Collections; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Vector; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java index 24c2efba4551f..c5f9f8314d9ef 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/MockConnectMetrics.java @@ -16,9 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.metrics.KafkaMetric; @@ -26,6 +23,10 @@ import org.apache.kafka.common.metrics.MetricsReporter; import org.apache.kafka.common.utils.MockTime; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + /** * A specialization of {@link ConnectMetrics} that uses a custom {@link MetricsReporter} to capture the metrics * that were created, and makes those metrics available even after the metrics were removed from the diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java index 28214bd5f331d..8d6f54ce2581b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartPlanTest.java @@ -16,13 +16,15 @@ */ package org.apache.kafka.connect.runtime; -import java.util.ArrayList; -import java.util.List; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo.TaskState; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; + import org.junit.jupiter.api.Test; +import java.util.ArrayList; +import java.util.List; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java index 1a28e425c8085..734bfbe440808 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/RestartRequestTest.java @@ -16,10 +16,11 @@ */ package org.apache.kafka.connect.runtime; +import org.junit.jupiter.api.Test; + import java.util.Arrays; import java.util.Collections; import java.util.List; -import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java index 562507425589c..19320736dc95c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleConverterWithHeaders.java @@ -16,8 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.UnsupportedEncodingException; -import java.util.Map; import org.apache.kafka.common.header.Header; import org.apache.kafka.common.header.Headers; import org.apache.kafka.common.utils.AppInfoParser; @@ -27,6 +25,9 @@ import org.apache.kafka.connect.errors.DataException; import org.apache.kafka.connect.storage.Converter; +import java.io.UnsupportedEncodingException; +import java.util.Map; + /** * This is a simple Converter implementation that uses "encoding" header to encode/decode strings via provided charset name */ diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java index f273e05ef8663..3491fde3988c0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleHeaderConverter.java @@ -16,8 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.IOException; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; @@ -25,6 +23,9 @@ import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.storage.HeaderConverter; +import java.io.IOException; +import java.util.Map; + public class SampleHeaderConverter implements HeaderConverter, Versioned { @Override public SchemaAndValue toConnectHeader(String topic, String headerKey, byte[] value) { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java index f573381d1e533..4d72df35ca3e3 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SamplePredicate.java @@ -16,13 +16,14 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.predicates.Predicate; +import java.util.Map; + public class SamplePredicate implements Predicate, Versioned { private boolean testResult; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java index 578f0a758f27e..da8fb231edc7a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSinkConnector.java @@ -16,12 +16,13 @@ */ package org.apache.kafka.connect.runtime; -import java.util.List; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.sink.SinkConnector; +import java.util.List; +import java.util.Map; + public class SampleSinkConnector extends SinkConnector { public static final String VERSION = "some great version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java index 02aefae0bfd78..cb91530439f3d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleSourceConnector.java @@ -16,14 +16,15 @@ */ package org.apache.kafka.connect.runtime; -import java.util.List; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.connect.connector.Task; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.source.SourceTask; +import java.util.List; +import java.util.Map; + public class SampleSourceConnector extends SourceConnector { public static final String VERSION = "an entirely different version"; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java index d7ea0ea776db6..443b488ef3b46 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SampleTransformation.java @@ -16,13 +16,14 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Map; import org.apache.kafka.common.config.ConfigDef; import org.apache.kafka.common.utils.AppInfoParser; import org.apache.kafka.connect.components.Versioned; import org.apache.kafka.connect.connector.ConnectRecord; import org.apache.kafka.connect.transforms.Transformation; +import java.util.Map; + public class SampleTransformation> implements Transformation, Versioned { boolean closed = false; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java index a867a094b63b2..b3ad1db30e71d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceConnectorConfigTest.java @@ -17,13 +17,15 @@ package org.apache.kafka.connect.runtime; +import org.apache.kafka.common.config.ConfigException; + +import org.junit.jupiter.api.Test; + import java.util.HashMap; import java.util.Map; import java.util.Objects; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; -import org.apache.kafka.common.config.ConfigException; -import org.junit.jupiter.api.Test; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_COMPACT; import static org.apache.kafka.common.config.TopicConfig.CLEANUP_POLICY_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java index c2e7c0b96fbea..158e51dc8e22c 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SourceTaskOffsetCommitterTest.java @@ -16,19 +16,12 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; -import java.util.Map; -import java.util.concurrent.CancellationException; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.ScheduledFuture; -import java.util.concurrent.TimeUnit; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.common.utils.ThreadUtils; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.runtime.standalone.StandaloneConfig; import org.apache.kafka.connect.util.ConnectorTaskId; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -38,6 +31,15 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CancellationException; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; + import static java.util.Collections.singletonMap; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java index 349230e696476..8c5535e809abf 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/StateTrackerTest.java @@ -18,6 +18,7 @@ import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.connect.runtime.AbstractStatus.State; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java index e39fe5cf8c731..8feeee0588a0f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/SubmittedRecordsTest.java @@ -16,6 +16,11 @@ */ package org.apache.kafka.connect.runtime; +import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + import java.util.Arrays; import java.util.Collections; import java.util.HashMap; @@ -24,9 +29,6 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; -import org.apache.kafka.connect.runtime.SubmittedRecords.SubmittedRecord; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; import static org.apache.kafka.connect.runtime.SubmittedRecords.CommittableOffsets; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java index 88fdf6d2d7713..2a6c0ed2b9d1d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationConfigTest.java @@ -16,7 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.tools.MockConnector; import org.apache.kafka.connect.transforms.Cast; @@ -31,8 +30,11 @@ import org.apache.kafka.connect.transforms.TimestampConverter; import org.apache.kafka.connect.transforms.TimestampRouter; import org.apache.kafka.connect.transforms.ValueToKey; + import org.junit.jupiter.api.Test; +import java.util.HashMap; + /** * Tests that transformations' configs can be composed with ConnectorConfig during its construction, ensuring no * conflicting fields or other issues. diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index 8ccb190050d44..7db714b6808f7 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -19,6 +19,7 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; + import org.junit.jupiter.api.Test; import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java index 7d1429d66a37a..4ad4c11ee89cd 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTest.java @@ -16,20 +16,22 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.MockAdminClient; import org.apache.kafka.common.Node; import org.apache.kafka.connect.errors.ConnectException; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.MockedStatic; import org.mockito.internal.stubbing.answers.CallsRealMethods; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java index 2857aeb4763a0..c3a8f151750ec 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConfigTransformerTest.java @@ -16,12 +16,9 @@ */ package org.apache.kafka.connect.runtime; -import java.util.Collections; -import java.util.HashMap; -import java.util.Map; -import java.util.Set; import org.apache.kafka.common.config.ConfigData; import org.apache.kafka.common.config.provider.ConfigProvider; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -30,6 +27,11 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONFIG_RELOAD_ACTION_NONE; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java index 465c6e0e006d3..1fd45e2bf00ed 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerConnectorTest.java @@ -16,8 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; -import java.util.Map; import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.errors.ConnectException; import org.apache.kafka.connect.health.ConnectorType; @@ -30,6 +28,7 @@ import org.apache.kafka.connect.storage.CloseableOffsetStorageReader; import org.apache.kafka.connect.storage.ConnectorOffsetBackingStore; import org.apache.kafka.connect.util.Callback; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; @@ -41,6 +40,9 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.HashMap; +import java.util.Map; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertInstanceOf; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index fc5294c0358a6..e956129b7cf58 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -16,13 +16,13 @@ */ package org.apache.kafka.connect.runtime; -import java.util.HashMap; import org.apache.kafka.common.MetricName; import org.apache.kafka.common.MetricNameTemplate; import org.apache.kafka.common.metrics.CompoundStat; import org.apache.kafka.common.metrics.Sensor; import org.apache.kafka.common.metrics.stats.CumulativeSum; import org.apache.kafka.connect.util.ConnectorTaskId; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -31,6 +31,8 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.HashMap; + import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyDouble; import static org.mockito.ArgumentMatchers.isNull; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java index 82b8c798e91ed..baa6d81aa83fe 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskTest.java @@ -16,24 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.time.Duration; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; -import java.util.function.Supplier; -import java.util.regex.Pattern; -import java.util.stream.Collectors; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -74,6 +56,7 @@ import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.util.ConnectorTaskId; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -86,6 +69,25 @@ import org.mockito.stubbing.Answer; import org.mockito.stubbing.OngoingStubbing; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + import static java.util.Arrays.asList; import static java.util.Collections.singleton; import static org.junit.jupiter.api.Assertions.assertEquals; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index 4be63978830a5..dd141161cc9ce 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -16,18 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.IOException; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.function.Function; import org.apache.kafka.clients.consumer.ConsumerRebalanceListener; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.apache.kafka.clients.consumer.ConsumerRecords; @@ -55,6 +43,7 @@ import org.apache.kafka.connect.storage.HeaderConverter; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -68,6 +57,19 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; +import java.io.IOException; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; + import static java.util.Collections.singletonList; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 10a54239c013c..5bed72c5be986 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -16,24 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.io.IOException; -import java.nio.charset.StandardCharsets; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Supplier; import org.apache.kafka.clients.admin.NewTopic; import org.apache.kafka.clients.producer.Callback; import org.apache.kafka.clients.producer.KafkaProducer; @@ -71,6 +53,7 @@ import org.apache.kafka.connect.util.ConnectorTaskId; import org.apache.kafka.connect.util.TopicAdmin; import org.apache.kafka.connect.util.TopicCreationGroup; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.extension.ExtendWith; import org.junit.jupiter.params.ParameterizedTest; @@ -83,6 +66,25 @@ import org.mockito.quality.Strictness; import org.mockito.stubbing.Answer; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Supplier; + import static org.apache.kafka.connect.integration.MonitorableSourceConnector.TOPIC_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.CONNECTOR_CLASS_CONFIG; import static org.apache.kafka.connect.runtime.ConnectorConfig.KEY_CONVERTER_CLASS_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java index 84bbf4b5e64b7..c8c8cc49d0565 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTaskTest.java @@ -16,12 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CountDownLatch; -import java.util.function.Supplier; import org.apache.kafka.common.utils.MockTime; import org.apache.kafka.common.utils.Time; import org.apache.kafka.connect.errors.ConnectException; @@ -34,6 +28,7 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.ConnectorTaskId; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; @@ -43,6 +38,13 @@ import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CountDownLatch; +import java.util.function.Supplier; + import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; import static org.junit.jupiter.api.Assertions.fail; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java index 1db34179cd844..bd7b980b4089d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTest.java @@ -16,26 +16,6 @@ */ package org.apache.kafka.connect.runtime; -import javax.management.MBeanServer; -import javax.management.ObjectName; -import java.lang.management.ManagementFactory; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicReference; -import java.util.function.Function; import org.apache.kafka.clients.CommonClientConfigs; import org.apache.kafka.clients.admin.Admin; import org.apache.kafka.clients.admin.AlterConsumerGroupOffsetsOptions; @@ -107,6 +87,7 @@ import org.apache.kafka.connect.util.FutureCallback; import org.apache.kafka.connect.util.SinkUtils; import org.apache.kafka.connect.util.TopicAdmin; + import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; @@ -120,6 +101,28 @@ import org.mockito.invocation.InvocationOnMock; import org.mockito.quality.Strictness; +import java.lang.management.ManagementFactory; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Function; + +import javax.management.MBeanServer; +import javax.management.ObjectName; + import static org.apache.kafka.clients.admin.AdminClientConfig.RETRY_BACKOFF_MS_CONFIG; import static org.apache.kafka.clients.consumer.ConsumerConfig.ISOLATION_LEVEL_CONFIG; import static org.apache.kafka.clients.producer.ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java index e0a9ea8ce41bc..f85e7e9bb0b04 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTestUtils.java @@ -16,6 +16,12 @@ */ package org.apache.kafka.connect.runtime; +import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; +import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; +import org.apache.kafka.connect.util.ConnectorTaskId; + import java.util.AbstractMap.SimpleEntry; import java.util.Collections; import java.util.HashMap; @@ -23,11 +29,6 @@ import java.util.Map; import java.util.stream.Collectors; import java.util.stream.IntStream; -import org.apache.kafka.connect.runtime.distributed.ExtendedAssignment; -import org.apache.kafka.connect.runtime.distributed.ExtendedWorkerState; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; -import org.apache.kafka.connect.util.ConnectorTaskId; import static org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.WorkerLoad; import static org.hamcrest.CoreMatchers.is; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java index 6906afa47012c..e9cc66d05aa33 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerTransactionContextTest.java @@ -17,6 +17,7 @@ package org.apache.kafka.connect.runtime; import org.apache.kafka.connect.source.SourceRecord; + import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertFalse; From d5071265a946728afb29e4bae311870bae499006 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:33:24 +0800 Subject: [PATCH 11/18] revert standalone --- .../runtime/standalone/StandaloneHerderTest.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 602d0c5a8521d..92ab6bd149a7a 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -41,20 +41,20 @@ import org.apache.kafka.connect.runtime.WorkerConfigTransformer; import org.apache.kafka.connect.runtime.distributed.SampleConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.runtime.isolation.LoaderSwap; +import org.apache.kafka.connect.runtime.rest.entities.Message; +import org.apache.kafka.connect.storage.AppliedConnectorConfig; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.runtime.isolation.PluginClassLoader; import org.apache.kafka.connect.runtime.isolation.Plugins; import org.apache.kafka.connect.runtime.rest.entities.ConnectorInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorStateInfo; import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; -import org.apache.kafka.connect.runtime.rest.entities.Message; import org.apache.kafka.connect.runtime.rest.entities.TaskInfo; import org.apache.kafka.connect.runtime.rest.errors.BadRequestException; import org.apache.kafka.connect.sink.SinkConnector; import org.apache.kafka.connect.sink.SinkTask; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.source.SourceTask; -import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.storage.MemoryConfigBackingStore; import org.apache.kafka.connect.storage.StatusBackingStore; import org.apache.kafka.connect.util.Callback; @@ -1205,16 +1205,16 @@ private void expectConfigValidation( } // We need to use a real class here due to some issue with mocking java.lang.Class - private abstract static class BogusSourceConnector extends SourceConnector { + private static abstract class BogusSourceConnector extends SourceConnector { } - private abstract static class BogusSourceTask extends SourceTask { + private static abstract class BogusSourceTask extends SourceTask { } - private abstract static class BogusSinkConnector extends SinkConnector { + private static abstract class BogusSinkConnector extends SinkConnector { } - private abstract static class BogusSinkTask extends SourceTask { + private static abstract class BogusSinkTask extends SourceTask { } private void verifyConnectorStatusRestart() { From 4dc8bc7b23198500d8eae815a231fc14c624cc1a Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:35:04 +0800 Subject: [PATCH 12/18] revert rest --- .../connect/runtime/rest/InternalRequestSignatureTest.java | 1 + .../org/apache/kafka/connect/runtime/rest/RestClientTest.java | 4 ++-- .../runtime/rest/resources/ConnectorPluginsResourceTest.java | 4 ++-- 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java index e15d06cc31d29..82fab1313067e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/InternalRequestSignatureTest.java @@ -30,6 +30,7 @@ import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import javax.ws.rs.core.HttpHeaders; + import java.security.NoSuchAlgorithmException; import java.util.Base64; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java index d611243a3b10f..3c104e0e9307d 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/RestClientTest.java @@ -49,14 +49,14 @@ import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertInstanceOf; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java index 091d32bfb1214..589dfb29bd0f5 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/rest/resources/ConnectorPluginsResourceTest.java @@ -45,8 +45,8 @@ import org.apache.kafka.connect.runtime.rest.entities.ConfigInfos; import org.apache.kafka.connect.runtime.rest.entities.ConfigKeyInfo; import org.apache.kafka.connect.runtime.rest.entities.ConfigValueInfo; -import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; import org.apache.kafka.connect.runtime.rest.entities.PluginInfo; +import org.apache.kafka.connect.runtime.rest.entities.ConnectorType; import org.apache.kafka.connect.source.SourceConnector; import org.apache.kafka.connect.storage.StringConverter; import org.apache.kafka.connect.tools.MockSinkConnector; @@ -88,10 +88,10 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.atLeastOnce; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; From b1c3253ebb3528d1cee9b01f00404c992190f2fb Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:35:47 +0800 Subject: [PATCH 13/18] revert isolation --- .../runtime/isolation/PluginScannerTest.java | 2 +- .../runtime/isolation/PluginsTest.java | 19 ++++++------ .../isolation/SynchronizationTest.java | 29 +++++++++---------- .../runtime/isolation/TestPlugins.java | 14 ++++----- 4 files changed, 32 insertions(+), 32 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java index 9126b2ae996af..4f20ccdeaae7e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginScannerTest.java @@ -34,8 +34,8 @@ import java.util.Set; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; @RunWith(Parameterized.class) public class PluginScannerTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java index c08c597f38636..8a637beee5ec0 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/PluginsTest.java @@ -17,6 +17,15 @@ package org.apache.kafka.connect.runtime.isolation; +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.nio.file.Path; +import java.util.Arrays; +import java.util.Collections; +import java.util.Map.Entry; + import org.apache.kafka.common.Configurable; import org.apache.kafka.common.config.AbstractConfig; import org.apache.kafka.common.config.ConfigDef; @@ -24,10 +33,10 @@ import org.apache.kafka.common.config.provider.ConfigProvider; import org.apache.kafka.common.utils.LogCaptureAppender; import org.apache.kafka.connect.components.Versioned; -import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.connector.policy.AllConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.connector.policy.ConnectorClientConfigOverridePolicy; import org.apache.kafka.connect.converters.ByteArrayConverter; +import org.apache.kafka.connect.connector.Connector; import org.apache.kafka.connect.data.Schema; import org.apache.kafka.connect.data.SchemaAndValue; import org.apache.kafka.connect.errors.ConnectException; @@ -48,17 +57,9 @@ import org.junit.Before; import org.junit.Test; -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.nio.file.Path; -import java.util.Arrays; -import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; import java.util.SortedSet; import java.util.stream.Collectors; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java index cbf1be866a20e..e8ba9153bc09b 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/SynchronizationTest.java @@ -17,19 +17,7 @@ package org.apache.kafka.connect.runtime.isolation; -import org.apache.kafka.common.config.AbstractConfig; -import org.apache.kafka.common.config.ConfigDef; -import org.apache.kafka.common.config.ConfigDef.Importance; -import org.apache.kafka.common.config.ConfigDef.Type; -import org.apache.kafka.connect.runtime.WorkerConfig; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.mockito.Mockito; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import static org.junit.Assert.fail; import java.lang.management.LockInfo; import java.lang.management.ManagementFactory; @@ -52,8 +40,19 @@ import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Predicate; import java.util.stream.Collectors; - -import static org.junit.Assert.fail; +import org.apache.kafka.common.config.AbstractConfig; +import org.apache.kafka.common.config.ConfigDef; +import org.apache.kafka.common.config.ConfigDef.Importance; +import org.apache.kafka.common.config.ConfigDef.Type; +import org.apache.kafka.connect.runtime.WorkerConfig; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestName; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public class SynchronizationTest { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java index 75e4c82f489bc..2bc03b2b7c25f 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/isolation/TestPlugins.java @@ -17,13 +17,6 @@ package org.apache.kafka.connect.runtime.isolation; -import org.apache.kafka.connect.components.Versioned; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import javax.tools.JavaCompiler; -import javax.tools.StandardJavaFileManager; -import javax.tools.ToolProvider; import java.io.BufferedInputStream; import java.io.File; import java.io.IOException; @@ -47,6 +40,13 @@ import java.util.jar.JarOutputStream; import java.util.jar.Manifest; import java.util.stream.Collectors; +import javax.tools.JavaCompiler; +import javax.tools.StandardJavaFileManager; +import javax.tools.ToolProvider; + +import org.apache.kafka.connect.components.Versioned; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Utility class for constructing test plugins for Connect. From ff17c5310e43e8ad873bf2568d9866fbea76ecb3 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:36:45 +0800 Subject: [PATCH 14/18] revert distributed --- .../connect/runtime/distributed/DistributedHerderTest.java | 4 ++-- .../distributed/IncrementalCooperativeAssignorTest.java | 2 +- .../connect/runtime/distributed/WorkerCoordinatorTest.java | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java index 028e5202bf529..f2b73e9699743 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java @@ -4275,10 +4275,10 @@ private static List expectRecordStages(Callback callback) { } // We need to use a real class here due to some issue with mocking java.lang.Class - private abstract static class BogusSourceConnector extends SourceConnector { + private static abstract class BogusSourceConnector extends SourceConnector { } - private abstract static class BogusSourceTask extends SourceTask { + private static abstract class BogusSourceTask extends SourceTask { } /** diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java index 751846ce462b9..48b7973fdc22e 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/IncrementalCooperativeAssignorTest.java @@ -24,8 +24,8 @@ import org.apache.kafka.connect.runtime.TargetState; import org.apache.kafka.connect.runtime.distributed.WorkerCoordinator.ConnectorsAndTasks; import org.apache.kafka.connect.storage.AppliedConnectorConfig; -import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.util.ConnectUtils; +import org.apache.kafka.connect.storage.ClusterConfigState; import org.apache.kafka.connect.util.ConnectorTaskId; import org.junit.Before; import org.junit.Test; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java index 5d728a62032e2..1911eb10b1303 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/WorkerCoordinatorTest.java @@ -68,8 +68,8 @@ import static org.apache.kafka.connect.runtime.distributed.ConnectProtocolCompatibility.EAGER; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertThrows; import static org.junit.runners.Parameterized.Parameter; import static org.junit.runners.Parameterized.Parameters; import static org.mockito.Mockito.mock; From a06aac9cc3ede3cec999d50a27ba285a1eef8a29 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:40:05 +0800 Subject: [PATCH 15/18] Update DistributedHerderTest.java --- .../connect/runtime/distributed/DistributedHerderTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java index f2b73e9699743..028e5202bf529 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java @@ -4275,10 +4275,10 @@ private static List expectRecordStages(Callback callback) { } // We need to use a real class here due to some issue with mocking java.lang.Class - private static abstract class BogusSourceConnector extends SourceConnector { + private abstract static class BogusSourceConnector extends SourceConnector { } - private static abstract class BogusSourceTask extends SourceTask { + private abstract static class BogusSourceTask extends SourceTask { } /** From 1b3f9445b1146b998141e36fa062b77d273ce4d2 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 11:41:07 +0800 Subject: [PATCH 16/18] Update StandaloneHerderTest.java --- .../connect/runtime/standalone/StandaloneHerderTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 92ab6bd149a7a..959e498931096 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -1205,16 +1205,16 @@ private void expectConfigValidation( } // We need to use a real class here due to some issue with mocking java.lang.Class - private static abstract class BogusSourceConnector extends SourceConnector { + private abstract static class BogusSourceConnector extends SourceConnector { } - private static abstract class BogusSourceTask extends SourceTask { + private abstract static class BogusSourceTask extends SourceTask { } - private static abstract class BogusSinkConnector extends SinkConnector { + private abstract static class BogusSinkConnector extends SinkConnector { } - private static abstract class BogusSinkTask extends SourceTask { + private abstract static class BogusSinkTask extends SourceTask { } private void verifyConnectorStatusRestart() { From c452750b16a37da8967597509196bb41ca0ee575 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Mon, 17 Jun 2024 18:27:56 +0800 Subject: [PATCH 17/18] fix test case --- .../connect/runtime/AbstractHerderTest.java | 1 + .../runtime/AbstractWorkerSourceTaskTest.java | 18 ++++++++++++++---- .../runtime/TransformationStageTest.java | 5 +++-- .../runtime/WorkerMetricsGroupTest.java | 5 ----- .../runtime/WorkerSinkTaskThreadedTest.java | 6 +++++- .../distributed/DistributedHerderTest.java | 4 ++-- .../standalone/StandaloneHerderTest.java | 8 ++++---- 7 files changed, 29 insertions(+), 18 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java index ad131bc8bbe0b..420cf5e745ced 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractHerderTest.java @@ -459,6 +459,7 @@ public void testConfigValidationEmptyConfig() { assertThrows(BadRequestException.class, () -> herder.validateConnectorConfig(Collections.emptyMap(), s -> null, false)); verify(transformer).transform(Collections.emptyMap()); + assertEquals(worker.getPlugins(), plugins); } @Test diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java index 2a1460bbfb822..0cb4db7064726 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/AbstractWorkerSourceTaskTest.java @@ -102,6 +102,7 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; @@ -253,6 +254,7 @@ public void testSendRecordsConvertsData() { ); expectSendRecord(emptyHeaders()); + expectApplyTransformationChain(); expectTopicCreation(TOPIC); workerTask.toSend = records; @@ -273,6 +275,7 @@ public void testSendRecordsPropagatesTimestamp() { createWorkerTask(); expectSendRecord(emptyHeaders()); + expectApplyTransformationChain(); expectTopicCreation(TOPIC); workerTask.toSend = Collections.singletonList( @@ -292,7 +295,8 @@ public void testSendRecordsCorruptTimestamp() { final Long timestamp = -3L; createWorkerTask(); - expectSendRecord(emptyHeaders()); + expectConvertHeadersAndKeyValue(emptyHeaders(), TOPIC); + expectApplyTransformationChain(); workerTask.toSend = Collections.singletonList( new SourceRecord(PARTITION, OFFSET, "topic", null, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD, timestamp) @@ -308,6 +312,7 @@ public void testSendRecordsNoTimestamp() { createWorkerTask(); expectSendRecord(emptyHeaders()); + expectApplyTransformationChain(); expectTopicCreation(TOPIC); workerTask.toSend = Collections.singletonList( @@ -333,6 +338,7 @@ public void testHeaders() { createWorkerTask(); expectSendRecord(headers); + expectApplyTransformationChain(); expectTopicCreation(TOPIC); workerTask.toSend = Collections.singletonList( @@ -360,6 +366,7 @@ public void testHeadersWithCustomConverter() throws Exception { Collections::emptyList); expectSendRecord(null); + expectApplyTransformationChain(); expectTopicCreation(TOPIC); String stringA = "Árvíztűrő tükörfúrógép"; @@ -621,6 +628,7 @@ public void testTopicCreateSucceedsWhenCreateReturnsExistingTopicFound() { SourceRecord record2 = new SourceRecord(PARTITION, OFFSET, TOPIC, 2, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD); expectSendRecord(emptyHeaders()); + expectApplyTransformationChain(); when(admin.describeTopics(TOPIC)).thenReturn(Collections.emptyMap()); when(admin.createOrFindTopics(any(NewTopic.class))).thenReturn(foundTopic(TOPIC)); @@ -645,6 +653,7 @@ public void testTopicCreateSucceedsWhenCreateReturnsNewTopicFound() { SourceRecord record2 = new SourceRecord(PARTITION, OFFSET, TOPIC, 2, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD); expectSendRecord(emptyHeaders()); + expectApplyTransformationChain(); when(admin.describeTopics(TOPIC)).thenReturn(Collections.emptyMap()); when(admin.createOrFindTopics(any(NewTopic.class))).thenReturn(createdTopic(TOPIC)); @@ -670,7 +679,6 @@ public void testSendRecordsRetriableException() { SourceRecord record3 = new SourceRecord(PARTITION, OFFSET, TOPIC, 3, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD); expectConvertHeadersAndKeyValue(emptyHeaders(), TOPIC); - expectTaskGetTopic(); when(transformationChain.apply(any(), eq(record1))).thenReturn(null); when(transformationChain.apply(any(), eq(record2))).thenReturn(null); @@ -702,8 +710,6 @@ private void expectSendRecord(Headers headers) { if (headers != null) expectConvertHeadersAndKeyValue(headers, TOPIC); - expectApplyTransformationChain(); - expectTaskGetTopic(); } @@ -796,11 +802,15 @@ private void expectConvertHeadersAndKeyValue(Headers headers, String topic) { when(valueConverter.fromConnectData(eq(topic), any(Headers.class), eq(RECORD_SCHEMA), eq(RECORD))) .thenReturn(SERIALIZED_RECORD); + assertEquals(keyConverter.fromConnectData(topic, headers, KEY_SCHEMA, KEY), SERIALIZED_KEY); + assertEquals(valueConverter.fromConnectData(topic, headers, RECORD_SCHEMA, RECORD), SERIALIZED_RECORD); } private void expectApplyTransformationChain() { when(transformationChain.apply(any(), any(SourceRecord.class))) .thenAnswer(AdditionalAnswers.returnsSecondArg()); + SourceRecord randomString = mock(SourceRecord.class); + assertEquals(transformationChain.apply(null, randomString), randomString); } private RecordHeaders emptyHeaders() { diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java index 7db714b6808f7..6a4bc1816a5fe 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/TransformationStageTest.java @@ -19,7 +19,6 @@ import org.apache.kafka.connect.source.SourceRecord; import org.apache.kafka.connect.transforms.Transformation; import org.apache.kafka.connect.transforms.predicates.Predicate; - import org.junit.jupiter.api.Test; import org.mockito.junit.jupiter.MockitoSettings; import org.mockito.quality.Strictness; @@ -53,7 +52,9 @@ private void applyAndAssert(boolean predicateResult, boolean negate, when(predicate.test(any())).thenReturn(predicateResult); @SuppressWarnings("unchecked") Transformation transformation = mock(Transformation.class); - when(transformation.apply(any())).thenReturn(transformed); + if (expectedResult == transformed) { + when(transformation.apply(any())).thenReturn(transformed); + } TransformationStage stage = new TransformationStage<>( predicate, negate, diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java index e956129b7cf58..9077c7fa58723 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerMetricsGroupTest.java @@ -18,9 +18,7 @@ import org.apache.kafka.common.MetricName; import org.apache.kafka.common.MetricNameTemplate; -import org.apache.kafka.common.metrics.CompoundStat; import org.apache.kafka.common.metrics.Sensor; -import org.apache.kafka.common.metrics.stats.CumulativeSum; import org.apache.kafka.connect.util.ConnectorTaskId; import org.junit.jupiter.api.BeforeEach; @@ -33,7 +31,6 @@ import java.util.HashMap; -import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyDouble; import static org.mockito.ArgumentMatchers.isNull; import static org.mockito.Mockito.mock; @@ -90,8 +87,6 @@ public void setup() { private Sensor mockSensor(ConnectMetrics.MetricGroup metricGroup, String name) { Sensor sensor = mock(Sensor.class); when(metricGroup.sensor(name)).thenReturn(sensor); - when(sensor.add(any(CompoundStat.class))).thenReturn(true); - when(sensor.add(any(MetricName.class), any(CumulativeSum.class))).thenReturn(true); return sensor; } diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index dd141161cc9ce..85b16bb3ff953 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -647,7 +647,11 @@ public Object answer(InvocationOnMock invocation) { } } }).when(sinkTask).preCommit(anyMap()); - + // if the only command has error, consumer don't commit, so we don't need to mock commitAsync. + // or else strictness will throw exception + if (commands.length == 1 && commands[0].error != null) { + return; + } doAnswer(new Answer() { int index = 0; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java index f2b73e9699743..028e5202bf529 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/distributed/DistributedHerderTest.java @@ -4275,10 +4275,10 @@ private static List expectRecordStages(Callback callback) { } // We need to use a real class here due to some issue with mocking java.lang.Class - private static abstract class BogusSourceConnector extends SourceConnector { + private abstract static class BogusSourceConnector extends SourceConnector { } - private static abstract class BogusSourceTask extends SourceTask { + private abstract static class BogusSourceTask extends SourceTask { } /** diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java index 92ab6bd149a7a..959e498931096 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/standalone/StandaloneHerderTest.java @@ -1205,16 +1205,16 @@ private void expectConfigValidation( } // We need to use a real class here due to some issue with mocking java.lang.Class - private static abstract class BogusSourceConnector extends SourceConnector { + private abstract static class BogusSourceConnector extends SourceConnector { } - private static abstract class BogusSourceTask extends SourceTask { + private abstract static class BogusSourceTask extends SourceTask { } - private static abstract class BogusSinkConnector extends SinkConnector { + private abstract static class BogusSinkConnector extends SinkConnector { } - private static abstract class BogusSinkTask extends SourceTask { + private abstract static class BogusSinkTask extends SourceTask { } private void verifyConnectorStatusRestart() { From c2609bdf3695ec726e40be7d54bd0d6d197a8a40 Mon Sep 17 00:00:00 2001 From: gongxuanzhang Date: Tue, 18 Jun 2024 09:35:23 +0800 Subject: [PATCH 18/18] refactor code --- .../runtime/WorkerSinkTaskThreadedTest.java | 46 +++++++++++-------- .../connect/runtime/WorkerSourceTaskTest.java | 6 +-- 2 files changed, 29 insertions(+), 23 deletions(-) diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java index 85b16bb3ff953..c91223af7ed97 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSinkTaskThreadedTest.java @@ -245,8 +245,10 @@ public void testCommit() { expectTaskGetTopic(); expectInitialAssignment(); expectPolls(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT); - expectOffsetCommit(new ExpectOffsetCommitCommand( - expectedMessages, null, null, 0, true)); + ExpectOffsetCommitCommand command = new ExpectOffsetCommitCommand( + expectedMessages, null, null, 0, true); + expectPreCommit(command); + expectOffsetCommit(command); workerTask.initialize(TASK_CONFIG); workerTask.initializeAndStart(); @@ -280,7 +282,7 @@ public void testCommitFailure() { expectTaskGetTopic(); expectInitialAssignment(); expectPolls(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT); - expectOffsetCommit(new ExpectOffsetCommitCommand( + expectPreCommit(new ExpectOffsetCommitCommand( 1L, new RuntimeException(), null, 0, true)); workerTask.initialize(TASK_CONFIG); @@ -317,10 +319,12 @@ public void testCommitSuccessFollowedByFailure() { expectTaskGetTopic(); expectInitialAssignment(); expectPolls(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT); - expectOffsetCommit( - new ExpectOffsetCommitCommand(1L, null, null, 0, true), - new ExpectOffsetCommitCommand(2L, new RuntimeException(), null, 0, true) - ); + ExpectOffsetCommitCommand[] commands = new ExpectOffsetCommitCommand[]{ + new ExpectOffsetCommitCommand(1L, null, null, 0, true), + new ExpectOffsetCommitCommand(2L, new RuntimeException(), null, 0, true) + }; + expectPreCommit(commands); + expectOffsetCommit(commands); workerTask.initialize(TASK_CONFIG); workerTask.initializeAndStart(); @@ -355,8 +359,10 @@ public void testCommitConsumerFailure() { expectTaskGetTopic(); expectInitialAssignment(); expectPolls(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT); - expectOffsetCommit(new ExpectOffsetCommitCommand( - 1L, null, new Exception(), 0, true)); + ExpectOffsetCommitCommand command = new ExpectOffsetCommitCommand( + 1L, null, new Exception(), 0, true); + expectPreCommit(command); + expectOffsetCommit(command); workerTask.initialize(TASK_CONFIG); workerTask.initializeAndStart(); @@ -387,8 +393,10 @@ public void testCommitTimeout() { expectInitialAssignment(); // Cut down amount of time to pass in each poll so we trigger exactly 1 offset commit expectPolls(WorkerConfig.OFFSET_COMMIT_INTERVAL_MS_DEFAULT / 2); - expectOffsetCommit(new ExpectOffsetCommitCommand( - 2L, null, null, WorkerConfig.OFFSET_COMMIT_TIMEOUT_MS_DEFAULT, false)); + ExpectOffsetCommitCommand command = new ExpectOffsetCommitCommand( + 2L, null, null, WorkerConfig.OFFSET_COMMIT_TIMEOUT_MS_DEFAULT, false); + expectPreCommit(command); + expectOffsetCommit(command); workerTask.initialize(TASK_CONFIG); workerTask.initializeAndStart(); @@ -630,15 +638,17 @@ private void expectRebalanceDuringPoll(long startOffset) { when(valueConverter.toConnectData(TOPIC, emptyHeaders(), RAW_VALUE)).thenReturn(new SchemaAndValue(VALUE_SCHEMA, VALUE)); } - private void expectOffsetCommit(ExpectOffsetCommitCommand... commands) { + private void expectPreCommit(ExpectOffsetCommitCommand... commands) { doAnswer(new Answer() { int index = 0; @Override public Object answer(InvocationOnMock invocation) { ExpectOffsetCommitCommand commitCommand = commands[index++]; - // All assigned partitions will have offsets committed, but we've only processed messages/updated offsets for one - final Map offsetsToCommit = offsetsToCommitFn.apply(commitCommand.expectedMessages); + // All assigned partitions will have offsets committed, but we've only processed messages/updated + // offsets for one + final Map offsetsToCommit = + offsetsToCommitFn.apply(commitCommand.expectedMessages); if (commitCommand.error != null) { throw commitCommand.error; @@ -647,11 +657,9 @@ public Object answer(InvocationOnMock invocation) { } } }).when(sinkTask).preCommit(anyMap()); - // if the only command has error, consumer don't commit, so we don't need to mock commitAsync. - // or else strictness will throw exception - if (commands.length == 1 && commands[0].error != null) { - return; - } + } + + private void expectOffsetCommit(ExpectOffsetCommitCommand... commands) { doAnswer(new Answer() { int index = 0; diff --git a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java index 5bed72c5be986..f55a9d66690af 100644 --- a/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java +++ b/connect/runtime/src/test/java/org/apache/kafka/connect/runtime/WorkerSourceTaskTest.java @@ -187,18 +187,16 @@ public class WorkerSourceTaskTest { new SourceRecord(PARTITION, OFFSET, "topic", null, KEY_SCHEMA, KEY, RECORD_SCHEMA, RECORD) ); - private boolean enableTopicCreation; public void setup(boolean enableTopicCreation) { - this.enableTopicCreation = enableTopicCreation; - Map workerProps = workerProps(); + Map workerProps = workerProps(enableTopicCreation); plugins = new Plugins(workerProps); config = new StandaloneConfig(workerProps); sourceConfig = new SourceConnectorConfig(plugins, sourceConnectorPropsWithGroups(TOPIC), true); metrics = new MockConnectMetrics(); } - private Map workerProps() { + private Map workerProps(boolean enableTopicCreation) { Map props = new HashMap<>(); props.put("key.converter", "org.apache.kafka.connect.json.JsonConverter"); props.put("value.converter", "org.apache.kafka.connect.json.JsonConverter");