gerrit.onap Code Review - policy/distribution.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.distribution.main.parameters;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.junit.Assert.fail;
  26
  27 import java.io.IOException;
  28 import java.nio.file.Files;
  29 import java.nio.file.Paths;
  30
  31 import org.junit.Test;
  32 import org.onap.policy.distribution.main.PolicyDistributionException;
  33 import org.onap.policy.distribution.main.startstop.DistributionCommandLineArguments;
  34
  35 /**
  36  * Class to perform unit test of DistributionParameterHandler.
  37  *
  38  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  39  */
  40 public class TestDistributionParameterHandler {
  41     @Test
  42     public void testParameterHandlerNoParameterFile() throws PolicyDistributionException {
  43         final String[] noArgumentString =
  44         { "-c", "parameters/NoParameterFile.json" };
  45
  46         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
  47         noArguments.parse(noArgumentString);
  48
  49         try {
  50             new DistributionParameterHandler().getParameters(noArguments);
  51             fail("test should throw an exception here");
  52         } catch (final Exception e) {
  53             assertTrue(e.getMessage().contains("FileNotFoundException"));
  54         }
  55     }
  56
  57     @Test
  58     public void testParameterHandlerEmptyParameters() throws PolicyDistributionException {
  59         final String[] emptyArgumentString =
  60         { "-c", "parameters/EmptyParameters.json" };
  61
  62         final DistributionCommandLineArguments emptyArguments = new DistributionCommandLineArguments();
  63         emptyArguments.parse(emptyArgumentString);
  64
  65         try {
  66             new DistributionParameterHandler().getParameters(emptyArguments);
  67             fail("test should throw an exception here");
  68         } catch (final Exception e) {
  69             assertEquals("no parameters found in \"parameters/EmptyParameters.json\"", e.getMessage());
  70         }
  71     }
  72
  73     @Test
  74     public void testParameterHandlerBadParameters() throws PolicyDistributionException {
  75         final String[] badArgumentString =
  76         { "-c", "parameters/BadParameters.json" };
  77
  78         final DistributionCommandLineArguments badArguments = new DistributionCommandLineArguments();
  79         badArguments.parse(badArgumentString);
  80
  81         try {
  82             new DistributionParameterHandler().getParameters(badArguments);
  83             fail("test should throw an exception here");
  84         } catch (final Exception e) {
  85             assertEquals("error reading parameters from \"parameters/BadParameters.json\"\n"
  86                     + "(JsonSyntaxException):java.lang.IllegalStateException: "
  87                     + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name", e.getMessage());
  88         }
  89     }
  90
  91     @Test
  92     public void testParameterHandlerInvalidParameters() throws PolicyDistributionException {
  93         final String[] invalidArgumentString =
  94         { "-c", "parameters/InvalidParameters.json" };
  95
  96         final DistributionCommandLineArguments invalidArguments = new DistributionCommandLineArguments();
  97         invalidArguments.parse(invalidArgumentString);
  98
  99         try {
 100             new DistributionParameterHandler().getParameters(invalidArguments);
 101             fail("test should throw an exception here");
 102         } catch (final Exception e) {
 103             assertEquals("error reading parameters from \"parameters/InvalidParameters.json\"\n"
 104                     + "(JsonSyntaxException):java.lang.IllegalStateException: "
 105                     + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name", e.getMessage());
 106         }
 107     }
 108
 109     @Test
 110     public void testParameterHandlerNoParameters() throws PolicyDistributionException {
 111         final String[] noArgumentString =
 112         { "-c", "parameters/NoParameters.json" };
 113
 114         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
 115         noArguments.parse(noArgumentString);
 116
 117         try {
 118             new DistributionParameterHandler().getParameters(noArguments);
 119             fail("test should throw an exception here");
 120         } catch (final Exception e) {
 121             assertEquals("map parameter \"receptionHandlerParameters\" is null", e.getMessage());
 122         }
 123     }
 124
 125     @Test
 126     public void testParameterHandlerMinumumParameters() throws PolicyDistributionException {
 127         final String[] minArgumentString =
 128         { "-c", "parameters/MinimumParameters.json" };
 129
 130         final DistributionCommandLineArguments minArguments = new DistributionCommandLineArguments();
 131         minArguments.parse(minArgumentString);
 132
 133         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(minArguments);
 134         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 135     }
 136
 137     @Test
 138     public void testDistributionParameterGroup() throws PolicyDistributionException {
 139         final String[] distributionConfigParameters =
 140         { "-c", "parameters/DistributionConfigParameters.json" };
 141
 142         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 143         arguments.parse(distributionConfigParameters);
 144
 145         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(arguments);
 146         assertTrue(arguments.checkSetConfigurationFilePath());
 147         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 148         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE, parGroup.getReceptionHandlerParameters()
 149                 .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
 150         assertEquals(CommonTestData.DECODER_TYPE,
 151                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 152                         .getPluginHandlerParameters().getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY)
 153                         .getDecoderType());
 154         assertEquals(CommonTestData.FORWARDER_TYPE,
 155                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 156                         .getPluginHandlerParameters().getPolicyForwarders()
 157                         .get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
 158     }
 159
 160     @Test
 161     public void testDistributionParameterGroup_InvalidName() throws PolicyDistributionException {
 162         final String[] distributionConfigParameters =
 163         { "-c", "parameters/DistributionConfigParameters_InvalidName.json" };
 164
 165         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 166         arguments.parse(distributionConfigParameters);
 167
 168         try {
 169             new DistributionParameterHandler().getParameters(arguments);
 170             fail("test should throw an exception here");
 171         } catch (final Exception e) {
 172             assertTrue(e.getMessage().contains(
 173                     "field \"name\" type \"java.lang.String\" value \" \" INVALID, must be a non-blank string"));
 174         }
 175     }
 176
 177     @Test
 178     public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
 179         final String[] distributionConfigParameters =
 180         { "-c", "parameters/DistributionConfigParameters_NoReceptionHandler.json" };
 181
 182         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 183         arguments.parse(distributionConfigParameters);
 184
 185         try {
 186             new DistributionParameterHandler().getParameters(arguments);
 187             fail("test should throw an exception here");
 188         } catch (final Exception e) {
 189             assertTrue(e.getMessage().contains("map parameter \"receptionHandlerParameters\" is null"));
 190         }
 191     }
 192
 193     @Test
 194     public void testDistributionParameterGroup_EmptyReceptionHandler() throws PolicyDistributionException {
 195         final String[] distributionConfigParameters =
 196         { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandler.json" };
 197
 198         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 199         arguments.parse(distributionConfigParameters);
 200
 201         try {
 202             new DistributionParameterHandler().getParameters(arguments);
 203             fail("test should throw an exception here");
 204         } catch (final Exception e) {
 205             assertTrue(e.getMessage().contains("must have at least one reception handler\n"));
 206         }
 207     }
 208
 209     @Test
 210     public void testDistributionParameterGroup_NoPolicyDecoder() throws PolicyDistributionException {
 211         final String[] distributionConfigParameters =
 212         { "-c", "parameters/DistributionConfigParameters_NoPolicyDecoder.json" };
 213
 214         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 215         arguments.parse(distributionConfigParameters);
 216
 217         try {
 218             new DistributionParameterHandler().getParameters(arguments);
 219             fail("test should throw an exception here");
 220         } catch (final Exception e) {
 221             assertTrue(e.getMessage().contains("map parameter \"policyDecoders\" is null"));
 222         }
 223     }
 224
 225     @Test
 226     public void testDistributionParameterGroup_NoPolicyForwarder() throws PolicyDistributionException {
 227         final String[] distributionConfigParameters =
 228         { "-c", "parameters/DistributionConfigParameters_NoPolicyForwarder.json" };
 229
 230         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 231         arguments.parse(distributionConfigParameters);
 232
 233         try {
 234             new DistributionParameterHandler().getParameters(arguments);
 235             fail("test should throw an exception here");
 236         } catch (final Exception e) {
 237             assertTrue(e.getMessage().contains("map parameter \"policyForwarders\" is null"));
 238         }
 239     }
 240
 241     @Test
 242     public void testDistributionParameterGroup_EmptyPolicyDecoder() throws PolicyDistributionException {
 243         final String[] distributionConfigParameters =
 244         { "-c", "parameters/DistributionConfigParameters_EmptyPolicyDecoder.json" };
 245
 246         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 247         arguments.parse(distributionConfigParameters);
 248
 249         try {
 250             new DistributionParameterHandler().getParameters(arguments);
 251             fail("test should throw an exception here");
 252         } catch (final Exception e) {
 253             assertTrue(e.getMessage().contains("must have at least one policy decoder\n"));
 254         }
 255     }
 256
 257     @Test
 258     public void testDistributionParameterGroup_EmptyPolicyForwarder() throws PolicyDistributionException {
 259         final String[] distributionConfigParameters =
 260         { "-c", "parameters/DistributionConfigParameters_EmptyPolicyForwarder.json" };
 261
 262         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 263         arguments.parse(distributionConfigParameters);
 264
 265         try {
 266             new DistributionParameterHandler().getParameters(arguments);
 267             fail("test should throw an exception here");
 268         } catch (final Exception e) {
 269             assertTrue(e.getMessage().endsWith("must have at least one policy forwarder\n"));
 270         }
 271     }
 272
 273     @Test
 274     public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
 275             throws PolicyDistributionException, IOException {
 276         final String[] distributionConfigParameters =
 277         { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
 278
 279         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 280         arguments.parse(distributionConfigParameters);
 281
 282         try {
 283             new DistributionParameterHandler().getParameters(arguments);
 284             fail("test should throw an exception here");
 285         } catch (final Exception e) {
 286             final String expectedResult = new String(Files.readAllBytes(
 287                     Paths.get("src/test/resources/expectedValidationResults/InvalidReceptionHandlerParameters.txt")))
 288                             .replaceAll("\\s+", "");
 289             assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
 290         }
 291     }
 292
 293     @Test
 294     public void testDistributionParameterGroup_InvalidDecoderAndForwarderParameters()
 295             throws PolicyDistributionException, IOException {
 296         final String[] distributionConfigParameters =
 297         { "-c", "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json" };
 298
 299         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 300         arguments.parse(distributionConfigParameters);
 301
 302         try {
 303             new DistributionParameterHandler().getParameters(arguments);
 304             fail("test should throw an exception here");
 305         } catch (final Exception e) {
 306             final String expectedResult = new String(Files.readAllBytes(
 307                     Paths.get("src/test/resources/expectedValidationResults/InvalidDecoderAndForwarderParameters.txt")))
 308                             .replaceAll("\\s+", "");
 309             assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
 310         }
 311     }
 312
 313     @Test
 314     public void testDistributionParameterGroup_InvalidRestServerParameters()
 315             throws PolicyDistributionException, IOException {
 316         final String[] distributionConfigParameters =
 317         { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
 318
 319         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 320         arguments.parse(distributionConfigParameters);
 321
 322         try {
 323             new DistributionParameterHandler().getParameters(arguments);
 324             fail("test should throw an exception here");
 325         } catch (final Exception e) {
 326             final String expectedResult = new String(Files.readAllBytes(
 327                     Paths.get("src/test/resources/expectedValidationResults/InvalidRestServerParameters.txt")))
 328                             .replaceAll("\\s+", "");
 329             assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
 330         }
 331     }
 332
 333     @Test
 334     public void testDistributionVersion() throws PolicyDistributionException {
 335         final String[] distributionConfigParameters =
 336         { "-v" };
 337         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 338         final String version = arguments.parse(distributionConfigParameters);
 339         assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
 340     }
 341
 342     @Test
 343     public void testDistributionHelp() throws PolicyDistributionException {
 344         final String[] distributionConfigParameters =
 345         { "-h" };
 346         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 347         final String help = arguments.parse(distributionConfigParameters);
 348         assertTrue(help.startsWith("usage:"));
 349     }
 350
 351     @Test
 352     public void testDistributionInvalidOption() throws PolicyDistributionException {
 353         final String[] distributionConfigParameters =
 354         { "-d" };
 355         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 356         try {
 357             arguments.parse(distributionConfigParameters);
 358         } catch (final Exception exp) {
 359             assertTrue(exp.getMessage().startsWith("invalid command line arguments specified"));
 360         }
 361     }
 362 }