artifactbroker/main/src/test/java/org/onap/policy/distribution/main/parameters/TestDistributionParameterHandler.java

   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 import org.onap.policy.distribution.main.testclasses.DummyArtifactForwarderParameterGroup;
  35
  36 /**
  37  * Class to perform unit test of DistributionParameterHandler.
  38  *
  39  * @author Ram Krishna Verma (ram.krishna.verma@ericsson.com)
  40  */
  41 public class TestDistributionParameterHandler {
  42     @Test
  43     public void testParameterHandlerNoParameterFile() throws PolicyDistributionException {
  44         final String[] noArgumentString =
  45             { "-c", "parameters/NoParameterFile.json" };
  46
  47         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
  48         noArguments.parse(noArgumentString);
  49
  50         try {
  51             new DistributionParameterHandler().getParameters(noArguments);
  52             fail("test should throw an exception here");
  53         } catch (final Exception e) {
  54             assertTrue(e.getMessage().contains("FileNotFoundException"));
  55         }
  56     }
  57
  58     @Test
  59     public void testParameterHandlerEmptyParameters() throws PolicyDistributionException {
  60         final String[] emptyArgumentString =
  61             { "-c", "parameters/EmptyParameters.json" };
  62
  63         final DistributionCommandLineArguments emptyArguments = new DistributionCommandLineArguments();
  64         emptyArguments.parse(emptyArgumentString);
  65
  66         try {
  67             new DistributionParameterHandler().getParameters(emptyArguments);
  68             fail("test should throw an exception here");
  69         } catch (final Exception e) {
  70             assertEquals("no parameters found in \"parameters/EmptyParameters.json\"", e.getMessage());
  71         }
  72     }
  73
  74     @Test
  75     public void testParameterHandlerBadParameters() throws PolicyDistributionException {
  76         final String[] badArgumentString =
  77             { "-c", "parameters/BadParameters.json" };
  78
  79         final DistributionCommandLineArguments badArguments = new DistributionCommandLineArguments();
  80         badArguments.parse(badArgumentString);
  81
  82         try {
  83             new DistributionParameterHandler().getParameters(badArguments);
  84             fail("test should throw an exception here");
  85         } catch (final Exception e) {
  86             assertEquals("error reading parameters from \"parameters/BadParameters.json\"\n"
  87                     + "(JsonSyntaxException):java.lang.IllegalStateException: "
  88                     + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name", e.getMessage());
  89         }
  90     }
  91
  92     @Test
  93     public void testParameterHandlerInvalidParameters() throws PolicyDistributionException {
  94         final String[] invalidArgumentString =
  95             { "-c", "parameters/InvalidParameters.json" };
  96
  97         final DistributionCommandLineArguments invalidArguments = new DistributionCommandLineArguments();
  98         invalidArguments.parse(invalidArgumentString);
  99
 100         try {
 101             new DistributionParameterHandler().getParameters(invalidArguments);
 102             fail("test should throw an exception here");
 103         } catch (final Exception e) {
 104             assertEquals("error reading parameters from \"parameters/InvalidParameters.json\"\n"
 105                     + "(JsonSyntaxException):java.lang.IllegalStateException: "
 106                     + "Expected a string but was BEGIN_ARRAY at line 2 column 15 path $.name", e.getMessage());
 107         }
 108     }
 109
 110     @Test
 111     public void testParameterHandlerNoParameters() throws PolicyDistributionException {
 112         final String[] noArgumentString =
 113             { "-c", "parameters/NoParameters.json" };
 114
 115         final DistributionCommandLineArguments noArguments = new DistributionCommandLineArguments();
 116         noArguments.parse(noArgumentString);
 117
 118         try {
 119             new DistributionParameterHandler().getParameters(noArguments);
 120             fail("test should throw an exception here");
 121         } catch (final Exception e) {
 122             assertEquals("map parameter \"receptionHandlerParameters\" is null", e.getMessage());
 123         }
 124     }
 125
 126     @Test
 127     public void testParameterHandlerMinumumParameters() throws PolicyDistributionException {
 128         final String[] minArgumentString =
 129             { "-c", "parameters/MinimumParameters.json" };
 130
 131         final DistributionCommandLineArguments minArguments = new DistributionCommandLineArguments();
 132         minArguments.parse(minArgumentString);
 133
 134         //final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(minArguments);
 135         //assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 136     }
 137
 138     @Test
 139     public void testDistributionParameterGroup() throws PolicyDistributionException {
 140         final String[] distributionConfigParameters =
 141             { "-c", "parameters/DistributionConfigParameters.json" };
 142
 143         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 144         arguments.parse(distributionConfigParameters);
 145
 146         final DistributionParameterGroup parGroup = new DistributionParameterHandler().getParameters(arguments);
 147         assertTrue(arguments.checkSetConfigurationFilePath());
 148         assertEquals(CommonTestData.DISTRIBUTION_GROUP_NAME, parGroup.getName());
 149         assertEquals(CommonTestData.RECEPTION_HANDLER_TYPE, parGroup.getReceptionHandlerParameters()
 150                 .get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY).getReceptionHandlerType());
 151         assertEquals(CommonTestData.FORWARDER_TYPE,
 152                 parGroup.getReceptionHandlerParameters().get(CommonTestData.DUMMY_RECEPTION_HANDLER_KEY)
 153                         .getPluginHandlerParameters().getArtifactForwarders()
 154                         .get(CommonTestData.DUMMY_ENGINE_FORWARDER_KEY).getForwarderType());
 155         assertEquals(CommonTestData.FORWARDER_HOST,
 156                 ((DummyArtifactForwarderParameterGroup) parGroup.getArtifactForwarderConfigurationParameters()
 157                         .get(CommonTestData.FORWARDER_CONFIGURATION_PARAMETERS)).getHostname());
 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         try {
 170             new DistributionParameterHandler().getParameters(arguments);
 171             fail("test should throw an exception here");
 172         } catch (final Exception e) {
 173             assertTrue(e.getMessage().contains("parameter \"parameterClassName\" value \"\" invalid in JSON file"));
 174         }
 175     }
 176
 177     @Test
 178     public void testDistributionParameterGroup_UnknownForwarderConfigurationClassName()
 179             throws PolicyDistributionException {
 180         final String[] distributionConfigParameters =
 181             { "-c", "parameters/DistributionConfigParameters_UnknownForwarderConfigurationClassName.json" };
 182
 183         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 184         arguments.parse(distributionConfigParameters);
 185
 186         try {
 187             new DistributionParameterHandler().getParameters(arguments);
 188             fail("test should throw an exception here");
 189         } catch (final Exception e) {
 190             assertTrue(e.getMessage().contains(
 191                     "parameter \"parameterClassName\" value \"org.onap.policy.Unknown\", could not find class"));
 192         }
 193     }
 194
 195     @Test
 196     public void testDistributionParameterGroup_InvalidName() throws PolicyDistributionException {
 197         final String[] distributionConfigParameters =
 198             { "-c", "parameters/DistributionConfigParameters_InvalidName.json" };
 199
 200         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 201         arguments.parse(distributionConfigParameters);
 202
 203         try {
 204             new DistributionParameterHandler().getParameters(arguments);
 205             fail("test should throw an exception here");
 206         } catch (final Exception e) {
 207             assertTrue(e.getMessage().contains(
 208                     "field \"name\" type \"java.lang.String\" value \" \" INVALID, must be a non-blank string"));
 209         }
 210     }
 211
 212     @Test
 213     public void testDistributionParameterGroup_NoReceptionHandler() throws PolicyDistributionException {
 214         final String[] distributionConfigParameters =
 215             { "-c", "parameters/DistributionConfigParameters_NoReceptionHandler.json" };
 216
 217         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 218         arguments.parse(distributionConfigParameters);
 219
 220         try {
 221             new DistributionParameterHandler().getParameters(arguments);
 222             fail("test should throw an exception here");
 223         } catch (final Exception e) {
 224             assertTrue(e.getMessage().contains("map parameter \"receptionHandlerParameters\" is null"));
 225         }
 226     }
 227
 228     @Test
 229     public void testDistributionParameterGroup_EmptyReceptionHandler() throws PolicyDistributionException {
 230         final String[] distributionConfigParameters =
 231             { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandler.json" };
 232
 233         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 234         arguments.parse(distributionConfigParameters);
 235
 236         try {
 237             new DistributionParameterHandler().getParameters(arguments);
 238             fail("test should throw an exception here");
 239         } catch (final Exception e) {
 240             assertTrue(e.getMessage().contains("must have at least one reception handler\n"));
 241         }
 242     }
 243
 244     @Test
 245     public void testDistributionParameterGroup_NoArtifactForwarder() throws PolicyDistributionException {
 246         final String[] distributionConfigParameters =
 247             { "-c", "parameters/DistributionConfigParameters_NoArtifactForwarder.json" };
 248
 249         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 250         arguments.parse(distributionConfigParameters);
 251
 252         try {
 253             new DistributionParameterHandler().getParameters(arguments);
 254             fail("test should throw an exception here");
 255         } catch (final Exception e) {
 256             assertTrue(e.getMessage().contains("map parameter \"artifactForwarders\" is null"));
 257         }
 258     }
 259
 260     @Test
 261     public void testDistributionParameterGroup_EmptyArtifactForwarder() throws PolicyDistributionException {
 262         final String[] distributionConfigParameters =
 263             { "-c", "parameters/DistributionConfigParameters_EmptyArtifactForwarder.json" };
 264
 265         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 266         arguments.parse(distributionConfigParameters);
 267
 268         try {
 269             new DistributionParameterHandler().getParameters(arguments);
 270             fail("test should throw an exception here");
 271         } catch (final Exception e) {
 272             System.out.println("libo result is " + e.getMessage());
 273             assertTrue(e.getMessage().endsWith("must have at least one policy forwarder\n"));
 274         }
 275     }
 276
 277     @Test
 278     public void testDistributionParameterGroup_InvalidReceptionHandlerParameters()
 279             throws PolicyDistributionException, IOException {
 280         final String[] distributionConfigParameters =
 281             { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerParameters.json" };
 282
 283         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 284         arguments.parse(distributionConfigParameters);
 285
 286         try {
 287             new DistributionParameterHandler().getParameters(arguments);
 288             fail("test should throw an exception here");
 289         } catch (final Exception e) {
 290             final String expectedResult = new String(Files.readAllBytes(
 291                     Paths.get("src/test/resources/expectedValidationResults/InvalidReceptionHandlerParameters.txt")))
 292                             .replaceAll("\\s+", "");
 293             assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
 294         }
 295     }
 296
 297     @Test
 298     public void testDistributionParameterGroup_InvalidRestServerParameters()
 299             throws PolicyDistributionException, IOException {
 300         final String[] distributionConfigParameters =
 301             { "-c", "parameters/DistributionConfigParameters_InvalidRestServerParameters.json" };
 302
 303         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 304         arguments.parse(distributionConfigParameters);
 305
 306         try {
 307             new DistributionParameterHandler().getParameters(arguments);
 308             fail("test should throw an exception here");
 309         } catch (final Exception e) {
 310             final String expectedResult = new String(Files.readAllBytes(
 311                     Paths.get("src/test/resources/expectedValidationResults/InvalidRestServerParameters.txt")))
 312                             .replaceAll("\\s+", "");
 313             assertEquals(expectedResult, e.getMessage().replaceAll("\\s+", ""));
 314         }
 315     }
 316
 317     @Test
 318     public void testDistributionVersion() throws PolicyDistributionException {
 319         final String[] distributionConfigParameters =
 320             { "-v" };
 321         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 322         final String version = arguments.parse(distributionConfigParameters);
 323         assertTrue(version.startsWith("ONAP Policy Framework Distribution Service"));
 324     }
 325
 326     @Test
 327     public void testDistributionHelp() throws PolicyDistributionException {
 328         final String[] distributionConfigParameters =
 329             { "-h" };
 330         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 331         final String help = arguments.parse(distributionConfigParameters);
 332         assertTrue(help.startsWith("usage:"));
 333     }
 334
 335     @Test
 336     public void testDistributionInvalidOption() throws PolicyDistributionException {
 337         final String[] distributionConfigParameters =
 338             { "-d" };
 339         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 340         try {
 341             arguments.parse(distributionConfigParameters);
 342         } catch (final Exception exp) {
 343             assertTrue(exp.getMessage().startsWith("invalid command line arguments specified"));
 344         }
 345     }
 346
 347     @Test
 348     public void testDistributionParameterGroup_InvalidReceptionHandlerClass() throws PolicyDistributionException {
 349         final String[] distributionConfigParameters =
 350             { "-c", "parameters/DistributionConfigParameters_InvalidReceptionHandlerClass.json" };
 351
 352         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 353         arguments.parse(distributionConfigParameters);
 354
 355         try {
 356             new DistributionParameterHandler().getParameters(arguments);
 357         } catch (final Exception e) {
 358             assertTrue(e.getMessage().contains("could not find class"));
 359         }
 360     }
 361
 362     @Test
 363     public void testDistributionParameterGroup_EmptyReceptionHandlerClass() throws PolicyDistributionException {
 364         final String[] distributionConfigParameters =
 365             { "-c", "parameters/DistributionConfigParameters_EmptyReceptionHandlerClass.json" };
 366
 367         final DistributionCommandLineArguments arguments = new DistributionCommandLineArguments();
 368         arguments.parse(distributionConfigParameters);
 369
 370         try {
 371             new DistributionParameterHandler().getParameters(arguments);
 372         } catch (final Exception e) {
 373             assertTrue(e.getMessage().contains("invalid in JSON file"));
 374         }
 375     }
 376
 377 }