diff options
Diffstat (limited to 'main/src')
17 files changed, 1735 insertions, 0 deletions
diff --git a/main/src/main/java/org/onap/cli/main/OnapCli.java b/main/src/main/java/org/onap/cli/main/OnapCli.java new file mode 100644 index 00000000..05daf116 --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/OnapCli.java @@ -0,0 +1,267 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main; + +import org.apache.commons.io.IOUtils; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandRegistrar; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandWarning; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.output.OnapCommandResult; +import org.onap.cli.main.conf.OnapCliConstants; +import org.onap.cli.main.interactive.StringCompleter; +import org.onap.cli.main.utils.OnapCliUtils; + +import jline.TerminalFactory; +import jline.console.ConsoleReader; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * Onap Command Line Interface (CLI). + * + */ +public class OnapCli { + + private List<String> args = new ArrayList<>(); + + private int exitCode = -1; + + public OnapCli(String[] args) { + this.args = Arrays.asList(args); + } + + private void exitSuccessfully() { + this.exitCode = OnapCliConstants.EXIT_SUCCESS; + } + + private void exitFailure() { + this.exitCode = OnapCliConstants.EXIT_FAILURE; + } + + private void print(String msg) { + System.out.println(msg); + } + + private void print(Throwable throwable) { + System.out.println(throwable.getMessage()); + } + + private String getShortOption(String opt) { + return OnapCommandParameter.printShortOption(opt); + } + + private String getLongOption(String opt) { + return OnapCommandParameter.printLongOption(opt); + } + + public int getExitCode() { + return this.exitCode; + } + + /** + * Handles help. --help or -h + */ + public void handleHelp() { + try { + // By default, it prints help + if ((args.isEmpty()) + || ((args.size() == 1) && (this.getLongOption(OnapCliConstants.PARAM_HELP_LOGN).equals(args.get(0)) + || this.getShortOption(OnapCliConstants.PARAM_HELP_SHORT).equals(args.get(0))))) { + this.print(IOUtils.toString(this.getClass().getClassLoader().getResourceAsStream("onap-readme.txt"))); + String help = OnapCommandRegistrar.getRegistrar().getHelp(); + this.print(help); + this.exitSuccessfully(); + } + } catch (Exception e) { + this.print(e); + this.exitFailure(); + } + } + + /** + * Handles version. --version or -v + */ + public void handleVersion() { + try { + if ((args.size() == 1) && (this.getLongOption(OnapCliConstants.PARAM_VERSION_LONG).equals(args.get(0)) + || this.getShortOption(OnapCliConstants.PARAM_VERSION_SHORT).equals(args.get(0)))) { + String version = OnapCommandRegistrar.getRegistrar().getVersion(); + this.print(version); + this.exitSuccessfully(); + } + } catch (Exception e) { + this.print(e); + this.exitFailure(); + } + } + + /** + * Handles Interactive Mode. --interactive or -i + */ + public void handleInteractive() { // NOSONAR + if (isInteractive()) { + ConsoleReader console = null; + try { + console = createConsoleReader(); + String line = null; + while ((line = console.readLine()) != null) { + if (OnapCliConstants.PARAM_INTERACTIVE_EXIT.equalsIgnoreCase(line) + || OnapCliConstants.PARAM_INTERACTIVE_BYE.equalsIgnoreCase(line)) { + break; + } else if (OnapCliConstants.PARAM_INTERACTIVE_CLEAR.equalsIgnoreCase(line)) { + console.clearScreen(); + continue; + } + this.args = Arrays.asList(line.split(OnapCliConstants.PARAM_INTERACTIVE_ARG_SPLIT_PATTERN)); + handleCommand(); + } + } catch (IOException e) { // NOSONAR + this.print("Failed to read console, " + e.getMessage()); + } finally { + try { + TerminalFactory.get().restore(); + } catch (Exception e) { // NOSONAR + } + if (console != null) { + console.close(); + } + this.exitSuccessfully(); + } + } + } + + /** + * Checks if the command is interactive. + * + * @return boolean + */ + public boolean isInteractive() { + if ((args.size() == 1) && (this.getLongOption(OnapCliConstants.PARAM_INTERACTIVE_LONG).equals(args.get(0)) + || this.getShortOption(OnapCliConstants.PARAM_INTERACTIVE_SHORT).equals(args.get(0)))) { + return true; + } + + return false; + } + + /** + * Creates console reader object. + * + * @return ConsoleReader + * @throws IOException + * exception + */ + private ConsoleReader createConsoleReader() throws IOException { + ConsoleReader console = new ConsoleReader(); + try { + StringCompleter strCompleter = new StringCompleter(OnapCommandRegistrar.getRegistrar().listCommands()); + strCompleter.add(OnapCliConstants.PARAM_INTERACTIVE_EXIT, + OnapCliConstants.PARAM_INTERACTIVE_CLEAR); + console.addCompleter(strCompleter); + console.setPrompt(OnapCliConstants.PARAM_INTERACTIVE_PROMPT); + } catch (OnapCommandException e) { // NOSONAR + this.print("Failed to load onap commands," + e.getMessage()); + } + + return console; + } + + /** + * Handles command. + */ + public void handleCommand() { + OnapCommand cmd; + if (!args.isEmpty()) { + try { + cmd = OnapCommandRegistrar.getRegistrar().get(args.get(0)); + } catch (Exception e) { + this.print(e); + this.exitFailure(); + return; + } + try { + // check for help or version + if (args.size() == 2) { + if (this.getLongOption(OnapCliConstants.PARAM_HELP_LOGN).equals(args.get(1)) + || this.getShortOption(OnapCliConstants.PARAM_HELP_SHORT).equals(args.get(1))) { + String help = cmd.printHelp(); + this.print(help); + this.exitSuccessfully(); + return; + } else if (this.getLongOption(OnapCliConstants.PARAM_VERSION_LONG).equals(args.get(1)) + || this.getShortOption(OnapCliConstants.PARAM_VERSION_SHORT).equals(args.get(1))) { + String version = cmd.printVersion(); + this.print(version); + this.exitSuccessfully(); + return; + } + } + + OnapCliUtils.populateParams(cmd.getParameters(), args); + OnapCommandResult result = cmd.execute(); + this.print(result.getDebugInfo()); + this.print(result.print()); + this.exitSuccessfully(); + } catch (Exception e) { + this.print(cmd.getResult().getDebugInfo()); + if (e instanceof OnapCommandWarning) { + this.exitSuccessfully(); + } else { + this.print(e); + this.exitFailure(); + } + } + } + } + + /** + * Handles all client input. + */ + public void handle() { + this.handleHelp(); + + if (this.exitCode == -1) { + this.handleVersion(); + } + + if (this.exitCode == -1) { + this.handleInteractive(); + } + + if (this.exitCode == -1) { + this.handleCommand(); + } + } + + /** + * Main method. + * + * @param args + * array + */ + public static void main(String[] args) { + OnapCli cli = new OnapCli(args); + cli.handle(); + System.exit(cli.getExitCode()); + } + +} diff --git a/main/src/main/java/org/onap/cli/main/conf/OnapCliConstants.java b/main/src/main/java/org/onap/cli/main/conf/OnapCliConstants.java new file mode 100644 index 00000000..7fb51cbe --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/conf/OnapCliConstants.java @@ -0,0 +1,39 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.conf; + +public final class OnapCliConstants { + + public static final String PARAM_HELP_SHORT = "h"; + public static final String PARAM_HELP_LOGN = "help"; + + public static final String PARAM_VERSION_SHORT = "v"; + public static final String PARAM_VERSION_LONG = "version"; + + public static final int EXIT_SUCCESS = 0; + public static final int EXIT_FAILURE = 1; + + public static final String PARAM_INTERACTIVE_SHORT = "i"; + public static final String PARAM_INTERACTIVE_LONG = "interactive"; + public static final String PARAM_INTERACTIVE_PROMPT = "onap>"; + public static final String PARAM_INTERACTIVE_EXIT = "exit"; + public static final String PARAM_INTERACTIVE_BYE = "bye"; + public static final String PARAM_INTERACTIVE_CLEAR = "clear"; + public static final String PARAM_INTERACTIVE_ARG_SPLIT_PATTERN = "\\s+"; + + private OnapCliConstants(){} +} diff --git a/main/src/main/java/org/onap/cli/main/error/OnapCliArgumentValueMissing.java b/main/src/main/java/org/onap/cli/main/error/OnapCliArgumentValueMissing.java new file mode 100644 index 00000000..f8f86e46 --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/error/OnapCliArgumentValueMissing.java @@ -0,0 +1,32 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.error; + +import org.onap.cli.fw.error.OnapCommandException; + +/** + * CLI argument missing. + * + */ +public class OnapCliArgumentValueMissing extends OnapCommandException { + + private static final long serialVersionUID = -6362824415803063442L; + + public OnapCliArgumentValueMissing(String arg) { + super("0x1001", "Value for argument " + arg + " is missing"); + } +} diff --git a/main/src/main/java/org/onap/cli/main/error/OnapCliInvalidArgument.java b/main/src/main/java/org/onap/cli/main/error/OnapCliInvalidArgument.java new file mode 100644 index 00000000..32d8ef6f --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/error/OnapCliInvalidArgument.java @@ -0,0 +1,42 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.error; + +import org.onap.cli.fw.error.OnapCommandException; + +/** + * CLI argument missing. + * + */ +public class OnapCliInvalidArgument extends OnapCommandException { + + private static final long serialVersionUID = -1438492553530993246L; + private static final String ERROR_CODE = "0x1000"; + private static final String ERROR_MESSAGE1 = "Invalid argument "; + + public OnapCliInvalidArgument(String arg) { + super(ERROR_CODE, ERROR_MESSAGE1 + arg); + } + + public OnapCliInvalidArgument(String arg, String errorMessage) { + super(ERROR_CODE, ERROR_MESSAGE1 + arg + " , " + errorMessage); + } + + public OnapCliInvalidArgument(String arg, Throwable throwable) { + this(arg , throwable.getMessage()); + } +} diff --git a/main/src/main/java/org/onap/cli/main/interactive/StringCompleter.java b/main/src/main/java/org/onap/cli/main/interactive/StringCompleter.java new file mode 100644 index 00000000..cf2a6c55 --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/interactive/StringCompleter.java @@ -0,0 +1,79 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.interactive; + +import jline.console.completer.Completer; + +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.SortedSet; +import java.util.TreeSet; + +/** + * String completer for autocomplete commands. + * + */ +public class StringCompleter implements Completer { + private final SortedSet<String> strings = new TreeSet<String>(); + + /** + * Public Constructor takes collection of strings. + * + * @param strings collection + */ + public StringCompleter(Collection<String> strings) { + this.strings.addAll(strings); + } + + /** + * Public Constructor takes array of strings. + * + * @param strings array of strings + */ + public void add(String... strings) { + this.strings.addAll(Arrays.asList(strings)); + } + + /** + * String completion. + * + * @param buffer + * string + * @param cursor + * int + * @param candidates + * list + * @return int + */ + public int complete(String buffer, int cursor, List<CharSequence> candidates) { + if (buffer == null) { + candidates.addAll(strings); + } else { + for (String match : strings.tailSet(buffer)) { + if (!match.startsWith(buffer)) { + break; + } + candidates.add(match); + } + } + if (candidates.size() == 1) { + candidates.set(0, candidates.get(0) + " "); + } + return candidates.isEmpty() ? -1 : 0; + } +} diff --git a/main/src/main/java/org/onap/cli/main/utils/OnapCliUtils.java b/main/src/main/java/org/onap/cli/main/utils/OnapCliUtils.java new file mode 100644 index 00000000..ed47bc68 --- /dev/null +++ b/main/src/main/java/org/onap/cli/main/utils/OnapCliUtils.java @@ -0,0 +1,270 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.utils; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; + +import net.minidev.json.JSONObject; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; +import org.onap.cli.main.error.OnapCliArgumentValueMissing; +import org.onap.cli.main.error.OnapCliInvalidArgument; + +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Onap CLI utilities. + * + */ +public class OnapCliUtils { + + /** + * private Constructor. + */ + private OnapCliUtils() { + + } + + /** + * It read thru the args and populate the given params for short optional, long option and postional args the idx of + * positional args, is calculated based on the position at which it present in the params and args. + * + * @param params + * List of command paramters + * @param args + * Array of arguments + * @throws OnapCliArgumentValueMissing + * ArgumentValueMissing exception + * @throws OnapCliInvalidArgument + * Invalid argument exception + * @throws OnapCommandInvalidParameterValue + * exception + */ + public static void populateParams(List<OnapCommandParameter> params, List<String> args) + throws OnapCommandException { + Map<String, String> shortOptionMap = new HashMap<>(); + Map<String, String> longOptionMap = new HashMap<>(); + List<String> positionArgs = new ArrayList<>(); + Map<String, OnapCommandParameter> paramMap = new HashMap<>(); + + for (OnapCommandParameter param : params) { + boolean positional = true; + if (param.getShortOption() != null) { + shortOptionMap.put(OnapCommandParameter.printShortOption(param.getShortOption()), param.getName()); + positional = false; + } + if (param.getLongOption() != null) { + longOptionMap.put(OnapCommandParameter.printLongOption(param.getLongOption()), param.getName()); + positional = false; + } + + if (positional) { + positionArgs.add(param.getName()); + } + + paramMap.put(param.getName(), param); + } + + int positionalIdx = 0; + // Skip the first args onap cmd name, so start from 1 + for (int i = 1; i < args.size(); i++) { + // check if short option exist + // (mrkanag) Optimize the below code to handle short and long options in one iteration + // now its redundant + if (shortOptionMap.containsKey(args.get(i))) { + // end of the list or if its option rather than a value + if ((i + 1) == args.size() || args.get(i + 1).startsWith("-")) { + if (paramMap.get(shortOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.BOOL)) { + paramMap.get(shortOptionMap.get(args.get(i))).setValue("true"); + continue; + } + throw new OnapCliArgumentValueMissing(args.get(i)); + } + + if (paramMap.get(shortOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.JSON)) { + paramMap.get(shortOptionMap.get(args.get(i))).setValue(readJsonStringFromUrl(args.get(i + 1), + paramMap.get(shortOptionMap.get(args.get(i))).getName())); + i++; + continue; + } else if (paramMap.get(shortOptionMap.get(args.get(i))).getParameterType() + .equals(ParameterType.ARRAY)) { + Object value = paramMap.get(shortOptionMap.get(args.get(i))).getValue(); + List<String> list; + if (value == "") { + list = new ArrayList<>(); + } else { + list = convertJsonToListString(paramMap.get(shortOptionMap.get(args.get(i))).getName(), + value.toString()); + } + list.add(args.get(i + 1)); + paramMap.get(shortOptionMap.get(args.get(i))).setValue(list); + i++; + continue; + } else if (paramMap.get(shortOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.MAP)) { + Object value = paramMap.get(shortOptionMap.get(args.get(i))).getValue(); + + Map<String, String> map; + + if (value == "") { + map = new HashMap<>(); + } else { + map = convertJsonToMapString(paramMap.get(shortOptionMap.get(args.get(i))).getName(), + value.toString()); + } + + String arg = args.get(i + 1); + String[] argArr = arg.split("="); + + if (argArr.length != 2) { + throw new OnapCliInvalidArgument(paramMap.get(shortOptionMap.get(args.get(i))).getName()); + } + + map.put(argArr[0], argArr[1]); + paramMap.get(shortOptionMap.get(args.get(i))).setValue(map); + i++; + continue; + } + + paramMap.get(shortOptionMap.get(args.get(i))).setValue(args.get(i + 1)); + + i++; + continue; + } + + // check if long option exist + if (longOptionMap.containsKey(args.get(i))) { + // end of the list or if its option rather than a value + if ((i + 1) == args.size() || args.get(i + 1).startsWith("-")) { + if (paramMap.get(longOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.BOOL)) { + paramMap.get(longOptionMap.get(args.get(i))).setValue("true"); + continue; + } + throw new OnapCliArgumentValueMissing(args.get(i)); + } + + if (paramMap.get(longOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.JSON)) { + paramMap.get(longOptionMap.get(args.get(i))).setValue(readJsonStringFromUrl(args.get(i + 1), + paramMap.get(longOptionMap.get(args.get(i))).getName())); + i++; + continue; + } else if (paramMap.get(longOptionMap.get(args.get(i))).getParameterType() + .equals(ParameterType.ARRAY)) { + Object value = paramMap.get(longOptionMap.get(args.get(i))).getValue(); + List<String> list; + if (value == "") { + list = new ArrayList<>(); + } else { + list = convertJsonToListString(paramMap.get(longOptionMap.get(args.get(i))).getName(), + value.toString()); + } + list.add(args.get(i + 1)); + paramMap.get(longOptionMap.get(args.get(i))).setValue(list); + i++; + continue; + } else if (paramMap.get(longOptionMap.get(args.get(i))).getParameterType().equals(ParameterType.MAP)) { + + Object value = paramMap.get(longOptionMap.get(args.get(i))).getValue(); + + Map<String, String> map; + + if (value == "") { + map = new HashMap<>(); + } else { + map = convertJsonToMapString(paramMap.get(longOptionMap.get(args.get(i))).getName(), + value.toString()); + } + + String arg = args.get(i + 1); + String[] argArr = arg.split("="); + + if (argArr.length != 2) { + throw new OnapCliInvalidArgument(paramMap.get(longOptionMap.get(args.get(i))).getName()); + } + + map.put(argArr[0], argArr[1]); + paramMap.get(longOptionMap.get(args.get(i))).setValue(map); + i++; + continue; + } + + paramMap.get(longOptionMap.get(args.get(i))).setValue(args.get(i + 1)); + + i++; + continue; + } + + // it is positional option + // Positional arg is missing from the params + if (positionalIdx >= positionArgs.size()) { + throw new OnapCliInvalidArgument(args.get(i)); + } + + paramMap.get(positionArgs.get(positionalIdx)).setValue(args.get(i)); + positionalIdx++; + } + + params.clear(); + params.addAll(paramMap.values()); + } + + private static String readJsonStringFromUrl(String input, String argName) throws OnapCliInvalidArgument { + ObjectMapper mapper = new ObjectMapper(); + try { + File file = new File(input); + if (file.isFile()) { + return mapper.readValue(file, JSONObject.class).toJSONString(); + } else if (input.startsWith("file:") || input.startsWith("http:") || input.startsWith("ftp:")) { + URL jsonUrl = new URL(input); + return mapper.readValue(jsonUrl, JSONObject.class).toJSONString(); + } else { + return mapper.readValue(input, JSONObject.class).toJSONString(); + } + } catch (IOException e) { + throw new OnapCliInvalidArgument(argName, e); + } + } + + private static List<String> convertJsonToListString(String arg, String json) throws OnapCliInvalidArgument { + TypeReference<List<String>> mapType = new TypeReference<List<String>>() { + }; + try { + return new ObjectMapper().readValue(json, mapType); + } catch (IOException e) { + throw new OnapCliInvalidArgument(arg, e); + } + } + + private static Map<String, String> convertJsonToMapString(String arg, String json) throws OnapCliInvalidArgument { + TypeReference<Map<String, String>> mapType = new TypeReference<Map<String, String>>() { + }; + try { + return new ObjectMapper().readValue(json, mapType); + } catch (IOException e) { + throw new OnapCliInvalidArgument(arg, e); + } + } +} diff --git a/main/src/main/resources/onap-readme.txt b/main/src/main/resources/onap-readme.txt new file mode 100644 index 00000000..737cd04d --- /dev/null +++ b/main/src/main/resources/onap-readme.txt @@ -0,0 +1,15 @@ +Onap Command-line interface (CLI). + +One Command to command whole Onap !! It provides the unified commands +to access and operate Onap functionalities. To use this CLI, please +configure the following environment variables: + +1. ONAP_MSB_URL - Onap Micro service bus(MSB) URL +2. ONAP_USERNAME - Onap user name +3. ONAP_PASSWORD - Onap user password + +To know the CLI version, type onap [-v|--version] +To know the CLI usage, type onap [-h|--help] +To know the usage of sub commands, type onap <command> [-h|--help] + +To know more, please refer the Onap wiki https://wiki.onap.org
\ No newline at end of file diff --git a/main/src/test/java/org/onap/cli/main/OnapCliMainTest.java b/main/src/test/java/org/onap/cli/main/OnapCliMainTest.java new file mode 100644 index 00000000..ca955cc9 --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/OnapCliMainTest.java @@ -0,0 +1,347 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main; + +import static org.junit.Assert.assertTrue; + +import jline.console.ConsoleReader; +import mockit.Invocation; +import mockit.Mock; +import mockit.MockUp; + +import org.aspectj.lang.annotation.After; +import org.junit.Ignore; +import org.junit.Test; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandRegistrar; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.main.utils.OnapCliUtils; + +import java.io.File; +import java.io.IOException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class OnapCliMainTest { + + OnapCli cli = null; + + /** + * Clean up. + */ + @After(value = "") + public void cleanup() { + if (this.cli != null) { + if (cli.getExitCode() != 0) { + // Fail test case + } + } + } + + private void handle(String[] args) { + cli = new OnapCli(args); + cli.handle(); + } + + @Test + public void testHelp() { + this.handle(new String[] { "--help" }); + } + + @Test + public void testHelpShort() { + this.handle(new String[] { "-h" }); + } + + @Test + public void testVersion() { + this.handle(new String[] { "--version" }); + } + + @Test + public void testVersionShort() { + this.handle(new String[] { "--v" }); + } + + @Test + public void testHelpSampleCommand() { + this.handle(new String[] { "sample-test", "--help" }); + } + + @Test + public void testHelpSampleCreateCommand() throws OnapCommandException { + ClassLoader cl = ClassLoader.getSystemClassLoader(); + URL[] urls = ((URLClassLoader) cl).getURLs(); + for (URL url : urls) { + if (url.getPath().contains("main/target/test-classes")) { + File file = new File(url.getPath() + "data"); + if (!file.exists()) { + file.mkdirs(); + } + break; + } + } + this.handle(new String[] { "sample-create", "--help" }); + OnapCommand cmd = OnapCommandRegistrar.getRegistrar().get("sample-create"); + List<String> args = new ArrayList<>(Arrays.asList(new String[] { "sample-create", "-u", "admin", "-p", + "Changeme_123", "-m", "http://192.168.99.100:80", "--service-name", "test-service", "-i", "ip1", "-i", + "ip2", "-o", "port1=value1", "-o", "port2=value2" })); + OnapCliUtils.populateParams(cmd.getParameters(), args); + } + + @Test + public void testHelpSampleCommandShort() { + this.handle(new String[] { "sample-test", "-h" }); + } + + @Test + public void testHelpServiceListCommandShort() { + this.handle(new String[] { "microservice-list", "-h" }); + } + + @Test + public void testHelpUserCreateCommand() { + this.handle(new String[] { "user-create", "--help" }); + } + + @Test + @Ignore + public void testUserCreateCommand() { + this.handle(new String[] { "user-create", "-u", "admin", "-p", "Changeme_123", "-m", "http://192.168.99.100:80", + "--username", "test", "--password", "sss", "--description", "test user", "-d" }); + } + + @Test + @Ignore + public void testHelpVimShowCommand() { + this.handle(new String[] { "vim-show", "--help" }); + } + + @Test + @Ignore + public void testVimListCommand() { + this.handle(new String[] { "vim-list", "-u", "admin", "-p", "Changeme_123", "-m", "http://192.168.99.100:80", + "--long", "--format", "table" }); + } + + @Test + public void tesVersionServiceListCommand() { + this.handle(new String[] { "microservice-list", "--version" }); + } + + @Test + public void tesVersionServiceListCommandShort() { + this.handle(new String[] { "microservice-list", "-v" }); + } + + @Test + @Ignore + public void testServiceListCommand() { + this.handle(new String[] { "microservice-list", "-u", "root1", "-p", "root123", "-m", "http://192.168.4.47:80", + "--long", "--no-title", "true", "-d" }); + } + + @Test + @Ignore + public void testServiceCreateCommand() { + this.handle(new String[] { "microservice-create", "-u", "admin", "-p", "Changeme_123", "-m", + "http://192.168.99.100:80", "--service-name", "test-service", "--service-version", "v1", + "--service-url", "/openapi/sampletest/v1", "127.0.0.1", "8080", "--debug", "--long" }); + } + + @Test + @Ignore + public void testServiceShowCommand() { + this.handle(new String[] { "microservice-show", "-u", "admin", "-p", "Changeme_123", "-m", + "http://192.168.99.100:80", "--service-name", "test-service", "--service-version", "v1", "--debug", + "--long" }); + } + + @Test + @Ignore + public void testServiceDeleteCommand() { + this.handle(new String[] { "microservice-delete", "-u", "admin", "-p", "Changeme_123", "-m", + "http://192.168.99.100:80", "--service-name", "test-service", "--service-version", "v1", "--debug", + "--long" }); + } + + @Test + @Ignore + public void testSdncCreate() { + + this.handle(new String[] { "sdnc-create", "-u", "root1", "-p", "root123", "-m", "http://192.168.4.47:80", + "--name", "testcontroller", "--vendor", "testvendor", "--sdnc-version", "v1", "--description", + "testingSDNC", "--type", "string", "--url", "onapapi/extsys/v1", "--username", "test", "--password", + "test", "--product-name", "testproduct", "--protocol", "http", "-d" }); + } + + @Test + @Ignore + public void testSdnclist() { + + this.handle(new String[] { "sdnc-list", "-p", "root123", "--msb-url", "http://192.168.99.100", "-u", "root1", + "-d" }); + } + + @Test + @Ignore + public void testNFVResourcelist() { + this.handle(new String[] { "resource-datacenter-show", "--id", "test", "-u", "root", "-p", "root123", + "--msb-url", "http://192.168.99.100", "-a", "-d" }); + } + + @Test + @Ignore + public void testNFVResourceShow() { + + this.handle(new String[] { "resource-datacenter-show", "--id", "test", "-u", "root", "-p", "root123", + "--msb-url", "http://192.168.99.100", "-a", "-d" }); + } + + @Test + @Ignore + public void testSdncdelete() { + + this.handle(new String[] { "sdnc-delete", "-p", "root123", "--msb-url", "http://192.168.4.47", "-u", "root1", + "--id", "053104c1-0f8b-481d-9456-f7b02e87c0e7" }); + } + + @Test + @Ignore + public void testServiceCreateHelpCommand() { + this.handle(new String[] { "microservice-create", "--help" }); + } + + @Test + @Ignore + public void testGsoServiceCreateCommand() { + this.handle(new String[] { "service-create", "-m", "http://192.168.4.47:80", "-u", "root1", "-p", "root123", + "-x", "test", "-z", "test", "-n", "test", "-r", "123", "-j", + "D:/workspace/onap/integration/test/csit/plans/gso/sanity-check/jsoninput/lcm_CreateServiceReq.json", + "-d" }); + } + + @Test + @Ignore + public void testCsrUpload() { + this.handle(new String[] { "catalog-csar-create", "-u", "root", "-p", "root123", "--msb-url", + "http://192.168.4.47", "-d", "-a", "-z", "D:\\enterprise2DC.csar" }); + } + + @Test + @Ignore + public void testCsrDelete() { + this.handle(new String[] { "catalog-csar-delete", "-u", "root", "-p", "root123", "--msb-url", + "http://192.168.4.47", "-d", "-a", "-i", "7aa791f9-4e5f-433a-afeb-3555bcbabb47" }); + } + + @Test + @Ignore + public void testPortCreate() { + this.handle(new String[] { "resource-link-create", "-u", "root", "-p", "root123", "--msb-url", + "http://192.168.4.213", "-d", "-n", "PradeepLink1", "-b", "19.5.6.13", "-c", "193.4.57.13", "-g", + "193.5.6.13", "-q", "189.78.6.13", "-y", "fiberLink" }); + } + + @Test + public void validateCommands() throws IOException, OnapCommandException { + Map<String, String> cmdSchemaMap = OnapCommandRegistrar.getRegistrar().getAllCommandToSchemaMap(); + for (String cmdName : cmdSchemaMap.keySet()) { + System.out.println( + "************************* '" + cmdSchemaMap.get(cmdName) + "' *******************************"); + this.handle(new String[] { "schema-validate", "-l", cmdSchemaMap.get(cmdName), "-i", "true", "-m", + "http://192.168.4.47:80", "-u", "root1", "-p", "root123" }); + } + } + + @Test + public void commandHelpTest() throws OnapCommandException { + Set<String> cmds = OnapCommandRegistrar.getRegistrar().listCommands(); + + for (String cmdName : cmds) { + System.out.println("************************* '" + cmdName + "' *******************************"); + this.handle(new String[] { cmdName, "-h" }); + } + + } + + @Test + public void interactiveTest() { + cli = new OnapCli(new String[] { "-i" }); + boolean isInter = cli.isInteractive(); + + assertTrue(isInter); + cli = new OnapCli(new String[] { "--interactive" }); + isInter = cli.isInteractive(); + assertTrue(isInter); + cli.getExitCode(); + + mockConsole("exit"); + cli.handleInteractive(); + + mockConsole("bye"); + cli.handleInteractive(); + + mockConsole("clear"); + try { + cli.handleInteractive(); + } catch (Exception e) { + } + + mockConsole("microservice-create -h"); + + try { + cli.handleInteractive(); + } catch (Exception e) { + } + + mockConsoleReader(); + cli.handleInteractive(); + + } + + private static void mockConsoleReader() { + new MockUp<OnapCli>() { + @Mock + public ConsoleReader createConsoleReader() throws IOException { + throw new IOException("Exception mock"); + } + }; + } + + private static void mockConsole(String input) { + new MockUp<ConsoleReader>() { + boolean isMock = true; + + @Mock + public String readLine(Invocation inv) throws IOException { + if (isMock) { + isMock = false; + return input; + } else { + return inv.proceed(input); + } + } + }; + } + +} diff --git a/main/src/test/java/org/onap/cli/main/OnapCommandSampleTest.java b/main/src/test/java/org/onap/cli/main/OnapCommandSampleTest.java new file mode 100644 index 00000000..517d6c4f --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/OnapCommandSampleTest.java @@ -0,0 +1,35 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandSchema; +import org.onap.cli.fw.error.OnapCommandException; + +/** + * This command helps to test the Command functionalities. + * + */ +@OnapCommandSchema(name = "sample-test", schema = "sample-test-schema.yaml") +public class OnapCommandSampleTest extends OnapCommand { + + @Override + protected void run() throws OnapCommandException { + + } + +} diff --git a/main/src/test/java/org/onap/cli/main/conf/OnapCliConstantsTest.java b/main/src/test/java/org/onap/cli/main/conf/OnapCliConstantsTest.java new file mode 100644 index 00000000..af19836a --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/conf/OnapCliConstantsTest.java @@ -0,0 +1,33 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.conf; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class OnapCliConstantsTest { + + @Test + public void test() { + assertTrue(1 == OnapCliConstants.EXIT_FAILURE && 0 == OnapCliConstants.EXIT_SUCCESS + && "help".equals(OnapCliConstants.PARAM_HELP_LOGN) && "h".equals(OnapCliConstants.PARAM_HELP_SHORT) + && "v".equals(OnapCliConstants.PARAM_VERSION_SHORT) + && "version".equals(OnapCliConstants.PARAM_VERSION_LONG)); + } + +} diff --git a/main/src/test/java/org/onap/cli/main/error/OnapCliArgumentTest.java b/main/src/test/java/org/onap/cli/main/error/OnapCliArgumentTest.java new file mode 100644 index 00000000..3916c630 --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/error/OnapCliArgumentTest.java @@ -0,0 +1,39 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.error; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +public class OnapCliArgumentTest { + + @Test + public void onapCliArgumentValueMissingTest() { + OnapCliArgumentValueMissing failed = new OnapCliArgumentValueMissing("Argument value missing"); + assertEquals("0x1001::Value for argument Argument value missing is missing", failed.getMessage()); + } + + @Test + public void onapCliInvalidArgumentTest() { + OnapCliInvalidArgument failed = new OnapCliInvalidArgument("Invalid Argument"); + assertEquals("0x1000::Invalid argument Invalid Argument", failed.getMessage()); + failed = new OnapCliInvalidArgument("Invalid Argument", new Exception("")); + assertEquals("0x1000::Invalid argument Invalid Argument , ", failed.getMessage()); + } + +} diff --git a/main/src/test/java/org/onap/cli/main/interactive/StringCompleterTest.java b/main/src/test/java/org/onap/cli/main/interactive/StringCompleterTest.java new file mode 100644 index 00000000..9d5cbf17 --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/interactive/StringCompleterTest.java @@ -0,0 +1,48 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.interactive; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; + +public class StringCompleterTest { + + @Test + public void completeTest() { + StringCompleter com = new StringCompleter(Arrays.asList(new String[] { "test", "testing1", "testing2" })); + int result = com.complete("test", 1, new ArrayList<CharSequence>()); + assertTrue(result == 0); + result = com.complete(null, 1, new ArrayList<CharSequence>()); + assertTrue(result == 0); + + com.add("test", "testing1", "testing2"); + result = com.complete("test", 1, new ArrayList<CharSequence>()); + assertTrue(result == 0); + + result = com.complete("sfds", 1, new ArrayList<CharSequence>()); + assertTrue(result == -1); + + + result = com.complete("test", 1, new ArrayList<CharSequence>()); + assertTrue(result == 0); + } + +} diff --git a/main/src/test/java/org/onap/cli/main/utils/OnapCliUtilsTest.java b/main/src/test/java/org/onap/cli/main/utils/OnapCliUtilsTest.java new file mode 100644 index 00000000..c7fb7985 --- /dev/null +++ b/main/src/test/java/org/onap/cli/main/utils/OnapCliUtilsTest.java @@ -0,0 +1,330 @@ +/* + * Copyright 2017 Huawei Technologies Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.cli.main.utils; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; +import org.onap.cli.main.error.OnapCliArgumentValueMissing; +import org.onap.cli.main.error.OnapCliInvalidArgument; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class OnapCliUtilsTest { + + @Test + public void testpopulateParamsLong() throws OnapCommandException { + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setLongOption("onap-username"); + param1.setName("onap-username"); + param1.setParameterType(ParameterType.STRING); + OnapCommandParameter param2 = new OnapCommandParameter(); + param2.setLongOption("onap-password"); + param2.setName("onap-password"); + param2.setParameterType(ParameterType.STRING); + OnapCommandParameter param3 = new OnapCommandParameter(); + param3.setLongOption("msb-url"); + param3.setName("msb-url"); + param3.setParameterType(ParameterType.STRING); + OnapCommandParameter param4 = new OnapCommandParameter(); + param4.setLongOption("string-param"); + param4.setName("string-param"); + param4.setParameterType(ParameterType.STRING); + OnapCommandParameter param5 = new OnapCommandParameter(); + param5.setLongOption("long-opt"); + param5.setName("long-opt"); + param5.setParameterType(ParameterType.STRING); + + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(param1); + paramslist.add(param2); + paramslist.add(param3); + paramslist.add(param4); + paramslist.add(param5); + + String[] args = new String[] { "sample-create", "--onap-username", "admin", "--onap-password", "123", + "--msb-url", "a@b.com", "--string-param", "blah", "--long-opt", "10" }; + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + + Assert.assertEquals("onap-username", expectedList.get(2), param1.getValue()); + Assert.assertEquals("onap-password", expectedList.get(4), param2.getValue()); + Assert.assertEquals("msb-url", expectedList.get(6), param3.getValue()); + Assert.assertEquals("string-param", expectedList.get(8), param4.getValue()); + Assert.assertEquals("long-opt", expectedList.get(10), param5.getValue()); + + } + + @Test + public void testpositionalargs() throws OnapCommandException { + OnapCommandParameter paramargs = new OnapCommandParameter(); + paramargs.setName("http://localhost:8082/file.txt"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(paramargs); + String[] args = new String[] { "positional-args", "http://localhost:8082/file.txt" }; + paramargs.setParameterType(ParameterType.STRING); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("positional-args", expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test + public void testboolparamslong() throws OnapCommandException { + OnapCommandParameter boolparam = new OnapCommandParameter(); + boolparam.setLongOption("bool"); + boolparam.setName("bool-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(boolparam); + String[] args = new String[] { "sample-create", "--bool" }; + + boolparam.setParameterType(ParameterType.BOOL); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertNotNull(expectedList.get(1), paramslist.get(0).getValue()); + + } + + @Test + public void testboolparamsshort() throws OnapCommandException { + OnapCommandParameter boolparam = new OnapCommandParameter(); + boolparam.setShortOption("b"); + boolparam.setName("bool-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(boolparam); + String[] args = new String[] { "sample-create", "-b", }; + + boolparam.setParameterType(ParameterType.BOOL); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertNotNull(expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test + public void testjsonparamsshort() throws OnapCommandException { + OnapCommandParameter jsonparam = new OnapCommandParameter(); + jsonparam.setShortOption("j"); + jsonparam.setName("json-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(jsonparam); + File resourcesDirectory = new File("src/test/resources/sampletest.json"); + String[] args = new String[] { "sample-create", "-j", "file:" + resourcesDirectory }; + jsonparam.setParameterType(ParameterType.JSON); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertNotNull(expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test + public void testjsonparamslong() throws OnapCommandException { + OnapCommandParameter jsonparam = new OnapCommandParameter(); + jsonparam.setLongOption("json-param"); + jsonparam.setName("json-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(jsonparam); + File resourcesDirectory = new File("src/test/resources/sampletest.json"); + String[] args = new String[] { "sample-create", "--json-param", "file:" + resourcesDirectory }; + jsonparam.setParameterType(ParameterType.JSON); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertNotNull(expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test + public void testpopulateParamsShort() throws OnapCommandException { + + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setShortOption("u"); + param1.setName("onap-username"); + param1.setParameterType(ParameterType.STRING); + OnapCommandParameter param2 = new OnapCommandParameter(); + param2.setShortOption("p"); + param2.setName("onap-password"); + param2.setParameterType(ParameterType.STRING); + OnapCommandParameter param3 = new OnapCommandParameter(); + param3.setShortOption("r"); + param3.setName("msb-url"); + param3.setParameterType(ParameterType.STRING); + OnapCommandParameter param4 = new OnapCommandParameter(); + param4.setShortOption("c"); + param4.setName("string-param"); + param4.setParameterType(ParameterType.STRING); + OnapCommandParameter param5 = new OnapCommandParameter(); + param5.setShortOption("l"); + param5.setName("long-opt"); + param5.setParameterType(ParameterType.STRING); + + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(param1); + paramslist.add(param2); + paramslist.add(param3); + paramslist.add(param4); + paramslist.add(param5); + + String[] args11 = new String[] { "sample-create", "-u", "admin", "-p", "123", "-r", "a@b.com", "-c", "blah", + "-l", "10", }; + OnapCliUtils.populateParams(paramslist, Arrays.asList(args11)); + + List<String> expectedList = Arrays.asList(args11); + + Assert.assertEquals("u", expectedList.get(2), param1.getValue()); + Assert.assertEquals("-p", expectedList.get(4), param2.getValue()); + Assert.assertEquals("r", expectedList.get(6), param3.getValue()); + Assert.assertEquals("c", expectedList.get(8), param4.getValue()); + Assert.assertEquals("l", expectedList.get(10), param5.getValue()); + } + + @Test + public void testArrayparamslong() throws OnapCommandException { + OnapCommandParameter arrayval = new OnapCommandParameter(); + arrayval.setLongOption("node-ip"); + arrayval.setName("node-ip"); + + String[] args = new String[] { "sample-create", "--node-ip", "{}" }; + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(arrayval); + + arrayval.setParameterType(ParameterType.ARRAY); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + + List<String> expectedList = Arrays.asList(args); + Assert.assertNotNull(expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test + public void testMapparamsShort() throws OnapCommandException { + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setLongOption("map"); + param1.setName("MAP"); + param1.setParameterType(ParameterType.MAP); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(param1); + + param1.setParameterType(ParameterType.MAP); + OnapCliUtils.populateParams(paramslist, + Arrays.asList("show", "--map", "param1=value1", "--map", "param2=value2")); + + Assert.assertEquals("{\"param1\":\"value1\",\"param2\":\"value2\"}", paramslist.get(0).getValue().toString()); + } + + @Test(expected = OnapCliInvalidArgument.class) + public void testMapparamsLongfail() throws OnapCommandException { + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setLongOption("map"); + param1.setName("MAP"); + param1.setParameterType(ParameterType.MAP); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(param1); + + param1.setParameterType(ParameterType.MAP); + OnapCliUtils.populateParams(paramslist, Arrays.asList("show", "--map", "param1=value1", "--map", "param2")); + Assert.assertEquals("{\"param1\":\"value1\",\"param2\"}", paramslist.get(0).getValue().toString()); + } + + @Test(expected = OnapCliInvalidArgument.class) + public void testMapparamsShortfail() throws OnapCommandException { + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setShortOption("o"); + param1.setName("node-port"); + param1.setParameterType(ParameterType.MAP); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(param1); + param1.setParameterType(ParameterType.MAP); + OnapCliUtils.populateParams(paramslist, Arrays.asList("show", "-o", "param1=value1", "-o", "param2")); + Assert.assertEquals("{\"param1\":\"value1\",\"param2\"}", paramslist.get(0).getValue().toString()); + } + + @Test(expected = OnapCliInvalidArgument.class) + public void testpositionalargsfails() throws OnapCommandException { + OnapCommandParameter paramargs = new OnapCommandParameter(); + paramargs.setName("http://localhost:8082/file.txt"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(paramargs); + String[] args = new String[] { "positional-args", "http://localhost:8082/file.txt", + "http://localhost:8082/file.txt" }; + paramargs.setParameterType(ParameterType.STRING); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("positional-args", expectedList.get(1), paramslist.get(0).getValue()); + } + + @Test(expected = OnapCliInvalidArgument.class) + public void testboolparamsshortfails() throws OnapCommandException { + OnapCommandParameter boolparam = new OnapCommandParameter(); + boolparam.setShortOption("b"); + boolparam.setName("bool-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(boolparam); + String[] args = new String[] { "sample-create", "-b", "-b", "-h" }; + + boolparam.setParameterType(ParameterType.BOOL); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("true", paramslist.get(0).getValue()); + } + + @Test(expected = OnapCliInvalidArgument.class) + public void testboolparamsLongfails() throws OnapCommandException { + OnapCommandParameter boolparam = new OnapCommandParameter(); + boolparam.setShortOption("bool"); + boolparam.setName("bool-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(boolparam); + String[] args = new String[] { "sample-create", "--bool", "--bool", "--help" }; + + boolparam.setParameterType(ParameterType.BOOL); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("true", paramslist.get(0).getValue()); + } + + @Test(expected = OnapCliArgumentValueMissing.class) + public void testjsonparamslongfails() throws OnapCommandException { + OnapCommandParameter jsonparam = new OnapCommandParameter(); + jsonparam.setLongOption("json-param"); + jsonparam.setName("json-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(jsonparam); + File resourcesDirectory = new File("src/test/resources/sampletest.json"); + String[] args = new String[] { "sample-create", "--json-param", "file:" + resourcesDirectory, "--json-param" }; + jsonparam.setParameterType(ParameterType.JSON); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("--json-param", paramslist.get(0).getValue()); + + } + + @Test(expected = OnapCliArgumentValueMissing.class) + public void testjsonparamsshortfails() throws OnapCommandException { + OnapCommandParameter jsonparam = new OnapCommandParameter(); + jsonparam.setShortOption("j"); + jsonparam.setName("json-param"); + List<OnapCommandParameter> paramslist = new ArrayList<>(); + paramslist.add(jsonparam); + File resourcesDirectory = new File("src/test/resources/sampletest.json"); + String[] args = new String[] { "sample-create", "-j", "file:" + resourcesDirectory, "-j" }; + jsonparam.setParameterType(ParameterType.JSON); + OnapCliUtils.populateParams(paramslist, Arrays.asList(args)); + List<String> expectedList = Arrays.asList(args); + Assert.assertEquals("--json-param", paramslist.get(0).getValue()); + + } +}
\ No newline at end of file diff --git a/main/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand b/main/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand new file mode 100644 index 00000000..16dd879a --- /dev/null +++ b/main/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand @@ -0,0 +1 @@ +org.onap.cli.main.OnapCommandSampleTest
\ No newline at end of file diff --git a/main/src/test/resources/onap-cli-schema/sample-create-schema.yaml b/main/src/test/resources/onap-cli-schema/sample-create-schema.yaml new file mode 100644 index 00000000..6e775334 --- /dev/null +++ b/main/src/test/resources/onap-cli-schema/sample-create-schema.yaml @@ -0,0 +1,71 @@ +onap_cmd_schema_version: 1.0 +name: sample-create +description: Sample create into Onap +service: + name: sample + version: v1 + no-auth: true +parameters: + - name: service-name + description: Onap service name + type: string + short_option: x + long_option: service-name + is_optional: false + - name: node-ip + description: Onap service running node IP + type: array + short_option: i + long_option: node-ip + - name: node-port + description: Onap service running node port + type: map + short_option: o + long_option: node-port +results: + direction: portrait + attributes: + - name: name + description: Onap service name + scope: short + type: string + - name: version + description: Onap service version + scope: short + type: string + - name: url + description: Onap service base url + scope: short + type: url + - name: status + description: Onap service status + scope: short + type: long + - name: nodes + description: Onap service running nodes + scope: long + type: string + - name: location + description: Onap service location + scope: long + type: url +http: + request: + uri: /services + method: POST + body: '{"serviceName":"${service-name}","nodeIp":"${node-ip}","nodePort":"${node-port}"}' + headers: + queries: + success_codes: + - 201 + - 200 + result_map: + name: $b{$.serviceName} + version: $b{$.version} + url: $b{$.url} + status: $b{$.status} + nodes: $b{$.nodes[*].ip}:$b{$.nodes[*].port} + location: $h{Location} + + sample_response: + body: {"serviceName":"test","version":"v1","url":"/api/test/v1","protocol":"REST","visualRange":"1","lb_policy":"hash","nodes":[{"ip":"127.0.0.1","port":"8012","ttl":0,"nodeId":"test_127.0.0.1_8012","expiration":"2017-02-10T05:33:25Z","created_at":"2017-02-10T05:33:25Z","updated_at":"2017-02-10T05:33:25Z"}],"status":"1"}
\ No newline at end of file diff --git a/main/src/test/resources/sample-test-schema.yaml b/main/src/test/resources/sample-test-schema.yaml new file mode 100644 index 00000000..419f416c --- /dev/null +++ b/main/src/test/resources/sample-test-schema.yaml @@ -0,0 +1,79 @@ +onap_cmd_schema_version: 1.0 +name: sample-test +description: Onap sample command to test the command features +service: + name: sample + version: v1 +parameters: + - name: bool-param + type: bool + description: Onap boolean param, by default its always false. + short_option: b + long_option: bool + is_optional: true + default_value: false + - name: secure-param + type: string + description: Onap secure param such as password + short_option: x + long_option: secure + is_secured: true + is_optional: false + default_Value: pass123# + - name: string-param + type: string + description: Onap string param + long_option: string-param + short_option: c + is_optional: false + default_Value: test + - name: yaml-param + type: json + description: Onap yaml file location param + long_option: yaml-param + short_option: y + is_optional: false + - name: json-param + type: json + description: Onap json file location param + long_option: json-param + short_option: j + is_optional: false + - name: long-param + type: long + description: Onap long param + short_option: l + long_option: long-opt + is_optional: false + default_value: 10 + - name: url-param + type: url + description: Onap url param + short_option: r + long_option: url + is_optional: false + default_value: http://localhost:8082/file.txt + - name: env-param + type: string + description: Onap env param. + short_option: z + long_option: env + is_optional: false + default_value: ${ENV_VAR} + default_value: http://localhost:8082/file.txt + - name: positional-args + type: string + description: Onap positional args, if no short option and no long option given for it + is_optional: false + default_value: http://localhost:8082/file.txt +results: + direction: portrait + attributes: + - name: output-1 + description: Onap output attribute marked in short + scope: short + type: string + - name: output-2 + description: Onap output attribute marked in long + scope: short + type: string
\ No newline at end of file diff --git a/main/src/test/resources/sampletest.json b/main/src/test/resources/sampletest.json new file mode 100644 index 00000000..44c101ce --- /dev/null +++ b/main/src/test/resources/sampletest.json @@ -0,0 +1,8 @@ +{ + "name": "test", + "messages": [ + "hello jackson 1", + "hello jackson 2", + "hello jackson 3" + ] +}
\ No newline at end of file |