-/*-
+/*-\r
* ============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
+ * Copyright (C) 2017 Amdocs\r
+ * =============================================================================\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0\r
*
- * 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.
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
*
* 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.domainmodel.lcm.VNFOperation;
-import org.openecomp.appc.lifecyclemanager.LifecycleManager;
-import org.openecomp.appc.lifecyclemanager.helper.MetadataReader;
-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.objects.*;
-
-import java.util.*;
-
-
-public class TestLifecycleManager {
-
- 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 {
-
- MetadataReader metadataReader = new MetadataReader();
- StateMachineMetadata metadata = metadataReader.readMetadata(null);
-
- 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<Event> negativeEvents = getNegativeEvents(state,metadata.getEvents());
-
- for(Event negativeEvent:negativeEvents){
- boolean flag =false;
- try{
- String response = lifecycleManager.getNextState(null,state.toString(),negativeEvent.toString());
-
- }
- catch (NoTransitionDefinedException e){
- flag =true;
- }
- Assert.assertEquals(flag,true);
-
- flag =false;
- try{
- String response = 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();
- String nextState = lifecycleManager.getNextState(null,"Software_Uploading",VNFOperation.Configure.toString());
- }
-
- private List<Event> getNegativeEvents(State state,Set<Event> events) {
- List<Event> negativeEventList = new ArrayList<>();
- negativeEventList.addAll(events);
-
- for(Transition transition: state.getTransitions()){
- negativeEventList.remove(transition.getEvent());
- }
- return negativeEventList;
- }
-
- @Test
- public void testLockStates() throws LifecycleException, NoTransitionDefinedException {
- MetadataReader metadataReader = new MetadataReader();
- StateMachineMetadata metadata = metadataReader.readMetadata(null);
- LifecycleManager lifecycleManager = new LifecycleManagerImpl();
- for(State state: metadata.getStates()) {
- if(isValidState(state, VALID_LOCK_STATES)) {
- assertSameNextState(lifecycleManager, state, VNFOperation.Lock);
- assertSameNextState(lifecycleManager, state, 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
- }
- }
-}
+ * ============LICENSE_END=========================================================\r
+ */\r
+\r
+package org.openecomp.appc;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Test;\r
+import org.openecomp.appc.exceptions.InvalidInputException;\r
+import org.openecomp.appc.lifecyclemanager.LifecycleManager;\r
+import org.openecomp.appc.statemachine.StateMetaDataReader;\r
+import org.openecomp.appc.lifecyclemanager.impl.LifecycleManagerImpl;\r
+import org.openecomp.appc.lifecyclemanager.objects.LifecycleException;\r
+import org.openecomp.appc.lifecyclemanager.objects.NoTransitionDefinedException;\r
+import org.openecomp.appc.statemachine.impl.readers.VnfMetaDataReader;\r
+import org.openecomp.appc.statemachine.impl.readers.VnfMetaDataReader.VNFOperation;\r
+import org.openecomp.appc.statemachine.objects.Event;\r
+import org.openecomp.appc.statemachine.objects.State;\r
+import org.openecomp.appc.statemachine.objects.StateMachineMetadata;\r
+import org.openecomp.appc.statemachine.objects.Transition;\r
+\r
+import java.util.*;\r
+\r
+\r
+public class LifecycleManagerTest {\r
+\r
+ private static final State[] VALID_LOCK_STATES = new State[] {\r
+ new State("instantiated"),\r
+ new State("configured"),\r
+ new State("tested"),\r
+ new State("running"),\r
+ new State("error"),\r
+ new State("unknown"),\r
+ new State("created"),\r
+ new State("not orchestrated"),\r
+ new State("stopped"),\r
+ };\r
+\r
+ @Test\r
+ public void handleEvent() throws InvalidInputException, LifecycleException, NoTransitionDefinedException {\r
+\r
+ StateMachineMetadata metadata = getMetaDataReader().readMetadata();\r
+ LifecycleManagerImpl lifecycleManager = new LifecycleManagerImpl();\r
+\r
+ /*\r
+ * Testing Positive Scenario passing the valid events and validating the StateMachineResponse\r
+ */\r
+ for(State state:metadata.getStates()){\r
+\r
+ for(Transition transition:state.getTransitions()){\r
+ Event event = transition.getEvent();\r
+ State nextStateFromMetadata = transition.getNextState();\r
+\r
+ String expectedNextState = lifecycleManager.getNextState(null,state.toString(),event.toString());\r
+ Assert.assertEquals(expectedNextState,nextStateFromMetadata.toString());\r
+ }\r
+ }\r
+\r
+ /*\r
+ Testing Negative Scenarios, 1. Passing the valid Events for which Transition is not defined in\r
+ Metadata and validating the StateMachineResponse 2. Passing the invalid events which are not\r
+ registered as events in the StateMachineMetadata and validating StateMachineResponse\r
+ */\r
+ for(State state:metadata.getStates()){\r
+\r
+ for(Transition transition:state.getTransitions()){\r
+ List<Event> negativeEvents = getNegativeEvents(state,metadata.getEvents());\r
+\r
+ for(Event negativeEvent:negativeEvents){\r
+ boolean flag =false;\r
+ try{\r
+ lifecycleManager.getNextState(null,state.toString(),negativeEvent.toString());\r
+\r
+ }\r
+ catch (NoTransitionDefinedException e){\r
+ flag =true;\r
+ }\r
+ Assert.assertEquals(flag,true);\r
+\r
+ flag = false;\r
+ try{\r
+ lifecycleManager.getNextState(null,state.toString(),"PUT");\r
+ }\r
+ catch(LifecycleException e){\r
+ flag = true;\r
+ }\r
+ Assert.assertTrue(flag);\r
+\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ @Test\r
+ public void testNotOrchestratedState() throws LifecycleException, NoTransitionDefinedException {\r
+ LifecycleManager lifecycleManager = new LifecycleManagerImpl();\r
+ String nextState = lifecycleManager.getNextState(\r
+ null,"NOT ORCHESTRATED",VNFOperation.Configure.toString());\r
+ Assert.assertEquals(nextState,"Configuring");\r
+ }\r
+\r
+ @Test(expected = NoTransitionDefinedException.class)\r
+ public void testBakckingUpState() throws LifecycleException, NoTransitionDefinedException {\r
+ LifecycleManager lifecycleManager = new LifecycleManagerImpl();\r
+ lifecycleManager.getNextState(null,"Software_Uploading",VNFOperation.Configure.toString());\r
+ }\r
+\r
+ private List<Event> getNegativeEvents(State state,Set<Event> events) {\r
+ List<Event> negativeEventList = new ArrayList<>();\r
+ negativeEventList.addAll(events);\r
+\r
+ for(Transition transition: state.getTransitions()){\r
+ negativeEventList.remove(transition.getEvent());\r
+ }\r
+ return negativeEventList;\r
+ }\r
+\r
+ @Test\r
+ public void testLockStates() throws LifecycleException, NoTransitionDefinedException {\r
+ StateMachineMetadata metadata = getMetaDataReader().readMetadata();\r
+ LifecycleManagerImpl lifecycleManager = new LifecycleManagerImpl();\r
+\r
+ for(State state: metadata.getStates()) {\r
+ if(isValidState(state, VALID_LOCK_STATES)) {\r
+ assertSameNextState(lifecycleManager, state, VNFOperation.Lock);\r
+ assertSameNextState(lifecycleManager, state, VnfMetaDataReader.VNFOperation.Unlock);\r
+ assertSameNextState(lifecycleManager, state, VNFOperation.CheckLock);\r
+ } else {\r
+ assertNoNextState(lifecycleManager, state, VNFOperation.Lock);\r
+ assertNoNextState(lifecycleManager, state, VNFOperation.Unlock);\r
+ assertNoNextState(lifecycleManager, state, VNFOperation.CheckLock);\r
+ }\r
+ }\r
+ }\r
+\r
+ private boolean isValidState(State state, State[] validStates) {\r
+ for(State validState: validStates) {\r
+ if(validState.equals(state)) {\r
+ return true;\r
+ }\r
+ }\r
+ return false;\r
+ }\r
+\r
+ private void assertSameNextState(LifecycleManager lifecycleManager, State state, VNFOperation operation)\r
+ throws LifecycleException, NoTransitionDefinedException {\r
+ Assert.assertEquals(state.getStateName(),\r
+ lifecycleManager.getNextState("no-matter", state.getStateName(), operation.toString()));\r
+ }\r
+\r
+ private void assertNoNextState(LifecycleManager lifecycleManager, State state, VNFOperation operation)\r
+ throws LifecycleException {\r
+ try {\r
+ lifecycleManager.getNextState("no-matter", state.getStateName(), operation.toString());\r
+ Assert.fail("lifecycleManager.getNextState() should fail for state [" + state\r
+ + "], operation [" + operation + "]");\r
+ } catch(NoTransitionDefinedException e) {\r
+ // this exception is excepted\r
+ }\r
+ }\r
+\r
+ private StateMetaDataReader getMetaDataReader() {\r
+ return new VnfMetaDataReader();\r
+ }\r
+}\r
Code Review / appc.git / blobdiff