framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java

   1 /*
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   3  * Copyright 2020 Nokia
   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
  18 package org.onap.cli.cmd.sample;
  19
  20 import static org.junit.Assert.assertEquals;
  21 import static org.junit.Assert.assertTrue;
  22 import static org.junit.Assert.fail;
  23
  24 import java.util.HashSet;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.UUID;
  29 import java.util.stream.Collectors;
  30
  31 import org.junit.Test;
  32 import org.onap.cli.fw.cmd.OnapCommand;
  33 import org.onap.cli.fw.cmd.OnapCommandType;
  34 import org.onap.cli.fw.conf.OnapCommandConstants;
  35 import org.onap.cli.fw.error.OnapCommandException;
  36 import org.onap.cli.fw.error.OnapCommandExecutionFailed;
  37 import org.onap.cli.fw.error.OnapCommandInvalidParameterValue;
  38 import org.onap.cli.fw.error.OnapCommandNotInitialized;
  39 import org.onap.cli.fw.info.OnapCommandInfo;
  40 import org.onap.cli.fw.info.OnapCommandState;
  41 import org.onap.cli.fw.input.OnapCommandParameter;
  42 import org.onap.cli.fw.input.OnapCommandParameterType;
  43 import org.onap.cli.fw.output.OnapCommandResultAttribute;
  44 import org.onap.cli.fw.registrar.OnapCommandRegistrar;
  45
  46 import org.onap.cli.fw.output.OnapCommandResult;
  47 import static org.junit.Assert.assertNotNull;
  48
  49 public class OnapCommandSampleTest {
  50
  51     private static final String SAMPLE_TEST_COMMAND_NAME = "sample-test";
  52     private static final int EXPECTED_NUMBER_OF_COMMAND_PARAMETERS = 18;
  53     private static final int EXPECTED_SIZE_OF_METADATA = 1;
  54
  55     @Test
  56     public void sampleTestVersion() {
  57
  58         try {
  59             Set<OnapCommandParameter> parameters = new HashSet<>();
  60             OnapCommandParameter version = new OnapCommandParameter();
  61             version.setName(OnapCommandConstants.DEFAULT_PARAMETER_VERSION);
  62             version.setValue(true);
  63             parameters.add(version);
  64             OnapCommandParameter hlp = new OnapCommandParameter();
  65             hlp.setName(OnapCommandConstants.DEFAULT_PARAMETER_HELP);
  66             hlp.setValue(false);
  67             parameters.add(hlp);
  68
  69             OnapCommand sample = givenOnapCommand("sample-test");
  70             sample.setParameters(parameters);
  71             sample.execute();
  72             OnapCommandResult onapCommandResult = sample.execute();
  73             assertEquals("open-cli::test",onapCommandResult.getOutput());
  74         } catch (OnapCommandException e) {
  75             fail();
  76         }
  77     }
  78
  79     @Test
  80     public void sampleTestHelp() {
  81         try {
  82             OnapCommandParameter ver = new OnapCommandParameter();
  83             ver.setName(OnapCommandConstants.DEFAULT_PARAMETER_HELP);
  84             ver.setValue(true);
  85             ver.setParameterType(OnapCommandParameterType.BOOL);
  86
  87             Set<OnapCommandParameter> parameters = new HashSet<>();
  88             parameters.add(ver);
  89
  90             OnapCommandSample sample = new OnapCommandSample();
  91             sample.setParameters(parameters);
  92             sample.execute();
  93             OnapCommandResult onapCommandResult = sample.execute();
  94             assertNotNull(onapCommandResult);
  95         } catch (OnapCommandException e) {
  96             fail();
  97         }
  98     }
  99
 100     @Test
 101     public void shouldContainValidParametersAfterChangingDefaultValueOfSelectedParameter() throws OnapCommandException {
 102         // given
 103         Set<OnapCommandParameter> parameters = new HashSet<>();
 104         OnapCommandParameter booleanParameter = givenBooleanParameter(true);
 105         parameters.add(booleanParameter);
 106
 107         // when
 108         OnapCommand onapCommand = givenOnapCommand(SAMPLE_TEST_COMMAND_NAME);
 109         onapCommand.setParameters(parameters);
 110
 111         // then
 112         final Set<OnapCommandParameter> params = onapCommand.getParameters();
 113         assertEquals(EXPECTED_NUMBER_OF_COMMAND_PARAMETERS, params.size());
 114         assertTrue(params.contains(booleanParameter));
 115         final List<OnapCommandParameter> stringParams = findParameter(params, "string-param");
 116         verifyThatParameterHasValue(stringParams, "test");
 117     }
 118
 119     @Test
 120     public void shouldContainParametersWithDefaultValuesWhenUserDoesNotChangeAnyParameter() throws OnapCommandException {
 121         // given
 122         OnapCommand onapCommand = givenOnapCommand(SAMPLE_TEST_COMMAND_NAME);
 123
 124         // when
 125         final Set<OnapCommandParameter> params = onapCommand.getParameters();
 126
 127         // then
 128         assertEquals(EXPECTED_NUMBER_OF_COMMAND_PARAMETERS, params.size());
 129         final List<OnapCommandParameter> stringParams = findParameter(params, "string-param");
 130         verifyThatParameterHasValue(stringParams, "test");
 131     }
 132
 133     @Test
 134     public void shouldContainValidInfoState() throws OnapCommandException {
 135         // given
 136         OnapCommand onapCommand = givenOnapCommand(SAMPLE_TEST_COMMAND_NAME);
 137
 138         // when
 139         final OnapCommandInfo info = onapCommand.getInfo();
 140
 141         // then
 142         assertEquals("open-cli", info.getProduct());
 143         assertEquals("test", info.getService());
 144         assertEquals(OnapCommandType.CMD, info.getCommandType());
 145         assertEquals("Kanagaraj Manickam kanagaraj.manickam@huawei.com", info.getAuthor());
 146         assertEquals(OnapCommandState.EXPERIMENTAL, info.getState());
 147         final Map<String, String> metadata = info.getMetadata();
 148         assertEquals(EXPECTED_SIZE_OF_METADATA, metadata.size());
 149         assertEquals("honolulu", metadata.get("release"));
 150     }
 151
 152     @Test
 153     public void sampleTest() {
 154
 155         try {
 156             Set<OnapCommandParameter> parameters = new HashSet<>();
 157             OnapCommandParameter ver = new OnapCommandParameter();
 158             ver.setName(OnapCommandConstants.DEFAULT_PARAMETER_VERSION);
 159             ver.setValue(false);
 160             parameters.add(ver);
 161             OnapCommandParameter hlp = new OnapCommandParameter();
 162             hlp.setName(OnapCommandConstants.DEFAULT_PARAMETER_HELP);
 163             hlp.setValue(false);
 164             parameters.add(hlp);
 165             OnapCommandParameter fmt = new OnapCommandParameter();
 166             fmt.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_FORMAT);
 167             fmt.setValue("table");
 168             parameters.add(fmt);
 169             OnapCommandParameter lng = new OnapCommandParameter();
 170             lng.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG);
 171             lng.setValue(true);
 172             parameters.add(lng);
 173             OnapCommandParameter title = new OnapCommandParameter();
 174             title.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE);
 175             title.setValue(true);
 176             parameters.add(title);
 177             OnapCommandParameter debug = new OnapCommandParameter();
 178             debug.setName(OnapCommandConstants.DEFAULT_PARAMETER_DEBUG);
 179             debug.setValue(true);
 180             parameters.add(debug);
 181
 182             OnapCommand sample = givenOnapCommand("sample-test");
 183             sample.setParameters(parameters);
 184             sample.execute();
 185
 186             //validate whether output attributes default value got initialized as part of execute()
 187             OnapCommandResultAttribute attr = sample.getResult().getRecordsMap().get("output-1");
 188             String attrValue = attr.getValues().get(0);
 189             UUID.fromString(attrValue.substring(4));
 190             attr = sample.getResult().getRecordsMap().get("output-2");
 191             attrValue = attr.getValues().get(0);
 192             assertEquals("Hello test !", attrValue);
 193         } catch (IllegalArgumentException e) {
 194             fail("Failed to replace the output default value on output-1");
 195         } catch (OnapCommandException e) {
 196             fail();
 197         }
 198     }
 199
 200     @Test(expected = OnapCommandExecutionFailed.class)
 201     public void sampleTestFailure() throws OnapCommandException {
 202         OnapCommandSample sample = new OnapCommandSample();
 203         sample.failCase = true;
 204
 205         Set<OnapCommandParameter> parameters = new HashSet();
 206         OnapCommandParameter ver = new OnapCommandParameter();
 207         ver.setName(OnapCommandConstants.DEFAULT_PARAMETER_VERSION);
 208         ver.setValue(false);
 209         parameters.add(ver);
 210         OnapCommandParameter hlp = new OnapCommandParameter();
 211         hlp.setName(OnapCommandConstants.DEFAULT_PARAMETER_HELP);
 212         hlp.setValue(false);
 213         parameters.add(hlp);
 214         OnapCommandParameter ffmt = new OnapCommandParameter();
 215         ffmt.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_FORMAT);
 216         ffmt.setValue("table");
 217         parameters.add(ffmt);
 218         OnapCommandParameter lng = new OnapCommandParameter();
 219         lng.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG);
 220         lng.setValue(true);
 221         parameters.add(lng);
 222         OnapCommandParameter titl = new OnapCommandParameter();
 223         titl.setName(OnapCommandConstants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE);
 224         titl.setValue(true);
 225         parameters.add(titl);
 226         OnapCommandParameter debug = new OnapCommandParameter();
 227         debug.setName(OnapCommandConstants.DEFAULT_PARAMETER_DEBUG);
 228         debug.setValue(true);
 229         parameters.add(debug);
 230         sample.setParameters(parameters);
 231         sample.execute();
 232     }
 233
 234     @Test(expected = OnapCommandNotInitialized.class)
 235     public void sampleTestIsInitialized() throws OnapCommandException {
 236         OnapCommandSample sample = new OnapCommandSample(false);
 237         sample.execute();
 238     }
 239
 240     private OnapCommand givenOnapCommand(String cmdName) throws OnapCommandException {
 241         return OnapCommandRegistrar.getRegistrar().get(cmdName);
 242     }
 243
 244     private OnapCommandParameter givenBooleanParameter(boolean value) throws OnapCommandInvalidParameterValue {
 245         OnapCommandParameter booleanParameter = new OnapCommandParameter();
 246         booleanParameter.setName("bool-param");
 247         booleanParameter.setLongOption("bool");
 248         booleanParameter.setShortOption("b");
 249         booleanParameter.setValue(value);
 250         return booleanParameter;
 251     }
 252
 253     private List<OnapCommandParameter> findParameter(Set<OnapCommandParameter> params, String parameterName) {
 254         return params.stream().filter(it -> it.getName().equals(parameterName)).collect(Collectors.toList());
 255     }
 256
 257     private void verifyThatParameterHasValue(List<OnapCommandParameter> stringParams, String expectedValue) {
 258         assertEquals(1, stringParams.size());
 259         assertEquals(expectedValue, stringParams.get(0).getValue());
 260     }
 261 }