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         verifyFailure("NoParameterFile.json",
  48                         PolicyDistributionException.class,
  49                         "FileNotFoundException");
  50     }
  51
  52     @Test
  53     public void testParameterHandlerEmptyParameters() throws PolicyDistributionException {
  54         verifyFailure("EmptyParameters.json",
  55                         PolicyDistributionException.class,
  56                         "no parameters found in \"parameters/EmptyParameters.json\"");
  57     }
  58
  59     @Test
  60     public void testParameterHandlerBadParameters() throws PolicyDistributionException {
  61         verifyFailure("BadParameters.json",
  62                         PolicyDistributionException.class,
  63                         "error reading parameters from \"parameters/BadParameters.json\"\n"
  64                             + "(JsonSyntaxException):java.lang.IllegalStateException: "
  65                             + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name");
  66     }
  67
  68     @Test
  69     public void testParameterHandlerInvalidParameters() throws PolicyDistributionException {
  70         verifyFailure("InvalidParameters.json",
  71                         PolicyDistributionException.class,
  72                         "error reading parameters from \"parameters/InvalidParameters.json\"\n"
  73                             + "(JsonSyntaxException):java.lang.IllegalStateException: "
  74                             + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name");
  75     }
  76
  77     @Test
  78     public void testParameterHandlerNoParameters() throws PolicyDistributionException {
  79         verifyFailure("NoParameters.json",
  80                         ParameterRuntimeException.class,
  81                         "map parameter \"receptionHandlerParameters\" is null");
  82     }
  83
  84     @Test
  85     public void testParameterHandlerMinumumParameters() throws PolicyDistributionException {
  86         final String[] minArgumentString =
  87             { "-c", "parameters/MinimumParameters.json" };
  88
  89         final DistributionCommandLineArguments minArguments = new DistributionCommandLineArguments();
  90         minArguments.parse(minArgumentString);
  91
  92         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(minArguments);
  93         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
  94     }
  95
  96     @Test
  97     public void testDistributionParameterGroup() throws PolicyDistributionException {
  98         final String[] distributionConfigParameters =
  99             { "-c", "parameters/DistributionConfigParameters.json" };
 100
 101         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 102         arguments.parse(distributionConfigParameters);
 103
 104         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(arguments);
 105         assertTrue(arguments.checkSetConfigurationFilePath());
 106         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 107         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE, parGroup.getReceptionHandlerParameters()
 108                 .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
 109         assertEquals(CommonTestData.DECODER_TYPE,
 110                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 111                         .getPluginHandlerParameters().getPolicyDecoders().get(CommonTestData.DUMMY_DECODER_KEY)
 112                         .getDecoderType());
 113         assertEquals(CommonTestData.FORWARDER_TYPE,
 114                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 115                         .getPluginHandlerParameters().getPolicyForwarders()
 116                         .get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
 117         assertEquals(CommonTestData.FORWARDER_HOST,
 118                 ((DummyPolicyForwarderParameterGroup) parGroup.getPolicyForwarderConfigurationParameters()
 119                         .get(CommonTestData.FORWARDER_CONFIGURATION_PARAMETERS)).getHostname());
 120         assertEquals(CommonTestData.POLICY_TYPE,
 121                 ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
 122                         .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyType());
 123         assertEquals(CommonTestData.POLICY_NAME,
 124                 ((DummyPolicyDecoderParameterGroup) parGroup.getPolicyDecoderConfigurationParameters()
 125                         .get(CommonTestData.DECODER_CONFIGURATION_PARAMETERS)).getPolicyName());
 126     }
 127
 128     @Test
 129     public void testDistributionParameterGroup_InvalidForwarderConfigurationClassName()
 130             throws PolicyDistributionException {
 131         verifyFailure("DistributionConfigParameters_InvalidForwarderConfigurationClassName.json",
 132                         PolicyDistributionException.class,
 133                         "parameter \"parameterClassName\" value \"\" invalid in JSON file");
 134     }
 135
 136     @Test
 137     public void testDistributionParameterGroup_UnknownForwarderConfigurationClassName()
 138             throws PolicyDistributionException {
 139         verifyFailure("DistributionConfigParameters_UnknownForwarderConfigurationClassName.json",
 140                         PolicyDistributionException.class,
 141                         "parameter \"parameterClassName\" value \"org.onap.policy.Unknown\", could not find class");
 142     }
 143
 144     @Test
 145     public void testDistributionParameterGroup_InvalidName() throws PolicyDistributionException {
 146         verifyFailure("DistributionConfigParameters_InvalidName.json",
 147                         PolicyDistributionException.class,
 148                         "field \"name\" type \"java.lang.String\" value \" \" INVALID, must be a non-blank string");
 149     }
 150
 151     @Test
 152     public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
 153         verifyFailure("DistributionConfigParameters_NoReceptionHandler.json",
 154                         ParameterRuntimeException.class,
 155                         "map parameter \"receptionHandlerParameters\" is null");
 156     }
 157
 158     @Test
 159     public void testDistributionParameterGroup_EmptyReceptionHandler() throws PolicyDistributionException {
 160         verifyFailure("DistributionConfigParameters_EmptyReceptionHandler.json",
 161                         PolicyDistributionException.class,
 162                         "must have at least one reception handler\n");
 163     }
 164
 165     @Test
 166     public void testDistributionParameterGroup_NoPolicyDecoder() throws PolicyDistributionException {
 167         verifyFailure("DistributionConfigParameters_NoPolicyDecoder.json",
 168                         ParameterRuntimeException.class,
 169                         "map parameter \"policyDecoders\" is null");
 170     }
 171
 172     @Test
 173     public void testDistributionParameterGroup_NoPolicyForwarder() throws PolicyDistributionException {
 174         verifyFailure("DistributionConfigParameters_NoPolicyForwarder.json",
 175                         ParameterRuntimeException.class,
 176                         "map parameter \"policyForwarders\" is null");
 177     }
 178
 179     @Test
 180     public void testDistributionParameterGroup_EmptyPolicyDecoder() throws PolicyDistributionException {
 181         verifyFailure("DistributionConfigParameters_EmptyPolicyDecoder.json",
 182                         PolicyDistributionException.class,
 183                         "must have at least one policy decoder\n");
 184     }
 185
 186     @Test
 187     public void testDistributionParameterGroup_EmptyPolicyForwarder() throws PolicyDistributionException {
 188         verifyFailure("DistributionConfigParameters_EmptyPolicyForwarder.json",
 189                         PolicyDistributionException.class,
 190                         "must have at least one policy forwarder\n");
 191     }
 192
 193     @Test
 194     public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
 195             throws PolicyDistributionException, IOException {
 196
 197         String resultString = Files.readString(Paths.get(
 198                         "src/test/resources/expectedValidationResults/InvalidReceptionHandlerParameters.txt"))
 199                         .trim().replaceAll("\\r\\n", "\\\n");
 200
 201         verifyFailure("DistributionConfigParameters_InvalidReceptionHandlerParameters.json",
 202                         PolicyDistributionException.class,
 203                         resultString);
 204     }
 205
 206     @Test
 207     public void testDistributionParameterGroup_InvalidDecoderAndForwarderParameters()
 208             throws PolicyDistributionException, IOException {
 209
 210         String resultString = new String(Files.readString(Paths.get(
 211                         "src/test/resources/expectedValidationResults/InvalidDecoderAndForwarderParameters.txt"))
 212                         .trim().replaceAll("\\r\\n", "\\\n"));
 213
 214         verifyFailure("DistributionConfigParameters_InvalidDecoderAndForwarderParameters.json",
 215                         PolicyDistributionException.class,
 216                         resultString);
 217     }
 218
 219     @Test
 220     public void testDistributionParameterGroup_InvalidRestServerParameters()
 221             throws PolicyDistributionException, IOException {
 222
 223         String resultString = new String(Files.readString(Paths.get(
 224                 "src/test/resources/expectedValidationResults/InvalidRestServerParameters.txt"))
 225                 .trim().replaceAll("\\r\\n", "\\\n"));
 226
 227         verifyFailure("DistributionConfigParameters_InvalidRestServerParameters.json",
 228                         PolicyDistributionException.class,
 229                         resultString);
 230     }
 231
 232     @Test
 233     public void testDistributionVersion() throws PolicyDistributionException {
 234         final String[] distributionConfigParameters =
 235             { "-v" };
 236         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 237         final String version = arguments.parse(distributionConfigParameters);
 238         assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
 239     }
 240
 241     @Test
 242     public void testDistributionHelp() throws PolicyDistributionException {
 243         final String[] distributionConfigParameters =
 244             { "-h" };
 245         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 246         final String help = arguments.parse(distributionConfigParameters);
 247         assertTrue(help.startsWith("usage:"));
 248     }
 249
 250     @Test
 251     public void testDistributionInvalidOption() throws PolicyDistributionException {
 252         final String[] distributionConfigParameters =
 253             { "-d" };
 254         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 255         assertThatThrownBy(() ->
 256             arguments.parse(distributionConfigParameters)
 257         ).isInstanceOf(PolicyDistributionException.class)
 258             .hasMessageContaining("invalid command line arguments specified");
 259     }
 260
 261     @Test
 262     public void testDistributionParameterGroup_InvalidReceptionHandlerClass() throws PolicyDistributionException {
 263         verifyFailure("DistributionConfigParameters_InvalidReceptionHandlerClass.json",
 264                         PolicyDistributionException.class, "could not find class");
 265     }
 266
 267     @Test
 268     public void testDistributionParameterGroup_EmptyReceptionHandlerClass() throws PolicyDistributionException {
 269         verifyFailure("DistributionConfigParameters_EmptyReceptionHandlerClass.json",
 270                         PolicyDistributionException.class, "invalid in JSON file");
 271     }
 272
 273     @Test
 274     public void testDistributionParameterGroup_InvalidDecoderConfigurationClassName()
 275             throws PolicyDistributionException {
 276         verifyFailure("DistributionConfigParameters_InvalidDecoderConfigurationClassName.json",
 277                         PolicyDistributionException.class,
 278                         "parameter \"parameterClassName\" value \"\" invalid in JSON file");
 279     }
 280
 281     @Test
 282     public void testDistributionParameterGroup_UnknownDecoderConfigurationClassName()
 283             throws PolicyDistributionException {
 284         verifyFailure("DistributionConfigParameters_UnknownDecoderConfigurationClassName.json",
 285                         PolicyDistributionException.class,
 286                         "parameter \"parameterClassName\" value \"org.onap.policy.Unknown\", could not find class");
 287     }
 288
 289     private <T> void verifyFailure(String fileName, Class<T> clazz, String expectedMessage)
 290                     throws PolicyDistributionException {
 291         final String[] distributionConfigParameters = {"-c", "parameters/" + fileName};
 292
 293         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 294         arguments.parse(distributionConfigParameters);
 295
 296         DistributionParameterHandler paramHandler = new DistributionParameterHandler();
 297
 298         assertThatThrownBy(() -> paramHandler.getParameters(arguments)).isInstanceOf(clazz)
 299                         .hasMessageContaining(expectedMessage);
 300     }
 301 }