Application mgt new (#7)

* Improve lifecycle state management

* Add unit tests for lifecycle management

* Add class level comments to lifecycle management

components/application-mgt/org.wso2.carbon.device.application.mgt.common/src/main/java/org/wso2/carbon/device/application/mgt/common/services/ApplicationManager.java

@@ -150,7 +150,7 @@ public interface ApplicationManager {
      * @param applicationUuid UUID of the Application Release.
      * @throws ApplicationManagementException Application Management Exception.
      */
-    void addLifecycleState(int applicationId, String applicationUuid, LifecycleState state) throws ApplicationManagementException;
+    void changeLifecycleState(int applicationId, String applicationUuid, LifecycleState state) throws ApplicationManagementException;
 
     /**
      * Get the application if application is an accessible one.

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/config/Configuration.java

@@ -18,6 +18,8 @@
  */
 package org.wso2.carbon.device.application.mgt.core.config;
 
+import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState;
+
 import java.util.List;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementWrapper;
@@ -37,6 +39,8 @@ public class Configuration {
 
     private PaginationConfiguration paginationConfiguration;
 
+    private List<LifecycleState> lifecycleStates;
+
     @XmlElement(name = "DatasourceName", required = true)
     public String getDatasourceName() {
         return datasourceName;
@@ -60,6 +64,17 @@ public class Configuration {
     public PaginationConfiguration getPaginationConfiguration() {
         return paginationConfiguration;
     }
+
+    @XmlElementWrapper(name = "LifecycleStates")
+    @XmlElement(name = "LifecycleState")
+    public List<LifecycleState> getLifecycleStates() {
+        return lifecycleStates;
+    }
+
+    public void setLifecycleStates(
+            List<LifecycleState> lifecycleStates) {
+        this.lifecycleStates = lifecycleStates;
+    }
 }
 
 

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/impl/ApplicationManagerImpl.java

@@ -37,7 +37,6 @@ import org.wso2.carbon.device.application.mgt.common.UnrestrictedRole;
 import org.wso2.carbon.device.application.mgt.common.User;
 import org.wso2.carbon.device.application.mgt.common.exception.ApplicationManagementException;
 import org.wso2.carbon.device.application.mgt.common.exception.DBConnectionException;
-import org.wso2.carbon.device.application.mgt.common.exception.LifecycleManagementException;
 import org.wso2.carbon.device.application.mgt.common.services.ApplicationManager;
 import org.wso2.carbon.device.application.mgt.core.dao.ApplicationDAO;
 import org.wso2.carbon.device.application.mgt.core.dao.ApplicationReleaseDAO;
@@ -49,6 +48,7 @@ import org.wso2.carbon.device.application.mgt.core.exception.LifeCycleManagement
 import org.wso2.carbon.device.application.mgt.core.exception.NotFoundException;
 import org.wso2.carbon.device.application.mgt.core.exception.ValidationException;
 import org.wso2.carbon.device.application.mgt.core.internal.DataHolder;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.LifecycleStateManger;
 import org.wso2.carbon.device.application.mgt.core.util.ConnectionManagerUtil;
 import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
 import org.wso2.carbon.device.mgt.core.dao.DeviceTypeDAO;
@@ -73,10 +73,12 @@ public class ApplicationManagerImpl implements ApplicationManager {
     private ApplicationDAO applicationDAO;
     private ApplicationReleaseDAO applicationReleaseDAO;
     private LifecycleStateDAO lifecycleStateDAO;
+    private LifecycleStateManger lifecycleStateManger;
 
 
     public ApplicationManagerImpl() {
         initDataAccessObjects();
+        lifecycleStateManger = DataHolder.getInstance().getLifecycleStateManager();
     }
 
     private void initDataAccessObjects() {
@@ -139,7 +141,7 @@ public class ApplicationManagerImpl implements ApplicationManager {
                 LifecycleState lifecycleState = new LifecycleState();
                 lifecycleState.setCurrentState(AppLifecycleState.CREATED.toString());
                 lifecycleState.setPreviousState(AppLifecycleState.CREATED.toString());
-                addLifecycleState(application.getId(), applicationRelease.getUuid(), lifecycleState);
+                changeLifecycleState(application.getId(), applicationRelease.getUuid(), lifecycleState);
 
                 applicationRelease.setLifecycleState(lifecycleState);
                 applicationReleases.add(applicationRelease);
@@ -216,7 +218,7 @@ public class ApplicationManagerImpl implements ApplicationManager {
             LifecycleState lifecycleState = new LifecycleState();
             lifecycleState.setCurrentState(AppLifecycleState.CREATED.toString());
             lifecycleState.setPreviousState(AppLifecycleState.CREATED.toString());
-            addLifecycleState(application.getId(), applicationRelease.getUuid(), lifecycleState);
+            changeLifecycleState(application.getId(), applicationRelease.getUuid(), lifecycleState);
 
             ConnectionManagerUtil.commitDBTransaction();
             return applicationRelease;
@@ -406,7 +408,7 @@ public class ApplicationManagerImpl implements ApplicationManager {
                 LifecycleState newAppLifecycleState = new LifecycleState();
                 newAppLifecycleState.setPreviousState(appLifecycleState.getCurrentState());
                 newAppLifecycleState.setCurrentState(AppLifecycleState.REMOVED.toString());
-                addLifecycleState(applicationId, applicationRelease.getUuid(), newAppLifecycleState);
+                changeLifecycleState(applicationId, applicationRelease.getUuid(), newAppLifecycleState);
                 storedLocations.add(applicationRelease.getAppHashValue());
             }
             ConnectionManagerUtil.openDBConnection();
@@ -437,7 +439,7 @@ public class ApplicationManagerImpl implements ApplicationManager {
             LifecycleState newAppLifecycleState = new LifecycleState();
             newAppLifecycleState.setPreviousState(appLifecycleState.getCurrentState());
             newAppLifecycleState.setCurrentState(AppLifecycleState.REMOVED.toString());
-            addLifecycleState(applicationId, applicationRelease.getUuid(), newAppLifecycleState);
+            changeLifecycleState(applicationId, applicationRelease.getUuid(), newAppLifecycleState);
         }else{
             throw new ApplicationManagementException("Can't delete the application release, You have to move the " +
                                                              "lifecycle state from "+ currentState + " to acceptable " +
@@ -689,7 +691,8 @@ public class ApplicationManagerImpl implements ApplicationManager {
                                 + applicationUuid);
 
             }
-            lifecycleState.setNextStates(getNextLifecycleStates(lifecycleState.getCurrentState()));
+            lifecycleState.setNextStates(new ArrayList<>(lifecycleStateManger.
+                    getNextLifecycleStates(lifecycleState.getCurrentState())));
         } catch (ApplicationManagementDAOException e) {
             throw new ApplicationManagementException("Failed to get lifecycle state", e);
         } catch (ApplicationManagementException e) {
@@ -701,7 +704,7 @@ public class ApplicationManagerImpl implements ApplicationManager {
     }
 
     @Override
-    public void addLifecycleState(int applicationId, String applicationUuid, LifecycleState state)
+    public void changeLifecycleState(int applicationId, String applicationUuid, LifecycleState state)
             throws ApplicationManagementException {
         try {
             ConnectionManagerUtil.openDBConnection();
@@ -712,9 +715,14 @@ public class ApplicationManagerImpl implements ApplicationManager {
             state.setUpdatedBy(userName);
 
             if (state.getCurrentState() != null && state.getPreviousState() != null) {
-                validateLifecycleState(state);
+                if (lifecycleStateManger.isValidStateChange(state.getPreviousState(), state.getCurrentState())) {
                     this.lifecycleStateDAO
                             .addLifecycleState(state, application.getId(), applicationRelease.getId(), tenantId);
+                } else {
+                    log.error("Invalid lifecycle state transition from '" + state.getPreviousState() + "'"
+                              + " to '" + state.getCurrentState() + "'");
+                    throw new ApplicationManagementException("Lifecycle State Validation failed");
+                }
             }
         } catch (LifeCycleManagementDAOException | DBConnectionException e) {
             throw new ApplicationManagementException("Failed to add lifecycle state", e);
@@ -725,99 +733,6 @@ public class ApplicationManagerImpl implements ApplicationManager {
         }
     }
 
-    private List<String> getNextLifecycleStates(String currentLifecycleState) {
-        List<String> nextLifecycleStates = new ArrayList<>();
-        if (AppLifecycleState.CREATED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.IN_REVIEW.toString());
-        }
-        if (AppLifecycleState.IN_REVIEW.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.APPROVED.toString());
-            nextLifecycleStates.add(AppLifecycleState.REJECTED.toString());
-        }
-        if (AppLifecycleState.REJECTED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.IN_REVIEW.toString());
-            nextLifecycleStates.add(AppLifecycleState.REMOVED.toString());
-        }
-        if (AppLifecycleState.APPROVED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.PUBLISHED.toString());
-        }
-        if (AppLifecycleState.PUBLISHED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.UNPUBLISHED.toString());
-            nextLifecycleStates.add(AppLifecycleState.DEPRECATED.toString());
-        }
-        if (AppLifecycleState.UNPUBLISHED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.PUBLISHED.toString());
-            nextLifecycleStates.add(AppLifecycleState.REMOVED.toString());
-        }
-        if (AppLifecycleState.DEPRECATED.toString().equals(currentLifecycleState)) {
-            nextLifecycleStates.add(AppLifecycleState.REMOVED.toString());
-        }
-        return nextLifecycleStates;
-    }
-
-    private void validateLifecycleState(LifecycleState state) throws LifecycleManagementException {
-
-        if (AppLifecycleState.CREATED.toString().equals(state.getCurrentState())) {
-            throw new LifecycleManagementException("Current State Couldn't be " + state.getCurrentState());
-        }
-        if (AppLifecycleState.IN_REVIEW.toString().equals(state.getCurrentState()) && !AppLifecycleState.CREATED
-                .toString().equals(state.getPreviousState()) && !AppLifecycleState.REJECTED.toString()
-                .equals(state.getPreviousState())) {
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be either "
-                            + AppLifecycleState.CREATED.toString() + " or " + AppLifecycleState.REJECTED.toString());
-
-        }
-        if (AppLifecycleState.APPROVED.toString().equals(state.getCurrentState()) && !AppLifecycleState.IN_REVIEW
-                .toString().equals(state.getPreviousState())) {
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be "
-                            + AppLifecycleState.IN_REVIEW.toString());
-
-        }
-        if (AppLifecycleState.PUBLISHED.toString().equals(state.getCurrentState()) && !AppLifecycleState.APPROVED
-                .toString().equals(state.getPreviousState()) && !AppLifecycleState.UNPUBLISHED.toString()
-                .equals(state.getPreviousState())) {
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be either "
-                            + AppLifecycleState.APPROVED.toString() + " or " + AppLifecycleState.UNPUBLISHED
-                            .toString());
-
-        }
-        if (AppLifecycleState.UNPUBLISHED.toString().equals(state.getCurrentState()) && !AppLifecycleState.PUBLISHED
-                .toString().equals(state.getPreviousState())) {
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be "
-                            + AppLifecycleState.PUBLISHED.toString());
-
-        }
-        if (AppLifecycleState.REJECTED.toString().equals(state.getCurrentState()) && !AppLifecycleState.IN_REVIEW
-                .toString().equals(state.getPreviousState())) {
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be "
-                            + AppLifecycleState.IN_REVIEW.toString());
-
-        }
-        if (AppLifecycleState.DEPRECATED.toString().equals(state.getCurrentState()) && !AppLifecycleState.PUBLISHED
-                .toString().equals(state.getPreviousState())) {
-
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be "
-                            + AppLifecycleState.PUBLISHED.toString());
-
-        }
-        if (AppLifecycleState.REMOVED.toString().equals(state.getCurrentState()) && !AppLifecycleState.DEPRECATED
-                .toString().equals(state.getPreviousState()) && !AppLifecycleState.REJECTED.toString()
-                .equals(state.getPreviousState()) && !AppLifecycleState.UNPUBLISHED.toString()
-                .equals(state.getPreviousState())) {
-
-            throw new LifecycleManagementException(
-                    "If Current State is " + state.getCurrentState() + "Previous State should be either "
-                            + AppLifecycleState.DEPRECATED.toString() + " or " + AppLifecycleState.REJECTED.toString()
-                            + " or " + AppLifecycleState.UNPUBLISHED.toString());
-        }
-    }
-
     @Override
     public Application updateApplication(Application application) throws ApplicationManagementException {
 

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/internal/DataHolder.java

@@ -23,6 +23,7 @@ import org.wso2.carbon.device.application.mgt.common.services.ApplicationStorage
 import org.wso2.carbon.device.application.mgt.common.services.ReviewManager;
 import org.wso2.carbon.device.application.mgt.common.services.SubscriptionManager;
 import org.wso2.carbon.device.application.mgt.common.services.UnrestrictedRoleManager;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.LifecycleStateManger;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
 import org.wso2.carbon.user.core.service.RealmService;
 
@@ -45,6 +46,8 @@ public class DataHolder {
 
     private ApplicationStorageManager applicationStorageManager;
 
+    private LifecycleStateManger lifecycleStateManger;
+
     private static final DataHolder applicationMgtDataHolder = new DataHolder();
 
     private DataHolder() {
@@ -110,4 +113,12 @@ public class DataHolder {
     public ApplicationStorageManager getApplicationStorageManager() {
         return applicationStorageManager;
     }
+
+    public LifecycleStateManger getLifecycleStateManager() {
+        return lifecycleStateManger;
+    }
+
+    public void setLifecycleStateManger(LifecycleStateManger lifecycleStateManger) {
+        this.lifecycleStateManger = lifecycleStateManger;
+    }
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/internal/ServiceComponent.java

@@ -31,12 +31,15 @@ import org.wso2.carbon.device.application.mgt.common.services.UnrestrictedRoleMa
 import org.wso2.carbon.device.application.mgt.core.config.ConfigurationManager;
 import org.wso2.carbon.device.application.mgt.core.dao.common.ApplicationManagementDAOFactory;
 import org.wso2.carbon.device.application.mgt.core.exception.ApplicationManagementDAOException;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.LifecycleStateManger;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState;
 import org.wso2.carbon.device.application.mgt.core.util.ApplicationManagementUtil;
 import org.wso2.carbon.device.mgt.core.service.DeviceManagementProviderService;
 import org.wso2.carbon.ndatasource.core.DataSourceService;
 import org.wso2.carbon.user.core.service.RealmService;
 
 import javax.naming.NamingException;
+import java.util.List;
 
 /**
  * @scr.component name="org.wso2.carbon.application.mgt.service" immediate="true"
@@ -93,6 +96,12 @@ public class ServiceComponent {
 
             ApplicationManagementDAOFactory.init(datasourceName);
             ApplicationManagementDAOFactory.initDatabases();
+
+            List<LifecycleState> lifecycleStates = ConfigurationManager.getInstance().
+                    getConfiguration().getLifecycleStates();
+            LifecycleStateManger lifecycleStateManger = new LifecycleStateManger(lifecycleStates);
+            DataHolder.getInstance().setLifecycleStateManger(lifecycleStateManger);
+
             log.info("ApplicationManagement core bundle has been successfully initialized");
         } catch (InvalidConfigurationException e) {
             log.error("Error while activating Application Management core component. ", e);

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/LifecycleStateManger.java

@@ -0,0 +1,34 @@
+package org.wso2.carbon.device.application.mgt.core.lifecycle;
+
+import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * This class represents the activities related to lifecycle management
+ */
+public class LifecycleStateManger {
+
+    private Map<String, State> lifecycleStates;
+
+    public LifecycleStateManger(List<LifecycleState> states) {
+        lifecycleStates = new HashMap<>();
+        for (LifecycleState s : states) {
+            lifecycleStates.put(s.getName(), new State(s.getName(), s.getProceedingStates()));
+        }
+    }
+
+    public Set<String> getNextLifecycleStates(String currentLifecycleState) {
+        return lifecycleStates.get(currentLifecycleState).getProceedingStates();
+    }
+
+    public boolean isValidStateChange(String currentState, String nextState) {
+        if (lifecycleStates.get(currentState).getProceedingStates().contains(nextState)) {
+            return true;
+        }
+        return false;
+    }
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/State.java

@@ -0,0 +1,30 @@
+package org.wso2.carbon.device.application.mgt.core.lifecycle;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This class represents the state of the lifecycle
+ */
+public class State {
+
+    private Set<String> proceedingStates;
+    private String stateName;
+
+    public State(String stateName, List<String> states) {
+        this.stateName = stateName;
+        if (states != null && !states.isEmpty()) {
+            proceedingStates = new HashSet<>(states);
+        }
+    }
+
+    public String getState() {
+        return stateName;
+    }
+
+    public Set<String> getProceedingStates() {
+        return proceedingStates;
+    }
+
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/config/LifecycleState.java

@@ -0,0 +1,35 @@
+package org.wso2.carbon.device.application.mgt.core.lifecycle.config;
+
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlElementWrapper;
+import java.util.List;
+
+/**
+ * This class represents the lifecycle state config
+ */
+public class LifecycleState {
+
+    private String name;
+
+    private List<String> proceedingStates;
+
+    @XmlAttribute(name = "name")
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @XmlElementWrapper(name = "ProceedingStates")
+    @XmlElement(name = "State")
+    public List<String> getProceedingStates() {
+        return proceedingStates;
+    }
+
+    public void setProceedingStates(List<String> proceedingStates) {
+        this.proceedingStates = proceedingStates;
+    }
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/test/java/org.wso2.carbon.device.application.mgt.core/ConfigurationTest.java

@@ -17,25 +17,30 @@
 */
 package org.wso2.carbon.device.application.mgt.core;
 
-import org.junit.BeforeClass;
+import org.junit.Assert;
-import org.junit.Test;
+import org.testng.annotations.Test;
-import org.wso2.carbon.device.application.mgt.common.exception.InvalidConfigurationException;
 import org.wso2.carbon.device.application.mgt.core.config.Configuration;
 import org.wso2.carbon.device.application.mgt.core.config.ConfigurationManager;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState;
 
-import java.io.File;
+import java.util.List;
 
 public class ConfigurationTest {
 
-    @BeforeClass
-    public static void init() throws InvalidConfigurationException {
-        File configPath = new File("src/test/resources/application-mgt.xml");
-        ConfigurationManager.setConfigLocation(configPath.getAbsolutePath());
-    }
-
     @Test
     public void validateConfiguration() {
         ConfigurationManager configurationManager = ConfigurationManager.getInstance();
         Configuration configuration = configurationManager.getConfiguration();
+        Assert.assertNotNull("Invalid app manager configuration", configuration);
+    }
+
+    @Test
+    public void validateLifecycleStateConfiguration() {
+        ConfigurationManager configurationManager = ConfigurationManager.getInstance();
+        Configuration configuration = configurationManager.getConfiguration();
+        List<LifecycleState> lifecycleStates = configuration.getLifecycleStates();
+        Assert.assertNotNull("Invalid lifecycle states configuration", lifecycleStates);
+        Assert.assertTrue("Invalid lifecycle states configuration. Lifecycle states cannot be empty",
+                          !lifecycleStates.isEmpty());
     }
 }

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/test/java/org.wso2.carbon.device.application.mgt.core/InitTest.java

@@ -0,0 +1,20 @@
+package org.wso2.carbon.device.application.mgt.core;
+
+import org.testng.annotations.BeforeSuite;
+import org.wso2.carbon.device.application.mgt.common.exception.InvalidConfigurationException;
+import org.wso2.carbon.device.application.mgt.core.config.ConfigurationManager;
+
+import java.io.File;
+
+/**
+ * This class initializes the required configurations prior running the tests
+ */
+public class InitTest {
+
+    @BeforeSuite
+    public void init() throws InvalidConfigurationException {
+        File configPath = new File("src/test/resources/application-mgt.xml");
+        ConfigurationManager.setConfigLocation(configPath.getAbsolutePath());
+    }
+
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/test/java/org.wso2.carbon.device.application.mgt.core/LifecycleManagementTest.java

@@ -0,0 +1,57 @@
+package org.wso2.carbon.device.application.mgt.core;
+
+import org.junit.Assert;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.Test;
+import org.wso2.carbon.device.application.mgt.core.config.Configuration;
+import org.wso2.carbon.device.application.mgt.core.config.ConfigurationManager;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.LifecycleStateManger;
+import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState;
+
+import java.util.List;
+import java.util.Set;
+
+public class LifecycleManagementTest {
+
+    private List<LifecycleState> lifecycleStates;
+    private LifecycleStateManger lifecycleStateManger;
+
+    private final String CURRENT_STATE = "Approved";
+    private final String NEXT_STATE = "Published";
+    private final String BOGUS_STATE = "Removed";
+
+    @BeforeClass
+    public void init() {
+        ConfigurationManager configurationManager = ConfigurationManager.getInstance();
+        Configuration configuration = configurationManager.getConfiguration();
+        lifecycleStates = configuration.getLifecycleStates();
+        lifecycleStateManger = new LifecycleStateManger(lifecycleStates);
+    }
+
+    @Test
+    public void checkValidNextLifecycleState() {
+        Set<String> proceedingStates = lifecycleStateManger.getNextLifecycleStates(CURRENT_STATE);
+        Assert.assertTrue("Invalid proceeding state of: " + CURRENT_STATE,
+                          proceedingStates.contains(NEXT_STATE));
+    }
+
+    @Test
+    public void checkInvalidNextLifecycleState() {
+        Set<String> proceedingStates = lifecycleStateManger.getNextLifecycleStates(CURRENT_STATE);
+        Assert.assertFalse("Invalid proceeding state of: " + CURRENT_STATE,
+                          proceedingStates.contains(BOGUS_STATE));
+    }
+
+    @Test
+    public void checkValidStateChange() {
+        Assert.assertTrue("Invalid state transition from: " + CURRENT_STATE + " to: " + NEXT_STATE,
+                           lifecycleStateManger.isValidStateChange(CURRENT_STATE, NEXT_STATE));
+    }
+
+    @Test
+    public void checkInvalidStateChange() {
+        Assert.assertFalse("Invalid state transition from: " + CURRENT_STATE + " to: " + BOGUS_STATE,
+                          lifecycleStateManger.isValidStateChange(CURRENT_STATE, BOGUS_STATE));
+    }
+
+}

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/test/resources/application-mgt.xml

@@ -58,4 +58,47 @@
         </Extension>
     </Extensions>
 
+    <LifecycleStates>
+        <LifecycleState name="Created">
+            <ProceedingStates>
+                <State>In-Review</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="In-Review">
+            <ProceedingStates>
+                <State>Rejected</State>
+                <State>Approved</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Approved">
+            <ProceedingStates>
+                <State>Published</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Rejected">
+            <ProceedingStates>
+                <State>In-Review</State>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Published">
+            <ProceedingStates>
+                <State>Unpublished</State>
+                <State>Deprecated</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Unpublished">
+            <ProceedingStates>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Deprecated">
+            <ProceedingStates>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Removed">
+        </LifecycleState>
+    </LifecycleStates>
+
 </ApplicationManagementConfiguration>

components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/test/resources/testng.xml

@@ -22,8 +22,11 @@
 <suite name="ApplicationManagementCore">
     <test name="Util classes tests" preserve-order="true">
         <classes>
+            <class name="org.wso2.carbon.device.application.mgt.core.InitTest"/>
             <class name="org.wso2.carbon.device.application.mgt.core.ArtifactParserTest"/>
             <class name="org.wso2.carbon.device.application.mgt.core.StorageManagementUtilTest"/>
+            <class name="org.wso2.carbon.device.application.mgt.core.ConfigurationTest"/>
+            <class name="org.wso2.carbon.device.application.mgt.core.LifecycleManagementTest"/>
         </classes>
     </test>
 </suite>

components/application-mgt/org.wso2.carbon.device.application.mgt.publisher.api/src/main/java/org/wso2/carbon/device/application/mgt/publisher/api/services/impl/ApplicationManagementAPIImpl.java

@@ -448,7 +448,7 @@ public class ApplicationManagementAPIImpl implements ApplicationManagementAPI {
             LifecycleState state) {
         ApplicationManager applicationManager = APIUtil.getApplicationManager();
         try {
-            applicationManager.addLifecycleState(applicationId, applicationUuid, state);
+            applicationManager.changeLifecycleState(applicationId, applicationUuid, state);
         } catch (ApplicationManagementException e) {
             String msg = "Error occurred while adding lifecycle state.";
             log.error(msg, e);

features/application-mgt/org.wso2.carbon.device.application.mgt.server.feature/src/main/resources/conf/application-mgt.xml

@@ -60,4 +60,61 @@
             </Parameters>
         </Extension>
     </Extensions>
+
+    <!-- This is for publisher lifecycle -->
+    <!-- The current lifecycle as follows
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        [Created] -> [In-Review] -> [Approved] -> [Published] -> [Unpublished] -> [Removed]
+                        ^                               |                               ^
+                        |                               |                               |
+                        |                               |-> [Deprecated] - - - - - - - -|
+                        |                                                               |
+                        |-> [Rejected]  - - - - - - - - - - - - - - - - - - - - - - - - |
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    If there is a requirement to introduce a new state to the lifecycle, please refer above
+    diagram and add relevant state to the below configuration appropriately.
+    -->
+    <LifecycleStates>
+        <LifecycleState name="Created">
+            <ProceedingStates>
+                <State>In-Review</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="In-Review">
+            <ProceedingStates>
+                <State>Rejected</State>
+                <State>Approved</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Approved">
+            <ProceedingStates>
+                <State>Published</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Rejected">
+            <ProceedingStates>
+                <State>In-Review</State>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Published">
+            <ProceedingStates>
+                <State>Unpublished</State>
+                <State>Deprecated</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Unpublished">
+            <ProceedingStates>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Deprecated">
+            <ProceedingStates>
+                <State>Removed</State>
+            </ProceedingStates>
+        </LifecycleState>
+        <LifecycleState name="Removed">
+        </LifecycleState>
+    </LifecycleStates>
+
 </ApplicationManagementConfiguration>