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

jchen21 pushed a commit to branch feature/GEODE-6118
in repository https://gitbox.apache.org/repos/asf/geode.git

commit 193db1b09d2f65b028c0162f316fd6649b7bed0d
Author: Darrel Schneider <dschnei...@pivotal.io>
AuthorDate: Fri Nov 30 13:25:06 2018 -0800

    GEODE-6118: Support slash on region name for jdbc-mapping commands
    
    Co-authored-by: Darrel Schneider <dschnei...@pivotal.io>
    Co-authored-by: Jianxia Chen <jche...@apache.org>
---
 geode-connectors/build.gradle                      |   4 +-
 .../cli/CreateMappingCommandDUnitTest.java         | 179 ++++++++++++---------
 .../cli/DescribeMappingCommandDUnitTest.java       |  23 ++-
 .../cli/DestroyMappingCommandDunitTest.java        |  46 +++++-
 .../jdbc/internal/cli/CreateMappingCommand.java    |   7 +
 .../jdbc/internal/cli/DescribeMappingCommand.java  |   4 +
 .../jdbc/internal/cli/DestroyMappingCommand.java   |   4 +
 .../internal/cli/CreateMappingCommandTest.java     |  35 ++++
 .../internal/cli/DescribeMappingCommandTest.java   |  18 +++
 .../internal/cli/DestroyMappingCommandTest.java    |  17 +-
 10 files changed, 249 insertions(+), 88 deletions(-)

