You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ambari.apache.org by mr...@apache.org on 2017/11/27 23:29:16 UTC
[04/30] ambari git commit: Merge trunk with feature branch and fix
some UT compilation issues (mradhakrishnan)
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/orm/dao/AmbariConfigurationDAOTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/orm/dao/AmbariConfigurationDAOTest.java b/ambari-server/src/test/java/org/apache/ambari/server/orm/dao/AmbariConfigurationDAOTest.java
new file mode 100644
index 0000000..f801fd6
--- /dev/null
+++ b/ambari-server/src/test/java/org/apache/ambari/server/orm/dao/AmbariConfigurationDAOTest.java
@@ -0,0 +1,298 @@
+/*
+ * 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.ambari.server.orm.dao;
+
+import static org.easymock.EasyMock.capture;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.newCapture;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import javax.persistence.EntityManager;
+
+import org.apache.ambari.server.orm.entities.AmbariConfigurationEntity;
+import org.easymock.Capture;
+import org.easymock.CaptureType;
+import org.easymock.EasyMockSupport;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.google.inject.Provider;
+
+import junit.framework.Assert;
+
+public class AmbariConfigurationDAOTest extends EasyMockSupport {
+
+ private static final String CATEGORY_NAME = "test-category";
+ private static Method methodMerge;
+ private static Method methodRemove;
+ private static Method methodCreate;
+ private static Method methodFindByCategory;
+
+ private static Field fieldEntityManagerProvider;
+
+ @BeforeClass
+ public static void beforeKDCKerberosOperationHandlerTest() throws Exception {
+ methodMerge = AmbariConfigurationDAO.class.getMethod("merge", AmbariConfigurationEntity.class);
+ methodRemove = CrudDAO.class.getMethod("remove", Object.class);
+ methodCreate = AmbariConfigurationDAO.class.getMethod("create", AmbariConfigurationEntity.class);
+ methodFindByCategory = AmbariConfigurationDAO.class.getMethod("findByCategory", String.class);
+
+ fieldEntityManagerProvider = CrudDAO.class.getDeclaredField("entityManagerProvider");
+ }
+
+ @Test
+ public void testReconcileCategoryNewCategory() throws Exception {
+ Capture<AmbariConfigurationEntity> capturedEntities = newCapture(CaptureType.ALL);
+
+ AmbariConfigurationDAO dao = createDao();
+
+ expect(dao.findByCategory(CATEGORY_NAME)).andReturn(null).once();
+
+ dao.create(capture(capturedEntities));
+ expectLastCall().anyTimes();
+
+ replayAll();
+
+ Map<String, String> properties;
+ properties = new HashMap<>();
+ properties.put("property1", "value1");
+ properties.put("property2", "value2");
+ dao.reconcileCategory(CATEGORY_NAME, properties, true);
+
+ verifyAll();
+
+ validateCapturedEntities(CATEGORY_NAME, properties, capturedEntities);
+ }
+
+ @Test
+ public void testReconcileCategoryReplaceCategory() throws Exception {
+
+ Map<String, String> existingProperties;
+ existingProperties = new HashMap<>();
+ existingProperties.put("property1", "value1");
+ existingProperties.put("property2", "value2");
+
+ Capture<AmbariConfigurationEntity> capturedCreatedEntities = newCapture(CaptureType.ALL);
+ Capture<AmbariConfigurationEntity> capturedRemovedEntities = newCapture(CaptureType.ALL);
+
+ AmbariConfigurationDAO dao = createDao();
+
+ expect(dao.findByCategory(CATEGORY_NAME)).andReturn(toEntities(CATEGORY_NAME, existingProperties)).once();
+
+ dao.remove(capture(capturedRemovedEntities));
+ expectLastCall().anyTimes();
+
+ dao.create(capture(capturedCreatedEntities));
+ expectLastCall().anyTimes();
+
+ replayAll();
+
+ Map<String, String> newProperties;
+ newProperties = new HashMap<>();
+ newProperties.put("property1_new", "value1");
+ newProperties.put("property2_new", "value2");
+ dao.reconcileCategory(CATEGORY_NAME, newProperties, true);
+
+ verifyAll();
+
+ validateCapturedEntities(CATEGORY_NAME, newProperties, capturedCreatedEntities);
+ validateCapturedEntities(CATEGORY_NAME, existingProperties, capturedRemovedEntities);
+ }
+
+ @Test
+ public void testReconcileCategoryUpdateCategoryKeepNotSpecified() throws Exception {
+
+ Map<String, String> existingProperties;
+ existingProperties = new HashMap<>();
+ existingProperties.put("property1", "value1");
+ existingProperties.put("property2", "value2");
+
+ Capture<AmbariConfigurationEntity> capturedCreatedEntities = newCapture(CaptureType.ALL);
+ Capture<AmbariConfigurationEntity> capturedMergedEntities = newCapture(CaptureType.ALL);
+
+ AmbariConfigurationDAO dao = createDao();
+
+ expect(dao.findByCategory(CATEGORY_NAME)).andReturn(toEntities(CATEGORY_NAME, existingProperties)).once();
+
+ expect(dao.merge(capture(capturedMergedEntities))).andReturn(createNiceMock(AmbariConfigurationEntity.class)).anyTimes();
+
+ dao.create(capture(capturedCreatedEntities));
+ expectLastCall().anyTimes();
+
+ replayAll();
+
+ Map<String, String> newProperties;
+ newProperties = new HashMap<>();
+ newProperties.put("property1", "new_value1");
+ newProperties.put("property2_new", "value2");
+ newProperties.put("property3", "value3");
+ dao.reconcileCategory(CATEGORY_NAME, newProperties, false);
+
+ verifyAll();
+
+ Map<String, String> expectedProperties;
+
+ expectedProperties = new HashMap<>();
+ expectedProperties.put("property2_new", "value2");
+ expectedProperties.put("property3", "value3");
+ validateCapturedEntities(CATEGORY_NAME, expectedProperties, capturedCreatedEntities);
+
+ expectedProperties = new HashMap<>();
+ expectedProperties.put("property1", "new_value1");
+ validateCapturedEntities(CATEGORY_NAME, expectedProperties, capturedMergedEntities);
+ }
+
+ @Test
+ public void testReconcileCategoryUpdateCategoryRemoveNotSpecified() throws Exception {
+
+ Map<String, String> existingProperties;
+ existingProperties = new HashMap<>();
+ existingProperties.put("property1", "value1");
+ existingProperties.put("property2", "value2");
+
+ Capture<AmbariConfigurationEntity> capturedCreatedEntities = newCapture(CaptureType.ALL);
+ Capture<AmbariConfigurationEntity> capturedRemovedEntities = newCapture(CaptureType.ALL);
+ Capture<AmbariConfigurationEntity> capturedMergedEntities = newCapture(CaptureType.ALL);
+
+ AmbariConfigurationDAO dao = createDao();
+
+ expect(dao.findByCategory(CATEGORY_NAME)).andReturn(toEntities(CATEGORY_NAME, existingProperties)).once();
+
+ expect(dao.merge(capture(capturedMergedEntities))).andReturn(createNiceMock(AmbariConfigurationEntity.class)).anyTimes();
+
+ dao.remove(capture(capturedRemovedEntities));
+ expectLastCall().anyTimes();
+
+ dao.create(capture(capturedCreatedEntities));
+ expectLastCall().anyTimes();
+
+ replayAll();
+
+ Map<String, String> newProperties;
+ newProperties = new HashMap<>();
+ newProperties.put("property1", "new_value1");
+ newProperties.put("property2_new", "value2");
+ newProperties.put("property3", "value3");
+ dao.reconcileCategory(CATEGORY_NAME, newProperties, true);
+
+ verifyAll();
+
+ Map<String, String> expectedProperties;
+
+ expectedProperties = new HashMap<>();
+ expectedProperties.put("property2_new", "value2");
+ expectedProperties.put("property3", "value3");
+ validateCapturedEntities(CATEGORY_NAME, expectedProperties, capturedCreatedEntities);
+
+ expectedProperties = new HashMap<>();
+ expectedProperties.put("property2", "value2");
+ validateCapturedEntities(CATEGORY_NAME, expectedProperties, capturedRemovedEntities);
+
+ expectedProperties = new HashMap<>();
+ expectedProperties.put("property1", "new_value1");
+ validateCapturedEntities(CATEGORY_NAME, expectedProperties, capturedMergedEntities);
+ }
+
+ @Test
+ public void testReconcileCategoryAppendCategory() throws Exception {
+
+ Map<String, String> existingProperties;
+ existingProperties = new HashMap<>();
+ existingProperties.put("property1", "value1");
+ existingProperties.put("property2", "value2");
+
+ Capture<AmbariConfigurationEntity> capturedCreatedEntities = newCapture(CaptureType.ALL);
+
+ AmbariConfigurationDAO dao = createDao();
+
+ expect(dao.findByCategory(CATEGORY_NAME)).andReturn(toEntities(CATEGORY_NAME, existingProperties)).once();
+
+ dao.create(capture(capturedCreatedEntities));
+ expectLastCall().anyTimes();
+
+ replayAll();
+
+ Map<String, String> newProperties;
+ newProperties = new HashMap<>();
+ newProperties.put("property3", "value3");
+ newProperties.put("property4", "value3");
+ dao.reconcileCategory(CATEGORY_NAME, newProperties, false);
+
+ verifyAll();
+
+ validateCapturedEntities(CATEGORY_NAME, newProperties, capturedCreatedEntities);
+ }
+
+ private AmbariConfigurationDAO createDao() throws IllegalAccessException {
+ AmbariConfigurationDAO dao = createMockBuilder(AmbariConfigurationDAO.class)
+ .addMockedMethods(methodMerge, methodRemove, methodCreate, methodFindByCategory)
+ .createMock();
+
+ EntityManager entityManager = createMock(EntityManager.class);
+ entityManager.flush();
+ expectLastCall().anyTimes();
+
+ Provider<EntityManager> entityManagerProvider = createMock(Provider.class);
+ expect(entityManagerProvider.get()).andReturn(entityManager).anyTimes();
+
+ fieldEntityManagerProvider.set(dao, entityManagerProvider);
+
+ return dao;
+ }
+
+ private List<AmbariConfigurationEntity> toEntities(String categoryName, Map<String, String> properties) {
+ List<AmbariConfigurationEntity> entities = new ArrayList<>();
+
+ for (Map.Entry<String, String> property : properties.entrySet()) {
+ AmbariConfigurationEntity entity = new AmbariConfigurationEntity();
+ entity.setCategoryName(categoryName);
+ entity.setPropertyName(property.getKey());
+ entity.setPropertyValue(property.getValue());
+ entities.add(entity);
+ }
+
+ return entities;
+ }
+
+ private void validateCapturedEntities(String expectedCategoryName, Map<String, String> expectedProperties, Capture<AmbariConfigurationEntity> capturedEntities) {
+ Assert.assertTrue(capturedEntities.hasCaptured());
+
+ List<AmbariConfigurationEntity> entities = capturedEntities.getValues();
+ Assert.assertNotNull(entities);
+
+ Map<String, String> capturedProperties = new TreeMap<>();
+ for (AmbariConfigurationEntity entity : entities) {
+ Assert.assertEquals(expectedCategoryName, entity.getCategoryName());
+ capturedProperties.put(entity.getPropertyName(), entity.getPropertyValue());
+ }
+
+ // Convert the Map to a TreeMap to help with comparisons
+ expectedProperties = new TreeMap<>(expectedProperties);
+ Assert.assertEquals(expectedProperties, capturedProperties);
+ }
+
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ADKerberosOperationHandlerTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ADKerberosOperationHandlerTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ADKerberosOperationHandlerTest.java
index 483cc0a..8b3c19a 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ADKerberosOperationHandlerTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ADKerberosOperationHandlerTest.java
@@ -19,11 +19,15 @@
package org.apache.ambari.server.serveraction.kerberos;
import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.anyString;
import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.expectLastCall;
+import static org.easymock.EasyMock.isNull;
import static org.easymock.EasyMock.newCapture;
import static org.easymock.EasyMock.replay;
+import java.lang.reflect.Method;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.List;
@@ -50,6 +54,8 @@ import org.apache.ambari.server.state.stack.OsFamily;
import org.easymock.Capture;
import org.easymock.CaptureType;
import org.easymock.IAnswer;
+import org.junit.Before;
+import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
@@ -65,6 +71,36 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
private static final String DEFAULT_LDAP_URL = "ldaps://10.0.100.4";
private static final String DEFAULT_PRINCIPAL_CONTAINER_DN = "ou=HDP,DC=HDP01,DC=LOCAL";
private static final String DEFAULT_REALM = "HDP01.LOCAL";
+ private static final Map<String, String> KERBEROS_ENV_MAP = new HashMap<String, String>() {
+ {
+ put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
+ put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
+ }
+ };
+
+ private static Method methodCreateInitialLdapContext;
+
+ private Injector injector;
+ private LdapContext ldapContext;
+
+ @BeforeClass
+ public static void beforeMITKerberosOperationHandlerTest() throws Exception {
+ methodCreateInitialLdapContext = ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext", Properties.class, Control[].class);
+ }
+
+ @Before
+ public void setup() {
+ injector = Guice.createInjector(new AbstractModule() {
+ @Override
+ protected void configure() {
+ bind(Clusters.class).toInstance(createNiceMock(Clusters.class));
+ bind(Configuration.class).toInstance(createNiceMock(Configuration.class));
+ bind(OsFamily.class).toInstance(createNiceMock(OsFamily.class));
+ }
+ });
+
+ ldapContext = createMock(LdapContext.class);
+ }
@Test(expected = KerberosKDCConnectionException.class)
public void testOpenExceptionLdapUrlNotProvided() throws Exception {
@@ -95,13 +131,8 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
@Test(expected = KerberosAdminAuthenticationException.class)
public void testOpenExceptionAdminCredentialsNotProvided() throws Exception {
KerberosOperationHandler handler = new ADKerberosOperationHandler();
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
- handler.open(null, DEFAULT_REALM, kerberosEnvMap);
+
+ handler.open(null, DEFAULT_REALM, getKerberosEnv());
handler.close();
}
@@ -124,13 +155,6 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
Injector injector = getInjector();
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, "wrong");
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
-
ADKerberosOperationHandler handler = createMockBuilder(ADKerberosOperationHandler.class)
.addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext", Properties.class, Control[].class))
.createNiceMock();
@@ -145,7 +169,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
replayAll();
- handler.open(kc, DEFAULT_REALM, kerberosEnvMap);
+ handler.open(kc, DEFAULT_REALM, getKerberosEnv());
handler.testAdministratorCredentials();
handler.close();
}
@@ -155,12 +179,6 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
Injector injector = getInjector();
PrincipalKeyCredential kc = new PrincipalKeyCredential("wrong", DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
ADKerberosOperationHandler handler = createMockBuilder(ADKerberosOperationHandler.class)
.addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext", Properties.class, Control[].class))
@@ -176,7 +194,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
replayAll();
- handler.open(kc, DEFAULT_REALM, kerberosEnvMap);
+ handler.open(kc, DEFAULT_REALM, getKerberosEnv());
handler.testAdministratorCredentials();
handler.close();
}
@@ -184,17 +202,8 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
@Test(expected = KerberosKDCConnectionException.class)
public void testTestAdministratorCredentialsKDCConnectionException() throws Exception {
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, "invalid");
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
-
- ADKerberosOperationHandler handler = createMockBuilder(ADKerberosOperationHandler.class)
- .addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext", Properties.class, Control[].class))
- .createNiceMock();
+ ADKerberosOperationHandler handler = createMockedHandler(methodCreateInitialLdapContext);
expect(handler.createInitialLdapContext(anyObject(Properties.class), anyObject(Control[].class))).andAnswer(new IAnswer<LdapContext>() {
@Override
public LdapContext answer() throws Throwable {
@@ -204,7 +213,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
replayAll();
- handler.open(kc, DEFAULT_REALM, kerberosEnvMap);
+ handler.open(kc, DEFAULT_REALM, getKerberosEnv());
handler.testAdministratorCredentials();
handler.close();
}
@@ -212,21 +221,8 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
@Test
public void testTestAdministratorCredentialsSuccess() throws Exception {
- Injector injector = getInjector();
-
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
-
- ADKerberosOperationHandler handler = createMockBuilder(ADKerberosOperationHandler.class)
- .addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext", Properties.class, Control[].class))
- .addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createSearchControls"))
- .createNiceMock();
- injector.injectMembers(handler);
+ ADKerberosOperationHandler handler = createMockedHandler(methodCreateInitialLdapContext);
expect(handler.createInitialLdapContext(anyObject(Properties.class), anyObject(Control[].class)))
.andAnswer(new IAnswer<LdapContext>() {
@@ -245,23 +241,14 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
}
})
.once();
- replay(ldapContext);
return ldapContext;
}
})
.once();
- expect(handler.createSearchControls()).andAnswer(new IAnswer<SearchControls>() {
- @Override
- public SearchControls answer() throws Throwable {
- SearchControls searchControls = createNiceMock(SearchControls.class);
- replay(searchControls);
- return searchControls;
- }
- }).once();
replayAll();
- handler.open(kc, DEFAULT_REALM, kerberosEnvMap);
+ handler.open(kc, DEFAULT_REALM, getKerberosEnv());
handler.testAdministratorCredentials();
handler.close();
}
@@ -271,12 +258,6 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
Injector injector = getInjector();
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- }
- };
Capture<Name> capturedName = newCapture(CaptureType.ALL);
Capture<Attributes> capturedAttributes = newCapture(CaptureType.ALL);
@@ -315,7 +296,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
replayAll();
- handler.open(kc, DEFAULT_REALM, kerberosEnvMap);
+ handler.open(kc, DEFAULT_REALM, getKerberosEnv());
handler.createPrincipal("nn/c6501.ambari.apache.org", "secret", true);
handler.createPrincipal("hdfs@" + DEFAULT_REALM, "secret", false);
handler.close();
@@ -384,31 +365,26 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
Injector injector = getInjector();
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<String, String>() {
- {
- put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
- put(ADKerberosOperationHandler.KERBEROS_ENV_AD_CREATE_ATTRIBUTES_TEMPLATE, "" +
- "#set( $user = \"${principal_primary}-${principal_digest}\" )" +
- "{" +
- " \"objectClass\": [" +
- " \"top\"," +
- " \"person\"," +
- " \"organizationalPerson\"," +
- " \"user\"" +
- " ]," +
- " \"cn\": \"$user\"," +
- " \"sAMAccountName\": \"$user.substring(0,20)\"," +
- " #if( $is_service )" +
- " \"servicePrincipalName\": \"$principal_name\"," +
- " #end" +
- " \"userPrincipalName\": \"$normalized_principal\"," +
- " \"unicodePwd\": \"$password\"," +
- " \"accountExpires\": \"0\"," +
- " \"userAccountControl\": \"66048\"" +
- "}");
- }
- };
+ Map<String, String> kerberosEnvMap = new HashMap<>(getKerberosEnv());
+ kerberosEnvMap.put(ADKerberosOperationHandler.KERBEROS_ENV_AD_CREATE_ATTRIBUTES_TEMPLATE, "" +
+ "#set( $user = \"${principal_primary}-${principal_digest}\" )" +
+ "{" +
+ " \"objectClass\": [" +
+ " \"top\"," +
+ " \"person\"," +
+ " \"organizationalPerson\"," +
+ " \"user\"" +
+ " ]," +
+ " \"cn\": \"$user\"," +
+ " \"sAMAccountName\": \"$user.substring(0,20)\"," +
+ " #if( $is_service )" +
+ " \"servicePrincipalName\": \"$principal_name\"," +
+ " #end" +
+ " \"userPrincipalName\": \"$normalized_principal\"," +
+ " \"unicodePwd\": \"$password\"," +
+ " \"accountExpires\": \"0\"," +
+ " \"userAccountControl\": \"66048\"" +
+ "}");
Capture<Name> capturedName = newCapture();
Capture<Attributes> capturedAttributes = newCapture();
@@ -491,9 +467,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
Injector injector = getInjector();
PrincipalKeyCredential kc = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
- Map<String, String> kerberosEnvMap = new HashMap<>();
- kerberosEnvMap.put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- kerberosEnvMap.put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
+ Map<String, String> kerberosEnvMap = new HashMap<>(getKerberosEnv());
kerberosEnvMap.put(ADKerberosOperationHandler.KERBEROS_ENV_AD_CREATE_ATTRIBUTES_TEMPLATE, "" +
"{" +
"\"principal_digest\": \"$principal_digest\"," +
@@ -596,7 +570,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
System.out.println("Test Admin Credentials: " + handler.testAdministratorCredentials());
// does the principal already exist?
- System.out.println("Principal exists: " + handler.principalExists("nn/c1508.ambari.apache.org"));
+ System.out.println("Principal exists: " + handler.principalExists("nn/c1508.ambari.apache.org", true));
handler.close();
@@ -605,15 +579,15 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
String evaluatedPrincipal;
evaluatedPrincipal = "nn/c6501.ambari.apache.org@" + DEFAULT_REALM;
- if (handler.principalExists(evaluatedPrincipal)) {
- handler.setPrincipalPassword(evaluatedPrincipal, "some password");
+ if (handler.principalExists(evaluatedPrincipal, true)) {
+ handler.setPrincipalPassword(evaluatedPrincipal, "some password", true);
} else {
handler.createPrincipal(evaluatedPrincipal, "some password", true);
}
evaluatedPrincipal = "hdfs@" + DEFAULT_REALM;
- if (handler.principalExists(evaluatedPrincipal)) {
- handler.setPrincipalPassword(evaluatedPrincipal, "some password");
+ if (handler.principalExists(evaluatedPrincipal, false)) {
+ handler.setPrincipalPassword(evaluatedPrincipal, "some password", false);
} else {
handler.createPrincipal(evaluatedPrincipal, "some password", true);
}
@@ -644,14 +618,14 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
handler.open(credentials, realm, kerberosEnvMap);
// remove the principal
- handler.removePrincipal("abcdefg");
- handler.removePrincipal("abcdefg/c1509.ambari.apache.org@" + DEFAULT_REALM);
+ handler.removePrincipal("abcdefg", false);
+ handler.removePrincipal("abcdefg/c1509.ambari.apache.org@" + DEFAULT_REALM, true);
handler.createPrincipal("abcdefg/c1509.ambari.apache.org@" + DEFAULT_REALM, "some password", true);
handler.createPrincipal("abcdefg@" + DEFAULT_REALM, "some password", false);
//update the password
- handler.setPrincipalPassword("abcdefg/c1509.ambari.apache.org@" + DEFAULT_REALM, "some password");
+ handler.setPrincipalPassword("abcdefg/c1509.ambari.apache.org@" + DEFAULT_REALM, "some password", true);
handler.close();
}
@@ -687,11 +661,7 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
replayAll();
- Map<String, String> kerberosConfiguration = new HashMap<>();
- kerberosConfiguration.put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL, DEFAULT_LDAP_URL);
- kerberosConfiguration.put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN, DEFAULT_PRINCIPAL_CONTAINER_DN);
-
- handler.open(new PrincipalKeyCredential("principal", "key"), "EXAMPLE.COM", kerberosConfiguration);
+ handler.open(new PrincipalKeyCredential("principal", "key"), "EXAMPLE.COM", getKerberosEnv());
Properties properties = capturedProperties.getValue();
Assert.assertNotNull(properties);
@@ -705,13 +675,78 @@ public class ADKerberosOperationHandlerTest extends KerberosOperationHandlerTest
}
private Injector getInjector() {
- return Guice.createInjector(new AbstractModule() {
- @Override
- protected void configure() {
- bind(Clusters.class).toInstance(createNiceMock(Clusters.class));
- bind(Configuration.class).toInstance(createNiceMock(Configuration.class));
- bind(OsFamily.class).toInstance(createNiceMock(OsFamily.class));
- }
- });
+ return injector;
+ }
+
+ @Override
+ protected KerberosOperationHandler createMockedHandler() throws KerberosOperationException {
+ return createMockedHandler(methodCreateInitialLdapContext);
+ }
+
+
+ private ADKerberosOperationHandler createMockedHandler(Method... mockedMethods) {
+ ADKerberosOperationHandler handler = createMockBuilder(ADKerberosOperationHandler.class)
+ .addMockedMethods(mockedMethods)
+ .createMock();
+ injector.injectMembers(handler);
+ return handler;
+ }
+
+
+ @Override
+ protected void setupOpenSuccess(KerberosOperationHandler handler) throws Exception {
+
+ ADKerberosOperationHandler adHandler = (ADKerberosOperationHandler) handler;
+
+ expect(adHandler.createInitialLdapContext(anyObject(Properties.class), isNull())).andReturn(ldapContext).anyTimes();
+ }
+
+ @Override
+ protected void setupOpenFailure(KerberosOperationHandler handler) throws Exception {
+ ADKerberosOperationHandler adHandler = (ADKerberosOperationHandler) handler;
+ expect(adHandler.createInitialLdapContext(anyObject(Properties.class), isNull())).andThrow(new AuthenticationException("Bogus error!")).anyTimes();
+ }
+
+ @Override
+ protected void setupPrincipalAlreadyExists(KerberosOperationHandler handler, boolean service) throws Exception {
+ setupPrincipalExists(handler, service);
+ }
+
+ @Override
+ protected void setupPrincipalDoesNotExist(KerberosOperationHandler handler, boolean service) throws Exception {
+ NamingEnumeration<SearchResult> results = createMock(NamingEnumeration.class);
+ results.close();
+ expectLastCall().once();
+ expect(results.hasMore()).andReturn(false).anyTimes();
+
+ expect(ldapContext.search(anyObject(Name.class), anyString(), anyObject(SearchControls.class)))
+ .andReturn(results)
+ .anyTimes();
+ ldapContext.close();
+ expectLastCall().once();
+ }
+
+ @Override
+ protected void setupPrincipalExists(KerberosOperationHandler handler, boolean service) throws Exception {
+ SearchResult result = createMock(SearchResult.class);
+ expect(result.getNameInNamespace()).andReturn("user/service dn").anyTimes();
+
+ NamingEnumeration<SearchResult> results = createMock(NamingEnumeration.class);
+ results.close();
+ expectLastCall().anyTimes();
+ expect(results.hasMore()).andReturn(true).once();
+ expect(results.next()).andReturn(result).once();
+ expect(results.hasMore()).andReturn(false).anyTimes();
+
+ expect(ldapContext.search(anyObject(Name.class), anyString(), anyObject(SearchControls.class)))
+ .andReturn(results)
+ .anyTimes();
+ ldapContext.close();
+ expectLastCall().once();
+ }
+
+ @Override
+ protected Map<String, String> getKerberosEnv() {
+ return KERBEROS_ENV_MAP;
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/AbstractPrepareKerberosServerActionTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/AbstractPrepareKerberosServerActionTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/AbstractPrepareKerberosServerActionTest.java
index 5522132..d580e6a 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/AbstractPrepareKerberosServerActionTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/AbstractPrepareKerberosServerActionTest.java
@@ -20,6 +20,7 @@ package org.apache.ambari.server.serveraction.kerberos;
import static org.easymock.EasyMock.anyBoolean;
import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
@@ -33,12 +34,15 @@ import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
+import javax.persistence.EntityManager;
+
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.agent.CommandReport;
import org.apache.ambari.server.audit.AuditLogger;
import org.apache.ambari.server.controller.KerberosHelper;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
+import org.apache.ambari.server.state.Host;
import org.apache.ambari.server.state.Service;
import org.apache.ambari.server.state.ServiceComponentHost;
import org.apache.ambari.server.state.kerberos.KerberosComponentDescriptor;
@@ -52,6 +56,7 @@ import org.junit.Test;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
+import com.google.inject.Provider;
public class AbstractPrepareKerberosServerActionTest {
private class PrepareKerberosServerAction extends AbstractPrepareKerberosServerAction{
@@ -79,6 +84,8 @@ public class AbstractPrepareKerberosServerActionTest {
bind(KerberosIdentityDataFileWriterFactory.class).toInstance(kerberosIdentityDataFileWriterFactory);
bind(Clusters.class).toInstance(clusters);
bind(AuditLogger.class).toInstance(auditLogger);
+ Provider<EntityManager> entityManagerProvider = EasyMock.createNiceMock(Provider.class);
+ bind(EntityManager.class).toProvider(entityManagerProvider);
}
});
@@ -131,10 +138,12 @@ public class AbstractPrepareKerberosServerActionTest {
expect(serviceComponentHostHDFS.getHostName()).andReturn(hostName).atLeastOnce();
expect(serviceComponentHostHDFS.getServiceName()).andReturn(hdfsService).atLeastOnce();
expect(serviceComponentHostHDFS.getServiceComponentName()).andReturn(hdfsComponent).atLeastOnce();
+ expect(serviceComponentHostHDFS.getHost()).andReturn(createNiceMock(Host.class)).atLeastOnce();
expect(serviceComponentHostZK.getHostName()).andReturn(hostName).atLeastOnce();
expect(serviceComponentHostZK.getServiceName()).andReturn(zookeeperService).atLeastOnce();
expect(serviceComponentHostZK.getServiceComponentName()).andReturn(zkComponent).atLeastOnce();
+ expect(serviceComponentHostZK.getHost()).andReturn(createNiceMock(Host.class)).atLeastOnce();
expect(kerberosDescriptor.getService(hdfsService)).andReturn(serviceDescriptor).once();
@@ -150,7 +159,7 @@ public class AbstractPrepareKerberosServerActionTest {
identityFilter,
"",
configurations, kerberosConfigurations,
- false, propertiesToIgnore, false);
+ false, propertiesToIgnore);
verify(kerberosHelper);
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ConfigureAmbariIdentitiesServerActionTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ConfigureAmbariIdentitiesServerActionTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ConfigureAmbariIdentitiesServerActionTest.java
index c232117..39dee24 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ConfigureAmbariIdentitiesServerActionTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/ConfigureAmbariIdentitiesServerActionTest.java
@@ -18,6 +18,9 @@
package org.apache.ambari.server.serveraction.kerberos;
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
@@ -75,13 +78,11 @@ public class ConfigureAmbariIdentitiesServerActionTest extends EasyMockSupport {
Injector injector = createInjector();
HostEntity hostEntity;
-
if (ambariServerHasAgent) {
KerberosPrincipalHostDAO kerberosPrincipalHostDAO = injector.getInstance(KerberosPrincipalHostDAO.class);
- expect(kerberosPrincipalHostDAO.exists(principal, 1L)).andReturn(false).once();
- kerberosPrincipalHostDAO.create(principal, 1L);
- expectLastCall().once();
-
+ expect(kerberosPrincipalHostDAO.exists(eq(principal), eq(1L), anyString())).andReturn(false).anyTimes();
+ kerberosPrincipalHostDAO.create(anyObject());
+ expectLastCall().anyTimes();
hostEntity = createMock(HostEntity.class);
expect(hostEntity.getHostId()).andReturn(1L).once();
} else {
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/FinalizeKerberosServerActionTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/FinalizeKerberosServerActionTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/FinalizeKerberosServerActionTest.java
index 8b679bf..c9301f3 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/FinalizeKerberosServerActionTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/FinalizeKerberosServerActionTest.java
@@ -30,6 +30,8 @@ import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import javax.persistence.EntityManager;
+
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.Role;
import org.apache.ambari.server.RoleCommand;
@@ -44,6 +46,7 @@ import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.Host;
import org.apache.ambari.server.state.ServiceComponentHost;
+import org.easymock.EasyMock;
import org.easymock.EasyMockSupport;
import org.junit.Rule;
import org.junit.Test;
@@ -52,6 +55,7 @@ import org.junit.rules.TemporaryFolder;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
+import com.google.inject.Provider;
import junit.framework.Assert;
@@ -193,6 +197,7 @@ public class FinalizeKerberosServerActionTest extends EasyMockSupport {
bind(KerberosHelper.class).toInstance(createMock(KerberosHelper.class));
bind(Clusters.class).toInstance(clusters);
bind(AuditLogger.class).toInstance(createNiceMock(AuditLogger.class));
+ bind(EntityManager.class).toProvider(EasyMock.createNiceMock(Provider.class));
}
});
}
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/IPAKerberosOperationHandlerTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/IPAKerberosOperationHandlerTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/IPAKerberosOperationHandlerTest.java
index f2a09ba..558ca79 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/IPAKerberosOperationHandlerTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/IPAKerberosOperationHandlerTest.java
@@ -18,36 +18,26 @@
package org.apache.ambari.server.serveraction.kerberos;
+import static org.easymock.EasyMock.anyObject;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
+import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
-import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.configuration.Configuration;
-import org.apache.ambari.server.security.credential.PrincipalKeyCredential;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.stack.OsFamily;
+import org.apache.ambari.server.utils.ShellCommandUtil;
import org.easymock.EasyMock;
import org.junit.BeforeClass;
-import org.junit.Test;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
-import junit.framework.Assert;
-
-public class IPAKerberosOperationHandlerTest extends KerberosOperationHandlerTest {
- private static final String DEFAULT_ADMIN_PRINCIPAL = "admin";
- private static final String DEFAULT_ADMIN_PASSWORD = "Hadoop12345";
-
- private static final String DEFAULT_REALM = "IPA01.LOCAL";
-
- private static Injector injector;
-
- private static boolean hasIpa = false;
+public class IPAKerberosOperationHandlerTest extends KDCKerberosOperationHandlerTest {
private static final Map<String, String> KERBEROS_ENV_MAP = new HashMap<String, String>() {
{
@@ -58,8 +48,10 @@ public class IPAKerberosOperationHandlerTest extends KerberosOperationHandlerTes
}
};
+ private static Injector injector;
+
@BeforeClass
- public static void beforeClass() throws AmbariException {
+ public static void beforeIPAKerberosOperationHandlerTest() throws Exception {
injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
@@ -72,85 +64,74 @@ public class IPAKerberosOperationHandlerTest extends KerberosOperationHandlerTes
bind(OsFamily.class).toInstance(EasyMock.createNiceMock(OsFamily.class));
}
});
- if (System.getenv("HAS_IPA") != null) {
- hasIpa = true;
- }
}
- @Test
- public void testSetPrincipalPasswordExceptions() throws Exception {
- if (!hasIpa) {
- return;
- }
+ @Override
+ protected IPAKerberosOperationHandler createMockedHandler(Method... mockedMethods) {
+ IPAKerberosOperationHandler handler = createMockBuilder(IPAKerberosOperationHandler.class)
+ .addMockedMethods(mockedMethods)
+ .createMock();
+ injector.injectMembers(handler);
+ return handler;
+ }
- IPAKerberosOperationHandler handler = injector.getInstance(IPAKerberosOperationHandler.class);
- handler.open(new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD), DEFAULT_REALM, KERBEROS_ENV_MAP);
- try {
- handler.setPrincipalPassword(DEFAULT_ADMIN_PRINCIPAL, null);
- Assert.fail("KerberosOperationException not thrown for null password");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
- }
+ @Override
+ protected Map<String, String> getKerberosEnv() {
+ return KERBEROS_ENV_MAP;
+ }
- try {
- handler.setPrincipalPassword(DEFAULT_ADMIN_PRINCIPAL, "");
- Assert.fail("KerberosOperationException not thrown for empty password");
- handler.createPrincipal("", "1234", false);
- Assert.fail("AmbariException not thrown for empty principal");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
+ @Override
+ protected void setupPrincipalAlreadyExists(KerberosOperationHandler handler, boolean service) throws Exception {
+ ShellCommandUtil.Result result = createMock(ShellCommandUtil.Result.class);
+ expect(result.getExitCode()).andReturn(1).anyTimes();
+ expect(result.isSuccessful()).andReturn(false).anyTimes();
+ if(service) {
+ expect(result.getStderr()).andReturn("ipa: ERROR: service with name \"service/host@EXAMPLE.COM\" already exists").anyTimes();
}
-
- try {
- handler.setPrincipalPassword(null, DEFAULT_ADMIN_PASSWORD);
- Assert.fail("KerberosOperationException not thrown for null principal");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
+ else {
+ expect(result.getStderr()).andReturn("ipa: ERROR: user with name \"user\" already exists").anyTimes();
}
+ expect(result.getStdout()).andReturn("").anyTimes();
- try {
- handler.setPrincipalPassword("", DEFAULT_ADMIN_PASSWORD);
- Assert.fail("KerberosOperationException not thrown for empty principal");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
- }
+ expect(handler.executeCommand(arrayContains(new String[]{"ipa", (service) ? "service-add" : "user-add"}), anyObject(Map.class), anyObject(KDCKerberosOperationHandler.InteractivePasswordHandler.class)))
+ .andReturn(result)
+ .anyTimes();
}
- @Test
- public void testCreateServicePrincipal_Exceptions() throws Exception {
- if (!hasIpa) {
- return;
- }
-
- IPAKerberosOperationHandler handler = new IPAKerberosOperationHandler();
- handler.open(new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD), DEFAULT_REALM, KERBEROS_ENV_MAP);
+ @Override
+ protected void setupPrincipalDoesNotExist(KerberosOperationHandler handler, boolean service) throws Exception {
+ ShellCommandUtil.Result result = createMock(ShellCommandUtil.Result.class);
+ expect(result.getExitCode()).andReturn(2).anyTimes();
+ expect(result.isSuccessful()).andReturn(false).anyTimes();
+ expect(result.getStderr()).andReturn(String.format("ipa: ERROR: %s: user not found", (service) ? "service/host" : "user")).anyTimes();
+ expect(result.getStdout()).andReturn("").anyTimes();
- try {
- handler.createPrincipal(DEFAULT_ADMIN_PRINCIPAL, null, false);
- Assert.fail("KerberosOperationException not thrown for null password");
- } catch (Throwable t) {
- Assert.fail("KerberosOperationException thrown on null password with IPA");
- }
- try {
- handler.createPrincipal(DEFAULT_ADMIN_PRINCIPAL, "", false);
- } catch (Throwable t) {
- Assert.fail("KerberosOperationException thrown for empty password");
- }
-
- try {
- handler.createPrincipal(null, DEFAULT_ADMIN_PASSWORD, false);
- Assert.fail("KerberosOperationException not thrown for null principal");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
- }
-
- try {
- handler.createPrincipal("", DEFAULT_ADMIN_PASSWORD, false);
- Assert.fail("KerberosOperationException not thrown for empty principal");
- } catch (Throwable t) {
- Assert.assertEquals(KerberosOperationException.class, t.getClass());
- }
+ expect(handler.executeCommand(arrayContains(new String[]{"ipa", (service) ? "service-show" : "user-show"}), anyObject(Map.class), anyObject(KDCKerberosOperationHandler.InteractivePasswordHandler.class)))
+ .andReturn(result)
+ .anyTimes();
}
+ @Override
+ protected void setupPrincipalExists(KerberosOperationHandler handler, boolean service) throws Exception {
+ ShellCommandUtil.Result result = createMock(ShellCommandUtil.Result.class);
+ expect(result.getExitCode()).andReturn(0).anyTimes();
+ expect(result.isSuccessful()).andReturn(true).anyTimes();
+ expect(result.getStderr()).andReturn("").anyTimes();
+ expect(result.getStdout()).andReturn(String.format(" User login: %s\n" +
+ " Last name: User\n" +
+ " Home directory: /home/user\n" +
+ " Login shell: /bin/bash\n" +
+ " Principal alias: user@EXAMPLE.COM\n" +
+ " UID: 324200000\n" +
+ " GID: 324200000\n" +
+ " Account disabled: False\n" +
+ " Password: True\n" +
+ " Member of groups: users\n" +
+ " Kerberos keys available: True", (service) ? "service/host" : "user")).anyTimes();
+
+ expect(handler.executeCommand(arrayContains(new String[]{"ipa", (service) ? "service-show" : "user-show"}), anyObject(Map.class), anyObject(KDCKerberosOperationHandler.InteractivePasswordHandler.class)))
+ .andReturn(result)
+ .anyTimes();
+ }
}
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KDCKerberosOperationHandlerTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KDCKerberosOperationHandlerTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KDCKerberosOperationHandlerTest.java
new file mode 100644
index 0000000..095b92a
--- /dev/null
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KDCKerberosOperationHandlerTest.java
@@ -0,0 +1,168 @@
+/*
+ * 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.ambari.server.serveraction.kerberos;
+
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.anyString;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.getCurrentArguments;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import org.apache.ambari.server.utils.ShellCommandUtil;
+import org.apache.commons.lang.StringUtils;
+import org.easymock.EasyMock;
+import org.easymock.IAnswer;
+import org.easymock.IArgumentMatcher;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import junit.framework.Assert;
+
+abstract public class KDCKerberosOperationHandlerTest extends KerberosOperationHandlerTest {
+
+ static Method methodExecuteCommand;
+
+ static Method methodGetExecutable;
+
+ @BeforeClass
+ public static void beforeKDCKerberosOperationHandlerTest() throws Exception {
+ methodExecuteCommand = KDCKerberosOperationHandler.class.getDeclaredMethod("executeCommand", String[].class, Map.class, ShellCommandUtil.InteractiveHandler.class);
+ methodGetExecutable = KerberosOperationHandler.class.getDeclaredMethod("getExecutable", String.class);
+ }
+
+ @Test
+ public void testInteractivePasswordHandler() {
+ KDCKerberosOperationHandler.InteractivePasswordHandler handler = new KDCKerberosOperationHandler.InteractivePasswordHandler("admin_password", "user_password");
+
+ handler.start();
+ Assert.assertEquals("admin_password", handler.getResponse("password"));
+ Assert.assertFalse(handler.done());
+ Assert.assertEquals("user_password", handler.getResponse("password"));
+ Assert.assertFalse(handler.done());
+ Assert.assertEquals("user_password", handler.getResponse("password"));
+ Assert.assertTrue(handler.done());
+
+ // Test restarting
+ handler.start();
+ Assert.assertEquals("admin_password", handler.getResponse("password"));
+ Assert.assertFalse(handler.done());
+ Assert.assertEquals("user_password", handler.getResponse("password"));
+ Assert.assertFalse(handler.done());
+ Assert.assertEquals("user_password", handler.getResponse("password"));
+ Assert.assertTrue(handler.done());
+ }
+
+ @Override
+ protected KerberosOperationHandler createMockedHandler() throws KerberosOperationException {
+ KDCKerberosOperationHandler handler = createMockedHandler(methodExecuteCommand, methodGetExecutable);
+
+ expect(handler.getExecutable(anyString()))
+ .andAnswer(new IAnswer<String>() {
+ @Override
+ public String answer() throws Throwable {
+ Object[] args = getCurrentArguments();
+ return args[0].toString();
+ }
+ }).anyTimes();
+ return handler;
+ }
+
+ @Override
+ protected void setupOpenSuccess(KerberosOperationHandler handler) throws Exception {
+ ShellCommandUtil.Result result = createMock(ShellCommandUtil.Result.class);
+ expect(result.isSuccessful()).andReturn(true);
+
+ expect(handler.executeCommand(arrayContains("kinit"), anyObject(Map.class), anyObject(KDCKerberosOperationHandler.InteractivePasswordHandler.class)))
+ .andReturn(result)
+ .anyTimes();
+ }
+
+ @Override
+ protected void setupOpenFailure(KerberosOperationHandler handler) throws Exception {
+ ShellCommandUtil.Result result = createMock(ShellCommandUtil.Result.class);
+ expect(result.isSuccessful()).andReturn(false).once();
+ expect(result.getExitCode()).andReturn(-1).once();
+ expect(result.getStdout()).andReturn("STDOUT data").once();
+ expect(result.getStderr()).andReturn("STDERR data").once();
+
+ expect(handler.executeCommand(arrayContains("kinit"), anyObject(Map.class), anyObject(KDCKerberosOperationHandler.InteractivePasswordHandler.class)))
+ .andReturn(result)
+ .anyTimes();
+ }
+
+ protected abstract KDCKerberosOperationHandler createMockedHandler(Method... mockedMethods);
+
+ public static class ArrayContains implements IArgumentMatcher {
+
+ private String[] startItems;
+
+ ArrayContains(String startItem) {
+ this.startItems = new String[]{startItem};
+ }
+
+ ArrayContains(String[] startItems) {
+ this.startItems = startItems;
+ }
+
+ @Override
+ public boolean matches(Object o) {
+ if (o instanceof String[]) {
+ String[] array = (String[]) o;
+
+ for (String item : startItems) {
+ boolean valueContains = false;
+ for (String value : array) {
+ if (value.contains(item)) {
+ valueContains = true;
+ break;
+ }
+ }
+
+ if (!valueContains) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ @Override
+ public void appendTo(StringBuffer stringBuffer) {
+ stringBuffer.append("arrayContains(");
+ stringBuffer.append(StringUtils.join(startItems, ", "));
+ stringBuffer.append("\")");
+ }
+ }
+
+ static String[] arrayContains(String in) {
+ EasyMock.reportMatcher(new ArrayContains(in));
+ return null;
+ }
+
+ static String[] arrayContains(String[] in) {
+ EasyMock.reportMatcher(new ArrayContains(in));
+ return null;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosIdentityDataFileTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosIdentityDataFileTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosIdentityDataFileTest.java
index cfe0fee..323ba8e 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosIdentityDataFileTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosIdentityDataFileTest.java
@@ -54,7 +54,7 @@ public class KerberosIdentityDataFileTest {
"principal" + i, "principal_type" + i, "keytabFilePath" + i,
"keytabFileOwnerName" + i, "keytabFileOwnerAccess" + i,
"keytabFileGroupName" + i, "keytabFileGroupAccess" + i,
- "false", "false");
+ "false");
}
// Add some odd characters
@@ -62,7 +62,7 @@ public class KerberosIdentityDataFileTest {
"principal", "principal_type", "keytabFilePath",
"'keytabFileOwnerName'", "<keytabFileOwnerAccess>",
"\"keytabFileGroupName\"", "keytab,File,Group,Access",
- "false", "false");
+ "false");
writer.close();
Assert.assertTrue(writer.isClosed());
@@ -153,7 +153,7 @@ public class KerberosIdentityDataFileTest {
"principal", "principal_type", "keytabFilePath",
"keytabFileOwnerName", "keytabFileOwnerAccess",
"keytabFileGroupName", "keytabFileGroupAccess",
- "true", "false");
+ "true");
writer.close();
Assert.assertTrue(writer.isClosed());
@@ -179,7 +179,7 @@ public class KerberosIdentityDataFileTest {
"principal", "principal_type", "keytabFilePath",
"keytabFileOwnerName", "keytabFileOwnerAccess",
"keytabFileGroupName", "keytabFileGroupAccess",
- "true", "false");
+ "true");
writer.close();
Assert.assertTrue(writer.isClosed());
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosOperationHandlerTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosOperationHandlerTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosOperationHandlerTest.java
index 88c841c..9d1e8e0 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosOperationHandlerTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosOperationHandlerTest.java
@@ -40,10 +40,128 @@ import junit.framework.Assert;
public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
+ static final String DEFAULT_ADMIN_PRINCIPAL = "admin";
+ static final String DEFAULT_ADMIN_PASSWORD = "hadoop";
+ static final String DEFAULT_REALM = "EXAMPLE.COM";
+ static final PrincipalKeyCredential DEFAULT_ADMIN_CREDENTIALS = new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL, DEFAULT_ADMIN_PASSWORD);
+
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Test
+ public void testOpenSucceeded() throws Exception {
+ KerberosOperationHandler handler = createMockedHandler();
+
+ setupOpenSuccess(handler);
+
+ replayAll();
+
+ handler.open(getAdminCredentials(), DEFAULT_REALM, getKerberosEnv());
+
+ verifyAll();
+
+ Assert.assertTrue(handler.isOpen());
+ }
+
+ @Test
+ public void testOpenFailed() throws Exception {
+ KerberosOperationHandler handler = createMockedHandler();
+
+ setupOpenFailure(handler);
+
+ replayAll();
+
+ try {
+ handler.open(getAdminCredentials(), DEFAULT_REALM, getKerberosEnv());
+ Assert.fail("KerberosAdminAuthenticationException expected");
+ } catch (KerberosAdminAuthenticationException e) {
+ // This is expected
+ }
+
+ verifyAll();
+
+ Assert.assertFalse(handler.isOpen());
+ }
+
+ @Test(expected = KerberosPrincipalAlreadyExistsException.class)
+ public void testCreateUserPrincipalPrincipalAlreadyExists() throws Exception {
+ testCreatePrincipalPrincipalAlreadyExists(false);
+ }
+
+ @Test(expected = KerberosPrincipalAlreadyExistsException.class)
+ public void testCreateServicePrincipalPrincipalAlreadyExists() throws Exception {
+ testCreatePrincipalPrincipalAlreadyExists(true);
+ }
+
+ private void testCreatePrincipalPrincipalAlreadyExists(boolean service) throws Exception {
+ KerberosOperationHandler handler = createMockedHandler();
+
+ setupOpenSuccess(handler);
+ setupPrincipalAlreadyExists(handler, service);
+
+ replayAll();
+
+ handler.open(getAdminCredentials(), DEFAULT_REALM, getKerberosEnv());
+ handler.createPrincipal(createPrincipal(service), "password", service);
+ handler.close();
+
+ verifyAll();
+
+ }
+
+
+ @Test
+ public void testUserPrincipalExistsNotFound() throws Exception {
+ testPrincipalExistsNotFound(false);
+ }
+
+ @Test
+ public void testServicePrincipalExistsNotFound() throws Exception {
+ testPrincipalExistsNotFound(true);
+ }
+
+ private void testPrincipalExistsNotFound(boolean service) throws Exception {
+ KerberosOperationHandler handler = createMockedHandler();
+
+ setupOpenSuccess(handler);
+ setupPrincipalDoesNotExist(handler, service);
+
+ replayAll();
+
+ handler.open(getAdminCredentials(), DEFAULT_REALM, getKerberosEnv());
+ Assert.assertFalse(handler.principalExists(createPrincipal(service), service));
+ handler.close();
+
+ verifyAll();
+ }
+
+ @Test
+ public void testUserPrincipalExistsFound() throws Exception {
+ testPrincipalExistsFound(false);
+ }
+
+ @Test
+ public void testServicePrincipalExistsFound() throws Exception {
+ testPrincipalExistsFound(true);
+ }
+
+ private void testPrincipalExistsFound(boolean service) throws Exception {
+ KerberosOperationHandler handler = createMockedHandler();
+
+ setupOpenSuccess(handler);
+ setupPrincipalExists(handler, service);
+
+ replayAll();
+
+ handler.open(getAdminCredentials(), DEFAULT_REALM, getKerberosEnv());
+ Assert.assertTrue(handler.principalExists(createPrincipal(service), service));
+ handler.close();
+
+ verifyAll();
+
+ }
+
+ @Test
public void testCreateKeytabFileOneAtATime() throws Exception {
KerberosOperationHandler handler = createHandler();
File file = folder.newFile();
@@ -285,7 +403,7 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
public void testAdminCredentialsNullCredential() throws KerberosOperationException {
KerberosOperationHandler handler = createHandler();
- PrincipalKeyCredential credentials = new PrincipalKeyCredential("principal", (char[])null);
+ PrincipalKeyCredential credentials = new PrincipalKeyCredential("principal", (char[]) null);
handler.setAdministratorCredential(credentials);
}
@@ -301,10 +419,10 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
public void testSetExecutableSearchPaths() throws KerberosOperationException {
KerberosOperationHandler handler = createHandler();
- handler.setExecutableSearchPaths((String)null);
+ handler.setExecutableSearchPaths((String) null);
Assert.assertNull(handler.getExecutableSearchPaths());
- handler.setExecutableSearchPaths((String[])null);
+ handler.setExecutableSearchPaths((String[]) null);
Assert.assertNull(handler.getExecutableSearchPaths());
handler.setExecutableSearchPaths("");
@@ -341,6 +459,24 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
Assert.assertEquals("path3/", handler.getExecutableSearchPaths()[2]);
}
+ protected abstract KerberosOperationHandler createMockedHandler() throws KerberosOperationException;
+
+ protected abstract void setupOpenSuccess(KerberosOperationHandler handler) throws Exception;
+
+ protected abstract void setupOpenFailure(KerberosOperationHandler handler) throws Exception;
+
+ protected abstract void setupPrincipalAlreadyExists(KerberosOperationHandler handler, boolean service) throws Exception;
+
+ protected abstract void setupPrincipalDoesNotExist(KerberosOperationHandler handler, boolean service) throws Exception;
+
+ protected abstract void setupPrincipalExists(KerberosOperationHandler handler, boolean service) throws Exception;
+
+ protected abstract Map<String, String> getKerberosEnv();
+
+ protected PrincipalKeyCredential getAdminCredentials() {
+ return DEFAULT_ADMIN_CREDENTIALS;
+ }
+
private KerberosOperationHandler createHandler() throws KerberosOperationException {
KerberosOperationHandler handler = new KerberosOperationHandler() {
@@ -357,7 +493,7 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
}
@Override
- public boolean principalExists(String principal) throws KerberosOperationException {
+ public boolean principalExists(String principal, boolean service) throws KerberosOperationException {
return false;
}
@@ -367,12 +503,12 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
}
@Override
- public Integer setPrincipalPassword(String principal, String password) throws KerberosOperationException {
+ public Integer setPrincipalPassword(String principal, String password, boolean service) throws KerberosOperationException {
return 0;
}
@Override
- public boolean removePrincipal(String principal) throws KerberosOperationException {
+ public boolean removePrincipal(String principal, boolean service) throws KerberosOperationException {
return false;
}
};
@@ -380,4 +516,8 @@ public abstract class KerberosOperationHandlerTest extends EasyMockSupport {
handler.open(new PrincipalKeyCredential("admin/admin", "hadoop"), "EXAMPLE.COM", null);
return handler;
}
+
+ private String createPrincipal(boolean service) {
+ return String.format("%s@%s", (service) ? "service/host" : "user", DEFAULT_REALM);
+ }
}
http://git-wip-us.apache.org/repos/asf/ambari/blob/e83bf1bd/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosServerActionTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosServerActionTest.java b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosServerActionTest.java
index a43db4d..e6f0868 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosServerActionTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/serveraction/kerberos/KerberosServerActionTest.java
@@ -18,20 +18,20 @@
package org.apache.ambari.server.serveraction.kerberos;
-import static org.easymock.EasyMock.createNiceMock;
+import static org.easymock.EasyMock.anyObject;
+import static org.easymock.EasyMock.anyString;
import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
+import static org.easymock.EasyMock.expectLastCall;
import java.io.File;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import javax.persistence.EntityManager;
+
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.actionmanager.HostRoleCommand;
import org.apache.ambari.server.actionmanager.HostRoleStatus;
@@ -43,7 +43,7 @@ import org.apache.ambari.server.security.credential.PrincipalKeyCredential;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.stack.OsFamily;
-import org.easymock.EasyMock;
+import org.easymock.EasyMockSupport;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
@@ -54,7 +54,7 @@ import com.google.inject.Injector;
import junit.framework.Assert;
-public class KerberosServerActionTest {
+public class KerberosServerActionTest extends EasyMockSupport {
Map<String, String> commandParams = new HashMap<>();
File temporaryDirectory;
@@ -63,47 +63,53 @@ public class KerberosServerActionTest {
@Before
public void setUp() throws Exception {
- final Cluster cluster = mock(Cluster.class);
+ Cluster cluster = createMock(Cluster.class);
+
+ Clusters clusters = createMock(Clusters.class);
+ expect(clusters.getCluster(anyString())).andReturn(cluster).anyTimes();
+
+ ExecutionCommand mockExecutionCommand = createMock(ExecutionCommand.class);
+ HostRoleCommand mockHostRoleCommand = createMock(HostRoleCommand.class);
- final Clusters clusters = mock(Clusters.class);
- when(clusters.getCluster(anyString())).thenReturn(cluster);
+ action = new KerberosServerAction() {
- final ExecutionCommand mockExecutionCommand = mock(ExecutionCommand.class);
- final HostRoleCommand mockHostRoleCommand = mock(HostRoleCommand.class);
+ @Override
+ protected CommandReport processIdentity(Map<String, String> identityRecord, String evaluatedPrincipal,
+ KerberosOperationHandler operationHandler,
+ Map<String, String> kerberosConfiguration,
+ Map<String, Object> requestSharedDataContext)
+ throws AmbariException {
+ Assert.assertNotNull(requestSharedDataContext);
+
+ if (requestSharedDataContext.get("FAIL") != null) {
+ return createCommandReport(1, HostRoleStatus.FAILED, "{}", "ERROR", "ERROR");
+ } else {
+ requestSharedDataContext.put(identityRecord.get(KerberosIdentityDataFileReader.PRINCIPAL), evaluatedPrincipal);
+ return null;
+ }
+ }
+
+ @Override
+ public CommandReport execute(ConcurrentMap<String, Object> requestSharedDataContext)
+ throws AmbariException, InterruptedException {
+ return processIdentities(requestSharedDataContext);
+ }
+ };
+ action.setExecutionCommand(mockExecutionCommand);
+ action.setHostRoleCommand(mockHostRoleCommand);
injector = Guice.createInjector(new AbstractModule() {
@Override
protected void configure() {
- bind(KerberosHelper.class).toInstance(createNiceMock(KerberosHelper.class));
- bind(KerberosServerAction.class).toInstance(new KerberosServerAction() {
-
- @Override
- protected CommandReport processIdentity(Map<String, String> identityRecord, String evaluatedPrincipal,
- KerberosOperationHandler operationHandler,
- Map<String, String> kerberosConfiguration,
- Map<String, Object> requestSharedDataContext)
- throws AmbariException {
- Assert.assertNotNull(requestSharedDataContext);
-
- if (requestSharedDataContext.get("FAIL") != null) {
- return createCommandReport(1, HostRoleStatus.FAILED, "{}", "ERROR", "ERROR");
- } else {
- requestSharedDataContext.put(identityRecord.get(KerberosIdentityDataFileReader.PRINCIPAL), evaluatedPrincipal);
- return null;
- }
- }
-
- @Override
- public CommandReport execute(ConcurrentMap<String, Object> requestSharedDataContext)
- throws AmbariException, InterruptedException {
- return processIdentities(requestSharedDataContext);
- }
- });
+ bind(KerberosHelper.class).toInstance(createMock(KerberosHelper.class));
+ bind(KerberosServerAction.class).toInstance(action);
+ bind(EntityManager.class).toInstance(createNiceMock(EntityManager.class));
bind(Clusters.class).toInstance(clusters);
bind(OsFamily.class).toInstance(createNiceMock(OsFamily.class));
bind(AuditLogger.class).toInstance(createNiceMock(AuditLogger.class));
+ bind(KerberosOperationHandlerFactory.class).toInstance(createMock(KerberosOperationHandlerFactory.class));
}
});
@@ -120,7 +126,7 @@ public class KerberosServerActionTest {
"principal|_HOST|_REALM" + i, "principal_type", "keytabFilePath" + i,
"keytabFileOwnerName" + i, "keytabFileOwnerAccess" + i,
"keytabFileGroupName" + i, "keytabFileGroupAccess" + i,
- "false", "false");
+ "false");
}
writer.close();
@@ -128,13 +134,17 @@ public class KerberosServerActionTest {
commandParams.put(KerberosServerAction.DEFAULT_REALM, "REALM.COM");
commandParams.put(KerberosServerAction.KDC_TYPE, KDCType.MIT_KDC.toString());
- when(mockExecutionCommand.getCommandParams()).thenReturn(commandParams);
- when(mockExecutionCommand.getClusterName()).thenReturn("c1");
-
- action = injector.getInstance(KerberosServerAction.class);
-
- action.setExecutionCommand(mockExecutionCommand);
- action.setHostRoleCommand(mockHostRoleCommand);
+ expect(mockExecutionCommand.getCommandParams()).andReturn(commandParams).anyTimes();
+ expect(mockExecutionCommand.getClusterName()).andReturn("c1").anyTimes();
+ expect(mockExecutionCommand.getConfigurations()).andReturn(Collections.emptyMap()).anyTimes();
+ expect(mockExecutionCommand.getRoleCommand()).andReturn(null).anyTimes();
+ expect(mockExecutionCommand.getConfigurationTags()).andReturn(null).anyTimes();
+ expect(mockExecutionCommand.getRole()).andReturn(null).anyTimes();
+ expect(mockExecutionCommand.getServiceName()).andReturn(null).anyTimes();
+ expect(mockExecutionCommand.getTaskId()).andReturn(1L).anyTimes();
+
+ expect(mockHostRoleCommand.getRequestId()).andReturn(1L).anyTimes();
+ expect(mockHostRoleCommand.getStageId()).andReturn(1L).anyTimes();
}
@After
@@ -184,17 +194,28 @@ public class KerberosServerActionTest {
@Test
public void testGetDataDirectoryPath() throws Exception {
+ replayAll();
Assert.assertEquals(temporaryDirectory.getAbsolutePath(), action.getDataDirectoryPath());
+ verifyAll();
}
@Test
public void testProcessIdentitiesSuccess() throws Exception {
KerberosHelper kerberosHelper = injector.getInstance(KerberosHelper.class);
- expect(kerberosHelper.getKDCAdministratorCredentials(EasyMock.anyObject(String.class)))
+ expect(kerberosHelper.getKDCAdministratorCredentials(anyObject(String.class)))
.andReturn(new PrincipalKeyCredential("principal", "password"))
.anyTimes();
- replay(kerberosHelper);
+ KerberosOperationHandler kerberosOperationHandler = createMock(KerberosOperationHandler.class);
+ kerberosOperationHandler.open(anyObject(PrincipalKeyCredential.class), anyString(), anyObject(Map.class));
+ expectLastCall().atLeastOnce();
+ kerberosOperationHandler.close();
+ expectLastCall().atLeastOnce();
+
+ KerberosOperationHandlerFactory factory = injector.getInstance(KerberosOperationHandlerFactory.class);
+ expect(factory.getKerberosOperationHandler(KDCType.MIT_KDC)).andReturn(kerberosOperationHandler).once();
+
+ replayAll();
ConcurrentMap<String, Object> sharedMap = new ConcurrentHashMap<>();
CommandReport report = action.processIdentities(sharedMap);
@@ -202,21 +223,29 @@ public class KerberosServerActionTest {
Assert.assertEquals(HostRoleStatus.COMPLETED.toString(), report.getStatus());
for (Map.Entry<String, Object> entry : sharedMap.entrySet()) {
- Assert.assertEquals(entry.getValue(),
- entry.getKey().replace("_HOST", "hostName").replace("_REALM", "REALM.COM"));
+ Assert.assertEquals(entry.getValue(), entry.getKey());
}
- verify(kerberosHelper);
+ verifyAll();
}
@Test
public void testProcessIdentitiesFail() throws Exception {
KerberosHelper kerberosHelper = injector.getInstance(KerberosHelper.class);
- expect(kerberosHelper.getKDCAdministratorCredentials(EasyMock.anyObject(String.class)))
+ expect(kerberosHelper.getKDCAdministratorCredentials(anyObject(String.class)))
.andReturn(new PrincipalKeyCredential("principal", "password"))
.anyTimes();
- replay(kerberosHelper);
+ KerberosOperationHandler kerberosOperationHandler = createMock(KerberosOperationHandler.class);
+ kerberosOperationHandler.open(anyObject(PrincipalKeyCredential.class), anyString(), anyObject(Map.class));
+ expectLastCall().atLeastOnce();
+ kerberosOperationHandler.close();
+ expectLastCall().atLeastOnce();
+
+ KerberosOperationHandlerFactory factory = injector.getInstance(KerberosOperationHandlerFactory.class);
+ expect(factory.getKerberosOperationHandler(KDCType.MIT_KDC)).andReturn(kerberosOperationHandler).once();
+
+ replayAll();
ConcurrentMap<String, Object> sharedMap = new ConcurrentHashMap<>();
sharedMap.put("FAIL", "true");
@@ -225,6 +254,6 @@ public class KerberosServerActionTest {
Assert.assertNotNull(report);
Assert.assertEquals(HostRoleStatus.FAILED.toString(), report.getStatus());
- verify(kerberosHelper);
+ verifyAll();
}
}