sdc-tosca/src/test/java/org/onap/sdc/tosca/parser/impl/ToscaParserNodeTemplateMockTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * sdc-tosca
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.sdc.tosca.parser.impl;
  22
  23 import org.apache.commons.lang3.StringUtils;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.Mock;
  28 import org.mockito.runners.MockitoJUnitRunner;
  29 import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
  30 import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
  31 import org.onap.sdc.tosca.parser.utils.PropertyUtils;
  32 import org.onap.sdc.toscaparser.api.NodeTemplate;
  33 import org.onap.sdc.toscaparser.api.Property;
  34 import org.onap.sdc.toscaparser.api.ToscaTemplate;
  35 import org.onap.sdc.toscaparser.api.elements.Metadata;
  36
  37 import java.util.LinkedHashMap;
  38 import java.util.NoSuchElementException;
  39
  40 import static org.junit.Assert.assertTrue;
  41 import static org.mockito.Mockito.when;
  42 import static org.testng.Assert.assertFalse;
  43
  44 @RunWith(MockitoJUnitRunner.class)
  45 public class ToscaParserNodeTemplateMockTest {
  46     @Mock
  47     private NodeTemplate nodeTemplate;
  48
  49     @Mock
  50     private Metadata metadata;
  51
  52     @Mock
  53     private ToscaTemplate toscaTemplate;
  54
  55     @Mock
  56     private Property property;
  57
  58     private static final String dataTypeA = String.format(".%s.aaa", PropertySchemaType.DATATYPE.getSchemaTypeName());
  59     private static final String dataTypeB = String.format(".%s.bbb", PropertySchemaType.DATATYPE.getSchemaTypeName());
  60     private static final String dataTypeD = String.format(".%s.ddd", PropertySchemaType.DATATYPE.getSchemaTypeName());
  61     private static final String dataTypeR = String.format(".%s.rrr", PropertySchemaType.DATATYPE.getSchemaTypeName());
  62
  63     @Before
  64     public void setUp() {
  65         when(property.getType()).thenReturn(dataTypeA);
  66     }
  67
  68
  69     @Test
  70     public void verifyCorrectPropertyPath() {
  71         String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
  72         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
  73         LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
  74         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "q", PropertySchemaType.STRING.getSchemaTypeName());
  75
  76         when(nodeTemplate.getCustomDef())
  77                 .thenReturn(bProp)
  78                 .thenReturn(cProp)
  79                 .thenReturn(dProp);
  80
  81         assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
  82     }
  83
  84     @Test
  85     public void verifyPropertyPathWithMapOfStringsType() {
  86         String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
  87         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
  88         LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
  89         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(PropertySchemaType.MAP.getSchemaTypeName(), "q", PropertySchemaType.STRING.getSchemaTypeName());
  90
  91         when(nodeTemplate.getCustomDef())
  92                 .thenReturn(bProp)
  93                 .thenReturn(cProp)
  94                 .thenReturn(dProp);
  95
  96         assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
  97     }
  98
  99     @Test
 100     public void verifyPropertyPathWithMapType() {
 101         String[] path = String.format("%s#%s#%s", "x", "y", "z").split("#");
 102         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
 103         LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
 104
 105         when(nodeTemplate.getCustomDef())
 106                 .thenReturn(bProp)
 107                 .thenReturn(cProp);
 108
 109         assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
 110     }
 111
 112
 113     @Test
 114     public void verifyPropertyPathWithListOfDataTypeShouldBeRejected() {
 115         String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
 116         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
 117         LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
 118         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), dataTypeR);
 119
 120         when(nodeTemplate.getCustomDef())
 121                 .thenReturn(bProp)
 122                 .thenReturn(cProp)
 123                 .thenReturn(dProp);
 124
 125         assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
 126     }
 127
 128     @Test
 129     public void verifyPropertyPathWithListOfIntegersAsType() {
 130         String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
 131         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
 132         LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
 133         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), PropertySchemaType.INTEGER.getSchemaTypeName());
 134
 135         when(nodeTemplate.getCustomDef())
 136                 .thenReturn(bProp)
 137                 .thenReturn(cProp)
 138                 .thenReturn(dProp);
 139
 140         assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
 141     }
 142
 143     @Test
 144     public void propertyPathIsRejectedAsShorterThanExpected() {
 145         String[] path = String.format("%s#%s", "x", "y").split("#");
 146         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
 147         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
 148
 149         when(nodeTemplate.getCustomDef())
 150                 .thenReturn(bProp)
 151                 .thenReturn(dProp);
 152
 153         assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
 154     }
 155
 156     @Test(expected = NoSuchElementException.class)
 157     public void propertyPathIsRejectedAsLongerThanExpected() {
 158         String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
 159         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
 160         LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
 161
 162         when(nodeTemplate.getCustomDef())
 163                 .thenReturn(bProp)
 164                 .thenReturn(dProp);
 165
 166         PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property);
 167     }
 168
 169     @Test(expected = NoSuchElementException.class)
 170     public void propertyPathIsRejectedAsPropertyIsNotFound() {
 171         String[] path = String.format("%s#%s", "x", "y").split("#");
 172         LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "t", dataTypeB);
 173         when(nodeTemplate.getCustomDef())
 174                 .thenReturn(bProp);
 175
 176         assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
 177     }
 178
 179     @Test
 180     public void verifyNodeTypeIsNotSupported() {
 181         when(nodeTemplate.getMetaData()).thenReturn(metadata);
 182         when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn("VFC-TEST");
 183
 184         ISdcCsarHelper sdcCsarHelper = new SdcCsarHelperImpl(toscaTemplate);
 185         assertFalse(sdcCsarHelper.isNodeTypeSupported(nodeTemplate));
 186     }
 187
 188
 189     private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type) {
 190         return fillDataTypeEntry(dataTypeName, propertyName, type, "");
 191     }
 192
 193     private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type, String entrySchemaType) {
 194         LinkedHashMap<String, Object> dataTypes = new LinkedHashMap<>();
 195         LinkedHashMap<String, Object> properties = new LinkedHashMap<>();
 196         LinkedHashMap<String, Object> property = new LinkedHashMap<>();
 197         LinkedHashMap<String, Object> dataType = new LinkedHashMap<>();
 198         property.put(SdcPropertyNames.PROPERTY_NAME_TYPE, type);
 199         property.put(SdcPropertyNames.PROPERTY_NAME_NAME, propertyName);
 200
 201         PropertySchemaType propertySchemaType = PropertySchemaType.getEnumByValue(type);
 202
 203         if (!StringUtils.isEmpty(entrySchemaType) &&
 204                 (propertySchemaType.getSchemaTypeComplexity() == PropertySchemaType.PropertySchemaComplexity.Complex)) {
 205             LinkedHashMap<String, Object> entry_schema = new LinkedHashMap<>();
 206             entry_schema.put(SdcPropertyNames.PROPERTY_NAME_TYPE, entrySchemaType);
 207             property.put(SdcPropertyNames.PROPERTY_NAME_ENTRY_SCHEMA, entry_schema);
 208         }
 209         properties.put(propertyName, property);
 210         dataType.put(SdcPropertyNames.PROPERTY_NAME_PROPERTIES,  properties);
 211         dataTypes.put(dataTypeName, dataType);
 212         return dataTypes;
 213     }
 214
 215
 216
 217 }