diff --git a/geode-connectors/build.gradle b/geode-connectors/build.gradle
index 9795dfe..bd05614 100644
--- a/geode-connectors/build.gradle
+++ b/geode-connectors/build.gradle
@@ -72,10 +72,12 @@ dependencies {
   integrationTestCompile('junit:junit:' + project.'junit.version')
   integrationTestCompile('junit:junit:4.12')
   integrationTestCompile('org.assertj:assertj-core:' + 
project.'assertj-core.version')
+  integrationTestCompile('pl.pragmatists:JUnitParams:' + 
project.'JUnitParams.version')
 
   distributedTestCompile('junit:junit:' + project.'junit.version')
   distributedTestCompile('org.assertj:assertj-core:' + 
project.'assertj-core.version')
   distributedTestCompile('org.mockito:mockito-core:2.19.1')
+  distributedTestCompile('pl.pragmatists:JUnitParams:' + 
project.'JUnitParams.version')
   distributedTestRuntime('org.apache.derby:derby:' + project.'derby.version')
 
   acceptanceTestCompile('com.github.stefanbirkner:system-rules:' + 
project.'system-rules.version') {
@@ -86,7 +88,7 @@ dependencies {
   acceptanceTestCompile('org.awaitility:awaitility:' + 
project.'awaitility.version')
   acceptanceTestCompile('org.mockito:mockito-core:' + 
project.'mockito-core.version')
   acceptanceTestCompile(group: 'com.palantir.docker.compose', name: 
'docker-compose-rule-core', version: '0.31.1')
-
+  acceptanceTestCompile('pl.pragmatists:JUnitParams:' + 
project.'JUnitParams.version')
   acceptanceTestCompile(group: 'com.palantir.docker.compose', name: 
'docker-compose-rule-junit4', version: '0.31.1')
 
   acceptanceTestRuntime(group: 'mysql', name: 'mysql-connector-java', version: 
'5.1.46')
diff --git 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandDUnitTest.java
 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandDUnitTest.java
index d9f8e94..6856fc7 100644
--- 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandDUnitTest.java
+++ 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandDUnitTest.java
@@ -24,10 +24,13 @@ import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.List;
 
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
 
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.asyncqueue.AsyncEventQueue;
@@ -49,6 +52,7 @@ import org.apache.geode.test.junit.rules.GfshCommandRule;
 import org.apache.geode.test.junit.rules.serializable.SerializableTestName;
 
 @Category({JDBCConnectorTest.class})
+@RunWith(JUnitParamsRunner.class)
 public class CreateMappingCommandDUnitTest {
 
   private static final String REGION_NAME = "testRegion";
@@ -74,96 +78,108 @@ public class CreateMappingCommandDUnitTest {
 
   }
 
-  private void setupReplicate() {
-    setupReplicate(false);
+  private void setupReplicate(String regionName) {
+    setupReplicate(regionName, false);
   }
 
-  private void setupReplicate(boolean addLoader) {
-    gfsh.executeAndAssertThat("create region --name=" + REGION_NAME + " 
--type=REPLICATE"
+  private void setupReplicate(String regionName, boolean addLoader) {
+    gfsh.executeAndAssertThat("create region --name=" + regionName + " 
--type=REPLICATE"
         + (addLoader ? " --cache-loader=" + JdbcLoader.class.getName() : ""))
         .statusIsSuccess();
   }
 
-  private void setupPartition() {
-    gfsh.executeAndAssertThat("create region --name=" + REGION_NAME + " 
--type=PARTITION")
+  private void setupPartition(String regionName) {
+    gfsh.executeAndAssertThat("create region --name=" + regionName + " 
--type=PARTITION")
         .statusIsSuccess();
   }
 
-  private void setupAsyncEventQueue() {
+  private void setupAsyncEventQueue(String regionName) {
     gfsh.executeAndAssertThat(
         "create async-event-queue --id="
-            + CreateMappingCommand.createAsyncEventQueueName(REGION_NAME)
+            + CreateMappingCommand.createAsyncEventQueueName(regionName)
             + " --listener=" + JdbcAsyncWriter.class.getName())
         .statusIsSuccess();
   }
 
-  private static RegionMapping getRegionMappingFromClusterConfig() {
+  private static RegionMapping getRegionMappingFromClusterConfig(String 
regionName) {
     CacheConfig cacheConfig =
         
InternalLocator.getLocator().getConfigurationPersistenceService().getCacheConfig(null);
     RegionConfig regionConfig = cacheConfig.getRegions().stream()
-        .filter(region -> 
region.getName().equals(REGION_NAME)).findFirst().orElse(null);
+        .filter(region -> 
region.getName().equals(convertRegionPathToName(regionName))).findFirst()
+        .orElse(null);
     return (RegionMapping) regionConfig.getCustomRegionElements().stream()
         .filter(element -> element instanceof 
RegionMapping).findFirst().orElse(null);
   }
 
-  private static RegionMapping getRegionMappingFromService() {
+  private static RegionMapping getRegionMappingFromService(String regionName) {
     return ClusterStartupRule.getCache().getService(JdbcConnectorService.class)
-        .getMappingForRegion(REGION_NAME);
+        .getMappingForRegion(convertRegionPathToName(regionName));
   }
 
-  private static void validateAsyncEventQueueCreatedInClusterConfig(boolean 
isParallel) {
+  private static void validateAsyncEventQueueCreatedInClusterConfig(String 
regionName,
+      boolean isParallel) {
     CacheConfig cacheConfig =
         
InternalLocator.getLocator().getConfigurationPersistenceService().getCacheConfig(null);
     List<CacheConfig.AsyncEventQueue> queueList = 
cacheConfig.getAsyncEventQueues();
     CacheConfig.AsyncEventQueue queue = queueList.get(0);
-    String queueName = 
CreateMappingCommand.createAsyncEventQueueName(REGION_NAME);
+    String queueName = 
CreateMappingCommand.createAsyncEventQueueName(regionName);
     assertThat(queue.getId()).isEqualTo(queueName);
     assertThat(queue.getAsyncEventListener().getClassName())
         .isEqualTo(JdbcAsyncWriter.class.getName());
     assertThat(queue.isParallel()).isEqualTo(isParallel);
   }
 
-  private static void validateRegionAlteredInClusterConfig(boolean 
synchronous) {
+  private static String convertRegionPathToName(String regionPath) {
+    if (regionPath.startsWith("/")) {
+      return regionPath.substring(1);
+    }
+    return regionPath;
+  }
+
+  private static void validateRegionAlteredInClusterConfig(String regionName, 
boolean synchronous) {
     CacheConfig cacheConfig =
         
InternalLocator.getLocator().getConfigurationPersistenceService().getCacheConfig(null);
     RegionConfig regionConfig = cacheConfig.getRegions().stream()
-        .filter(region -> 
region.getName().equals(REGION_NAME)).findFirst().orElse(null);
+        .filter(region -> 
region.getName().equals(convertRegionPathToName(regionName))).findFirst()
+        .orElse(null);
     RegionAttributesType attributes = 
regionConfig.getRegionAttributes().get(0);
     
assertThat(attributes.getCacheLoader().getClassName()).isEqualTo(JdbcLoader.class.getName());
     if (synchronous) {
       
assertThat(attributes.getCacheWriter().getClassName()).isEqualTo(JdbcWriter.class.getName());
     } else {
-      String queueName = 
CreateMappingCommand.createAsyncEventQueueName(REGION_NAME);
+      String queueName = 
CreateMappingCommand.createAsyncEventQueueName(regionName);
       assertThat(attributes.getAsyncEventQueueIds()).isEqualTo(queueName);
     }
   }
 
-  private static void validateAsyncEventQueueCreatedOnServer(boolean 
isParallel) {
+  private static void validateAsyncEventQueueCreatedOnServer(String regionName,
+      boolean isParallel) {
     InternalCache cache = ClusterStartupRule.getCache();
-    String queueName = 
CreateMappingCommand.createAsyncEventQueueName(REGION_NAME);
+    String queueName = 
CreateMappingCommand.createAsyncEventQueueName(regionName);
     AsyncEventQueue queue = cache.getAsyncEventQueue(queueName);
     assertThat(queue).isNotNull();
     
assertThat(queue.getAsyncEventListener()).isInstanceOf(JdbcAsyncWriter.class);
     assertThat(queue.isParallel()).isEqualTo(isParallel);
   }
 
-  private static void validateRegionAlteredOnServer(boolean synchronous) {
+  private static void validateRegionAlteredOnServer(String regionName, boolean 
synchronous) {
     InternalCache cache = ClusterStartupRule.getCache();
-    Region<?, ?> region = cache.getRegion(REGION_NAME);
+    Region<?, ?> region = cache.getRegion(regionName);
     
assertThat(region.getAttributes().getCacheLoader()).isInstanceOf(JdbcLoader.class);
     if (synchronous) {
       
assertThat(region.getAttributes().getCacheWriter()).isInstanceOf(JdbcWriter.class);
     } else {
-      String queueName = 
CreateMappingCommand.createAsyncEventQueueName(REGION_NAME);
+      String queueName = 
CreateMappingCommand.createAsyncEventQueueName(regionName);
       
assertThat(region.getAttributes().getAsyncEventQueueIds()).contains(queueName);
     }
   }
 
   @Test
-  public void createMappingUpdatesServiceAndClusterConfig() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingUpdatesServiceAndClusterConfig(String regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "myTable");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
@@ -171,29 +187,30 @@ public class CreateMappingCommandDUnitTest {
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     server.invoke(() -> {
-      RegionMapping mapping = getRegionMappingFromService();
+      RegionMapping mapping = getRegionMappingFromService(regionName);
       assertThat(mapping.getDataSourceName()).isEqualTo("connection");
       assertThat(mapping.getTableName()).isEqualTo("myTable");
       assertThat(mapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredOnServer(false);
-      validateAsyncEventQueueCreatedOnServer(false);
+      validateRegionAlteredOnServer(regionName, false);
+      validateAsyncEventQueueCreatedOnServer(regionName, false);
     });
 
     locator.invoke(() -> {
-      RegionMapping regionMapping = getRegionMappingFromClusterConfig();
+      RegionMapping regionMapping = 
getRegionMappingFromClusterConfig(regionName);
       assertThat(regionMapping.getDataSourceName()).isEqualTo("connection");
       assertThat(regionMapping.getTableName()).isEqualTo("myTable");
       assertThat(regionMapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredInClusterConfig(false);
-      validateAsyncEventQueueCreatedInClusterConfig(false);
+      validateRegionAlteredInClusterConfig(regionName, false);
+      validateAsyncEventQueueCreatedInClusterConfig(regionName, false);
     });
   }
 
   @Test
-  public void createSynchronousMappingUpdatesServiceAndClusterConfig() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createSynchronousMappingUpdatesServiceAndClusterConfig(String 
regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "myTable");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
@@ -202,27 +219,28 @@ public class CreateMappingCommandDUnitTest {
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     server.invoke(() -> {
-      RegionMapping mapping = getRegionMappingFromService();
+      RegionMapping mapping = getRegionMappingFromService(regionName);
       assertThat(mapping.getDataSourceName()).isEqualTo("connection");
       assertThat(mapping.getTableName()).isEqualTo("myTable");
       assertThat(mapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredOnServer(true);
+      validateRegionAlteredOnServer(regionName, true);
     });
 
     locator.invoke(() -> {
-      RegionMapping regionMapping = getRegionMappingFromClusterConfig();
+      RegionMapping regionMapping = 
getRegionMappingFromClusterConfig(regionName);
       assertThat(regionMapping.getDataSourceName()).isEqualTo("connection");
       assertThat(regionMapping.getTableName()).isEqualTo("myTable");
       assertThat(regionMapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredInClusterConfig(true);
+      validateRegionAlteredInClusterConfig(regionName, true);
     });
   }
 
   @Test
-  public void createMappingWithPartitionUpdatesServiceAndClusterConfig() {
-    setupPartition();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithPartitionUpdatesServiceAndClusterConfig(String 
regionName) {
+    setupPartition(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "myTable");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
@@ -230,80 +248,83 @@ public class CreateMappingCommandDUnitTest {
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     server.invoke(() -> {
-      RegionMapping mapping = getRegionMappingFromService();
+      RegionMapping mapping = getRegionMappingFromService(regionName);
       assertThat(mapping.getDataSourceName()).isEqualTo("connection");
       assertThat(mapping.getTableName()).isEqualTo("myTable");
       assertThat(mapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredOnServer(false);
-      validateAsyncEventQueueCreatedOnServer(true);
+      validateRegionAlteredOnServer(regionName, false);
+      validateAsyncEventQueueCreatedOnServer(regionName, true);
     });
 
     locator.invoke(() -> {
-      RegionMapping regionMapping = getRegionMappingFromClusterConfig();
+      RegionMapping regionMapping = 
getRegionMappingFromClusterConfig(regionName);
       assertThat(regionMapping.getDataSourceName()).isEqualTo("connection");
       assertThat(regionMapping.getTableName()).isEqualTo("myTable");
       assertThat(regionMapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredInClusterConfig(false);
-      validateAsyncEventQueueCreatedInClusterConfig(true);
+      validateRegionAlteredInClusterConfig(regionName, false);
+      validateAsyncEventQueueCreatedInClusterConfig(regionName, true);
     });
   }
 
   @Test
-  public void createMappingWithNoTable() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithNoTable(String regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
 
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     server.invoke(() -> {
-      RegionMapping mapping = getRegionMappingFromService();
+      RegionMapping mapping = getRegionMappingFromService(regionName);
       assertThat(mapping.getDataSourceName()).isEqualTo("connection");
       assertThat(mapping.getTableName()).isNull();
       assertThat(mapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredOnServer(false);
-      validateAsyncEventQueueCreatedOnServer(false);
+      validateRegionAlteredOnServer(regionName, false);
+      validateAsyncEventQueueCreatedOnServer(regionName, false);
     });
 
     locator.invoke(() -> {
-      RegionMapping regionMapping = getRegionMappingFromClusterConfig();
+      RegionMapping regionMapping = 
getRegionMappingFromClusterConfig(regionName);
       assertThat(regionMapping.getDataSourceName()).isEqualTo("connection");
       assertThat(regionMapping.getTableName()).isNull();
       assertThat(regionMapping.getPdxName()).isEqualTo("myPdxClass");
-      validateRegionAlteredInClusterConfig(false);
-      validateAsyncEventQueueCreatedInClusterConfig(false);
+      validateRegionAlteredInClusterConfig(regionName, false);
+      validateAsyncEventQueueCreatedInClusterConfig(regionName, false);
     });
   }
 
   @Test
-  public void createExistingRegionMappingFails() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createExistingRegionMappingFails(String regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "myTable");
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "bogusConnection");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "bogusPdxClass");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "bogusTable");
     gfsh.executeAndAssertThat(csb.toString()).statusIsError()
-        .containsOutput("A jdbc-mapping for " + REGION_NAME + " already 
exists");
+        .containsOutput(
+            "A jdbc-mapping for " + convertRegionPathToName(regionName) + " 
already exists");
 
     server.invoke(() -> {
-      RegionMapping mapping = getRegionMappingFromService();
+      RegionMapping mapping = getRegionMappingFromService(regionName);
       assertThat(mapping.getDataSourceName()).isEqualTo("connection");
       assertThat(mapping.getTableName()).isEqualTo("myTable");
       assertThat(mapping.getPdxName()).isEqualTo("myPdxClass");
     });
 
     locator.invoke(() -> {
-      RegionMapping regionMapping = getRegionMappingFromClusterConfig();
+      RegionMapping regionMapping = 
getRegionMappingFromClusterConfig(regionName);
       assertThat(regionMapping.getDataSourceName()).isEqualTo("connection");
       assertThat(regionMapping.getTableName()).isEqualTo("myTable");
       assertThat(regionMapping.getPdxName()).isEqualTo("myPdxClass");
@@ -311,10 +332,11 @@ public class CreateMappingCommandDUnitTest {
   }
 
   @Test
-  public void createMappingWithoutPdxNameFails() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithoutPdxNameFails(String regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
 
     // NOTE: --table is optional so it should not be in the output but it is. 
See GEODE-3468.
@@ -324,8 +346,9 @@ public class CreateMappingCommandDUnitTest {
   }
 
   @Test
-  public void createMappingWithNonExistentRegionFails() {
-    setupReplicate();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithNonExistentRegionFails(String regionName) {
+    setupReplicate(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
     csb.addOption(CREATE_MAPPING__REGION_NAME, "bogusRegion");
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
@@ -336,30 +359,32 @@ public class CreateMappingCommandDUnitTest {
   }
 
   @Test
-  public void createMappingWithRegionThatHasALoaderFails() {
-    setupReplicate(true);
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithRegionThatHasALoaderFails(String regionName) {
+    setupReplicate(regionName, true);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
 
     gfsh.executeAndAssertThat(csb.toString()).statusIsError()
-        .containsOutput("The existing region " + REGION_NAME
+        .containsOutput("The existing region " + 
convertRegionPathToName(regionName)
             + " must not already have a cache-loader, but it has " + 
JdbcLoader.class.getName());
   }
 
   @Test
-  public void createMappingWithExistingQueueFails() {
-    setupReplicate();
-    setupAsyncEventQueue();
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void createMappingWithExistingQueueFails(String regionName) {
+    setupReplicate(regionName);
+    setupAsyncEventQueue(regionName);
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
 
     gfsh.executeAndAssertThat(csb.toString()).statusIsError()
         .containsOutput("An async-event-queue named "
-            + CreateMappingCommand.createAsyncEventQueueName(REGION_NAME)
+            + CreateMappingCommand.createAsyncEventQueueName(regionName)
             + " must not already exist.");
   }
 
diff --git 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandDUnitTest.java
 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandDUnitTest.java
index 06896f7..a79a9ba 100644
--- 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandDUnitTest.java
+++ 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandDUnitTest.java
@@ -26,9 +26,12 @@ import static org.assertj.core.api.Assertions.assertThat;
 import java.io.Serializable;
 import java.util.Properties;
 
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
+import org.junit.runner.RunWith;
 
 import org.apache.geode.connectors.jdbc.internal.JdbcConnectorService;
 import org.apache.geode.connectors.jdbc.internal.RegionMappingExistsException;
@@ -44,6 +47,7 @@ import org.apache.geode.test.junit.rules.GfshCommandRule;
 import org.apache.geode.test.junit.rules.serializable.SerializableTestName;
 
 @Category({JDBCConnectorTest.class})
+@RunWith(JUnitParamsRunner.class)
 public class DescribeMappingCommandDUnitTest implements Serializable {
 
   private static final String REGION_NAME = "testRegion";
@@ -59,17 +63,25 @@ public class DescribeMappingCommandDUnitTest implements 
Serializable {
 
   private MemberVM locator, server;
 
+  private static String convertRegionPathToName(String regionPath) {
+    if (regionPath.startsWith("/")) {
+      return regionPath.substring(1);
+    }
+    return regionPath;
+  }
+
   @Test
-  public void describesExistingMapping() throws Exception {
+  @Parameters({REGION_NAME, "/" + REGION_NAME})
+  public void describesExistingMapping(String regionName) throws Exception {
     locator = startupRule.startLocatorVM(0);
     server = startupRule.startServerVM(1, locator.getPort());
 
     gfsh.connectAndVerify(locator);
-    gfsh.executeAndAssertThat("create region --name=" + REGION_NAME + " 
--type=REPLICATE")
+    gfsh.executeAndAssertThat("create region --name=" + regionName + " 
--type=REPLICATE")
         .statusIsSuccess();
 
     CommandStringBuilder csb = new CommandStringBuilder(CREATE_MAPPING);
-    csb.addOption(CREATE_MAPPING__REGION_NAME, REGION_NAME);
+    csb.addOption(CREATE_MAPPING__REGION_NAME, regionName);
     csb.addOption(CREATE_MAPPING__DATA_SOURCE_NAME, "connection");
     csb.addOption(CREATE_MAPPING__TABLE_NAME, "testTable");
     csb.addOption(CREATE_MAPPING__PDX_NAME, "myPdxClass");
@@ -77,12 +89,13 @@ public class DescribeMappingCommandDUnitTest implements 
Serializable {
     gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
 
     csb = new 
CommandStringBuilder(DESCRIBE_MAPPING).addOption(DESCRIBE_MAPPING__REGION_NAME,
-        REGION_NAME);
+        regionName);
 
     CommandResultAssert commandResultAssert = 
gfsh.executeAndAssertThat(csb.toString());
 
     commandResultAssert.statusIsSuccess();
-    commandResultAssert.containsKeyValuePair(CREATE_MAPPING__REGION_NAME, 
REGION_NAME);
+    commandResultAssert.containsKeyValuePair(CREATE_MAPPING__REGION_NAME,
+        convertRegionPathToName(regionName));
     commandResultAssert.containsKeyValuePair(CREATE_MAPPING__DATA_SOURCE_NAME, 
"connection");
     commandResultAssert.containsKeyValuePair(CREATE_MAPPING__TABLE_NAME, 
"testTable");
     commandResultAssert.containsKeyValuePair(CREATE_MAPPING__PDX_NAME, 
"myPdxClass");
diff --git 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandDunitTest.java
 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandDunitTest.java
index cda69dc..a7b8d38 100644
--- 
a/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandDunitTest.java
+++ 
b/geode-connectors/src/distributedTest/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandDunitTest.java
@@ -95,7 +95,7 @@ public class DestroyMappingCommandDunitTest implements 
Serializable {
   }
 
   @Test
-  public void destroysAsyncMapping() throws Exception {
+  public void destroysAsyncMapping() {
     setupAsyncMapping();
     CommandStringBuilder csb = new CommandStringBuilder(DESTROY_MAPPING);
     csb.addOption(DESTROY_MAPPING__REGION_NAME, REGION_NAME);
@@ -117,6 +117,28 @@ public class DestroyMappingCommandDunitTest implements 
Serializable {
   }
 
   @Test
+  public void destroysAsyncMappingWithRegionPath() {
+    setupAsyncMapping();
+    CommandStringBuilder csb = new CommandStringBuilder(DESTROY_MAPPING);
+    csb.addOption(DESTROY_MAPPING__REGION_NAME, "/" + REGION_NAME);
+
+    gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
+
+    locator.invoke(() -> {
+      assertThat(getRegionMappingFromClusterConfig()).isNull();
+      validateAsyncEventQueueRemovedFromClusterConfig();
+      validateRegionAlteredInClusterConfig(false);
+    });
+
+    server.invoke(() -> {
+      InternalCache cache = ClusterStartupRule.getCache();
+      verifyMappingRemovedFromService(cache);
+      verifyRegionAltered(cache);
+      verifyQueueRemoved(cache);
+    });
+  }
+
+  @Test
   public void destroysSynchronousMapping() throws Exception {
     setupSynchronousMapping();
     CommandStringBuilder csb = new CommandStringBuilder(DESTROY_MAPPING);
@@ -138,6 +160,28 @@ public class DestroyMappingCommandDunitTest implements 
Serializable {
     });
   }
 
+  @Test
+  public void destroysSynchronousMappingWithRegionPath() throws Exception {
+    setupSynchronousMapping();
+    CommandStringBuilder csb = new CommandStringBuilder(DESTROY_MAPPING);
+    csb.addOption(DESTROY_MAPPING__REGION_NAME, "/" + REGION_NAME);
+
+    gfsh.executeAndAssertThat(csb.toString()).statusIsSuccess();
+
+    locator.invoke(() -> {
+      assertThat(getRegionMappingFromClusterConfig()).isNull();
+      validateAsyncEventQueueRemovedFromClusterConfig();
+      validateRegionAlteredInClusterConfig(true);
+    });
+
+    server.invoke(() -> {
+      InternalCache cache = ClusterStartupRule.getCache();
+      verifyMappingRemovedFromService(cache);
+      verifyRegionAltered(cache);
+      verifyQueueRemoved(cache);
+    });
+  }
+
   private static RegionMapping getRegionMappingFromClusterConfig() {
     CacheConfig cacheConfig =
         
InternalLocator.getLocator().getConfigurationPersistenceService().getCacheConfig(null);
diff --git 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommand.java
 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommand.java
index 4137f42..8c70df9 100644
--- 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommand.java
+++ 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommand.java
@@ -65,6 +65,9 @@ public class CreateMappingCommand extends SingleGfshCommand {
       "By default, writes will be asynchronous. If true, writes will be 
synchronous.";
 
   public static String createAsyncEventQueueName(String regionPath) {
+    if (regionPath.startsWith("/")) {
+      regionPath = regionPath.substring(1);
+    }
     return "JDBC#" + regionPath.replace('/', '_');
   }
 
@@ -84,6 +87,10 @@ public class CreateMappingCommand extends SingleGfshCommand {
       @CliOption(key = CREATE_MAPPING__SYNCHRONOUS_NAME,
           help = CREATE_MAPPING__SYNCHRONOUS_NAME__HELP,
           specifiedDefaultValue = "true", unspecifiedDefaultValue = "false") 
boolean synchronous) {
+    if (regionName.startsWith("/")) {
+      regionName = regionName.substring(1);
+    }
+
     // input
     Set<DistributedMember> targetMembers = getMembers(null, null);
     RegionMapping mapping = new RegionMapping(regionName, pdxName, table, 
dataSourceName);
diff --git 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommand.java
 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommand.java
index 18d7121..6d6f310 100644
--- 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommand.java
+++ 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommand.java
@@ -54,6 +54,10 @@ public class DescribeMappingCommand extends GfshCommand {
       operation = ResourcePermission.Operation.MANAGE)
   public ResultModel describeMapping(@CliOption(key = 
DESCRIBE_MAPPING__REGION_NAME,
       mandatory = true, help = DESCRIBE_MAPPING__REGION_NAME__HELP) String 
regionName) {
+    if (regionName.startsWith("/")) {
+      regionName = regionName.substring(1);
+    }
+
     RegionMapping mapping = null;
 
     Set<DistributedMember> members = findMembers(null, null);
diff --git 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommand.java
 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommand.java
index d797c49..3de83b0 100644
--- 
a/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommand.java
+++ 
b/geode-connectors/src/main/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommand.java
@@ -56,6 +56,10 @@ public class DestroyMappingCommand extends SingleGfshCommand 
{
       operation = ResourcePermission.Operation.MANAGE)
   public ResultModel destroyMapping(@CliOption(key = 
DESTROY_MAPPING__REGION_NAME, mandatory = true,
       help = DESTROY_MAPPING__REGION_NAME__HELP) String regionName) {
+    if (regionName.startsWith("/")) {
+      regionName = regionName.substring(1);
+    }
+
     // input
     Set<DistributedMember> targetMembers = getMembers(null, null);
 
diff --git 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandTest.java
 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandTest.java
index 7fb820a..6038853 100644
--- 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandTest.java
+++ 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/CreateMappingCommandTest.java
@@ -139,6 +139,21 @@ public class CreateMappingCommandTest {
   }
 
   @Test
+  public void createsMappingWithRegionPathCreatesMappingWithSlashRemoved() {
+    setupRequiredPreconditions();
+    results.add(successFunctionResult);
+
+    ResultModel result = createRegionMappingCommand.createMapping("/" + 
regionName, dataSourceName,
+        tableName, pdxClass, false);
+
+    assertThat(result.getStatus()).isSameAs(Result.Status.OK);
+    Object[] results = (Object[]) result.getConfigObject();
+    RegionMapping regionMapping = (RegionMapping) results[0];
+    assertThat(regionMapping).isNotNull();
+    assertThat(regionMapping.getRegionName()).isEqualTo(regionName);
+  }
+
+  @Test
   public void createsMappingReturnsStatusERRORWhenFunctionResultIsEmpty() {
     setupRequiredPreconditions();
     results.clear();
@@ -534,4 +549,24 @@ public class CreateMappingCommandTest {
 
     assertThat(queueList).isEmpty();
   }
+
+  @Test
+  public void 
createAsyncEventQueueNameWithRegionPathReturnsQueueNameThatIsTheSameAsRegionWithNoSlash()
 {
+    String queueName1 = 
CreateMappingCommand.createAsyncEventQueueName("regionName");
+    String queueName2 = 
CreateMappingCommand.createAsyncEventQueueName("/regionName");
+    assertThat(queueName1).isEqualTo(queueName2);
+  }
+
+  @Test
+  public void createAsyncEventQueueNameWithEmptyStringReturnsQueueName() {
+    String queueName = CreateMappingCommand.createAsyncEventQueueName("");
+    assertThat(queueName).isEqualTo("JDBC#");
+  }
+
+  @Test
+  public void 
createAsyncEventQueueNameWithSubregionNameReturnsQueueNameWithNoSlashes() {
+    String queueName = 
CreateMappingCommand.createAsyncEventQueueName("/parent/child/grandchild");
+    assertThat(queueName).isEqualTo("JDBC#parent_child_grandchild");
+  }
+
 }
diff --git 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandTest.java
 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandTest.java
index 01bcc35..d317982 100644
--- 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandTest.java
+++ 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DescribeMappingCommandTest.java
@@ -15,9 +15,12 @@
 package org.apache.geode.connectors.jdbc.internal.cli;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import java.util.Collections;
@@ -79,6 +82,21 @@ public class DescribeMappingCommandTest {
   }
 
   @Test
+  public void 
whenMemberExistsWithRegionPathFunctionIsCalledWithNoSlashRegionName() {
+    
doReturn(Collections.singleton(mock(DistributedMember.class))).when(command).findMembers(null,
+        null);
+    ResultCollector rc = mock(ResultCollector.class);
+    doReturn(rc).when(command).executeFunction(any(), any(), any(Set.class));
+    when(rc.getResult()).thenReturn(
+        Collections.singletonList(
+            new CliFunctionResult("server-1", mock(RegionMapping.class), 
"success")));
+
+    command.describeMapping("/regionName");
+
+    verify(command, times(1)).executeFunctionAndGetFunctionResult(any(), 
eq("regionName"), any());
+  }
+
+  @Test
   public void whenNoMappingFoundOnMember() {
     
doReturn(Collections.singleton(mock(DistributedMember.class))).when(command).findMembers(null,
         null);
diff --git 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandTest.java
 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandTest.java
index 210f19f..9018055 100644
--- 
a/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandTest.java
+++ 
b/geode-connectors/src/test/java/org/apache/geode/connectors/jdbc/internal/cli/DestroyMappingCommandTest.java
@@ -16,6 +16,7 @@ package org.apache.geode.connectors.jdbc.internal.cli;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
@@ -59,7 +60,6 @@ public class DestroyMappingCommandTest {
   private Set<InternalDistributedMember> members;
   private List<CliFunctionResult> results;
   private CliFunctionResult successFunctionResult;
-  private RegionMapping mapping;
   private CacheConfig cacheConfig;
   RegionConfig matchingRegion;
   RegionAttributesType matchingRegionAttributes;
@@ -82,9 +82,6 @@ public class DestroyMappingCommandTest {
     
doReturn(results).when(destroyRegionMappingCommand).executeAndGetFunctionResult(any(),
 any(),
         any());
 
-    mapping = mock(RegionMapping.class);
-    when(mapping.getRegionName()).thenReturn(regionName);
-
     cacheConfig = mock(CacheConfig.class);
 
     matchingRegion = mock(RegionConfig.class);
@@ -107,6 +104,18 @@ public class DestroyMappingCommandTest {
   }
 
   @Test
+  public void 
destroyMappingGivenARegionPathReturnsTheNoSlashRegionNameAsTheConfigObject() {
+    results.add(successFunctionResult);
+
+    ResultModel result = destroyRegionMappingCommand.destroyMapping("/" + 
regionName);
+
+    verify(destroyRegionMappingCommand, 
times(1)).executeAndGetFunctionResult(any(), eq(regionName),
+        any());
+    assertThat(result.getStatus()).isSameAs(Result.Status.OK);
+    assertThat(result.getConfigObject()).isEqualTo(regionName);
+  }
+
+  @Test
   public void updateClusterConfigWithNoRegionsDoesNotThrowException() {
     when(cacheConfig.getRegions()).thenReturn(Collections.emptyList());
 

Reply via email to