bpmn/MSOCommonBPMN/src/test/groovy/org/onap/so/bpmn/common/scripts/CreateAAIVfModuleTest.groovy

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2018 Nokia.
   8  * ================================================================================
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  * ============LICENSE_END=========================================================
  22  */
  23
  24 package org.onap.so.bpmn.common.scripts
  25
  26 import static org.assertj.core.api.Assertions.assertThat
  27 import static org.mockito.ArgumentMatchers.any
  28 import static org.mockito.ArgumentMatchers.anyObject
  29 import static org.mockito.Mockito.mock
  30 import static org.mockito.Mockito.when
  31
  32 import org.camunda.bpm.extension.mockito.delegate.DelegateExecutionFake
  33 import org.junit.Before
  34 import org.junit.Test
  35 import org.mockito.Mockito
  36 import org.mockito.MockitoAnnotations
  37 import org.mockito.Spy
  38 import org.onap.aai.domain.yang.GenericVnf
  39 import org.onap.aai.domain.yang.VfModule
  40 import org.onap.aai.domain.yang.VfModules
  41 import org.onap.so.bpmn.core.UrnPropertiesReader
  42 import org.onap.so.client.aai.entities.uri.AAIResourceUri
  43 import org.springframework.core.env.Environment
  44
  45 class CreateAAIVfModuleTest extends MsoGroovyTest{
  46
  47         private static final String VNF_ID = "vnfIdTest"
  48         private static final String VNF_TYPE = "vnfTypeTest"
  49         private static final String VNF_NAME = "testVnf"
  50         private static final String SERVICE_ID = "123"
  51         private static final String PERSONAL_MODEL_ID = "modelTest"
  52         private static final String PERSONAL_MODEL_VERSION = "12"
  53         private static final String MODEL_CUST_ID = "modelCustIdTest"
  54         private static final String VNF_PERSONAL_MODEL_ID = "perModIdTest"
  55         private static final String VNF_PERSONAL_MODEL_VER = "14"
  56         private static final String VF_MODULE_NAME = "modTestName"
  57         private static final String VF_MODULE_MODEL_NAME = "modModelNameTest"
  58         private static final String DEFAULT_AAI_VERSION = "9"
  59         private static final String DEFAULT_AAI_NAMESPACE = "defaultTestNamespace"
  60
  61     @Spy
  62     CreateAAIVfModule createAAIVfModule ;
  63
  64         private DelegateExecutionFake executionFake;
  65
  66     @Before
  67     public void init() throws IOException {
  68         super.init("CreateAAIVfModule")
  69         MockitoAnnotations.initMocks(this);
  70         executionFake = new DelegateExecutionFake()
  71         when(createAAIVfModule.getAAIClient()).thenReturn(client)
  72     }
  73
  74     @Test
  75     void testQueryAAIForGenericVnf(){
  76         when(mockExecution.getVariable("CAAIVfMod_vnfId")).thenReturn("vnfId1")
  77         when(mockExecution.getVariable("CAAIVfMod_vnfName")).thenReturn("vnfName")
  78         Optional<GenericVnf> expectedResponse = mockAAIGenericVnf("vnfId1")
  79         createAAIVfModule.queryAAIForGenericVnf(mockExecution)
  80         Mockito.verify(mockExecution).setVariable("CAAIVfMod_queryGenericVnfResponseCode", 200)
  81         Mockito.verify(mockExecution).setVariable("CAAIVfMod_queryGenericVnfResponse", expectedResponse.get())
  82     }
  83
  84     @Test
  85     void testQueryAAIForGenericVnfNotFound(){
  86         when(mockExecution.getVariable("CAAIVfMod_vnfId")).thenReturn("vnfIdNotFound")
  87         when(mockExecution.getVariable("CAAIVfMod_vnfName")).thenReturn("vnfName")
  88         mockAAIGenericVnfNotFound("vnfIdNotFound")
  89         createAAIVfModule.queryAAIForGenericVnf(mockExecution)
  90         Mockito.verify(mockExecution).setVariable("CAAIVfMod_queryGenericVnfResponseCode", 404)
  91         Mockito.verify(mockExecution).setVariable("CAAIVfMod_queryGenericVnfResponse", "Generic Vnf not Found!")
  92     }
  93
  94
  95     @Test
  96     void testCreateGenericVnf(){
  97         when(mockExecution.getVariable("CAAIVfMod_vnfName")).thenReturn("vnfName")
  98         Mockito.doNothing().when(client).create(any(AAIResourceUri.class),anyObject())
  99         createAAIVfModule.createGenericVnf(mockExecution)
 100         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createGenericVnfResponseCode", 201)
 101         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createGenericVnfResponse","Vnf Created")
 102     }
 103
 104
 105
 106     @Test
 107     void testCreateVfModule(){
 108         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 109         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 110
 111         when(mockExecution.getVariable("CAAIVfMod_personaId")).thenReturn("model1")
 112         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("vfModuleName")
 113         Mockito.doNothing().when(client).create(any(AAIResourceUri.class),anyObject())
 114         createAAIVfModule.createVfModule(mockExecution,false)
 115         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createVfModuleResponseCode", 201)
 116         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createVfModuleResponse","Vf Module Created")
 117     }
 118
 119     @Test
 120     void testParseForAddOnModule(){
 121         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 122         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 123         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("newVfModule")
 124         createAAIVfModule.parseForAddOnModule(mockExecution)
 125         Mockito.verify(mockExecution).setVariable("CAAIVfMod_moduleExists", false)
 126     }
 127
 128     @Test
 129     void testParseForAddOnModuleTrue(){
 130         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 131         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 132         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("testVfModuleNameGWPrim")
 133         createAAIVfModule.parseForAddOnModule(mockExecution)
 134         Mockito.verify(mockExecution).setVariable("CAAIVfMod_moduleExists", true)
 135     }
 136
 137     @Test
 138     void testParseForBaseModule(){
 139         Optional<GenericVnf> genericVnfOps = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json")
 140         GenericVnf genericVnf = genericVnfOps.get()
 141         genericVnf.getVfModules().getVfModule().remove(0)
 142         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf)
 143         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("newVfModule")
 144         createAAIVfModule.parseForBaseModule(mockExecution)
 145         Mockito.verify(mockExecution).setVariable("CAAIVfMod_moduleExists", false)
 146     }
 147
 148     @Test
 149     void testParseForBaseModuleConflict(){
 150         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 151         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 152         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("testVfModuleNameGWPrim")
 153         when(mockExecution.getVariable("CAAIVfMod_baseModuleConflict")).thenReturn(true)
 154         createAAIVfModule.parseForBaseModule(mockExecution)
 155         Mockito.verify(mockExecution).setVariable("CAAIVfMod_baseModuleConflict", true)
 156     }
 157
 158     @Test
 159     void testParseForBaseModuleExists(){
 160         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 161         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 162         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("newVfModule")
 163         when(mockExecution.getVariable("CAAIVfMod_baseModuleConflict")).thenReturn(false)
 164         createAAIVfModule.parseForBaseModule(mockExecution)
 165         Mockito.verify(mockExecution).setVariable("CAAIVfMod_moduleExists", false)
 166         Mockito.verify(mockExecution).setVariable("CAAIVfMod_baseModuleConflict", true)
 167     }
 168
 169     @Test
 170     void testCreateVfModuleBase(){
 171         Optional<GenericVnf> genericVnf = getAAIObjectFromJson(GenericVnf.class,"__files/aai/GenericVnfVfModule.json");
 172         when(mockExecution.getVariable("CAAIVfMod_queryGenericVnfResponse")).thenReturn(genericVnf.get())
 173         when(mockExecution.getVariable("CAAIVfMod_moduleName")).thenReturn("vfModuleName")
 174         Mockito.doNothing().when(client).create(any(AAIResourceUri.class),anyObject())
 175         createAAIVfModule.createVfModule(mockExecution,true)
 176         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createVfModuleResponseCode", 201)
 177         Mockito.verify(mockExecution).setVariable("CAAIVfMod_createVfModuleResponse","Vf Module Created")
 178     }
 179         @Test
 180     void preProcessRequest_successful() {
 181         //given
 182         prepareUrnPropertiesReader()
 183         executionFake.setVariable("vnfId", VNF_ID)
 184         executionFake.setVariable("vnfType", VNF_TYPE)
 185         executionFake.setVariable("vnfName", VNF_NAME)
 186         executionFake.setVariable("serviceId", SERVICE_ID)
 187         executionFake.setVariable("personaModelId", PERSONAL_MODEL_ID)
 188         executionFake.setVariable("personaModelVersion", PERSONAL_MODEL_VERSION)
 189         executionFake.setVariable("modelCustomizationId", MODEL_CUST_ID)
 190         executionFake.setVariable("vnfPersonaModelId", VNF_PERSONAL_MODEL_ID)
 191         executionFake.setVariable("vnfPersonaModelVersion", VNF_PERSONAL_MODEL_VER)
 192         executionFake.setVariable("isBaseVfModule", "true")
 193         executionFake.setVariable("vfModuleName", VF_MODULE_NAME)
 194         executionFake.setVariable("vfModuleModelName", VF_MODULE_MODEL_NAME)
 195         //when
 196         createAAIVfModule.preProcessRequest(executionFake)
 197         //then
 198         assertThat(executionFake.getVariable("CAAIVfMod_vnfId")).isEqualTo(VNF_ID)
 199         assertThat(executionFake.getVariable("CAAIVfMod_vnfName")).isEqualTo(VNF_NAME)
 200         assertThat(executionFake.getVariable("CAAIVfMod_vnfType")).isEqualTo(VNF_TYPE)
 201         assertThat(executionFake.getVariable("CAAIVfMod_serviceId")).isEqualTo(SERVICE_ID)
 202         assertThat(executionFake.getVariable("CAAIVfMod_personaId")).isEqualTo(PERSONAL_MODEL_ID)
 203         assertThat(executionFake.getVariable("CAAIVfMod_personaVer")).isEqualTo(PERSONAL_MODEL_VERSION)
 204         assertThat(executionFake.getVariable("CAAIVfMod_modelCustomizationId")).isEqualTo(MODEL_CUST_ID)
 205         assertThat(executionFake.getVariable("CAAIVfMod_vnfPersonaId")).isEqualTo(VNF_PERSONAL_MODEL_ID)
 206         assertThat(executionFake.getVariable("CAAIVfMod_vnfPersonaVer")).isEqualTo(VNF_PERSONAL_MODEL_VER)
 207         assertThat(executionFake.getVariable("CAAIVfMod_isBaseVfModule")).isEqualTo(true)
 208         assertThat(executionFake.getVariable("CAAIVfMod_moduleName")).isEqualTo(VF_MODULE_NAME)
 209         assertThat(executionFake.getVariable("CAAIVfMod_moduleModelName")).isEqualTo(VF_MODULE_MODEL_NAME)
 210         assertThat(executionFake.getVariable("CAAIVfMod_aaiNamespace"))
 211                 .isEqualTo(DEFAULT_AAI_NAMESPACE + "v" + DEFAULT_AAI_VERSION)
 212     }
 213
 214     @Test
 215     void processAAIGenericVnfQuery_setVnfResponse() {
 216         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponseCode", 200)
 217         executionFake.setVariable("CAAIVfMod_vnfId", "")
 218         executionFake.setVariable("CAAIVfMod_vnfName", VNF_NAME)
 219
 220         createAAIVfModule.processAAIGenericVnfQuery(executionFake)
 221
 222         assertThat(executionFake.getVariable("CAAIVfMod_queryGenericVnfResponse"))
 223                 .isEqualTo("Invalid request for new Generic VNF which already exists, Vnf Name=" + VNF_NAME)
 224     }
 225
 226     @Test
 227     void processAAIGenericVnfQuery_setVfModuleResponse() {
 228         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponseCode", 500)
 229         executionFake.setVariable("CAAIVfMod_vnfId", VNF_ID)
 230
 231         createAAIVfModule.processAAIGenericVnfQuery(executionFake)
 232
 233         assertThat(executionFake.getVariable("CAAIVfMod_createVfModuleResponse"))
 234                 .isEqualTo("Invalid request for Add-on Module requested for non-existant Generic VNF, VNF Id=" + VNF_ID)
 235     }
 236
 237     @Test
 238     void parseForAddOnModule_moduleNameFound() {
 239
 240                 GenericVnf vnf = new GenericVnf();
 241                 VfModule module = new VfModule();
 242                 VfModules modules = new VfModules();
 243                 vnf.setVnfName(VNF_NAME)
 244                 vnf.setVfModules(modules)
 245                 modules.getVfModule().add(module)
 246                 module.setVfModuleName(VF_MODULE_NAME)
 247         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponse", vnf)
 248         executionFake.setVariable("CAAIVfMod_moduleName", VF_MODULE_NAME)
 249
 250         createAAIVfModule.parseForAddOnModule(executionFake)
 251
 252         assertThat(executionFake.getVariable("CAAIVfMod_vnfNameFromAAI")).isEqualTo(VNF_NAME)
 253         assertThat(executionFake.getVariable("CAAIVfMod_moduleExists")).isEqualTo(true)
 254         assertThat(executionFake.getVariable("CAAIVfMod_parseModuleResponse"))
 255                 .isEqualTo("VF Module " + VF_MODULE_NAME + " already exists for Generic VNF " + VNF_NAME)
 256     }
 257
 258     @Test
 259     void parseForAddOnModule_moduleNameNotFound() {
 260         GenericVnf vnf = new GenericVnf();
 261                 vnf.setVnfName(VNF_NAME)
 262         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponse", vnf)
 263         executionFake.setVariable("CAAIVfMod_moduleName", VF_MODULE_NAME)
 264         executionFake.setVariable("CAAIVfMod_moduleExists", false)
 265
 266         createAAIVfModule.parseForAddOnModule(executionFake)
 267
 268         assertThat(executionFake.getVariable("CAAIVfMod_vnfNameFromAAI")).isEqualTo(VNF_NAME)
 269         assertThat(executionFake.getVariable("CAAIVfMod_moduleExists")).isEqualTo(false)
 270         assertThat(executionFake.getVariable("CAAIVfMod_parseModuleResponse"))
 271                 .isEqualTo("VF Module " + VF_MODULE_NAME + " does not exist for Generic VNF " + VNF_NAME)
 272     }
 273
 274     @Test
 275     void parseForBaseModule_moduleNameFound() {
 276         GenericVnf vnf = new GenericVnf();
 277                 VfModule module = new VfModule();
 278                 VfModules modules = new VfModules();
 279                 vnf.setVnfName(VNF_NAME)
 280                 vnf.setVfModules(modules)
 281                 modules.getVfModule().add(module)
 282                 module.setVfModuleName(VF_MODULE_NAME)
 283         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponse", vnf)
 284         executionFake.setVariable("CAAIVfMod_moduleName", VF_MODULE_NAME)
 285
 286         createAAIVfModule.parseForBaseModule(executionFake)
 287
 288         assertThat(executionFake.getVariable("CAAIVfMod_vnfNameFromAAI")).isEqualTo(VNF_NAME)
 289         assertThat(executionFake.getVariable("CAAIVfMod_moduleExists")).isEqualTo(false)
 290         assertThat(executionFake.getVariable("CAAIVfMod_baseModuleConflict")).isEqualTo(true)
 291         assertThat(executionFake.getVariable("CAAIVfMod_parseModuleResponse"))
 292                 .isEqualTo("VF Module " + VF_MODULE_NAME + " already exists for Generic VNF " + VNF_NAME)
 293     }
 294
 295     @Test
 296     void parseForBaseModule_isBaseVfModule() {
 297                 GenericVnf vnf = new GenericVnf();
 298                 VfModule module = new VfModule();
 299                 VfModules modules = new VfModules();
 300                 vnf.setVfModules(modules)
 301                 vnf.setVnfName(VNF_NAME)
 302                 modules.getVfModule().add(module)
 303                 module.setVfModuleName(VF_MODULE_NAME)
 304                 module.setIsBaseVfModule(true)
 305
 306         executionFake.setVariable("CAAIVfMod_queryGenericVnfResponse", vnf)
 307         executionFake.setVariable("CAAIVfMod_baseModuleConflict", false)
 308
 309         createAAIVfModule.parseForBaseModule(executionFake)
 310
 311         assertThat(executionFake.getVariable("CAAIVfMod_vnfNameFromAAI")).isEqualTo(VNF_NAME)
 312         assertThat(executionFake.getVariable("CAAIVfMod_moduleExists")).isEqualTo(false)
 313         assertThat(executionFake.getVariable("CAAIVfMod_baseModuleConflict")).isEqualTo(true)
 314         assertThat(executionFake.getVariable("CAAIVfMod_parseModuleResponse"))
 315                 .isEqualTo("Base VF Module already exists for Generic VNF " + VNF_NAME)
 316     }
 317
 318     @Test
 319     void parseForBaseModule_baseModuleConflictIsFalse() {
 320                 GenericVnf vnf = new GenericVnf();
 321                 vnf.setVnfName(VNF_NAME)
 322                 executionFake.setVariable("CAAIVfMod_queryGenericVnfResponse", vnf)
 323         executionFake.setVariable("CAAIVfMod_baseModuleConflict", false)
 324         executionFake.setVariable("CAAIVfMod_moduleName", VF_MODULE_NAME)
 325
 326         createAAIVfModule.parseForBaseModule(executionFake)
 327
 328         assertThat(executionFake.getVariable("CAAIVfMod_vnfNameFromAAI")).isEqualTo(VNF_NAME)
 329         assertThat(executionFake.getVariable("CAAIVfMod_moduleExists")).isEqualTo(false)
 330         assertThat(executionFake.getVariable("CAAIVfMod_parseModuleResponse"))
 331                 .isEqualTo("VF Module " + VF_MODULE_NAME + " does not exist for Generic VNF " + VNF_NAME)
 332     }
 333
 334     private void prepareUrnPropertiesReader() {
 335         Environment mockEnvironment = mock(Environment.class)
 336         when(mockEnvironment.getProperty("mso.workflow.global.default.aai.version")).thenReturn(DEFAULT_AAI_VERSION)
 337         when(mockEnvironment.getProperty("mso.workflow.global.default.aai.namespace")).thenReturn(DEFAULT_AAI_NAMESPACE)
 338         UrnPropertiesReader urnPropertiesReader = new UrnPropertiesReader()
 339         urnPropertiesReader.setEnvironment(mockEnvironment)
 340     }
 341 }