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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  *  Modifications Copyright (C) 2020 Nordix Foundation
   5  *  Modifications Copyright (C) 2020 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  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.distribution.main.parameters;
  24
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertTrue;
  28
  29 import java.io.IOException;
  30 import java.nio.file.Files;
  31 import java.nio.file.Paths;
  32 import org.junit.Test;
  33 import org.onap.policy.common.parameters.ParameterRuntimeException;
  34 import org.onap.policy.distribution.main.PolicyDistributionException;
  35 import org.onap.policy.distribution.main.startstop.DistributionCommandLineArguments;
  36 import org.onap.policy.distribution.main.testclasses.DummyPolicyDecoderParameterGroup;
  37 import org.onap.policy.distribution.main.testclasses.DummyPolicyForwarderParameterGroup;
  38
  39 /**
  40  * Class to perform unit test of DistributionParameterHandler.
  41  *
  42  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  43  */
  44 public class TestDistributionParameterHandler {
  45     @Test
  46     public void testParameterHandlerNoParameterFile() throws PolicyDistributionException {
  47         final String[] noArgumentString =
  48             { "-c", "parameters/NoParameterFile.json" };
  49
  50         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
  51         noArguments.parse(noArgumentString);
  52         assertThatThrownBy(() ->
  53             new DistributionParameterHandler().getParameters(noArguments)
  54         ).isInstanceOf(PolicyDistributionException.class).hasMessageContaining("FileNotFoundException");
  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         assertThatThrownBy(() ->
  66             new DistributionParameterHandler().getParameters(emptyArguments)
  67         ).isInstanceOf(PolicyDistributionException.class)
  68         .hasMessageContaining("no parameters found in \"parameters/EmptyParameters.json\"");
  69     }
  70
  71     @Test
  72     public void testParameterHandlerBadParameters() throws PolicyDistributionException {
  73         final String[] badArgumentString =
  74             { "-c", "parameters/BadParameters.json" };
  75
  76         final DistributionCommandLineArguments badArguments = new DistributionCommandLineArguments();
  77         badArguments.parse(badArgumentString);
  78
  79         assertThatThrownBy(() ->
  80             new DistributionParameterHandler().getParameters(badArguments)
  81         ).isInstanceOf(PolicyDistributionException.class)
  82             .hasMessageContaining("error reading parameters from \"parameters/BadParameters.json\"\n"
  83                 + "(JsonSyntaxException):java.lang.IllegalStateException: "
  84                 + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name");
  85     }
  86
  87     @Test
  88     public void testParameterHandlerInvalidParameters() throws PolicyDistributionException {
  89         final String[] invalidArgumentString =
  90             { "-c", "parameters/InvalidParameters.json" };
  91
  92         final DistributionCommandLineArguments invalidArguments = new DistributionCommandLineArguments();
  93         invalidArguments.parse(invalidArgumentString);
  94
  95         assertThatThrownBy(() ->
  96             new DistributionParameterHandler().getParameters(invalidArguments)
  97         ).isInstanceOf(PolicyDistributionException.class)
  98             .hasMessageContaining("error reading parameters from \"parameters/InvalidParameters.json\"\n"
  99                 + "(JsonSyntaxException):java.lang.IllegalStateException: "
 100                 + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name");
 101     }
 102
 103     @Test
 104     public void testParameterHandlerNoParameters() throws PolicyDistributionException {
 105         final String[] noArgumentString =
 106             { "-c", "parameters/NoParameters.json" };
 107
 108         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
 109         final DistributionParameterHandler paramHandler = new DistributionParameterHandler();
 110         noArguments.parse(noArgumentString);
 111         assertThatThrownBy(() -> paramHandler.getParameters(noArguments)).isInstanceOf(ParameterRuntimeException.class)
 112             .hasMessageContaining("map parameter \"receptionHandlerParameters\" is null");
 113     }
 114
 115     @Test
 116     public void testParameterHandlerMinumumParameters() throws PolicyDistributionException {
 117         final String[] minArgumentString =
 118             { "-c", "parameters/MinimumParameters.json" };
 119
 120         final DistributionCommandLineArguments minArguments = new DistributionCommandLineArguments();
 121         minArguments.parse(minArgumentString);
 122
 123         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(minArguments);
 124         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 125     }
 126
 127     @Test
 128     public void testDistributionParameterGroup() throws PolicyDistributionException {
 129         final String[] distributionConfigParameters =
 130             { "-c", "parameters/DistributionConfigParameters.json" };
 131
 132         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 133         arguments.parse(distributionConfigParameters);
 134
 135         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(arguments);
 136         assertTrue(arguments.checkSetConfigurationFilePath());
 137         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 138         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE, parGroup.getReceptionHandlerParameters()
 139                 .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
 140         assertEquals(CommonTestData.DECODER_TYPE,
 141                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 142                         .getPluginHandlerParameters().getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY)
 143                         .getDecoderType());
 144         assertEquals(CommonTestData.FORWARDER_TYPE,
 145                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 146                         .getPluginHandlerParameters().getPolicyForwarders()
 147                         .get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
 148         assertEquals(CommonTestData.FORWARDER_HOST,
 149                 ((DummyPolicyForwarderParameterGroup) parGroup.getPolicyForwarderConfigurationParameters()
 150                         .get(CommonTestData.FORWARDER_CONFIGURATION_PARAMETERS)).getHostname());
 151         assertEquals(CommonTestData.POLICY_TYPE,
 152                 ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
 153                         .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyType());
 154         assertEquals(CommonTestData.POLICY_NAME,
 155                 ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
 156                         .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyName());
 157     }
 158
 159     @Test
 160     public void testDistributionParameterGroup_InvalidForwarderConfigurationClassName()
 161             throws PolicyDistributionException {
 162         final String[] distributionConfigParameters =
 163             { "-c", "parameters/DistributionConfigParameters_InvalidForwarderConfigurationClassName.json" };
 164
 165         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 166         arguments.parse(distributionConfigParameters);
 167
 168         assertThatThrownBy(() ->
 169             new DistributionParameterHandler().getParameters(arguments)
 170         ).isInstanceOf(PolicyDistributionException.class)
 171             .hasMessageContaining("parameter \"parameterClassName\" value \"\" invalid in JSON file");
 172     }
 173
 174     @Test
 175     public void testDistributionParameterGroup_UnknownForwarderConfigurationClassName()
 176             throws PolicyDistributionException {
 177         final String[] distributionConfigParameters =
 178             { "-c", "parameters/DistributionConfigParameters_UnknownForwarderConfigurationClassName.json" };
 179
 180         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 181         arguments.parse(distributionConfigParameters);
 182
 183         assertThatThrownBy(() ->
 184             new DistributionParameterHandler().getParameters(arguments)
 185         ).isInstanceOf(PolicyDistributionException.class)
 186             .hasMessageContaining("parameter \"parameterClassName\" value \"org.onap.policy.Unknown\", "
 187             + "could not find class");
 188     }
 189
 190     @Test
 191     public void testDistributionParameterGroup_InvalidName() throws PolicyDistributionException {
 192         final String[] distributionConfigParameters =
 193             { "-c", "parameters/DistributionConfigParameters_InvalidName.json" };
 194
 195         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 196         arguments.parse(distributionConfigParameters);
 197
 198         assertThatThrownBy(() ->
 199             new DistributionParameterHandler().getParameters(arguments)
 200         ).isInstanceOf(PolicyDistributionException.class)
 201             .hasMessageContaining("field \"name\" type \"java.lang.String\" value \" "
 202             + "\" INVALID, must be a non-blank string");
 203     }
 204
 205     @Test
 206     public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
 207         final String[] distributionConfigParameters =
 208             { "-c", "parameters/DistributionConfigParameters_NoReceptionHandler.json" };
 209
 210         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 211         final DistributionParameterHandler paramHandler = new DistributionParameterHandler();
 212         arguments.parse(distributionConfigParameters);
 213
 214         assertThatThrownBy(() -> paramHandler.getParameters(arguments)).isInstanceOf(ParameterRuntimeException.class)
 215             .hasMessageContaining("map parameter \"receptionHandlerParameters\" is null");
 216     }
 217
 218     @Test
 219     public void testDistributionParameterGroup_EmptyReceptionHandler() throws PolicyDistributionException {
 220         final String[] distributionConfigParameters =
 221             { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandler.json" };
 222
 223         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 224         arguments.parse(distributionConfigParameters);
 225
 226         assertThatThrownBy(() ->
 227             new DistributionParameterHandler().getParameters(arguments)
 228         ).isInstanceOf(PolicyDistributionException.class)
 229             .hasMessageContaining("must have at least one reception handler\n");
 230     }
 231
 232     @Test
 233     public void testDistributionParameterGroup_NoPolicyDecoder() throws PolicyDistributionException {
 234         final String[] distributionConfigParameters =
 235             { "-c", "parameters/DistributionConfigParameters_NoPolicyDecoder.json" };
 236
 237         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 238         final DistributionParameterHandler paramHandler = new DistributionParameterHandler();
 239         arguments.parse(distributionConfigParameters);
 240
 241         assertThatThrownBy(() -> paramHandler.getParameters(arguments)).isInstanceOf(ParameterRuntimeException.class)
 242             .hasMessageContaining("map parameter \"policyDecoders\" is null");
 243     }
 244
 245     @Test
 246     public void testDistributionParameterGroup_NoPolicyForwarder() throws PolicyDistributionException {
 247         final String[] distributionConfigParameters =
 248             { "-c", "parameters/DistributionConfigParameters_NoPolicyForwarder.json" };
 249
 250         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 251         final DistributionParameterHandler paramHandler = new DistributionParameterHandler();
 252         arguments.parse(distributionConfigParameters);
 253
 254         assertThatThrownBy(() -> paramHandler.getParameters(arguments)).isInstanceOf(ParameterRuntimeException.class)
 255             .hasMessageContaining("map parameter \"policyForwarders\" is null");
 256     }
 257
 258     @Test
 259     public void testDistributionParameterGroup_EmptyPolicyDecoder() throws PolicyDistributionException {
 260         final String[] distributionConfigParameters =
 261             { "-c", "parameters/DistributionConfigParameters_EmptyPolicyDecoder.json" };
 262
 263         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 264         arguments.parse(distributionConfigParameters);
 265
 266         assertThatThrownBy(() ->
 267             new DistributionParameterHandler().getParameters(arguments)
 268         ).isInstanceOf(PolicyDistributionException.class)
 269             .hasMessageContaining("must have at least one policy decoder\n");
 270     }
 271
 272     @Test
 273     public void testDistributionParameterGroup_EmptyPolicyForwarder() throws PolicyDistributionException {
 274         final String[] distributionConfigParameters =
 275             { "-c", "parameters/DistributionConfigParameters_EmptyPolicyForwarder.json" };
 276
 277         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 278         arguments.parse(distributionConfigParameters);
 279
 280         assertThatThrownBy(() ->
 281             new DistributionParameterHandler().getParameters(arguments)
 282         ).isInstanceOf(PolicyDistributionException.class)
 283             .hasMessageContaining("must have at least one policy forwarder\n");
 284     }
 285
 286     @Test
 287     public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
 288             throws PolicyDistributionException, IOException {
 289         final String[] distributionConfigParameters =
 290             { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
 291
 292         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 293         arguments.parse(distributionConfigParameters);
 294
 295         String resultString = Files.readString(Paths.get(
 296                 "src/test/resources/expectedValidationResults/InvalidReceptionHandlerParameters.txt"))
 297                 .trim().replaceAll("\\r\\n", "\\\n");
 298         assertThatThrownBy(() ->
 299             new DistributionParameterHandler().getParameters(arguments)
 300         ).isInstanceOf(PolicyDistributionException.class)
 301             .hasMessageContaining(resultString);
 302     }
 303
 304     @Test
 305     public void testDistributionParameterGroup_InvalidDecoderAndForwarderParameters()
 306             throws PolicyDistributionException, IOException {
 307         final String[] distributionConfigParameters =
 308             { "-c", "parameters/DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json" };
 309
 310         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 311         arguments.parse(distributionConfigParameters);
 312         String resultString = new String(Files.readString(Paths.get(
 313                 "src/test/resources/expectedValidationResults/InvalidDecoderAndForwarderParameters.txt"))
 314                 .trim().replaceAll("\\r\\n", "\\\n"));
 315         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 316         .isInstanceOf(PolicyDistributionException.class)
 317             .hasMessageContaining((resultString));
 318     }
 319
 320     @Test
 321     public void testDistributionParameterGroup_InvalidRestServerParameters()
 322             throws PolicyDistributionException, IOException {
 323         final String[] distributionConfigParameters =
 324             { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
 325
 326         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 327         arguments.parse(distributionConfigParameters);
 328
 329         String resultString = new String(Files.readString(Paths.get(
 330                 "src/test/resources/expectedValidationResults/InvalidRestServerParameters.txt"))
 331                 .trim().replaceAll("\\r\\n", "\\\n"));
 332         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 333         .isInstanceOf(PolicyDistributionException.class)
 334             .hasMessageContaining(resultString);
 335     }
 336
 337     @Test
 338     public void testDistributionVersion() throws PolicyDistributionException {
 339         final String[] distributionConfigParameters =
 340             { "-v" };
 341         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 342         final String version = arguments.parse(distributionConfigParameters);
 343         assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
 344     }
 345
 346     @Test
 347     public void testDistributionHelp() throws PolicyDistributionException {
 348         final String[] distributionConfigParameters =
 349             { "-h" };
 350         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 351         final String help = arguments.parse(distributionConfigParameters);
 352         assertTrue(help.startsWith("usage:"));
 353     }
 354
 355     @Test
 356     public void testDistributionInvalidOption() throws PolicyDistributionException {
 357         final String[] distributionConfigParameters =
 358             { "-d" };
 359         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 360         assertThatThrownBy(() ->
 361             arguments.parse(distributionConfigParameters)
 362         ).isInstanceOf(PolicyDistributionException.class)
 363             .hasMessageContaining("invalid command line arguments specified");
 364     }
 365
 366     @Test
 367     public void testDistributionParameterGroup_InvalidReceptionHandlerClass() throws PolicyDistributionException {
 368         final String[] distributionConfigParameters =
 369             { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerClass.json" };
 370
 371         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 372         arguments.parse(distributionConfigParameters);
 373
 374         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 375         .isInstanceOf(PolicyDistributionException.class)
 376             .hasMessageContaining("could not find class");
 377     }
 378
 379     @Test
 380     public void testDistributionParameterGroup_EmptyReceptionHandlerClass() throws PolicyDistributionException {
 381         final String[] distributionConfigParameters =
 382             { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandlerClass.json" };
 383
 384         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 385         arguments.parse(distributionConfigParameters);
 386
 387         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 388         .isInstanceOf(PolicyDistributionException.class)
 389             .hasMessageContaining("invalid in JSON file");
 390     }
 391
 392     @Test
 393     public void testDistributionParameterGroup_InvalidDecoderConfigurationClassName()
 394             throws PolicyDistributionException {
 395         final String[] distributionConfigParameters =
 396             { "-c", "parameters/DistributionConfigParameters_InvalidDecoderConfigurationClassName.json" };
 397
 398         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 399         arguments.parse(distributionConfigParameters);
 400
 401         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 402         .isInstanceOf(PolicyDistributionException.class)
 403             .hasMessageContaining("parameter \"parameterClassName\" value \"\" invalid in JSON file");
 404     }
 405
 406     @Test
 407     public void testDistributionParameterGroup_UnknownDecoderConfigurationClassName()
 408             throws PolicyDistributionException {
 409         final String[] distributionConfigParameters =
 410             { "-c", "parameters/DistributionConfigParameters_UnknownDecoderConfigurationClassName.json" };
 411
 412         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 413         arguments.parse(distributionConfigParameters);
 414
 415         assertThatThrownBy(() -> new DistributionParameterHandler().getParameters(arguments))
 416             .isInstanceOf(PolicyDistributionException.class)
 417             .hasMessageContaining("parameter \"parameterClassName\" value"
 418                 + " \"org.onap.policy.Unknown\", could not find class");
 419     }
 420 }