add tests

Signed-off-by: Abhishek Kumar <[email protected]>

Author: shwstppr

server/src/main/java/com/cloud/alert/AlertManagerImpl.java

@@ -48,6 +48,7 @@
 import org.apache.cloudstack.utils.mailing.SMTPMailProperties;
 import org.apache.cloudstack.utils.mailing.SMTPMailSender;
 import org.apache.commons.lang3.ArrayUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.math.NumberUtils;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -233,14 +234,17 @@ public boolean configure(String name, Map<String, Object> params) throws Configu
         return true;
     }
 
-    private void setupRepetitiveAlertTypes() {
+    protected void setupRepetitiveAlertTypes() {
         allowedRepetitiveAlertTypes.clear();
         String allowedRepetitiveAlertsStr = AllowedRepetitiveAlertTypes.value();
         logger.trace("Allowed repetitive alert types specified by {}: {} ", AllowedRepetitiveAlertTypes.key(),
                 allowedRepetitiveAlertsStr);
+        if (StringUtils.isBlank(allowedRepetitiveAlertsStr)) {
+            return;
+        }
         String[] allowedRepetitiveAlertTypesArray = allowedRepetitiveAlertsStr.split(",");
         for (String alertTypeName : allowedRepetitiveAlertTypesArray) {
-            AlertType type = AlertType.getAlertTypeByName(alertTypeName);
+            AlertType type = AlertType.getAlertTypeByName(alertTypeName.trim());
             if (type == null) {
                 logger.warn("Unknown alert type name: {}, skipping it.", alertTypeName);
                 continue;
@@ -875,13 +879,12 @@ public boolean generateAlert(AlertType alertType, long dataCenterId, Long podId,
     }
 
     @SuppressWarnings("unchecked")
-    private void initMessageBusListener() {
+    protected void initMessageBusListener() {
         messageBus.subscribe(EventTypes.EVENT_CONFIGURATION_VALUE_EDIT, (senderAddress, subject, args) -> {
             Ternary<String, ConfigKey.Scope, Long> updatedSetting = (Ternary<String, ConfigKey.Scope, Long>) args;
             String updatedSettingName = updatedSetting.first();
             if (!AllowedRepetitiveAlertTypes.key().equals(updatedSettingName)) {
                 return;
-
             }
             setupRepetitiveAlertTypes();
         });

server/src/test/java/com/cloud/alert/AlertManagerImplTest.java

@@ -21,6 +21,10 @@
 
 import javax.mail.MessagingException;
 
+import org.apache.cloudstack.alert.AlertService;
+import org.apache.cloudstack.framework.config.ConfigKey;
+import org.apache.cloudstack.framework.messagebus.MessageBus;
+import org.apache.cloudstack.framework.messagebus.MessageSubscriber;
 import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao;
 import org.apache.cloudstack.storage.datastore.db.StoragePoolVO;
 import org.apache.cloudstack.utils.mailing.SMTPMailSender;
@@ -35,6 +39,7 @@
 import org.mockito.Mockito;
 import org.mockito.Spy;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.test.util.ReflectionTestUtils;
 
 import com.cloud.alert.dao.AlertDao;
 import com.cloud.capacity.Capacity;
@@ -45,10 +50,12 @@
 import com.cloud.dc.dao.ClusterDao;
 import com.cloud.dc.dao.DataCenterDao;
 import com.cloud.dc.dao.HostPodDao;
+import com.cloud.event.EventTypes;
 import com.cloud.host.Host;
 import com.cloud.host.HostVO;
 import com.cloud.host.dao.HostDao;
 import com.cloud.storage.StorageManager;
+import com.cloud.utils.Ternary;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
@@ -219,4 +226,79 @@ public void testRecalculateStorageCapacities() {
         Mockito.verify(storageManager, Mockito.times(2)).createCapacityEntry(sharedPool, Capacity.CAPACITY_TYPE_STORAGE_ALLOCATED, 10L);
         Mockito.verify(storageManager, Mockito.times(1)).createCapacityEntry(nonSharedPool, Capacity.CAPACITY_TYPE_LOCAL_STORAGE, 20L);
     }
+    
+    @Test
+    public void initMessageBusListenerSubscribesToConfigurationEditEvent() {
+        MessageBus messageBusMock = Mockito.mock(MessageBus.class);
+        alertManagerImplMock.messageBus = messageBusMock;
+        alertManagerImplMock.initMessageBusListener();
+        Mockito.verify(messageBusMock).subscribe(Mockito.eq(EventTypes.EVENT_CONFIGURATION_VALUE_EDIT), Mockito.any());
+    }
+
+    @Test
+    public void initMessageBusListenerTriggersSetupRepetitiveAlertTypesOnAllowedKeyEdit() {
+        MessageBus messageBusMock = Mockito.mock(MessageBus.class);
+        alertManagerImplMock.messageBus = messageBusMock;
+        alertManagerImplMock.initMessageBusListener();
+        ArgumentCaptor<MessageSubscriber> captor = ArgumentCaptor.forClass(MessageSubscriber.class);
+        Mockito.verify(messageBusMock).subscribe(Mockito.eq(EventTypes.EVENT_CONFIGURATION_VALUE_EDIT), captor.capture());
+        Ternary<String, ConfigKey.Scope, Long> args = new Ternary<>(AlertManager.AllowedRepetitiveAlertTypes.key(), ConfigKey.Scope.Global, 1L);
+        captor.getValue().onPublishMessage(null, null, args);
+        Mockito.verify(alertManagerImplMock).setupRepetitiveAlertTypes();
+    }
+
+    @Test
+    public void initMessageBusListenerDoesNotTriggerSetupRepetitiveAlertTypesOnOtherKeyEdit() {
+        MessageBus messageBusMock = Mockito.mock(MessageBus.class);
+        alertManagerImplMock.messageBus = messageBusMock;
+        alertManagerImplMock.initMessageBusListener();
+        ArgumentCaptor<MessageSubscriber> captor = ArgumentCaptor.forClass(MessageSubscriber.class);
+        Mockito.verify(messageBusMock).subscribe(Mockito.eq(EventTypes.EVENT_CONFIGURATION_VALUE_EDIT), captor.capture());
+        Ternary<String, ConfigKey.Scope, Long> args = new Ternary<>("some.other.key", ConfigKey.Scope.Global, 1L);
+        captor.getValue().onPublishMessage(null, null, args);
+        Mockito.verify(alertManagerImplMock, Mockito.never()).setupRepetitiveAlertTypes();
+    }
+
+    private void mockAllowedRepetitiveAlertTypesConfigKey(String value) {
+        ReflectionTestUtils.setField(AlertManager.AllowedRepetitiveAlertTypes, "_defaultValue", value);
+    }
+
+    @Test
+    public void setupRepetitiveAlertTypesParsesValidAlertTypesCorrectly() {
+        mockAllowedRepetitiveAlertTypesConfigKey("ALERT.CPU,ALERT.MEMORY");
+        alertManagerImplMock.setupRepetitiveAlertTypes();
+        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        Assert.assertNotNull(expectedTypes);
+        Assert.assertEquals(2, expectedTypes.size());
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU));
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_MEMORY));
+    }
+
+    @Test
+    public void setupRepetitiveAlertTypesHandlesEmptyConfigValue() {
+        mockAllowedRepetitiveAlertTypesConfigKey("");
+        alertManagerImplMock.setupRepetitiveAlertTypes();
+        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        Assert.assertNotNull(expectedTypes);
+        Assert.assertTrue(expectedTypes.isEmpty());
+    }
+
+    @Test
+    public void setupRepetitiveAlertTypesIgnoresUnknownAlertTypes() {
+        mockAllowedRepetitiveAlertTypesConfigKey("ALERT.CPU,UNKNOWN_ALERT_TYPE");
+        alertManagerImplMock.setupRepetitiveAlertTypes();
+        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        Assert.assertNotNull(expectedTypes);
+        Assert.assertEquals(1, expectedTypes.size());
+        Assert.assertTrue(expectedTypes.contains(AlertManager.AlertType.ALERT_TYPE_CPU));
+    }
+
+    @Test
+    public void setupRepetitiveAlertTypesHandlesNullConfigValue() {
+        mockAllowedRepetitiveAlertTypesConfigKey(null);
+        alertManagerImplMock.setupRepetitiveAlertTypes();
+        List<AlertService.AlertType> expectedTypes = (List<AlertService.AlertType>)ReflectionTestUtils.getField(alertManagerImplMock, "allowedRepetitiveAlertTypes");
+        Assert.assertNotNull(expectedTypes);
+        Assert.assertTrue(expectedTypes.isEmpty());
+    }
 }