geode-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jstew...@apache.org
Subject [2/5] geode git commit: GEODE-2966: RefactorLauncherLifecycleCommands
Date Thu, 01 Jun 2017 16:06:20 GMT
http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/GfshCommandJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/GfshCommandJUnitTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/GfshCommandJUnitTest.java
new file mode 100644
index 0000000..8ee27a6
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/GfshCommandJUnitTest.java
@@ -0,0 +1,397 @@
+/*
+ * 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.geode.management.internal.cli.commands;
+
+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.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.geode.cache.execute.Function;
+import org.apache.geode.cache.execute.FunctionService;
+import org.apache.geode.distributed.DistributedMember;
+import org.apache.geode.distributed.DistributedSystem;
+import org.apache.geode.internal.cache.InternalCache;
+import org.apache.geode.internal.lang.StringUtils;
+import org.apache.geode.internal.util.CollectionUtils;
+import org.apache.geode.management.cli.CliMetaData;
+import org.apache.geode.management.internal.cli.i18n.CliStrings;
+import org.apache.geode.management.internal.cli.shell.Gfsh;
+import org.apache.geode.management.internal.cli.util.MemberNotFoundException;
+import org.apache.geode.test.junit.categories.UnitTest;
+import org.jmock.Expectations;
+import org.jmock.Mockery;
+import org.jmock.lib.concurrent.Synchroniser;
+import org.jmock.lib.legacy.ClassImposteriser;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * The GfshCommandJUnitTest class is a test suite of test cases testing the contract and
+ * functionality of the GfshCommand class for implementing GemFire shell (Gfsh) commands.
+ *
+ * @see GfshCommand
+ * @see org.jmock.Expectations
+ * @see org.jmock.Mockery
+ * @see org.jmock.lib.legacy.ClassImposteriser
+ * @see org.junit.Assert
+ * @see org.junit.Test
+ * @since GemFire 7.0
+ */
+@Category(UnitTest.class)
+public class GfshCommandJUnitTest {
+
+  private Mockery mockContext;
+
+  private static class DefaultGfshCommmand implements GfshCommand {
+  }
+
+  private DefaultGfshCommmand defaultGfshCommmand;
+
+  @Before
+  public void setup() {
+    mockContext = new Mockery();
+    mockContext.setImposteriser(ClassImposteriser.INSTANCE);
+    mockContext.setThreadingPolicy(new Synchroniser());
+
+    defaultGfshCommmand = new DefaultGfshCommmand();
+  }
+
+  @After
+  public void tearDown() {
+    mockContext.assertIsSatisfied();
+    mockContext = null;
+  }
+
+  private GfshCommand createAbstractCommandsSupport(final InternalCache cache) {
+    return new TestCommands(cache);
+  }
+
+  private DistributedMember createMockMember(final String memberId, final String memberName)
{
+    final DistributedMember mockMember =
+        mockContext.mock(DistributedMember.class, "DistributedMember " + memberId);
+
+    mockContext.checking(new Expectations() {
+      {
+        allowing(mockMember).getName();
+        will(returnValue(memberName));
+        allowing(mockMember).getId();
+        will(returnValue(memberId));
+      }
+    });
+
+    return mockMember;
+  }
+
+  @Test
+  public void testConvertDefaultValue() {
+    assertNull(defaultGfshCommmand.convertDefaultValue(null, StringUtils.EMPTY));
+    assertEquals(StringUtils.EMPTY,
+        defaultGfshCommmand.convertDefaultValue(StringUtils.EMPTY, "test"));
+    assertEquals(StringUtils.SPACE,
+        defaultGfshCommmand.convertDefaultValue(StringUtils.SPACE, "testing"));
+    assertEquals("tested",
+        defaultGfshCommmand.convertDefaultValue(CliMetaData.ANNOTATION_DEFAULT_VALUE, "tested"));
+  }
+
+  @Test
+  public void testGetMemberWithMatchingMemberId() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+    final DistributedMember mockMemberOne = createMockMember("1", "One");
+    final DistributedMember mockMemberTwo = createMockMember("2", "Two");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(CollectionUtils.asSet(mockMemberOne, mockMemberTwo)));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    assertSame(mockMemberTwo, commands.getMember(mockCache, "2"));
+  }
+
+  @Test
+  public void testGetMemberWithMatchingMemberName() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+    final DistributedMember mockMemberOne = createMockMember("1", "One");
+    final DistributedMember mockMemberTwo = createMockMember("2", "Two");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(CollectionUtils.asSet(mockMemberOne, mockMemberTwo)));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    assertSame(mockMemberOne, commands.getMember(mockCache, "One"));
+  }
+
+  @Test
+  public void testGetMemberWithMatchingMemberNameCaseInsensitive() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+    final DistributedMember mockMemberOne = createMockMember("1", "One");
+    final DistributedMember mockMemberTwo = createMockMember("2", "Two");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(CollectionUtils.asSet(mockMemberOne, mockMemberTwo)));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    assertSame(mockMemberSelf, commands.getMember(mockCache, "self"));
+  }
+
+  @Test(expected = MemberNotFoundException.class)
+  public void testGetMemberThrowsMemberNotFoundException() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+    final DistributedMember mockMemberOne = createMockMember("1", "One");
+    final DistributedMember mockMemberTwo = createMockMember("2", "Two");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(CollectionUtils.asSet(mockMemberOne, mockMemberTwo)));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    try {
+      commands.getMember(mockCache, "zero");
+    } catch (MemberNotFoundException expected) {
+      assertEquals(CliStrings.format(CliStrings.MEMBER_NOT_FOUND_ERROR_MESSAGE, "zero"),
+          expected.getMessage());
+      throw expected;
+    }
+  }
+
+  @Test
+  public void testGetMembers() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+    final DistributedMember mockMemberOne = createMockMember("1", "One");
+    final DistributedMember mockMemberTwo = createMockMember("2", "Two");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(CollectionUtils.asSet(mockMemberOne, mockMemberTwo)));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    final Set<DistributedMember> expectedMembers =
+        CollectionUtils.asSet(mockMemberOne, mockMemberTwo, mockMemberSelf);
+    final Set<DistributedMember> actualMembers = commands.getMembers(mockCache);
+
+    assertNotNull(actualMembers);
+    assertEquals(expectedMembers.size(), actualMembers.size());
+    assertTrue(actualMembers.containsAll(expectedMembers));
+  }
+
+  @Test
+  public void testGetMembersContainsOnlySelf() {
+    final InternalCache mockCache = mockContext.mock(InternalCache.class, "InternalCache");
+
+    final DistributedSystem mockDistributedSystem =
+        mockContext.mock(DistributedSystem.class, "DistributedSystem");
+    final DistributedMember mockMemberSelf = createMockMember("S", "Self");
+
+    mockContext.checking(new Expectations() {
+      {
+        oneOf(mockCache).getMembers();
+        will(returnValue(Collections.emptySet()));
+        oneOf(mockCache).getDistributedSystem();
+        will(returnValue(mockDistributedSystem));
+        oneOf(mockDistributedSystem).getDistributedMember();
+        will(returnValue(mockMemberSelf));
+      }
+    });
+
+    final GfshCommand commands = createAbstractCommandsSupport(mockCache);
+
+    final Set<DistributedMember> expectedMembers = CollectionUtils.asSet(mockMemberSelf);
+    final Set<DistributedMember> actualMembers = commands.getMembers(mockCache);
+
+    assertNotNull(actualMembers);
+    assertEquals(expectedMembers.size(), actualMembers.size());
+    assertTrue(actualMembers.containsAll(expectedMembers));
+  }
+
+  @Test
+  public void testRegister() {
+    try {
+      final Function mockFunction = mockContext.mock(Function.class, "Function");
+
+      mockContext.checking(new Expectations() {
+        {
+          exactly(3).of(mockFunction).getId();
+          will(returnValue("testRegister"));
+          oneOf(mockFunction).isHA();
+          will(returnValue(true));
+          oneOf(mockFunction).hasResult();
+          will(returnValue(true));
+        }
+      });
+
+      final GfshCommand commands =
+          createAbstractCommandsSupport(mockContext.mock(InternalCache.class));
+
+      assertFalse(FunctionService.isRegistered("testRegister"));
+      assertSame(mockFunction, commands.register(mockFunction));
+      assertTrue(FunctionService.isRegistered("testRegister"));
+    } finally {
+      FunctionService.unregisterFunction("testRegister");
+    }
+  }
+
+  @Test
+  public void testRegisteredAlready() {
+    try {
+      final Function registeredFunction = mockContext.mock(Function.class, "Registered Function");
+      final Function unregisteredFunction =
+          mockContext.mock(Function.class, "Unregistered Function");
+
+      mockContext.checking(new Expectations() {
+        {
+          exactly(2).of(registeredFunction).getId();
+          will(returnValue("testRegisteredAlready"));
+          oneOf(registeredFunction).isHA();
+          will(returnValue(false));
+          exactly(2).of(unregisteredFunction).getId();
+          will(returnValue("testRegisteredAlready"));
+        }
+      });
+
+      final GfshCommand commands =
+          createAbstractCommandsSupport(mockContext.mock(InternalCache.class));
+
+      FunctionService.registerFunction(registeredFunction);
+
+      assertTrue(FunctionService.isRegistered("testRegisteredAlready"));
+      assertSame(registeredFunction, commands.register(unregisteredFunction));
+      assertTrue(FunctionService.isRegistered("testRegisteredAlready"));
+    } finally {
+      FunctionService.unregisterFunction("testRegisteredAlready");
+    }
+  }
+
+  @Test
+  public void testToStringOnBoolean() {
+    assertEquals("false", defaultGfshCommmand.toString(null, null, null));
+    assertEquals("true", defaultGfshCommmand.toString(true, null, null));
+    assertEquals("true", defaultGfshCommmand.toString(Boolean.TRUE, null, null));
+    assertEquals("false", defaultGfshCommmand.toString(false, null, null));
+    assertEquals("false", defaultGfshCommmand.toString(Boolean.FALSE, null, null));
+    assertEquals("false", defaultGfshCommmand.toString(true, "false", "true"));
+    assertEquals("true", defaultGfshCommmand.toString(false, "false", "true"));
+    assertEquals("Yes", defaultGfshCommmand.toString(true, "Yes", "No"));
+    assertEquals("Yes", defaultGfshCommmand.toString(false, "No", "Yes"));
+    assertEquals("TRUE", defaultGfshCommmand.toString(Boolean.TRUE, "TRUE", "FALSE"));
+    assertEquals("FALSE", defaultGfshCommmand.toString(Boolean.FALSE, "TRUE", "FALSE"));
+  }
+
+  @Test
+  public void testToStringOnThrowable() {
+    assertEquals("test", defaultGfshCommmand.toString(new Throwable("test"), false));
+  }
+
+  @Test
+  public void testToStringOnThrowablePrintingStackTrace() {
+    final StringWriter writer = new StringWriter();
+    final Throwable t = new Throwable("test");
+
+    t.printStackTrace(new PrintWriter(writer));
+
+    assertEquals(writer.toString(), defaultGfshCommmand.toString(t, true));
+  }
+
+  private static class TestCommands implements GfshCommand {
+
+    private final InternalCache cache;
+
+    protected TestCommands(final InternalCache cache) {
+      assert cache != null : "The InternalCache cannot be null!";
+      this.cache = cache;
+    }
+
+    @Override
+    public InternalCache getCache() {
+      return this.cache;
+    }
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/IndexCommandsJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/IndexCommandsJUnitTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/IndexCommandsJUnitTest.java
index e3a644d..0d1f340 100644
--- a/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/IndexCommandsJUnitTest.java
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/IndexCommandsJUnitTest.java
@@ -203,18 +203,18 @@ public class IndexCommandsJUnitTest {
     }
 
     @Override
-    protected InternalCache getCache() {
+    public InternalCache getCache() {
       return this.cache;
     }
 
     @Override
-    protected Set<DistributedMember> getMembers(final InternalCache cache) {
+    public Set<DistributedMember> getMembers(final InternalCache cache) {
       assertSame(getCache(), cache);
       return Collections.emptySet();
     }
 
     @Override
-    protected Execution getMembersFunctionExecutor(final Set<DistributedMember> members)
{
+    public Execution getMembersFunctionExecutor(final Set<DistributedMember> members)
{
       Assert.assertNotNull(members);
       return functionExecutor;
     }

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/lifecycle/StartJConsoleCommandTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/lifecycle/StartJConsoleCommandTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/lifecycle/StartJConsoleCommandTest.java
new file mode 100644
index 0000000..32dc93c
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/commands/lifecycle/StartJConsoleCommandTest.java
@@ -0,0 +1,42 @@
+/*
+ * 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.geode.management.internal.cli.commands.lifecycle;
+
+import static org.junit.Assert.assertEquals;
+
+import org.apache.geode.management.internal.cli.i18n.CliStrings;
+import org.apache.geode.test.junit.categories.UnitTest;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+@Category(UnitTest.class)
+public class StartJConsoleCommandTest {
+  @Test
+  public void testCreateJmxServerUrlWithMemberName() {
+    assertEquals("service:jmx:rmi://localhost:8192/jndi/rmi://localhost:8192/jmxrmi",
+        new StartJConsoleCommand().getJmxServiceUrlAsString("localhost[8192]"));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testCreateJmxServiceUrlWithInvalidMemberName() {
+    try {
+      System.err.println(new StartJConsoleCommand().getJmxServiceUrlAsString("memberOne[]"));
+    } catch (IllegalArgumentException expected) {
+      assertEquals(CliStrings.START_JCONSOLE__CONNECT_BY_MEMBER_NAME_ID_ERROR_MESSAGE,
+          expected.getMessage());
+      throw expected;
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/HostUtilsTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/HostUtilsTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/HostUtilsTest.java
new file mode 100644
index 0000000..55d6d54
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/HostUtilsTest.java
@@ -0,0 +1,44 @@
+/*
+ * 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.geode.management.internal.cli.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.apache.geode.cache.server.CacheServer;
+import org.apache.geode.internal.DistributionLocator;
+import org.apache.geode.test.junit.categories.UnitTest;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+@Category(UnitTest.class)
+public class HostUtilsTest {
+
+  @Test
+  public void testGetLocatorId() {
+    assertEquals("machine[11235]", HostUtils.getLocatorId("machine", 11235));
+    assertEquals("machine.domain.org[11235]", HostUtils.getLocatorId("machine.domain.org",
11235));
+    assertEquals("machine[" + DistributionLocator.DEFAULT_LOCATOR_PORT + "]",
+        HostUtils.getLocatorId("machine", null));
+  }
+
+  @Test
+  public void testGetServerId() {
+    assertEquals("machine[12480]", HostUtils.getServerId("machine", 12480));
+    assertEquals("machine.domain.org[12480]", HostUtils.getServerId("machine.domain.org",
12480));
+    assertEquals("machine[" + CacheServer.DEFAULT_PORT + "]",
+        HostUtils.getServerId("machine", null));
+  }
+
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/JdkToolTest.java
----------------------------------------------------------------------
diff --git a/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/JdkToolTest.java
b/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/JdkToolTest.java
new file mode 100644
index 0000000..9d0c7fc
--- /dev/null
+++ b/geode-core/src/test/java/org/apache/geode/management/internal/cli/util/JdkToolTest.java
@@ -0,0 +1,75 @@
+/*
+ * 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.geode.management.internal.cli.util;
+
+import static org.junit.Assert.assertEquals;
+
+import org.apache.geode.GemFireException;
+import org.apache.geode.internal.util.IOUtils;
+import org.apache.geode.test.junit.categories.UnitTest;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.util.Stack;
+
+@Category(UnitTest.class)
+public class JdkToolTest {
+
+  @Test
+  public void testGetJavaPathname() {
+    assertEquals(
+        IOUtils.appendToPath(System.getProperty("java.home"), "bin",
+            "java" + JdkTool.getExecutableSuffix()),
+        JdkTool.getJdkToolPathname("java" + JdkTool.getExecutableSuffix(),
+            new GemFireException() {}));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testGetJdkToolPathnameWithNullPathnames() {
+    try {
+      JdkTool.getJdkToolPathname((Stack<String>) null, new GemFireException() {});
+    } catch (NullPointerException expected) {
+      assertEquals("The JDK tool executable pathnames cannot be null!", expected.getMessage());
+      throw expected;
+    }
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void testGetJdkToolPathnameWithNullGemFireException() {
+    try {
+      JdkTool.getJdkToolPathname(new Stack<String>(), null);
+    } catch (NullPointerException expected) {
+      assertEquals("The GemFireException cannot be null!", expected.getMessage());
+      throw expected;
+    }
+  }
+
+  @Test
+  public void testGetJdkToolPathnameForNonExistingTool() {
+    try {
+      final GemFireException expected = new GemFireException() {
+        @Override
+        public String getMessage() {
+          return "expected";
+        }
+      };
+
+      JdkTool.getJdkToolPathname("nonExistingTool.exe", expected);
+    } catch (GemFireException expected) {
+      assertEquals("expected", expected.getMessage());
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommands.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommands.java
b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommands.java
index 2fa9356..da0dfa2 100755
--- a/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommands.java
+++ b/geode-lucene/src/main/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommands.java
@@ -36,7 +36,7 @@ import org.apache.geode.management.cli.ConverterHint;
 import org.apache.geode.management.cli.Result;
 import org.apache.geode.management.internal.cli.CliUtil;
 import org.apache.geode.management.internal.cli.LogWrapper;
-import org.apache.geode.management.internal.cli.commands.AbstractCommandsSupport;
+import org.apache.geode.management.internal.cli.commands.GfshCommand;
 import org.apache.geode.management.internal.cli.functions.CliFunctionResult;
 import org.apache.geode.management.internal.cli.i18n.CliStrings;
 import org.apache.geode.management.internal.cli.result.CommandResult;
@@ -64,12 +64,12 @@ import java.util.stream.Collectors;
  * The LuceneIndexCommands class encapsulates all Geode shell (Gfsh) commands related to
Lucene
  * indexes defined in Geode.
  *
- * @see AbstractCommandsSupport
+ * @see GfshCommand
  * @see LuceneIndexDetails
  * @see LuceneListIndexFunction
  */
 @SuppressWarnings("unused")
-public class LuceneIndexCommands extends AbstractCommandsSupport {
+public class LuceneIndexCommands implements GfshCommand {
   private static final LuceneCreateIndexFunction createIndexFunction =
       new LuceneCreateIndexFunction();
   private static final LuceneDescribeIndexFunction describeIndexFunction =

http://git-wip-us.apache.org/repos/asf/geode/blob/9046c8dc/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommandsJUnitTest.java
----------------------------------------------------------------------
diff --git a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommandsJUnitTest.java
b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommandsJUnitTest.java
index 66e15bb..8deac25 100644
--- a/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommandsJUnitTest.java
+++ b/geode-lucene/src/test/java/org/apache/geode/cache/lucene/internal/cli/LuceneIndexCommandsJUnitTest.java
@@ -643,18 +643,18 @@ public class LuceneIndexCommandsJUnitTest {
     }
 
     @Override
-    protected InternalCache getCache() {
+    public InternalCache getCache() {
       return this.cache;
     }
 
     @Override
-    protected Set<DistributedMember> getMembers(final InternalCache cache) {
+    public Set<DistributedMember> getMembers(final InternalCache cache) {
       assertSame(getCache(), cache);
       return Collections.emptySet();
     }
 
     @Override
-    protected Execution getMembersFunctionExecutor(final Set<DistributedMember> members)
{
+    public Execution getMembersFunctionExecutor(final Set<DistributedMember> members)
{
       Assert.assertNotNull(members);
       return functionExecutor;
     }


Mime
View raw message