openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/services/SchemaGeneratorTest.java

   1 package org.openecomp.sdc.vendorsoftwareproduct.services;
   2
   3 import org.openecomp.core.utilities.json.JsonUtil;
   4 import org.everit.json.schema.EmptySchema;
   5 import org.everit.json.schema.loader.SchemaLoader;
   6 import org.json.JSONObject;
   7 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.ComponentData;
   8 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.CompositionEntityType;
   9 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Network;
  10 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.NetworkType;
  11 import org.openecomp.sdc.vendorsoftwareproduct.types.composition.Nic;
  12 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentCompositionSchemaInput;
  13 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.ComponentQuestionnaireSchemaInput;
  14 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NetworkCompositionSchemaInput;
  15 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.NicCompositionSchemaInput;
  16 import org.openecomp.sdc.vendorsoftwareproduct.types.schemagenerator.SchemaTemplateContext;
  17 import org.testng.Assert;
  18 import org.testng.annotations.Test;
  19
  20 import java.util.Arrays;
  21 import java.util.Map;
  22
  23 public class SchemaGeneratorTest {
  24
  25   private static int getMinOfVmMax(JSONObject schemaJson) {
  26     return schemaJson.getJSONObject("properties").getJSONObject("compute")
  27         .getJSONObject("properties").getJSONObject("numOfVMs").getJSONObject("properties")
  28         .getJSONObject("maximum").getInt("minimum");
  29   }
  30
  31   private static JSONObject validateSchema(String schema) {
  32     System.out.println(schema);
  33     Assert.assertNotNull(schema);
  34     Assert.assertTrue(JsonUtil.isValidJson(schema));
  35     JSONObject schemaJson = new JSONObject(schema);
  36     Assert.assertFalse(SchemaLoader.load(schemaJson) instanceof EmptySchema);
  37     return schemaJson;
  38   }
  39
  40   @Test
  41   public void testGenerateVspQuestionnaire() {
  42     String schema = SchemaGenerator
  43         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.vsp, null);
  44     validateSchema(schema);
  45   }
  46
  47   @Test
  48   public void testGenerateNetworkCompositionUpload() {
  49     Network network = new Network();
  50     network.setName("upload network1 name");
  51     network.setDhcp(true);
  52
  53     NetworkCompositionSchemaInput input = new NetworkCompositionSchemaInput();
  54     input.setManual(false);
  55     input.setNetwork(network);
  56
  57     String schema = SchemaGenerator
  58         .generate(SchemaTemplateContext.composition, CompositionEntityType.network, input);
  59     validateSchema(schema);
  60   }
  61
  62   @Test
  63   public void testGenerateNetworkCompositionManual() {
  64     NetworkCompositionSchemaInput input = new NetworkCompositionSchemaInput();
  65     input.setManual(true);
  66
  67     String schema = SchemaGenerator
  68         .generate(SchemaTemplateContext.composition, CompositionEntityType.network, input);
  69
  70     validateSchema(schema);
  71   }
  72
  73   @Test
  74   public void testGenerateComponentQuestionnaireWithoutInput() {
  75     String schema = SchemaGenerator
  76         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component, null);
  77     validateSchema(schema);
  78   }
  79
  80   @Test
  81   public void testGenerateComponentQuestionnaireWithMissingInput() {
  82     ComponentQuestionnaireSchemaInput input =
  83         new ComponentQuestionnaireSchemaInput(Arrays.asList("nic1", "nic2"),
  84             JsonUtil.json2Object("{\n" +
  85                 "  \"compute\": {\n" +
  86                 "    \"numOfVMs\": {\n" +
  87                 "      \"blabla\": 70\n" + // no minimum
  88                 "    }\n" +
  89                 "  }\n" +
  90                 "}", Map.class));
  91     String schema = SchemaGenerator
  92         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component, input);
  93     JSONObject schemaJson = validateSchema(schema);
  94     //Assert.assertEquals(getMinOfVmMax(schemaJson), 0);
  95   }
  96
  97   @Test
  98   public void testGenerateComponentQuestionnaireWithInvalidTypeInput() {
  99     ComponentQuestionnaireSchemaInput input =
 100         new ComponentQuestionnaireSchemaInput(Arrays.asList("nic1", "nic2"),
 101             JsonUtil.json2Object("{\n" +
 102                 "  \"compute\": {\n" +
 103                 "    \"numOfVMs\": {\n" +
 104                 "      \"minimum\": \"some string instead of integer\"\n" +
 105                 // invalid minimum - string
 106                 "    }\n" +
 107                 "  }\n" +
 108                 "}", Map.class));
 109     String schema = SchemaGenerator
 110         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component, input);
 111     JSONObject schemaJson = validateSchema(schema);
 112     Assert.assertEquals(getMinOfVmMax(schemaJson), 0);
 113   }
 114
 115   @Test
 116   public void testGenerateComponentQuestionnaireWithInvalidRangeInput() {
 117     ComponentQuestionnaireSchemaInput input =
 118         new ComponentQuestionnaireSchemaInput(Arrays.asList("nic1", "nic2"),
 119             JsonUtil.json2Object("{\n" +
 120                 "  \"compute\": {\n" +
 121                 "    \"numOfVMs\": {\n" +
 122                 "      \"minimum\": 150\n" + // invalid minimum - integer out of range (0-100)
 123                 "    }\n" +
 124                 "  }\n" +
 125                 "}", Map.class));
 126     String schema = SchemaGenerator
 127         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component, input);
 128     JSONObject schemaJson = validateSchema(schema);
 129     Assert.assertEquals(getMinOfVmMax(schemaJson), 0);
 130   }
 131
 132   @Test
 133   public void testGenerateComponentQuestionnaireWithValidInput() {
 134     ComponentQuestionnaireSchemaInput input =
 135         new ComponentQuestionnaireSchemaInput(Arrays.asList("nic1", "nic2"),
 136             JsonUtil.json2Object("{\n" +
 137                 "  \"compute\": {\n" +
 138                 "    \"numOfVMs\": {\n" +
 139                 "      \"minimum\": 30\n" + // valid minimum - integer at the correct range (0-100)
 140                 "    }\n" +
 141                 "  }\n" +
 142                 "}", Map.class));
 143     String schema = SchemaGenerator
 144         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.component, input);
 145     JSONObject schemaJson = validateSchema(schema);
 146     Assert.assertEquals(getMinOfVmMax(schemaJson), 30);
 147   }
 148
 149   @Test
 150   public void testGenerateNicQuestionnaire() {
 151     String schema = SchemaGenerator
 152         .generate(SchemaTemplateContext.questionnaire, CompositionEntityType.nic, null);
 153     validateSchema(schema);
 154   }
 155
 156   @Test
 157   public void testGenerateComponentCompositionUpload() {
 158     ComponentData component = new ComponentData();
 159     component.setName("upload comp1 name");
 160     component.setDescription("upload comp1 desc");
 161
 162     ComponentCompositionSchemaInput input = new ComponentCompositionSchemaInput();
 163     input.setManual(false);
 164     input.setComponent(component);
 165
 166     String schema = SchemaGenerator
 167         .generate(SchemaTemplateContext.composition, CompositionEntityType.component, input);
 168     validateSchema(schema);
 169   }
 170
 171   @Test
 172   public void testGenerateComponentCompositionManual() {
 173     ComponentCompositionSchemaInput input = new ComponentCompositionSchemaInput();
 174     input.setManual(true);
 175
 176     String schema = SchemaGenerator
 177         .generate(SchemaTemplateContext.composition, CompositionEntityType.component, input);
 178     validateSchema(schema);
 179   }
 180
 181   @Test
 182   public void testGenerateNicCompositionUpload() {
 183     Nic nic = new Nic();
 184     nic.setName("upload nic1 name");
 185     nic.setDescription("upload nic1 desc");
 186     nic.setNetworkId("upload nic1 networkId");
 187     //nic.setNetworkName("upload nic1 networkName");
 188     nic.setNetworkType(NetworkType.External);
 189
 190     NicCompositionSchemaInput input = new NicCompositionSchemaInput();
 191     input.setManual(false);
 192     input.setNic(nic);
 193
 194     String schema = SchemaGenerator
 195         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, input);
 196     validateSchema(schema);
 197   }
 198
 199
 200 //    @Test
 201 //    public void testGenerateNicCompositionManualWithoutNetworkId() {
 202 //        Nic nic = new Nic();
 203 //        nic.setName("upload nic1 name");
 204 //        nic.setDescription("upload nic1 desc");
 205 //        //nic.setNetworkName("upload nic1 networkName");
 206 //        nic.setNetworkType(NetworkType.External);
 207 //
 208 //        NicCompositionSchemaInput input = new NicCompositionSchemaInput();
 209 //        input.setManual(true);
 210 //        input.setNic(nic);
 211 //
 212 //        String schema = SchemaGenerator.generate(SchemaTemplateContext.composition, CompositionEntityType.nic, input);
 213 //        validateSchema(schema);
 214 //    }
 215
 216   @Test
 217   public void testGenerateNicCompositionUploadWithoutNetworkId() {
 218     Nic nic = new Nic();
 219     nic.setName("upload nic1 name");
 220     nic.setDescription("upload nic1 desc");
 221     //nic.setNetworkName("upload nic1 networkName");
 222     nic.setNetworkType(NetworkType.External);
 223
 224     NicCompositionSchemaInput input = new NicCompositionSchemaInput();
 225     input.setManual(false);
 226     input.setNic(nic);
 227
 228     String schema = SchemaGenerator
 229         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, input);
 230     validateSchema(schema);
 231   }
 232
 233   @Test
 234   public void testGenerateNicCompositionManual() {
 235     NicCompositionSchemaInput input = new NicCompositionSchemaInput();
 236     input.setManual(true);
 237     input.setNetworkIds(
 238         Arrays.asList("manual networkId1", "manual networkId2", "manual networkId3"));
 239
 240     String schema = SchemaGenerator
 241         .generate(SchemaTemplateContext.composition, CompositionEntityType.nic, input);
 242     validateSchema(schema);
 243   }
 244 }