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