This is an automated email from the ASF dual-hosted git repository. github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/dev/pr-13081-94adef596685ee37e506c96a52baa6ae13de5da3 in repository https://gitbox.apache.org/repos/asf/seatunnel.git
commit 0215a8f95562e941f358be6bf92e48196c7089ad Author: Celine <[email protected]> AuthorDate: Wed Nov 18 15:42:06 2026 +0000 [Fix][Core] Make CLI enum argument parsing locale independent (#13081) --- .../apache/seatunnel/common/config/DeployMode.java | 16 ++++- .../seatunnel/common/config/DeployModeTest.java | 60 ++++++++++++++++ .../core/starter/flink/args/FlinkCommandArgs.java | 7 +- .../flink/args/FlinkCommandArgsConverterTest.java | 84 ++++++++++++++++++++++ .../core/starter/spark/args/SparkCommandArgs.java | 3 +- .../spark/args/SparkCommandArgsConverterTest.java | 61 ++++++++++++++++ .../starter/seatunnel/args/ClientCommandArgs.java | 3 +- .../seatunnel/args/ConnectorCheckCommandArgs.java | 4 +- .../seatunnel/args/MetadataExportCommandArgs.java | 4 +- .../seatunnel/command/ClientExecuteCommand.java | 20 ++++-- .../args/ConnectorCheckCommandArgsTest.java | 33 +++++++++ .../ClientExecuteCommandCheckpointStatusTest.java | 83 +++++++++++++++++++++ 12 files changed, 367 insertions(+), 11 deletions(-) diff --git a/seatunnel-common/src/main/java/org/apache/seatunnel/common/config/DeployMode.java b/seatunnel-common/src/main/java/org/apache/seatunnel/common/config/DeployMode.java index 5b9508e105..ba3de7a25a 100644 --- a/seatunnel-common/src/main/java/org/apache/seatunnel/common/config/DeployMode.java +++ b/seatunnel-common/src/main/java/org/apache/seatunnel/common/config/DeployMode.java @@ -18,6 +18,7 @@ package org.apache.seatunnel.common.config; import java.util.Arrays; +import java.util.Locale; import java.util.Map; import java.util.Optional; import java.util.function.Function; @@ -46,7 +47,20 @@ public enum DeployMode { Arrays.stream(DeployMode.values()) .collect(Collectors.toMap(DeployMode::getDeployMode, Function.identity())); + /** + * Resolves a command line deploy mode token. + * + * <p>The token is lower-cased with {@link Locale#ROOT}, so {@code CLIENT} resolves to {@link + * #CLIENT} on a JVM whose default locale is Turkish or Azerbaijani, where {@code toLowerCase()} + * would otherwise produce a dotless {@code ı}. + * + * @param deployMode the raw token, may be {@code null} + * @return the matching mode, or {@link Optional#empty()} for {@code null} and unknown tokens + */ public static Optional<DeployMode> from(String deployMode) { - return Optional.ofNullable(NAME_MAP.get(deployMode.toLowerCase())); + if (deployMode == null) { + return Optional.empty(); + } + return Optional.ofNullable(NAME_MAP.get(deployMode.toLowerCase(Locale.ROOT))); } } diff --git a/seatunnel-common/src/test/java/org/apache/seatunnel/common/config/DeployModeTest.java b/seatunnel-common/src/test/java/org/apache/seatunnel/common/config/DeployModeTest.java new file mode 100644 index 0000000000..7d19e45557 --- /dev/null +++ b/seatunnel-common/src/test/java/org/apache/seatunnel/common/config/DeployModeTest.java @@ -0,0 +1,60 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.common.config; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; + +import java.util.Locale; +import java.util.Optional; + +/** + * Verifies that {@link DeployMode#from(String)} resolves command line tokens independently of the + * JVM default locale, and that {@code null} and unknown tokens resolve to an empty result. + */ +@ResourceLock("java.util.Locale") +public class DeployModeTest { + + @Test + public void testFromResolvesDeployMode() { + Assertions.assertEquals(Optional.of(DeployMode.CLIENT), DeployMode.from("client")); + Assertions.assertEquals(Optional.of(DeployMode.CLIENT), DeployMode.from("CLIENT")); + Assertions.assertEquals( + Optional.of(DeployMode.RUN_APPLICATION), DeployMode.from("run-application")); + Assertions.assertEquals(Optional.empty(), DeployMode.from("unknown")); + Assertions.assertEquals(Optional.empty(), DeployMode.from(null)); + } + + @Test + public void testFromIsLocaleIndependent() { + Locale base = Locale.getDefault(); + Locale display = Locale.getDefault(Locale.Category.DISPLAY); + Locale format = Locale.getDefault(Locale.Category.FORMAT); + try { + Locale.setDefault(new Locale("tr", "TR")); + Assertions.assertEquals(Optional.of(DeployMode.CLIENT), DeployMode.from("CLIENT")); + Assertions.assertEquals( + Optional.of(DeployMode.RUN_APPLICATION), DeployMode.from("RUN-APPLICATION")); + } finally { + Locale.setDefault(base); + Locale.setDefault(Locale.Category.DISPLAY, display); + Locale.setDefault(Locale.Category.FORMAT, format); + } + } +} diff --git a/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/main/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgs.java b/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/main/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgs.java index ff098b9df9..44e32eaa5e 100644 --- a/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/main/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgs.java +++ b/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/main/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgs.java @@ -34,6 +34,7 @@ import lombok.EqualsAndHashCode; import java.util.ArrayList; import java.util.List; +import java.util.Locale; @EqualsAndHashCode(callSuper = true) @Data @@ -103,7 +104,8 @@ public class FlinkCommandArgs extends AbstractCommandArgs { @Override public MasterType convert(String value) { - MasterType masterType = MasterType.valueOf(value.toUpperCase().replaceAll("-", "_")); + MasterType masterType = + MasterType.valueOf(value.toUpperCase(Locale.ROOT).replaceAll("-", "_")); if (MASTER_TYPE_LIST.contains(masterType)) { return masterType; } else { @@ -125,7 +127,8 @@ public class FlinkCommandArgs extends AbstractCommandArgs { @Override public DeployMode convert(String value) { - DeployMode deployMode = DeployMode.valueOf(value.toUpperCase().replaceAll("-", "_")); + DeployMode deployMode = + DeployMode.valueOf(value.toUpperCase(Locale.ROOT).replaceAll("-", "_")); if (DEPLOY_MODE_TYPE_LIST.contains(deployMode)) { return deployMode; } else { diff --git a/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/test/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgsConverterTest.java b/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/test/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgsConverterTest.java new file mode 100644 index 0000000000..c301d495cc --- /dev/null +++ b/seatunnel-core/seatunnel-flink-starter/seatunnel-flink-starter-common/src/test/java/org/apache/seatunnel/core/starter/flink/args/FlinkCommandArgsConverterTest.java @@ -0,0 +1,84 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.core.starter.flink.args; + +import org.apache.seatunnel.common.config.DeployMode; +import org.apache.seatunnel.core.starter.enums.MasterType; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; + +import java.util.Locale; + +/** + * Verifies that the Flink argument converters resolve {@code --deploy-mode} and {@code --target} + * values independently of the JVM default locale. + */ +@ResourceLock("java.util.Locale") +public class FlinkCommandArgsConverterTest { + + @Test + public void testDeployModeConverter() { + FlinkCommandArgs.FlinkDeployModeConverter converter = + new FlinkCommandArgs.FlinkDeployModeConverter(); + + Assertions.assertEquals(DeployMode.RUN, converter.convert("run")); + Assertions.assertEquals(DeployMode.RUN, converter.convert("RUN")); + Assertions.assertEquals(DeployMode.RUN_APPLICATION, converter.convert("run-application")); + Assertions.assertEquals(DeployMode.RUN_APPLICATION, converter.convert("RUN-APPLICATION")); + } + + @Test + public void testMasterTargetConverter() { + FlinkCommandArgs.FlinkMasterTargetConverter converter = + new FlinkCommandArgs.FlinkMasterTargetConverter(); + + Assertions.assertEquals(MasterType.LOCAL, converter.convert("local")); + Assertions.assertEquals(MasterType.YARN_SESSION, converter.convert("yarn-session")); + Assertions.assertEquals( + MasterType.KUBERNETES_APPLICATION, converter.convert("kubernetes-application")); + } + + @Test + public void testConvertersAreLocaleIndependent() { + Locale base = Locale.getDefault(); + Locale display = Locale.getDefault(Locale.Category.DISPLAY); + Locale format = Locale.getDefault(Locale.Category.FORMAT); + try { + Locale.setDefault(new Locale("tr", "TR")); + + FlinkCommandArgs.FlinkDeployModeConverter deployModeConverter = + new FlinkCommandArgs.FlinkDeployModeConverter(); + Assertions.assertEquals( + DeployMode.RUN_APPLICATION, deployModeConverter.convert("run-application")); + + FlinkCommandArgs.FlinkMasterTargetConverter masterTargetConverter = + new FlinkCommandArgs.FlinkMasterTargetConverter(); + Assertions.assertEquals( + MasterType.YARN_SESSION, masterTargetConverter.convert("yarn-session")); + Assertions.assertEquals( + MasterType.KUBERNETES_APPLICATION, + masterTargetConverter.convert("kubernetes-application")); + } finally { + Locale.setDefault(base); + Locale.setDefault(Locale.Category.DISPLAY, display); + Locale.setDefault(Locale.Category.FORMAT, format); + } + } +} diff --git a/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/main/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgs.java b/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/main/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgs.java index 8413839272..abdd348196 100644 --- a/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/main/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgs.java +++ b/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/main/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgs.java @@ -33,6 +33,7 @@ import lombok.EqualsAndHashCode; import java.util.ArrayList; import java.util.List; +import java.util.Locale; @EqualsAndHashCode(callSuper = true) @Data @@ -76,7 +77,7 @@ public class SparkCommandArgs extends AbstractCommandArgs { @Override public DeployMode convert(String value) { - DeployMode deployMode = DeployMode.valueOf(value.toUpperCase()); + DeployMode deployMode = DeployMode.valueOf(value.toUpperCase(Locale.ROOT)); if (DEPLOY_MODE_TYPE_LIST.contains(deployMode)) { return deployMode; } else { diff --git a/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/test/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgsConverterTest.java b/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/test/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgsConverterTest.java new file mode 100644 index 0000000000..6b5cf80db8 --- /dev/null +++ b/seatunnel-core/seatunnel-spark-starter/seatunnel-spark-starter-common/src/test/java/org/apache/seatunnel/core/starter/spark/args/SparkCommandArgsConverterTest.java @@ -0,0 +1,61 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.core.starter.spark.args; + +import org.apache.seatunnel.common.config.DeployMode; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; + +import java.util.Locale; + +/** + * Verifies that the Spark {@code --deploy-mode} converter resolves the value independently of the + * JVM default locale, and keeps rejecting modes Spark does not support. + */ +@ResourceLock("java.util.Locale") +public class SparkCommandArgsConverterTest { + + @Test + public void testDeployModeConverter() { + SparkCommandArgs.SparkDeployModeConverter converter = + new SparkCommandArgs.SparkDeployModeConverter(); + + Assertions.assertEquals(DeployMode.CLIENT, converter.convert("client")); + Assertions.assertEquals(DeployMode.CLUSTER, converter.convert("CLUSTER")); + Assertions.assertThrows(IllegalArgumentException.class, () -> converter.convert("run")); + } + + @Test + public void testDeployModeConverterIsLocaleIndependent() { + Locale base = Locale.getDefault(); + Locale display = Locale.getDefault(Locale.Category.DISPLAY); + Locale format = Locale.getDefault(Locale.Category.FORMAT); + try { + Locale.setDefault(new Locale("tr", "TR")); + SparkCommandArgs.SparkDeployModeConverter converter = + new SparkCommandArgs.SparkDeployModeConverter(); + Assertions.assertEquals(DeployMode.CLIENT, converter.convert("client")); + } finally { + Locale.setDefault(base); + Locale.setDefault(Locale.Category.DISPLAY, display); + Locale.setDefault(Locale.Category.FORMAT, format); + } + } +} diff --git a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ClientCommandArgs.java b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ClientCommandArgs.java index e0625c4877..4861507707 100644 --- a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ClientCommandArgs.java +++ b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ClientCommandArgs.java @@ -39,6 +39,7 @@ import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; +import java.util.Locale; @EqualsAndHashCode(callSuper = true) @Data @@ -331,7 +332,7 @@ public class ClientCommandArgs extends AbstractCommandArgs { @Override public MasterType convert(String value) { - MasterType masterType = MasterType.valueOf(value.toUpperCase()); + MasterType masterType = MasterType.valueOf(value.toUpperCase(Locale.ROOT)); if (MASTER_TYPE_LIST.contains(masterType)) { return masterType; } else { diff --git a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgs.java b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgs.java index 56ea581c8e..be7a462c42 100644 --- a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgs.java +++ b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgs.java @@ -27,6 +27,8 @@ import com.beust.jcommander.Parameter; import lombok.Data; import lombok.EqualsAndHashCode; +import java.util.Locale; + @EqualsAndHashCode(callSuper = true) @Data public class ConnectorCheckCommandArgs extends CommandArgs { @@ -56,7 +58,7 @@ public class ConnectorCheckCommandArgs extends CommandArgs { @Override public PluginType convert(String value) { try { - return PluginType.valueOf(value.toUpperCase()); + return PluginType.valueOf(value.toUpperCase(Locale.ROOT)); } catch (IllegalArgumentException e) { throw new IllegalArgumentException( "The plugin type of seaTunnel only " diff --git a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/MetadataExportCommandArgs.java b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/MetadataExportCommandArgs.java index 31fb24df3e..bbff14353b 100644 --- a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/MetadataExportCommandArgs.java +++ b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/args/MetadataExportCommandArgs.java @@ -27,6 +27,8 @@ import com.beust.jcommander.Parameter; import lombok.Data; import lombok.EqualsAndHashCode; +import java.util.Locale; + @EqualsAndHashCode(callSuper = true) @Data public class MetadataExportCommandArgs extends CommandArgs { @@ -71,7 +73,7 @@ public class MetadataExportCommandArgs extends CommandArgs { @Override public PluginType convert(String value) { try { - return PluginType.valueOf(value.toUpperCase()); + return PluginType.valueOf(value.toUpperCase(Locale.ROOT)); } catch (IllegalArgumentException e) { throw new IllegalArgumentException( "Plugin type must be one of: [source, sink, transform]"); diff --git a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommand.java b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommand.java index b2190e8ba9..06f287eb83 100644 --- a/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommand.java +++ b/seatunnel-core/seatunnel-starter/src/main/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommand.java @@ -61,6 +61,7 @@ import java.time.Duration; import java.time.LocalDateTime; import java.util.Collections; import java.util.List; +import java.util.Locale; import java.util.Random; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; @@ -158,10 +159,8 @@ public class ClientExecuteCommand implements Command<ClientCommandArgs> { if (clientCommandArgs.getCheckpointHistoryStatus() != null) { try { status = - CheckpointStatus.valueOf( - clientCommandArgs - .getCheckpointHistoryStatus() - .toUpperCase()); + parseCheckpointStatus( + clientCommandArgs.getCheckpointHistoryStatus()); } catch (IllegalArgumentException ex) { throw new CommandExecuteException( String.format( @@ -317,6 +316,19 @@ public class ClientExecuteCommand implements Command<ClientCommandArgs> { } } + /** + * Parses the value of {@code --checkpoint-history-status} without going through the JVM default + * locale. + * + * <p>{@code "failed".toUpperCase()} yields {@code FAİLED} (dotted {@code İ}, {@code U+0130}) + * under a Turkish default locale, so {@link CheckpointStatus#valueOf} stops recognising a value + * that is valid everywhere else and the command reports {@code Unsupported checkpoint history + * status}. {@link Locale#ROOT} keeps the fold independent of the machine's language. + */ + static CheckpointStatus parseCheckpointStatus(String status) { + return CheckpointStatus.valueOf(status.toUpperCase(Locale.ROOT)); + } + private void closeClient() { if (engineClient != null) { engineClient.close(); diff --git a/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgsTest.java b/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgsTest.java index d78dd82194..b43f009026 100644 --- a/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgsTest.java +++ b/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/args/ConnectorCheckCommandArgsTest.java @@ -22,7 +22,15 @@ import org.apache.seatunnel.core.starter.utils.CommandLineUtils; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; +import java.util.Locale; + +/** + * Verifies that the {@code -pt} plugin type argument is parsed independently of the JVM default + * locale, through the command line parser and the metadata export converter. + */ +@ResourceLock("java.util.Locale") public class ConnectorCheckCommandArgsTest { @Test public void testConnectorCheckCommandArgs() { @@ -44,4 +52,29 @@ public class ConnectorCheckCommandArgsTest { "seatunnel-connector.sh", false)); } + + @Test + public void testPluginTypeArgumentIsLocaleIndependent() { + Locale base = Locale.getDefault(); + Locale display = Locale.getDefault(Locale.Category.DISPLAY); + Locale format = Locale.getDefault(Locale.Category.FORMAT); + try { + Locale.setDefault(new Locale("tr", "TR")); + + String[] args = {"-pt", "sink"}; + ConnectorCheckCommandArgs connectorCheckCommandArgs = + CommandLineUtils.parse( + args, new ConnectorCheckCommandArgs(), "seatunnel-connector.sh", false); + Assertions.assertEquals(PluginType.SINK, connectorCheckCommandArgs.getPluginType()); + + MetadataExportCommandArgs metadataExportCommandArgs = new MetadataExportCommandArgs(); + metadataExportCommandArgs.setPluginType( + new MetadataExportCommandArgs.PluginTypeConverter().convert("sink")); + Assertions.assertEquals(PluginType.SINK, metadataExportCommandArgs.getPluginType()); + } finally { + Locale.setDefault(base); + Locale.setDefault(Locale.Category.DISPLAY, display); + Locale.setDefault(Locale.Category.FORMAT, format); + } + } } diff --git a/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommandCheckpointStatusTest.java b/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommandCheckpointStatusTest.java new file mode 100644 index 0000000000..b49a642f45 --- /dev/null +++ b/seatunnel-core/seatunnel-starter/src/test/java/org/apache/seatunnel/core/starter/seatunnel/command/ClientExecuteCommandCheckpointStatusTest.java @@ -0,0 +1,83 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.seatunnel.core.starter.seatunnel.command; + +import org.apache.seatunnel.engine.core.checkpoint.CheckpointStatus; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.parallel.ResourceLock; + +import java.util.Locale; + +/** + * Verifies that the CLI enum arguments parsed by {@link ClientExecuteCommand} do not depend on the + * JVM default locale. + * + * <p>The default locale is switched to Turkish, where {@code i} upper-cases to a dotted capital + * {@code I} ({@code U+0130}), in {@link BeforeEach} and restored in {@link AfterEach}, so a failing + * assertion cannot leak the locale into other tests sharing the JVM. + */ +@ResourceLock("java.util.Locale") +public class ClientExecuteCommandCheckpointStatusTest { + + private Locale base; + private Locale display; + private Locale format; + + @BeforeEach + public void switchToTurkishLocale() { + base = Locale.getDefault(); + display = Locale.getDefault(Locale.Category.DISPLAY); + format = Locale.getDefault(Locale.Category.FORMAT); + Locale.setDefault(new Locale("tr", "TR")); + } + + @AfterEach + public void restoreDefaultLocale() { + Locale.setDefault(base); + Locale.setDefault(Locale.Category.DISPLAY, display); + Locale.setDefault(Locale.Category.FORMAT, format); + } + + @Test + public void testParseCheckpointStatusUnderTurkishLocale() { + // "failed" and "in_progress" are the values that a bare toUpperCase() breaks under tr-TR; + // the other two are here so the test pins the whole enum, not only today's default path. + Assertions.assertEquals( + CheckpointStatus.FAILED, + ClientExecuteCommand.parseCheckpointStatus("failed"), + "failed must map to FAILED under tr-TR, not throw on FAİLED"); + Assertions.assertEquals( + CheckpointStatus.IN_PROGRESS, + ClientExecuteCommand.parseCheckpointStatus("in_progress"), + "in_progress must map to IN_PROGRESS under tr-TR"); + Assertions.assertEquals( + CheckpointStatus.COMPLETED, + ClientExecuteCommand.parseCheckpointStatus("Completed")); + Assertions.assertEquals( + CheckpointStatus.CANCELED, ClientExecuteCommand.parseCheckpointStatus("CANCELED")); + + Assertions.assertThrows( + IllegalArgumentException.class, + () -> ClientExecuteCommand.parseCheckpointStatus("finished"), + "an unknown value must still be rejected"); + } +}
