From fe0e98940048cad839c629821da78b3fcf33b6d2 Mon Sep 17 00:00:00 2001 From: "beili.zhou" Date: Thu, 10 Aug 2017 14:54:42 -0400 Subject: [APPC-44] APPC Lifecycle Management refactor Pull APPC lifecycle Management out of APPC dispatcher, so that it can be used by both APPC dispatcher and APPC OAM. This is the pre-step of introducing APPC OAM operations. Issue-Id: APPC-44 Change-Id: Icbde399b5121fae9e1919cfdd5c77bbe55d61188 Signed-off-by: beili.zhou --- .../org/openecomp/appc/LifecycleManagerTest.java | 185 +++++++++++++++++++++ .../openecomp/appc/OamLifeCycleManagerTest.java | 152 +++++++++++++++++ 2 files changed, 337 insertions(+) create mode 100644 appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/LifecycleManagerTest.java create mode 100644 appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/OamLifeCycleManagerTest.java (limited to 'appc-lifecycle-management/appc-lifecycle-management-core/src/test') diff --git a/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/LifecycleManagerTest.java b/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/LifecycleManagerTest.java new file mode 100644 index 000000000..e58dcc901 --- /dev/null +++ b/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/LifecycleManagerTest.java @@ -0,0 +1,185 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP : APPC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Copyright (C) 2017 Amdocs + * ============================================================================= + * Licensed 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. + * + * ECOMP is a trademark and service mark of AT&T Intellectual Property. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.appc; + +import org.junit.Assert; +import org.junit.Test; +import org.openecomp.appc.exceptions.InvalidInputException; +import org.openecomp.appc.lifecyclemanager.LifecycleManager; +import org.openecomp.appc.statemachine.StateMetaDataReader; +import org.openecomp.appc.lifecyclemanager.impl.LifecycleManagerImpl; +import org.openecomp.appc.lifecyclemanager.objects.LifecycleException; +import org.openecomp.appc.lifecyclemanager.objects.NoTransitionDefinedException; +import org.openecomp.appc.statemachine.impl.readers.VnfMetaDataReader; +import org.openecomp.appc.statemachine.impl.readers.VnfMetaDataReader.VNFOperation; +import org.openecomp.appc.statemachine.objects.Event; +import org.openecomp.appc.statemachine.objects.State; +import org.openecomp.appc.statemachine.objects.StateMachineMetadata; +import org.openecomp.appc.statemachine.objects.Transition; + +import java.util.*; + + +public class LifecycleManagerTest { + + private static final State[] VALID_LOCK_STATES = new State[] { + new State("instantiated"), + new State("configured"), + new State("tested"), + new State("running"), + new State("error"), + new State("unknown"), + new State("created"), + new State("not orchestrated"), + new State("stopped"), + }; + + @Test + public void handleEvent() throws InvalidInputException, LifecycleException, NoTransitionDefinedException { + + StateMachineMetadata metadata = getMetaDataReader().readMetadata(); + LifecycleManagerImpl lifecycleManager = new LifecycleManagerImpl(); + + /* + * Testing Positive Scenario passing the valid events and validating the StateMachineResponse + */ + for(State state:metadata.getStates()){ + + for(Transition transition:state.getTransitions()){ + Event event = transition.getEvent(); + State nextStateFromMetadata = transition.getNextState(); + + String expectedNextState = lifecycleManager.getNextState(null,state.toString(),event.toString()); + Assert.assertEquals(expectedNextState,nextStateFromMetadata.toString()); + } + } + + /* + Testing Negative Scenarios, 1. Passing the valid Events for which Transition is not defined in + Metadata and validating the StateMachineResponse 2. Passing the invalid events which are not + registered as events in the StateMachineMetadata and validating StateMachineResponse + */ + for(State state:metadata.getStates()){ + + for(Transition transition:state.getTransitions()){ + List negativeEvents = getNegativeEvents(state,metadata.getEvents()); + + for(Event negativeEvent:negativeEvents){ + boolean flag =false; + try{ + lifecycleManager.getNextState(null,state.toString(),negativeEvent.toString()); + + } + catch (NoTransitionDefinedException e){ + flag =true; + } + Assert.assertEquals(flag,true); + + flag = false; + try{ + lifecycleManager.getNextState(null,state.toString(),"PUT"); + } + catch(LifecycleException e){ + flag = true; + } + Assert.assertTrue(flag); + + } + } + } + } + + @Test + public void testNotOrchestratedState() throws LifecycleException, NoTransitionDefinedException { + LifecycleManager lifecycleManager = new LifecycleManagerImpl(); + String nextState = lifecycleManager.getNextState( + null,"NOT ORCHESTRATED",VNFOperation.Configure.toString()); + Assert.assertEquals(nextState,"Configuring"); + } + + @Test(expected = NoTransitionDefinedException.class) + public void testBakckingUpState() throws LifecycleException, NoTransitionDefinedException { + LifecycleManager lifecycleManager = new LifecycleManagerImpl(); + lifecycleManager.getNextState(null,"Software_Uploading",VNFOperation.Configure.toString()); + } + + private List getNegativeEvents(State state,Set events) { + List negativeEventList = new ArrayList<>(); + negativeEventList.addAll(events); + + for(Transition transition: state.getTransitions()){ + negativeEventList.remove(transition.getEvent()); + } + return negativeEventList; + } + + @Test + public void testLockStates() throws LifecycleException, NoTransitionDefinedException { + StateMachineMetadata metadata = getMetaDataReader().readMetadata(); + LifecycleManagerImpl lifecycleManager = new LifecycleManagerImpl(); + + for(State state: metadata.getStates()) { + if(isValidState(state, VALID_LOCK_STATES)) { + assertSameNextState(lifecycleManager, state, VNFOperation.Lock); + assertSameNextState(lifecycleManager, state, VnfMetaDataReader.VNFOperation.Unlock); + assertSameNextState(lifecycleManager, state, VNFOperation.CheckLock); + } else { + assertNoNextState(lifecycleManager, state, VNFOperation.Lock); + assertNoNextState(lifecycleManager, state, VNFOperation.Unlock); + assertNoNextState(lifecycleManager, state, VNFOperation.CheckLock); + } + } + } + + private boolean isValidState(State state, State[] validStates) { + for(State validState: validStates) { + if(validState.equals(state)) { + return true; + } + } + return false; + } + + private void assertSameNextState(LifecycleManager lifecycleManager, State state, VNFOperation operation) + throws LifecycleException, NoTransitionDefinedException { + Assert.assertEquals(state.getStateName(), + lifecycleManager.getNextState("no-matter", state.getStateName(), operation.toString())); + } + + private void assertNoNextState(LifecycleManager lifecycleManager, State state, VNFOperation operation) + throws LifecycleException { + try { + lifecycleManager.getNextState("no-matter", state.getStateName(), operation.toString()); + Assert.fail("lifecycleManager.getNextState() should fail for state [" + state + + "], operation [" + operation + "]"); + } catch(NoTransitionDefinedException e) { + // this exception is excepted + } + } + + private StateMetaDataReader getMetaDataReader() { + return new VnfMetaDataReader(); + } +} diff --git a/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/OamLifeCycleManagerTest.java b/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/OamLifeCycleManagerTest.java new file mode 100644 index 000000000..d3fe3eae7 --- /dev/null +++ b/appc-lifecycle-management/appc-lifecycle-management-core/src/test/java/org/openecomp/appc/OamLifeCycleManagerTest.java @@ -0,0 +1,152 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP : APPC + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Copyright (C) 2017 Amdocs + * ============================================================================= + * Licensed 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. + * + * ECOMP is a trademark and service mark of AT&T Intellectual Property. + * ============LICENSE_END========================================================= + */ + +package org.openecomp.appc; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.openecomp.appc.lifecyclemanager.impl.LifecycleManagerImpl; +import org.openecomp.appc.lifecyclemanager.objects.LifecycleException; +import org.openecomp.appc.lifecyclemanager.objects.NoTransitionDefinedException; +import org.openecomp.appc.statemachine.impl.readers.AppcOamMetaDataReader; +import org.openecomp.appc.statemachine.impl.readers.AppcOamStates; + +import java.util.Arrays; +import java.util.List; + + +public class OamLifeCycleManagerTest { + private static final String VNF_TYPE_APPC = "APPC"; + private static final String NO_DEFINITION_FORMAT = "No Transition Defined for currentState = %s, event = %s"; + + private LifecycleManagerImpl lifecycleManager; + + @Rule + public ExpectedException expectedException = ExpectedException.none(); + + @Before + public void setUp() throws Exception { + lifecycleManager = new LifecycleManagerImpl(); + } + + private void validateProper(String state, String event, String expectedResult) + throws LifecycleException, NoTransitionDefinedException { + String nextState = lifecycleManager.getNextState(VNF_TYPE_APPC, state, event); + Assert.assertEquals(String.format("Should return %s", expectedResult), expectedResult, nextState); + } + + private void validateException(String state, String event) throws LifecycleException, NoTransitionDefinedException { + expectedException.expect(NoTransitionDefinedException.class); + expectedException.expectMessage(String.format(NO_DEFINITION_FORMAT, state, event)); + lifecycleManager.getNextState(VNF_TYPE_APPC, state, event); + + // Reset to no expectation + expectedException = ExpectedException.none(); + } + + @Test + public void testOamStateTransitionForMaintenanceMode() throws Exception { + String event = AppcOamMetaDataReader.AppcOperation.MaintenanceMode.name(); + String expecteResult = AppcOamStates.EnteringMaintenanceMode.toString(); + + for (AppcOamStates appcOamStates : AppcOamStates.values()) { + String state = appcOamStates.toString(); + if (appcOamStates == AppcOamStates.Started) { + validateProper(state, event, expecteResult); + } else { + validateException(state, event); + } + } + } + + @Test + public void testOamStateTransitionForStart() throws Exception { + String event = AppcOamMetaDataReader.AppcOperation.Start.name(); + String expectResult = AppcOamStates.Starting.toString(); + + List goodStates = Arrays.asList( + AppcOamStates.MaintenanceMode, + AppcOamStates.Stopped, + AppcOamStates.Stopping); + + for (AppcOamStates appcOamStates : AppcOamStates.values()) { + String state = appcOamStates.toString(); + if (goodStates.contains(appcOamStates)) { + validateProper(state, event, expectResult); + } else { + validateException(state, event); + } + } + } + + @Test + public void testOamStateTransitionForStop() throws Exception { + String event = AppcOamMetaDataReader.AppcOperation.Stop.name(); + String expectResult = AppcOamStates.Stopping.toString(); + + List goodStates = Arrays.asList( + AppcOamStates.Error, + AppcOamStates.EnteringMaintenanceMode, + AppcOamStates.MaintenanceMode, + AppcOamStates.Started, + AppcOamStates.Starting); + + for (AppcOamStates appcOamStates : AppcOamStates.values()) { + String state = appcOamStates.toString(); + if (goodStates.contains(appcOamStates)) { + validateProper(state, event, expectResult); + } else { + validateException(state, event); + } + } + } + + + @Test + public void testOamStateTransitionForRestart() throws Exception { + String event = AppcOamMetaDataReader.AppcOperation.Restart.name(); + String expectResult = AppcOamStates.Restarting.toString(); + + List goodStates = Arrays.asList( + AppcOamStates.Error, + AppcOamStates.EnteringMaintenanceMode, + AppcOamStates.MaintenanceMode, + AppcOamStates.Started, + AppcOamStates.Starting, + AppcOamStates.Stopped, + AppcOamStates.Stopping); + + for (AppcOamStates appcOamStates : AppcOamStates.values()) { + String state = appcOamStates.toString(); + if (goodStates.contains(appcOamStates)) { + validateProper(state, event, expectResult); + } else { + validateException(state, event); + } + } + } +} -- cgit 1.2.3-korg