/**
* 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.controller.internal;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertTrue;
import static org.easymock.EasyMock.capture;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.createStrictMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.newCapture;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.resetToStrict;
import static org.easymock.EasyMock.verify;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.ambari.server.api.resources.AlertTargetResourceDefinition;
import org.apache.ambari.server.controller.AmbariManagementController;
import org.apache.ambari.server.controller.spi.Predicate;
import org.apache.ambari.server.controller.spi.Request;
import org.apache.ambari.server.controller.spi.Resource;
import org.apache.ambari.server.controller.utilities.PredicateBuilder;
import org.apache.ambari.server.controller.utilities.PropertyHelper;
import org.apache.ambari.server.metadata.ActionMetadata;
import org.apache.ambari.server.orm.InMemoryDefaultTestModule;
import org.apache.ambari.server.orm.dao.AlertDispatchDAO;
import org.apache.ambari.server.orm.entities.AlertGroupEntity;
import org.apache.ambari.server.orm.entities.AlertTargetEntity;
import org.apache.ambari.server.security.TestAuthenticationFactory;
import org.apache.ambari.server.security.authorization.AuthorizationException;
import org.apache.ambari.server.state.AlertState;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.alert.TargetType;
import org.apache.ambari.server.utils.CollectionPresentationUtils;
import org.easymock.Capture;
import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import com.google.inject.Binder;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Module;
import com.google.inject.util.Modules;
/**
* {@link AlertTargetResourceProvider} tests.
*/
public class AlertTargetResourceProviderTest {
private static final Long ALERT_TARGET_ID = Long.valueOf(28);
private static final String ALERT_TARGET_NAME = "The Administrators";
private static final String ALERT_TARGET_DESC = "Admins and Others";
private static final String ALERT_TARGET_TYPE = TargetType.EMAIL.name();
private static final String ALERT_TARGET_PROPS = "{\"foo\":\"bar\",\"foobar\":\"baz\"}";
private static final String ALERT_TARGET_PROPS2 = "{\"foobar\":\"baz\"}";
private AlertDispatchDAO m_dao;
private Injector m_injector;
private AmbariManagementController m_amc;
@Before
public void before() {
m_dao = createStrictMock(AlertDispatchDAO.class);
m_amc = createMock(AmbariManagementController.class);
// create an injector which will inject the mocks
m_injector = Guice.createInjector(Modules.override(
new InMemoryDefaultTestModule()).with(new MockModule()));
Assert.assertNotNull(m_injector);
}
@After
public void clearAuthentication() {
SecurityContextHolder.getContext().setAuthentication(null);
}
@Test
public void testGetResourcesNoPredicateAsAdministrator() throws Exception {
testGetResourcesNoPredicate(TestAuthenticationFactory.createAdministrator());
}
@Test
public void testGetResourcesNoPredicateAsClusterAdministrator() throws Exception {
testGetResourcesNoPredicate(TestAuthenticationFactory.createClusterAdministrator());
}
@Test
public void testGetResourcesNoPredicateAsServiceAdministrator() throws Exception {
testGetResourcesNoPredicate(TestAuthenticationFactory.createServiceAdministrator());
}
@Test
public void testGetResourcesNoPredicateAsClusterUser() throws Exception {
testGetResourcesNoPredicate(TestAuthenticationFactory.createClusterUser());
}
@Test
public void testGetResourcesNoPredicateAsViewUser() throws Exception {
testGetResourcesNoPredicate(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
@SuppressWarnings("unchecked")
public void testGetResourcesNoPredicate(Authentication authentication) throws Exception {
Request request = PropertyHelper.getReadRequest(
AlertTargetResourceProvider.ALERT_TARGET_DESCRIPTION,
AlertTargetResourceProvider.ALERT_TARGET_ID,
AlertTargetResourceProvider.ALERT_TARGET_NAME,
AlertTargetResourceProvider.ALERT_TARGET_NOTIFICATION_TYPE);
expect(m_dao.findAllTargets()).andReturn(getMockEntities());
replay(m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Set<Resource> results = provider.getResources(request, null);
assertEquals(1, results.size());
Resource resource = results.iterator().next();
Assert.assertEquals(ALERT_TARGET_NAME,
resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_NAME));
// ensure that properties is null if not requested
Map<String, String> properties = (Map<String, String>) resource.getPropertyValue(
AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES);
Collection<String> alertStates = (Collection<String>) resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_STATES);
assertNull(properties);
assertNull(alertStates);
assertNull(resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_GLOBAL));
verify(m_dao);
}
@Test
public void testGetSingleResourceAsAdministrator() throws Exception {
testGetSingleResource(TestAuthenticationFactory.createAdministrator());
}
@Test
public void testGetSingleResourceAsClusterAdministrator() throws Exception {
testGetSingleResource(TestAuthenticationFactory.createClusterAdministrator());
}
@Test
public void testGetSingleResourceAsServiceAdministrator() throws Exception {
testGetSingleResource(TestAuthenticationFactory.createServiceAdministrator());
}
@Test
public void testGetSingleResourceAsClusterUser() throws Exception {
testGetSingleResource(TestAuthenticationFactory.createClusterUser());
}
@Test
public void testGetSingleResourceAsViewUser() throws Exception {
testGetSingleResource(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
@SuppressWarnings("unchecked")
private void testGetSingleResource(Authentication authentication) throws Exception {
Request request = PropertyHelper.getReadRequest(
AlertTargetResourceProvider.ALERT_TARGET_DESCRIPTION,
AlertTargetResourceProvider.ALERT_TARGET_ID,
AlertTargetResourceProvider.ALERT_TARGET_NAME,
AlertTargetResourceProvider.ALERT_TARGET_NOTIFICATION_TYPE,
AlertTargetResourceProvider.ALERT_TARGET_STATES,
AlertTargetResourceProvider.ALERT_TARGET_GLOBAL);
Predicate predicate = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
expect(m_dao.findTargetById(ALERT_TARGET_ID.longValue())).andReturn(
getMockEntities().get(0)).atLeastOnce();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Set<Resource> results = provider.getResources(request, predicate);
assertEquals(1, results.size());
Resource resource = results.iterator().next();
Assert.assertEquals(ALERT_TARGET_ID,
resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_ID));
Assert.assertEquals(ALERT_TARGET_NAME,
resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_NAME));
// alert states were requested
Collection<String> alertStates = (Collection<String>) resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_STATES);
Assert.assertNotNull(alertStates);
Assert.assertEquals(2, alertStates.size());
Assert.assertTrue(alertStates.contains(AlertState.CRITICAL));
Assert.assertTrue(alertStates.contains(AlertState.WARNING));
// properties were not requested, they should not be included
Map<String, String> properties = (Map<String, String>) resource.getPropertyValue(
AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES);
assertNull(properties);
assertEquals(
Boolean.FALSE,
resource.getPropertyValue(AlertTargetResourceProvider.ALERT_TARGET_GLOBAL));
// ask for all fields
request = PropertyHelper.getReadRequest();
results = provider.getResources(request, predicate);
assertEquals(1, results.size());
resource = results.iterator().next();
// ensure properties is included
properties = (Map<String, String>) resource.getPropertyValue(
AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES);
assertEquals("bar", properties.get("foo"));
assertEquals( "baz", properties.get("foobar") );
verify(m_amc, m_dao);
}
@Test
public void testCreateResourcesAsAdministrator() throws Exception {
testCreateResources(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesAsClusterAdministrator() throws Exception {
testCreateResources(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesAsServiceAdministrator() throws Exception {
testCreateResources(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesAsClusterUser() throws Exception {
testCreateResources(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesAsViewUser() throws Exception {
testCreateResources(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testCreateResources(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> targetCapture = newCapture();
m_dao.create(capture(targetCapture));
expectLastCall();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
AlertTargetEntity entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertTrue(CollectionPresentationUtils.isJsonsEquals(ALERT_TARGET_PROPS, entity.getProperties()));
assertEquals(false, entity.isGlobal());
// no alert states were set explicitely in the request, so all should be set
// by the backend
assertNotNull(entity.getAlertStates());
assertEquals(EnumSet.allOf(AlertState.class), entity.getAlertStates());
verify(m_amc, m_dao);
}
@Test
public void testCreateResourcesWithGroupsAsAdministrator() throws Exception {
testCreateResourcesWithGroups(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesWithGroupsAsClusterAdministrator() throws Exception {
testCreateResourcesWithGroups(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesWithGroupsAsServiceAdministrator() throws Exception {
testCreateResourcesWithGroups(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesWithGroupsAsClusterUser() throws Exception {
testCreateResourcesWithGroups(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesWithGroupsAsViewUser() throws Exception {
testCreateResourcesWithGroups(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testCreateResourcesWithGroups(Authentication authentication) throws Exception {
List<Long> groupIds = Arrays.asList(1L, 2L, 3L);
List<AlertGroupEntity> groups = new ArrayList<>();
AlertGroupEntity group1 = new AlertGroupEntity();
AlertGroupEntity group2 = new AlertGroupEntity();
AlertGroupEntity group3 = new AlertGroupEntity();
group1.setGroupId(1L);
group2.setGroupId(2L);
group3.setGroupId(3L);
groups.addAll(Arrays.asList(group1, group2, group3));
expect(m_dao.findGroupsById(groupIds)).andReturn(groups).once();
Capture<AlertTargetEntity> targetCapture = EasyMock.newCapture();
m_dao.create(capture(targetCapture));
expectLastCall();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
// add the group IDs to the request so that we're associating groups
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GROUPS, groupIds);
Request request = PropertyHelper.getCreateRequest(Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
AlertTargetEntity entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertTrue(CollectionPresentationUtils.isJsonsEquals(ALERT_TARGET_PROPS, entity.getProperties()));
assertEquals(false, entity.isGlobal());
assertEquals(3, entity.getAlertGroups().size());
// no alert states were set explicitely in the request, so all should be set
// by the backend
assertNotNull(entity.getAlertStates());
assertEquals(EnumSet.allOf(AlertState.class), entity.getAlertStates());
verify(m_amc, m_dao);
}
@Test
public void testCreateGlobalTargetAsAdministrator() throws Exception {
testCreateGlobalTarget(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateGlobalTargetAsClusterAdministrator() throws Exception {
testCreateGlobalTarget(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateGlobalTargetAsServiceAdministrator() throws Exception {
testCreateGlobalTarget(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateGlobalTargetAsClusterUser() throws Exception {
testCreateGlobalTarget(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testCreateGlobalTargetAsViewUser() throws Exception {
testCreateGlobalTarget(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testCreateGlobalTarget(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> targetCapture = EasyMock.newCapture();
m_dao.create(capture(targetCapture));
expectLastCall();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
// make this alert target global
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GLOBAL, "true");
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
AlertTargetEntity entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertTrue(CollectionPresentationUtils.isJsonsEquals(ALERT_TARGET_PROPS, entity.getProperties()));
assertEquals(true, entity.isGlobal());
// no alert states were set explicitely in the request, so all should be set
// by the backend
assertNotNull(entity.getAlertStates());
assertEquals(EnumSet.allOf(AlertState.class), entity.getAlertStates());
verify(m_amc, m_dao);
}
@Test
public void testCreateResourceWithRecipientArrayAsAdministrator() throws Exception {
testCreateResourceWithRecipientArray(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithRecipientArrayAsClusterAdministrator() throws Exception {
testCreateResourceWithRecipientArray(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithRecipientArrayAsServiceAdministrator() throws Exception {
testCreateResourceWithRecipientArray(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithRecipientArrayAsClusterUser() throws Exception {
testCreateResourceWithRecipientArray(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourcesWithRecipientArrayAsViewUser() throws Exception {
testCreateResourceWithRecipientArray(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testCreateResourceWithRecipientArray(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> targetCapture = EasyMock.newCapture();
m_dao.create(capture(targetCapture));
expectLastCall();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getRecipientCreationProperties();
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
AlertTargetEntity entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertEquals(
"{\"ambari.dispatch.recipients\":\"[\\\"ambari@ambari.apache.org\\\"]\"}",
entity.getProperties());
// no alert states were set explicitely in the request, so all should be set
// by the backend
assertNotNull(entity.getAlertStates());
assertEquals(EnumSet.allOf(AlertState.class), entity.getAlertStates());
verify(m_amc, m_dao);
}
@Test
public void testCreateResourceWithAlertStatesAsAdministrator() throws Exception {
testCreateResourceWithAlertStates(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithAlertStatesAsClusterAdministrator() throws Exception {
testCreateResourceWithAlertStates(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithAlertStatesAsServiceAdministrator() throws Exception {
testCreateResourceWithAlertStates(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithAlertStatesAsClusterUser() throws Exception {
testCreateResourceWithAlertStates(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testCreateResourceWithAlertStatesAsViewUser() throws Exception {
testCreateResourceWithAlertStates(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testCreateResourceWithAlertStates(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> targetCapture = EasyMock.newCapture();
m_dao.create(capture(targetCapture));
expectLastCall();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
requestProps.put(
AlertTargetResourceProvider.ALERT_TARGET_STATES,
new ArrayList<>(Arrays.asList(AlertState.OK.name(),
AlertState.UNKNOWN.name())));
Request request = PropertyHelper.getCreateRequest(Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
AlertTargetEntity entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertTrue(CollectionPresentationUtils.isJsonsEquals(ALERT_TARGET_PROPS, entity.getProperties()));
Set<AlertState> alertStates = entity.getAlertStates();
assertNotNull(alertStates);
assertEquals(2, alertStates.size());
assertTrue(alertStates.contains(AlertState.OK));
assertTrue(alertStates.contains(AlertState.UNKNOWN));
verify(m_amc, m_dao);
}
@Test
public void testUpdateResourcesAsAdministrator() throws Exception {
testUpdateResources(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesAsClusterAdministrator() throws Exception {
testUpdateResources(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesAsServiceAdministrator() throws Exception {
testUpdateResources(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesAsClusterUser() throws Exception {
testUpdateResources(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesAsViewUser() throws Exception {
testUpdateResources(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testUpdateResources(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> entityCapture = EasyMock.newCapture();
m_dao.create(capture(entityCapture));
expectLastCall().times(1);
AlertTargetEntity target = new AlertTargetEntity();
expect(m_dao.findTargetById(ALERT_TARGET_ID)).andReturn(target).times(1);
expect(m_dao.merge(capture(entityCapture))).andReturn(target).once();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
// create new properties, and include the ID since we're not going through
// a service layer which would add it for us automatically
requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_ID,
ALERT_TARGET_ID.toString());
String newName = ALERT_TARGET_NAME + " Foo";
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_NAME, newName);
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES
+ "/foobar", "baz");
Predicate predicate = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
request = PropertyHelper.getUpdateRequest(requestProps, null);
provider.updateResources(request, predicate);
assertTrue(entityCapture.hasCaptured());
AlertTargetEntity entity = entityCapture.getValue();
assertEquals(newName, entity.getTargetName());
assertEquals(ALERT_TARGET_PROPS2, entity.getProperties());
verify(m_amc, m_dao);
}
@Test
public void testUpdateResourcesWithGroupsAsAdministrator() throws Exception {
testUpdateResourcesWithGroups(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesWithGroupsAsClusterAdministrator() throws Exception {
testUpdateResourcesWithGroups(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesWithGroupsAsServiceAdministrator() throws Exception {
testUpdateResourcesWithGroups(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesWithGroupsAsClusterUser() throws Exception {
testUpdateResourcesWithGroups(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testUpdateResourcesWithGroupsAsViewUser() throws Exception {
testUpdateResourcesWithGroups(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testUpdateResourcesWithGroups(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> entityCapture = EasyMock.newCapture();
m_dao.create(capture(entityCapture));
expectLastCall().times(1);
AlertTargetEntity target = new AlertTargetEntity();
expect(m_dao.findTargetById(ALERT_TARGET_ID)).andReturn(target).times(1);
List<Long> groupIds = Arrays.asList(1L, 2L, 3L);
List<AlertGroupEntity> groups = new ArrayList<>();
AlertGroupEntity group1 = new AlertGroupEntity();
AlertGroupEntity group2 = new AlertGroupEntity();
AlertGroupEntity group3 = new AlertGroupEntity();
group1.setGroupId(1L);
group2.setGroupId(2L);
group3.setGroupId(3L);
groups.addAll(Arrays.asList(group1, group2, group3));
expect(m_dao.findGroupsById(EasyMock.eq(groupIds))).andReturn(groups).once();
expect(m_dao.merge(capture(entityCapture))).andReturn(target).once();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
// create new properties, and include the ID since we're not going through
// a service layer which would add it for us automatically
requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_ID,
ALERT_TARGET_ID.toString());
// add the group IDs to the request so that we're associating groups
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GROUPS, groupIds);
Predicate predicate = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
request = PropertyHelper.getUpdateRequest(requestProps, null);
provider.updateResources(request, predicate);
assertTrue(entityCapture.hasCaptured());
AlertTargetEntity entity = entityCapture.getValue();
assertEquals(3, entity.getAlertGroups().size());
verify(m_amc, m_dao);
}
@Test
public void testDeleteResourcesAsAdministrator() throws Exception {
testDeleteResources(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testDeleteResourcesAsClusterAdministrator() throws Exception {
testDeleteResources(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testDeleteResourcesAsServiceAdministrator() throws Exception {
testDeleteResources(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testDeleteResourcesAsClusterUser() throws Exception {
testDeleteResources(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testDeleteResourcesAsViewUser() throws Exception {
testDeleteResources(TestAuthenticationFactory.createViewUser(99L));
}
/**
* @throws Exception
*/
private void testDeleteResources(Authentication authentication) throws Exception {
Capture<AlertTargetEntity> entityCapture = EasyMock.newCapture();
m_dao.create(capture(entityCapture));
expectLastCall().times(1);
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(Collections.singleton(requestProps), null);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
AlertTargetEntity entity = entityCapture.getValue();
Assert.assertNotNull(entity);
Predicate p = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
// everything is mocked, there is no DB
entity.setTargetId(ALERT_TARGET_ID);
resetToStrict(m_dao);
expect(m_dao.findTargetById(ALERT_TARGET_ID.longValue())).andReturn(entity).anyTimes();
m_dao.remove(capture(entityCapture));
expectLastCall();
replay(m_dao);
provider.deleteResources(new RequestImpl(null, null, null, null), p);
AlertTargetEntity entity1 = entityCapture.getValue();
Assert.assertEquals(ALERT_TARGET_ID, entity1.getTargetId());
verify(m_amc, m_dao);
}
@Test
public void testOverwriteDirectiveAsAdministrator() throws Exception {
testOverwriteDirective(TestAuthenticationFactory.createAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testOverwriteDirectiveAsClusterAdministrator() throws Exception {
testOverwriteDirective(TestAuthenticationFactory.createClusterAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testOverwriteDirectiveAsServiceAdministrator() throws Exception {
testOverwriteDirective(TestAuthenticationFactory.createServiceAdministrator());
}
@Test(expected = AuthorizationException.class)
public void testOverwriteDirectiveAsClusterUser() throws Exception {
testOverwriteDirective(TestAuthenticationFactory.createClusterUser());
}
@Test(expected = AuthorizationException.class)
public void testOverwriteDirectiveAsViewUser() throws Exception {
testOverwriteDirective(TestAuthenticationFactory.createViewUser(99L));
}
private void testOverwriteDirective(Authentication authentication) throws Exception {
// mock out returning an existing entity
AlertTargetEntity entity = getMockEntities().get(0);
expect(m_dao.findTargetByName(ALERT_TARGET_NAME)).andReturn(entity).atLeastOnce();
Capture<AlertTargetEntity> targetCapture = EasyMock.newCapture();
expect(m_dao.merge(capture(targetCapture))).andReturn(entity).once();
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(authentication);
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
// mock out the directive
Map<String, String> requestInfoProperties = new HashMap<>();
requestInfoProperties.put(
AlertTargetResourceDefinition.OVERWRITE_DIRECTIVE, "true");
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), requestInfoProperties);
provider.createResources(request);
Assert.assertTrue(targetCapture.hasCaptured());
entity = targetCapture.getValue();
Assert.assertNotNull(entity);
assertEquals(ALERT_TARGET_NAME, entity.getTargetName());
assertEquals(ALERT_TARGET_DESC, entity.getDescription());
assertEquals(ALERT_TARGET_TYPE, entity.getNotificationType());
assertTrue(CollectionPresentationUtils.isJsonsEquals(ALERT_TARGET_PROPS, entity.getProperties()));
assertEquals(false, entity.isGlobal());
// no alert states were set explicitely in the request, so all should be set
// by the backend
assertNotNull(entity.getAlertStates());
assertEquals(EnumSet.allOf(AlertState.class), entity.getAlertStates());
verify(m_amc, m_dao);
}
@Test
public void testUpdateAlertTargetsWithCustomGroups() throws Exception{
Capture<AlertTargetEntity> entityCapture = EasyMock.newCapture();
m_dao.create(capture(entityCapture));
expectLastCall().times(1);
AlertTargetEntity target = new AlertTargetEntity();
expect(m_dao.findTargetById(ALERT_TARGET_ID)).andReturn(target).once();
Capture<AlertGroupEntity> groupEntityCapture = EasyMock.newCapture();
//All Groups in the Database with CLuster ID = 1L
List<AlertGroupEntity> groups = getMockGroupEntities();
//List of group ids to be selected in Custom option
List<Long> groupIds = Arrays.asList(1L, 2L, 3L);
expect(m_dao.findGroupsById(EasyMock.eq(groupIds))).andReturn(groups).anyTimes();
expect(m_dao.findAllGroups()).andReturn(groups).anyTimes();
for(AlertGroupEntity group: groups){
expect(m_dao.merge(capture(groupEntityCapture))).andReturn(group).anyTimes();
}
expect(m_dao.merge(capture(entityCapture))).andReturn(target).anyTimes();
//start execution with the above Expectation setters
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_ID, ALERT_TARGET_ID.toString());
//selecting CUSTOM option for Groups, 2 group ids selected from the available options
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GLOBAL, "false");
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GROUPS, groupIds);
Predicate predicate = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
request = PropertyHelper.getUpdateRequest(requestProps, null);
provider.updateResources(request, predicate);
assertTrue(entityCapture.hasCaptured());
AlertTargetEntity entity = entityCapture.getValue();
//verify that only the selected 2 groups were mapped with the target
assertEquals(3, entity.getAlertGroups().size());
//target must not be global for CUSTOM option
assertEquals(false,entity.isGlobal());
verify(m_amc, m_dao);
}
@Test
public void testUpdateAlertTargetsWithAllGroups() throws Exception{
Capture<AlertTargetEntity> entityCapture = EasyMock.newCapture();
m_dao.create(capture(entityCapture));
expectLastCall().times(1);
AlertTargetEntity target = new AlertTargetEntity();
expect(m_dao.findTargetById(ALERT_TARGET_ID)).andReturn(target).once();
//All Groups in the Database with CLuster ID = 1L
List<AlertGroupEntity> groups = getMockGroupEntities();
//Groups to be selected for ALL option
List<Long> groupIds = Arrays.asList(1L, 2L, 3L);
expect(m_dao.findGroupsById(EasyMock.eq(groupIds))).andReturn(groups).anyTimes();
expect(m_dao.findAllGroups()).andReturn(groups).once();
expect(m_dao.merge(capture(entityCapture))).andReturn(target).anyTimes();
//start execution with these Expectation setters
replay(m_amc, m_dao);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
AlertTargetResourceProvider provider = createProvider(m_amc);
Map<String, Object> requestProps = getCreationProperties();
Request request = PropertyHelper.getCreateRequest(
Collections.singleton(requestProps), null);
provider.createResources(request);
requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_ID, ALERT_TARGET_ID.toString());
//selecting ALL option for Groups
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_GLOBAL, "true");
Predicate predicate = new PredicateBuilder().property(
AlertTargetResourceProvider.ALERT_TARGET_ID).equals(
ALERT_TARGET_ID.toString()).toPredicate();
request = PropertyHelper.getUpdateRequest(requestProps, null);
provider.updateResources(request, predicate);
assertTrue(entityCapture.hasCaptured());
AlertTargetEntity entity = entityCapture.getValue();
//verify that all the groups got mapped with target
assertEquals(3, entity.getAlertGroups().size());
//Target must be global for ALL option
assertEquals(true,entity.isGlobal());
verify(m_amc, m_dao);
}
/**
* @param amc
* @return
*/
private AlertTargetResourceProvider createProvider(
AmbariManagementController amc) {
return new AlertTargetResourceProvider();
}
/**
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
private List<AlertTargetEntity> getMockEntities() throws Exception {
AlertTargetEntity entity = new AlertTargetEntity();
entity.setTargetId(ALERT_TARGET_ID);
entity.setDescription(ALERT_TARGET_DESC);
entity.setTargetName(ALERT_TARGET_NAME);
entity.setNotificationType(ALERT_TARGET_TYPE);
entity.setProperties(ALERT_TARGET_PROPS);
entity.setAlertStates(new HashSet(Arrays.asList(AlertState.CRITICAL,
AlertState.WARNING)));
return Arrays.asList(entity);
}
/**
* Gets the maps of properties that simulate a deserialzied JSON request to
* create an alert target.
*
* @return
* @throws Exception
*/
private Map<String, Object> getCreationProperties() throws Exception {
Map<String, Object> requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_NAME,
ALERT_TARGET_NAME);
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_DESCRIPTION,
ALERT_TARGET_DESC);
requestProps.put(
AlertTargetResourceProvider.ALERT_TARGET_NOTIFICATION_TYPE,
ALERT_TARGET_TYPE);
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES
+ "/foo", "bar");
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES
+ "/foobar", "baz");
return requestProps;
}
/**
* Gets the maps of properties that simulate a deserialzied JSON request with
* a nested JSON array.
*
* @return
* @throws Exception
*/
private Map<String, Object> getRecipientCreationProperties() throws Exception {
Map<String, Object> requestProps = new HashMap<>();
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_NAME,
ALERT_TARGET_NAME);
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_DESCRIPTION,
ALERT_TARGET_DESC);
requestProps.put(
AlertTargetResourceProvider.ALERT_TARGET_NOTIFICATION_TYPE,
ALERT_TARGET_TYPE);
requestProps.put(AlertTargetResourceProvider.ALERT_TARGET_PROPERTIES
+ "/ambari.dispatch.recipients", "[\"ambari@ambari.apache.org\"]");
return requestProps;
}
/**
* @return
*/
private List<AlertGroupEntity> getMockGroupEntities() throws Exception {
AlertGroupEntity group1 = new AlertGroupEntity();
AlertGroupEntity group2 = new AlertGroupEntity();
AlertGroupEntity group3 = new AlertGroupEntity();
group1.setGroupId(1L);
group1.setClusterId(1L);
group2.setGroupId(2L);
group2.setClusterId(1L);
group3.setGroupId(3L);
group3.setClusterId(1L);
return Arrays.asList(group1, group2, group3);
}
/**
*
*/
private class MockModule implements Module {
/**
*
*/
@Override
public void configure(Binder binder) {
binder.bind(AlertDispatchDAO.class).toInstance(m_dao);
binder.bind(Clusters.class).toInstance(
EasyMock.createNiceMock(Clusters.class));
binder.bind(Cluster.class).toInstance(
EasyMock.createNiceMock(Cluster.class));
binder.bind(ActionMetadata.class);
}
}
}