main/src/test/java/org/onap/cli/main/utils/OnapCliUtilsTest.java

   1 /*
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.cli.main.utils;
  18
  19 import java.io.File;
  20 import java.util.Arrays;
  21 import java.util.HashSet;
  22 import java.util.List;
  23 import java.util.Set;
  24
  25 import org.junit.Assert;
  26 import org.junit.Test;
  27 import org.onap.cli.fw.error.OnapCommandException;
  28 import org.onap.cli.fw.input.OnapCommandParameter;
  29 import org.onap.cli.fw.input.OnapCommandParameterType;
  30 import org.onap.cli.main.error.OnapCliArgumentValueMissing;
  31 import org.onap.cli.main.error.OnapCliInvalidArgument;
  32
  33 public class OnapCliUtilsTest {
  34
  35     @Test
  36     public void testpopulateParamsLong() throws OnapCommandException {
  37         OnapCommandParameter param1 = new OnapCommandParameter();
  38         param1.setLongOption("host-username");
  39         param1.setName("host-username");
  40         param1.setParameterType(OnapCommandParameterType.STRING);
  41         OnapCommandParameter param2 = new OnapCommandParameter();
  42         param2.setLongOption("host-password");
  43         param2.setName("host-password");
  44         param2.setParameterType(OnapCommandParameterType.STRING);
  45         OnapCommandParameter param3 = new OnapCommandParameter();
  46         param3.setLongOption("host-url");
  47         param3.setName("host-url");
  48         param3.setParameterType(OnapCommandParameterType.STRING);
  49         OnapCommandParameter param4 = new OnapCommandParameter();
  50         param4.setLongOption("string-param");
  51         param4.setName("string-param");
  52         param4.setParameterType(OnapCommandParameterType.STRING);
  53         OnapCommandParameter param5 = new OnapCommandParameter();
  54         param5.setLongOption("long-opt");
  55         param5.setName("long-opt");
  56         param5.setParameterType(OnapCommandParameterType.STRING);
  57
  58         Set<OnapCommandParameter> paramslist = new HashSet<>();
  59         paramslist.add(param1);
  60         paramslist.add(param2);
  61         paramslist.add(param3);
  62         paramslist.add(param4);
  63         paramslist.add(param5);
  64
  65         String[] args = new String[] {
  66             "--host-username", "admin",
  67             "--host-password", "123",
  68             "--host-url", "a@b.com",
  69             "--string-param", "blah",
  70             "--long-opt", "10" };
  71         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
  72         List<String> expectedList = Arrays.asList(args);
  73
  74         Assert.assertEquals("host-username", expectedList.get(1), param1.getValue());
  75         Assert.assertEquals("host-password", expectedList.get(3), param2.getValue());
  76         Assert.assertEquals("host-url", expectedList.get(5), param3.getValue());
  77         Assert.assertEquals("string-param", expectedList.get(7), param4.getValue());
  78         Assert.assertEquals("long-opt", expectedList.get(9), param5.getValue());
  79
  80     }
  81
  82     @Test
  83     public void testpositionalargs() throws OnapCommandException {
  84         OnapCommandParameter paramargs = new OnapCommandParameter();
  85         paramargs.setParameterType(OnapCommandParameterType.STRING);
  86         paramargs.setName("test");
  87         Set<OnapCommandParameter> paramslist = new HashSet<>();
  88         paramslist.add(paramargs);
  89
  90         String[] args = new String[] { "positional-args"};
  91
  92         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
  93
  94         List<String> expectedList = Arrays.asList(args);
  95         Assert.assertEquals(expectedList.get(0), paramslist.iterator().next().getValue());
  96     }
  97
  98     @Test
  99     public void testboolparamslong() throws OnapCommandException {
 100         OnapCommandParameter boolparam = new OnapCommandParameter();
 101         boolparam.setLongOption("bool");
 102         boolparam.setName("bool-param");
 103         Set<OnapCommandParameter> paramslist = new HashSet<>();
 104         paramslist.add(boolparam);
 105         String[] args = new String[] {  "--bool" };
 106
 107         boolparam.setParameterType(OnapCommandParameterType.BOOL);
 108         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 109         List<String> expectedList = Arrays.asList(args);
 110         Assert.assertNotNull(expectedList.get(0), paramslist.iterator().next().getValue());
 111
 112     }
 113
 114     @Test
 115     public void testboolparamsshort() throws OnapCommandException {
 116         OnapCommandParameter boolparam = new OnapCommandParameter();
 117         boolparam.setShortOption("b");
 118         boolparam.setName("bool-param");
 119         Set<OnapCommandParameter> paramslist = new HashSet<>();
 120         paramslist.add(boolparam);
 121         String[] args = new String[] {  "-b", };
 122
 123         boolparam.setParameterType(OnapCommandParameterType.BOOL);
 124         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 125         List<String> expectedList = Arrays.asList(args);
 126         Assert.assertNotNull(expectedList.get(0), paramslist.iterator().next().getValue());
 127     }
 128
 129     @Test
 130     public void testTextparamslong() throws OnapCommandException {
 131         OnapCommandParameter boolparam = new OnapCommandParameter();
 132         boolparam.setLongOption("text-param");
 133         boolparam.setName("text-param");
 134         Set<OnapCommandParameter> paramslist = new HashSet<>();
 135         paramslist.add(boolparam);
 136         String[] args = new String[] {  "--text-param" , "text"};
 137
 138         boolparam.setParameterType(OnapCommandParameterType.TEXT);
 139         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 140         List<String> expectedList = Arrays.asList(args);
 141         Assert.assertNotNull(expectedList.get(1), paramslist.iterator().next().getValue());
 142
 143     }
 144
 145     @Test
 146     public void testTextparamsshort() throws OnapCommandException {
 147         OnapCommandParameter boolparam = new OnapCommandParameter();
 148         boolparam.setShortOption("e");
 149         boolparam.setName("text-param");
 150         Set<OnapCommandParameter> paramslist = new HashSet<>();
 151         paramslist.add(boolparam);
 152         String[] args = new String[] {  "-e" , "text"};
 153
 154         boolparam.setParameterType(OnapCommandParameterType.TEXT);
 155         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 156         List<String> expectedList = Arrays.asList(args);
 157         Assert.assertNotNull(expectedList.get(1), paramslist.iterator().next().getValue());
 158     }
 159
 160     @Test
 161     public void testjsonparamsshort() throws OnapCommandException {
 162         OnapCommandParameter jsonparam = new OnapCommandParameter();
 163         jsonparam.setShortOption("j");
 164         jsonparam.setName("json-param");
 165         Set<OnapCommandParameter> paramslist = new HashSet<>();
 166         paramslist.add(jsonparam);
 167         File resourcesDirectory = new File("src/test/resources/sampletest.json");
 168         String[] args = new String[] {  "-j", "file:" + resourcesDirectory };
 169         jsonparam.setParameterType(OnapCommandParameterType.JSON);
 170         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 171         List<String> expectedList = Arrays.asList(args);
 172         Assert.assertNotNull(expectedList.get(1), paramslist.iterator().next().getValue());
 173     }
 174
 175     @Test
 176     public void testjsonparamslong() throws OnapCommandException {
 177         OnapCommandParameter jsonparam = new OnapCommandParameter();
 178         jsonparam.setLongOption("json-param");
 179         jsonparam.setName("json-param");
 180         Set<OnapCommandParameter> paramslist = new HashSet<>();
 181         paramslist.add(jsonparam);
 182         File resourcesDirectory = new File("src/test/resources/sampletest.json");
 183         String[] args = new String[] {  "--json-param", "file:" + resourcesDirectory };
 184         jsonparam.setParameterType(OnapCommandParameterType.JSON);
 185         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 186         List<String> expectedList = Arrays.asList(args);
 187         Assert.assertNotNull(expectedList.get(1), paramslist.iterator().next().getValue());
 188     }
 189
 190     @Test
 191     public void testpopulateParamsShort() throws OnapCommandException {
 192
 193         OnapCommandParameter param1 = new OnapCommandParameter();
 194         param1.setShortOption("u");
 195         param1.setName("host-username");
 196         param1.setParameterType(OnapCommandParameterType.STRING);
 197         OnapCommandParameter param2 = new OnapCommandParameter();
 198         param2.setShortOption("p");
 199         param2.setName("host-password");
 200         param2.setParameterType(OnapCommandParameterType.STRING);
 201         OnapCommandParameter param3 = new OnapCommandParameter();
 202         param3.setShortOption("r");
 203         param3.setName("host-url");
 204         param3.setParameterType(OnapCommandParameterType.STRING);
 205         OnapCommandParameter param4 = new OnapCommandParameter();
 206         param4.setShortOption("c");
 207         param4.setName("string-param");
 208         param4.setParameterType(OnapCommandParameterType.STRING);
 209         OnapCommandParameter param5 = new OnapCommandParameter();
 210         param5.setShortOption("l");
 211         param5.setName("long-opt");
 212         param5.setParameterType(OnapCommandParameterType.STRING);
 213
 214         Set<OnapCommandParameter> paramslist = new HashSet<>();
 215         paramslist.add(param1);
 216         paramslist.add(param2);
 217         paramslist.add(param3);
 218         paramslist.add(param4);
 219         paramslist.add(param5);
 220
 221         String[] args11 = new String[] {
 222             "-u", "admin",
 223             "-p", "123",
 224             "-r", "a@b.com",
 225             "-c", "blah",
 226             "-l", "10", };
 227         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args11));
 228
 229         List<String> expectedList = Arrays.asList(args11);
 230
 231         Assert.assertEquals("u", expectedList.get(1), param1.getValue());
 232         Assert.assertEquals("-p", expectedList.get(3), param2.getValue());
 233         Assert.assertEquals("r", expectedList.get(5), param3.getValue());
 234         Assert.assertEquals("c", expectedList.get(7), param4.getValue());
 235         Assert.assertEquals("l", expectedList.get(9), param5.getValue());
 236     }
 237
 238     @Test
 239     public void testArrayparamslong() throws OnapCommandException {
 240         OnapCommandParameter arrayval = new OnapCommandParameter();
 241         arrayval.setLongOption("node-ip");
 242         arrayval.setName("node-ip");
 243
 244         String[] args = new String[] {  "--node-ip", "{}" };
 245         Set<OnapCommandParameter> paramslist = new HashSet<>();
 246         paramslist.add(arrayval);
 247
 248         arrayval.setParameterType(OnapCommandParameterType.ARRAY);
 249         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 250
 251         List<String> expectedList = Arrays.asList(args);
 252         Assert.assertNotNull(expectedList.get(1), paramslist.iterator().next().getValue());
 253     }
 254
 255     @Test
 256     public void testMapparamsShort() throws OnapCommandException {
 257         OnapCommandParameter param1 = new OnapCommandParameter();
 258         param1.setLongOption("map");
 259         param1.setName("MAP");
 260         param1.setParameterType(OnapCommandParameterType.MAP);
 261         Set<OnapCommandParameter> paramslist = new HashSet<>();
 262         paramslist.add(param1);
 263
 264         param1.setParameterType(OnapCommandParameterType.MAP);
 265         OnapCliArgsParser.populateParams(paramslist,
 266                 Arrays.asList("--map", "param1=value1", "--map", "param2=value2"));
 267
 268         Assert.assertEquals("{param1=value1, param2=value2}",
 269             paramslist.iterator().next().getValue().toString());
 270     }
 271
 272     @Test(expected = OnapCliInvalidArgument.class)
 273     public void testMapparamsLongfail() throws OnapCommandException {
 274         OnapCommandParameter param1 = new OnapCommandParameter();
 275         param1.setLongOption("map");
 276         param1.setName("MAP");
 277         param1.setParameterType(OnapCommandParameterType.MAP);
 278         Set<OnapCommandParameter> paramslist = new HashSet<>();
 279         paramslist.add(param1);
 280
 281         param1.setParameterType(OnapCommandParameterType.MAP);
 282         OnapCliArgsParser.populateParams(paramslist,
 283                 Arrays.asList("show", "--map", "param1=value1", "--map", "param2"));
 284     }
 285
 286     @Test(expected = OnapCliInvalidArgument.class)
 287     public void testMapparamsShortfail() throws OnapCommandException {
 288         OnapCommandParameter param1 = new OnapCommandParameter();
 289         param1.setShortOption("o");
 290         param1.setName("node-port");
 291         param1.setParameterType(OnapCommandParameterType.MAP);
 292         Set<OnapCommandParameter> paramslist = new HashSet<>();
 293         paramslist.add(param1);
 294         param1.setParameterType(OnapCommandParameterType.MAP);
 295         OnapCliArgsParser.populateParams(paramslist,
 296                 Arrays.asList("show", "-o", "param1=value1", "-o", "param2"));
 297     }
 298
 299     @Test(expected = OnapCliInvalidArgument.class)
 300     public void testpositionalargsfails() throws OnapCommandException {
 301         OnapCommandParameter paramargs = new OnapCommandParameter();
 302         paramargs.setName("http://localhost:8082/file.txt");
 303         Set<OnapCommandParameter> paramslist = new HashSet<>();
 304         paramslist.add(paramargs);
 305         String[] args = new String[] {
 306             "positional-args",
 307             "http://localhost:8082/file.txt",
 308             "http://localhost:8082/file.txt" };
 309         paramargs.setParameterType(OnapCommandParameterType.STRING);
 310         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 311         List<String> expectedList = Arrays.asList(args);
 312     }
 313
 314     @Test(expected = OnapCliInvalidArgument.class)
 315     public void testboolparamsshortfails() throws OnapCommandException {
 316         OnapCommandParameter boolparam = new OnapCommandParameter();
 317         boolparam.setShortOption("b");
 318         boolparam.setName("bool-param");
 319         Set<OnapCommandParameter> paramslist = new HashSet<>();
 320         paramslist.add(boolparam);
 321         String[] args = new String[] {  "-b", "-b", "-h" };
 322
 323         boolparam.setParameterType(OnapCommandParameterType.BOOL);
 324         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 325     }
 326
 327     @Test(expected = OnapCliInvalidArgument.class)
 328     public void testboolparamsLongfails() throws OnapCommandException {
 329         OnapCommandParameter boolparam = new OnapCommandParameter();
 330         boolparam.setShortOption("bool");
 331         boolparam.setName("bool-param");
 332         Set<OnapCommandParameter> paramslist = new HashSet<>();
 333         paramslist.add(boolparam);
 334         String[] args = new String[] {  "--bool", "--bool", "--help" };
 335
 336         boolparam.setParameterType(OnapCommandParameterType.BOOL);
 337         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 338     }
 339
 340     @Test(expected = OnapCliArgumentValueMissing.class)
 341     public void testjsonparamslongfails() throws OnapCommandException {
 342         OnapCommandParameter jsonparam = new OnapCommandParameter();
 343         jsonparam.setLongOption("json-param");
 344         jsonparam.setName("json-param");
 345         Set<OnapCommandParameter> paramslist = new HashSet<>();
 346         paramslist.add(jsonparam);
 347         File resourcesDirectory = new File("src/test/resources/sampletest.json");
 348         String[] args = new String[] {
 349              "--json-param",
 350             "file:" + resourcesDirectory, "--json-param" };
 351         jsonparam.setParameterType(OnapCommandParameterType.JSON);
 352         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 353
 354     }
 355
 356     @Test(expected = OnapCliArgumentValueMissing.class)
 357     public void testjsonparamsshortfails() throws OnapCommandException {
 358         OnapCommandParameter jsonparam = new OnapCommandParameter();
 359         jsonparam.setShortOption("j");
 360         jsonparam.setName("json-param");
 361         Set<OnapCommandParameter> paramslist = new HashSet<>();
 362         paramslist.add(jsonparam);
 363         File resourcesDirectory = new File("src/test/resources/sampletest.json");
 364         String[] args = new String[] {  "-j", "file:" + resourcesDirectory, "-j" };
 365         jsonparam.setParameterType(OnapCommandParameterType.JSON);
 366         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 367
 368     }
 369
 370     @Test
 371     public void testArrayCommandArg() throws OnapCommandException {
 372         OnapCommandParameter arrParam = new OnapCommandParameter();
 373         arrParam.setShortOption("q");
 374         arrParam.setParameterType(OnapCommandParameterType.ARRAY);
 375         arrParam.setName("array-param");
 376         Set<OnapCommandParameter> paramslist = new HashSet<>();
 377         paramslist.add(arrParam);
 378         String[] args = new String[] {  "-q", "test1", "-q", "test2" };
 379
 380         OnapCliArgsParser.populateParams(paramslist, Arrays.asList(args));
 381         Assert.assertTrue(((List<String>) arrParam.getValue())
 382                 .containsAll(Arrays.asList("test1", "test2")));
 383     }
 384     @Test
 385     public void testReadYamlStringFromUrl() throws OnapCommandException {
 386         OnapCommandParameter param1 = new OnapCommandParameter();
 387         param1.setLongOption("yaml");
 388         param1.setName("name");
 389         param1.setParameterType(OnapCommandParameterType.YAML);
 390         Set<OnapCommandParameter> paramslist = new HashSet<>();
 391         paramslist.add(param1);
 392         OnapCliArgsParser.populateParams(paramslist,
 393                 Arrays.asList("--yaml", "name", "--yaml", "test-schema"));
 394         Assert.assertEquals("test-schema", paramslist.iterator().next().getValue());
 395     }
 396     @Test
 397     public void testReadYamlStringFromUrlForFile() throws OnapCommandException {
 398         OnapCommandParameter param1 = new OnapCommandParameter();
 399         param1.setLongOption("yaml");
 400         param1.setName("name");
 401         param1.setParameterType(OnapCommandParameterType.YAML);
 402         Set<OnapCommandParameter> paramslist = new HashSet<>();
 403         paramslist.add(param1);
 404         OnapCliArgsParser.populateParams(paramslist,
 405                         Arrays.asList("--yaml", "main/src/test/resources/open-cli-schema/sample-test-schema.yaml", "--yaml", "test-schema"));
 406         Assert.assertEquals("test-schema", paramslist.iterator().next().getValue());
 407     }
 408 }