diff options
Diffstat (limited to 'framework/src')
126 files changed, 12139 insertions, 0 deletions
diff --git a/framework/src/main/java/org/onap/cli/fw/OnapCommand.java b/framework/src/main/java/org/onap/cli/fw/OnapCommand.java new file mode 100644 index 00000000..d67538cc --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/OnapCommand.java @@ -0,0 +1,304 @@ +/* + * 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.fw; + +import org.onap.cli.fw.ad.OnapAuthClient; +import org.onap.cli.fw.ad.OnapCredentials; +import org.onap.cli.fw.ad.OnapService; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandHelpFailed; +import org.onap.cli.fw.error.OnapCommandInvalidParameterType; +import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection; +import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope; +import org.onap.cli.fw.error.OnapCommandInvalidSchema; +import org.onap.cli.fw.error.OnapCommandInvalidSchemaVersion; +import org.onap.cli.fw.error.OnapCommandNotInitialized; +import org.onap.cli.fw.error.OnapCommandParameterNameConflict; +import org.onap.cli.fw.error.OnapCommandParameterOptionConflict; +import org.onap.cli.fw.error.OnapCommandRegistrationFailed; +import org.onap.cli.fw.error.OnapCommandSchemaNotFound; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.output.OnapCommandResult; +import org.onap.cli.fw.output.OnapCommandResultAttributeScope; +import org.onap.cli.fw.output.ResultType; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +/** + * Onap Command. + * + */ +public abstract class OnapCommand { + + private String cmdDescription; + + private String cmdName; + + private String cmdSchemaName; + + private OnapService onapService = new OnapService(); + + private List<OnapCommandParameter> cmdParameters = new ArrayList<>(); + + private OnapCommandResult cmdResult = new OnapCommandResult(); + + protected OnapAuthClient authClient; + + protected boolean isInitialzied = false; + + public String getSchemaVersion() { + return Constants.ONAP_CMD_SCHEMA_VERSION_VALUE; + } + + /** + * Onap command description, defined by derived command. + */ + public String getDescription() { + return this.cmdDescription; + } + + public void setDescription(String description) { + this.cmdDescription = description; + } + + /* + * Onap command name like user-create, ns-list, etc , defined by derived command + */ + public String getName() { + return this.cmdName; + } + + public void setName(String name) { + this.cmdName = name; + } + + /* + * Onap service, this command uses to execute it. , defined by derived command + */ + public OnapService getService() { + return this.onapService; + } + + public void setService(OnapService service) { + this.onapService = service; + } + + public void setParameters(List<OnapCommandParameter> parameters) { + this.cmdParameters = parameters; + } + + /* + * Onap command input parameters, defined by derived command + */ + public List<OnapCommandParameter> getParameters() { + return this.cmdParameters; + } + + /* + * Onap command input parameters, defined by derived command + */ + public Map<String, OnapCommandParameter> getParametersMap() { + return OnapCommandUtils.getInputMap(this.getParameters()); + } + + /* + * Onap command output results, defined by derived command + */ + public OnapCommandResult getResult() { + return this.cmdResult; + } + + public void setResult(OnapCommandResult result) { + this.cmdResult = result; + } + + public String getSchemaName() { + return cmdSchemaName; + } + + protected void setSchemaName(String schemaName) { + this.cmdSchemaName = schemaName; + } + + /** + * Initialize this command from command schema. + * + * @throws OnapCommandRegistrationFailed + * Command Registration Exception + * @throws OnapCommandInvalidResultAttributeScope + * InvalidResultAttribute Exception + * @throws OnapCommandInvalidPrintDirection + * InvalidPrintDirection Exception + * @throws OnapCommandInvalidParameterType + * InvalidParameterType Exception + * @throws OnapCommandSchemaNotFound + * SchemaNotFound Exception + * @throws OnapCommandInvalidSchema + * InvalidSchema Exception + * @throws OnapCommandParameterOptionConflict + * ParameterOptionConflict Exception + * @throws OnapCommandParameterNameConflict + * ParameterNameConflict Exception + * @throws OnapCommandInvalidSchemaVersion + * InvalidSchemaVersion Exception + */ + public void initializeSchema(String schema) throws OnapCommandException { + this.setSchemaName(schema); + OnapCommandUtils.loadSchema(this, schema, true); + this.initializeProfileSchema(); + this.isInitialzied = true; + } + + /** + * Any additional profile based such as http/swagger schema could be initialized. + */ + protected void initializeProfileSchema() throws OnapCommandException { + + } + + /* + * Validate input parameters. This can be overridden in derived commands + */ + protected void validate() throws OnapCommandException { + for (OnapCommandParameter param : this.getParameters()) { + param.validate(); + } + } + + /** + * Onap command execute with given parameters on service. Before calling this method, its mandatory to set all + * parameters value. + * + * @throws OnapCommandException + * : General Command Exception + */ + public OnapCommandResult execute() throws OnapCommandException { + if (!this.isInitialzied) { + throw new OnapCommandNotInitialized(this.getClass().getName()); + } + + Map<String, OnapCommandParameter> paramMap = this.getParametersMap(); + + // -h or --help is always higher precedence !, user can set this value to get help message + if ("true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_HELP).getValue())) { + OnapCommandResult result = new OnapCommandResult(); + result.setType(ResultType.TEXT); + result.setOutput(this.printHelp()); + return result; + } + + // -v or --version is next higher precedence !, user can set this value to get help message + if ("true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_VERSION).getValue())) { + OnapCommandResult result = new OnapCommandResult(); + result.setType(ResultType.TEXT); + result.setOutput(this.printVersion()); + return result; + } + + // validate + this.validate(); + + // -f or --format + this.cmdResult.setType( + ResultType.get(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_FORMAT).getValue().toString())); + if ("true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG).getValue())) { + this.cmdResult.setScope(OnapCommandResultAttributeScope.LONG); + } + // --no-title + if ("true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE).getValue())) { + this.cmdResult.setIncludeTitle(false); + } + + // --debug + if ("true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_DEBUG).getValue())) { + this.cmdResult.setDebug(true); + } + + try { + // login + OnapCredentials creds = OnapCommandUtils.fromParameters(this.getParameters()); + this.authClient = new OnapAuthClient(creds, this.getResult().isDebug()); + + if (!this.onapService.isNoAuth() + && !"true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue())) { + this.authClient.login(); + } + + // execute + this.run(); + + // logout + if (!this.onapService.isNoAuth() + && !"true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue())) { + this.authClient.logout(); + } + + if (this.cmdResult.isDebug()) { + this.cmdResult.setDebugInfo(this.authClient.getDebugInfo()); + } + } catch (OnapCommandException e) { + if (this.cmdResult.isDebug()) { + this.cmdResult.setDebugInfo(this.authClient.getDebugInfo()); + } + throw e; + } + + return this.cmdResult; + } + + /* + * Each command implements run method to executing the command. + * + */ + protected abstract void run() throws OnapCommandException; + + /* + * Get my service base path (endpoint). + */ + protected String getBasePath() throws OnapCommandException { + return this.authClient.getServiceBasePath(this.getService()); + } + + protected String getAuthToken() { + return this.authClient.getAuthToken(); + } + + /** + * Returns the service service version it supports. + * + * @return version + */ + public String printVersion() { + return this.getService().toString(); + } + + /** + * Provides help message for this command. + * + * @return help message + * @throws OnapCommandHelpFailed + * Failed to execute Help command. + */ + public String printHelp() throws OnapCommandHelpFailed { + return OnapCommandUtils.help(this); + } + // (mrkanag) Add toString for all command, parameter, result, etc objects in JSON format +} diff --git a/framework/src/main/java/org/onap/cli/fw/OnapCommandRegistrar.java b/framework/src/main/java/org/onap/cli/fw/OnapCommandRegistrar.java new file mode 100644 index 00000000..567e0381 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/OnapCommandRegistrar.java @@ -0,0 +1,243 @@ +/* + * 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.fw; + +import org.onap.cli.fw.cmd.OnapHttpCommand; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.conf.OnapCommandConfg; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandHelpFailed; +import org.onap.cli.fw.error.OnapCommandInvalidRegistration; +import org.onap.cli.fw.error.OnapCommandNotFound; +import org.onap.cli.fw.error.OnapCommandRegistrationFailed; +import org.onap.cli.fw.output.OnapCommandResult; +import org.onap.cli.fw.output.OnapCommandResultAttribute; +import org.onap.cli.fw.output.OnapCommandResultAttributeScope; +import org.onap.cli.fw.output.PrintDirection; +import org.onap.cli.fw.output.ResultType; +import org.onap.cli.fw.utils.ExternalSchema; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Onap Command registrar provides a common place, where every command would get registered automatically when its + * loaded into JVM. + * + */ +public class OnapCommandRegistrar { + /* + * static { //Start the AOP for logging new OnapCommandLogger(); } + */ + private Map<String, Class<? extends OnapCommand>> registry = new HashMap<>(); + + private static OnapCommandRegistrar registrar = null; + + /** + * Register the command into registrar and throws OnapInvalidCommandRegistration for invalid command. + * + * @param name + * Command Name + * @param cmd + * Command Class + * @throws OnapCommandInvalidRegistration + * Invalid registration exception + */ + public void register(String name, Class<? extends OnapCommand> cmd) throws OnapCommandInvalidRegistration { + this.registry.put(name, cmd); + } + + /** + * Get global registrar. + * + * @throws OnapCommandException + * exception + */ + public static OnapCommandRegistrar getRegistrar() throws OnapCommandException { + if (registrar == null) { + registrar = new OnapCommandRegistrar(); + registrar.autoDiscover(); + registrar.autoDiscoverHttpSchemas(); + } + + return registrar; + } + + /** + * Get the list of discovered commands by registrar. + * + * @return set + */ + public Set<String> listCommands() { + return this.registry.keySet(); + } + + /** + * Returns map of command to schema. + * + * @return map + * @throws OnapCommandException + * exception + */ + public Map<String, String> getAllCommandToSchemaMap() throws OnapCommandException { + Map<String, String> map = new HashMap<>(); + List<ExternalSchema> schemas = OnapCommandUtils.findAllExternalSchemas(); + if (schemas != null) { + for (ExternalSchema schema : schemas) { + map.put(schema.getCmdName(), schema.getSchemaName()); + } + } + if (this.registry != null) { + for (String cmd : this.registry.keySet()) { + if (!map.containsKey(cmd) && registry.get(cmd) != null) { + map.put(cmd, this.getSchemaFileName(registry.get(cmd))); + } + } + } + + return map; + } + + /** + * Get the OnapCommand, which CLI main would use to find the command based on the command name. + * + * @param cmdName + * Name of command + * @return OnapCommand + * @throws OnapCommandException + * Exception + */ + public OnapCommand get(String cmdName) throws OnapCommandException { + OnapCommand cmd; + Class<? extends OnapCommand> cls = registry.get(cmdName); + if (cls == null) { + throw new OnapCommandNotFound(cmdName); + } + + try { + Constructor<?> constr = cls.getConstructor(); + cmd = (OnapCommand) constr.newInstance(); + + String schemaName; + if (cmd.getClass().equals(OnapHttpCommand.class)) { // NOSONAR + schemaName = OnapCommandUtils.loadExternalSchemaFromJson(cmdName).getSchemaName(); + } else { + schemaName = this.getSchemaFileName(cls); + } + cmd.initializeSchema(schemaName); + } catch (OnapCommandException | NoSuchMethodException | SecurityException | InstantiationException + | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + throw new OnapCommandRegistrationFailed(cmdName, e); + } + + return cmd; + } + + private void autoDiscover() throws OnapCommandInvalidRegistration { + List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands(); + + for (Class<OnapCommand> cmd : cmds) { + if (cmd.isAnnotationPresent(OnapCommandSchema.class)) { + OnapCommandSchema ano = cmd.getAnnotation(OnapCommandSchema.class); + this.register(ano.name(), cmd); + } + } + } + + private void autoDiscoverHttpSchemas() throws OnapCommandException { + List<ExternalSchema> schemas = OnapCommandUtils.loadExternalSchemasFromJson(); + for (ExternalSchema schema : schemas) { + this.register(schema.getCmdName(), OnapHttpCommand.class); + } + } + + private String getSchemaFileName(Class<? extends OnapCommand> cmd) { + OnapCommandSchema ano = (OnapCommandSchema) cmd.getAnnotation(OnapCommandSchema.class); + if (ano.schema().isEmpty()) { + return "onap-" + ano.name() + "-schema.yaml"; + } + return ano.schema(); + } + + /** + * Helps to find the Onap CLI version, could be used with --version or -v option. + * + * @return string + */ + public String getVersion() { + String version = this.getClass().getPackage().getImplementationVersion(); + if (version == null) { + version = OnapCommandConfg.getVersion(); + } + return version; + } + + /** + * Provides the help message in tabular format for all commands registered in this registrar. + * + * @return string + * @throws OnapCommandHelpFailed + * Help cmd failed + */ + public String getHelp() throws OnapCommandHelpFailed { + OnapCommandResult help = new OnapCommandResult(); + help.setType(ResultType.TABLE); + help.setPrintDirection(PrintDirection.LANDSCAPE); + + OnapCommandResultAttribute attr = new OnapCommandResultAttribute(); + attr.setName(Constants.NAME.toUpperCase()); + attr.setDescription(Constants.DESCRIPTION); + attr.setScope(OnapCommandResultAttributeScope.SHORT); + help.getRecords().add(attr); + + OnapCommandResultAttribute attrSrv = new OnapCommandResultAttribute(); + attrSrv.setName(Constants.SERVICE.toUpperCase()); + attrSrv.setDescription(Constants.SERVICE); + attrSrv.setScope(OnapCommandResultAttributeScope.SHORT); + help.getRecords().add(attrSrv); + + OnapCommandResultAttribute attrDesc = new OnapCommandResultAttribute(); + attrDesc.setName(Constants.DESCRIPTION.toUpperCase()); + attrDesc.setDescription(Constants.DESCRIPTION); + attrDesc.setScope(OnapCommandResultAttributeScope.SHORT); + help.getRecords().add(attrDesc); + + for (String cmdName : OnapCommandUtils.sort(this.listCommands())) { + OnapCommand cmd; + try { + cmd = this.get(cmdName); + } catch (OnapCommandException e) { + throw new OnapCommandHelpFailed(e); + } + + attr.getValues().add(cmd.getName()); + attrSrv.getValues().add(cmd.printVersion()); + attrDesc.getValues().add(cmd.getDescription()); + } + + try { + return "\n\nOnap sub-commands:\n" + help.print(); + } catch (OnapCommandException e) { + throw new OnapCommandHelpFailed(e); + } + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/OnapCommandSchema.java b/framework/src/main/java/org/onap/cli/fw/OnapCommandSchema.java new file mode 100644 index 00000000..853d3583 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/OnapCommandSchema.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.fw; + +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +/** + * Provide command name and schema file location, which is placed in the main resources folder (in classpath). It is + * recommended to keep the name for schema, in the form of onap-[command-name]-schema.yaml, considered this format as + * default if the schema declaration is missing for a command abc-create, schema file name could be + * abc-create-schema.yaml, corresponding command would like as below + * + * @OnapCommandSchema(name="abc-create", schema="onap-abc-create-schema.yaml") public class AbcCreate extends + * OnapCommand { ... } + */ +@Retention(RetentionPolicy.RUNTIME) +@Documented +public @interface OnapCommandSchema { + /** + * Command name + * + * @return + */ + String name(); + + /** + * Schema file name placed under class path + * + * @return + */ + String schema() default ""; +} diff --git a/framework/src/main/java/org/onap/cli/fw/ad/OnapAuthClient.java b/framework/src/main/java/org/onap/cli/fw/ad/OnapAuthClient.java new file mode 100644 index 00000000..0150ee98 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/ad/OnapAuthClient.java @@ -0,0 +1,194 @@ +/* + * 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.fw.ad; + +import com.jayway.jsonpath.JsonPath; +import org.apache.http.HttpStatus; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.conf.OnapCommandConfg; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandHttpFailure; +import org.onap.cli.fw.error.OnapCommandLoginFailed; +import org.onap.cli.fw.error.OnapCommandLogoutFailed; +import org.onap.cli.fw.error.OnapCommandServiceNotFound; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.http.HttpResult; +import org.onap.cli.fw.http.OnapHttpConnection; + +/** + * Onap Auth client helps to do login and logout. + * + */ +public class OnapAuthClient { + + /* + * Onap credentials + */ + private OnapHttpConnection http = null; + + private OnapCredentials creds = null; + + public OnapAuthClient(OnapCredentials creds, boolean debug) throws OnapCommandHttpFailure { + this.creds = creds; + this.http = new OnapHttpConnection(creds.getMsbUrl().startsWith("https"), debug); + } + + /** + * Login. + * + * @throws OnapCommandLoginFailed + * LoginFailed Exception + * @throws OnapCommandHttpFailure + * Http request failed + * @throws OnapCommandExecutionFailed + * cmd exec failed + * @throws OnapCommandServiceNotFound + * service not found + */ + public void login() throws OnapCommandException { + + // For development purpose, its introduced and is not supported for production + if (OnapCommandConfg.isAuthIgnored()) { + return; + } + + HttpInput input = new HttpInput().setUri(this.getAuthUrl() + "/tokens") + .setBody(String.format(Constants.TOKEN, creds.getUsername(), creds.getPassword())) + .setMethod("post"); + + HttpResult result; + try { + result = this.run(input); + } catch (OnapCommandHttpFailure e) { + throw new OnapCommandLoginFailed(e); + } + if (result.getStatus() != HttpStatus.SC_OK && result.getStatus() != HttpStatus.SC_CREATED) { + throw new OnapCommandLoginFailed(result.getBody(), result.getStatus()); + } + + if (OnapCommandConfg.isCookiesBasedAuth()) { + this.http.setAuthToken(result.getRespCookies().get(Constants.X_AUTH_TOKEN)); + } else { + this.http.setAuthToken(result.getRespHeaders().get(Constants.X_AUTH_TOKEN)); + } + } + + /** + * Logout. + * + * @throws OnapCommandExecutionFailed + * cmd exec failed + * @throws OnapCommandServiceNotFound + * service not found + * @throws OnapCommandLogoutFailed + * logout failed + * @throws OnapCommandHttpFailure + * exception + */ + public void logout() throws OnapCommandException { + // For development purpose, its introduced and is not supported for production + if (OnapCommandConfg.isAuthIgnored()) { + return; + } + + HttpInput input = new HttpInput().setUri(this.getAuthUrl() + "/tokens").setMethod("delete"); + + HttpResult result; + try { + result = this.run(input); + } catch (OnapCommandHttpFailure e) { + throw new OnapCommandLogoutFailed(e); + } + if (result.getStatus() != HttpStatus.SC_NO_CONTENT) { + throw new OnapCommandLogoutFailed(result.getStatus()); + } + + this.http.close(); + } + + /** + * Find given service base path. + * + * @param srv + * onap service + * @return string + * @throws OnapCommandExecutionFailed + * Cmd execution failed exception + * @throws OnapCommandServiceNotFound + * Service not found + * @throws OnapCommandHttpFailure + * http request failed + */ + public String getServiceBasePath(OnapService srv) throws OnapCommandException { + if (srv.getName().equals(Constants.MSB)) { + return this.getMsbUrl(); + } + + HttpInput input = new HttpInput().setUri(this.creds.getMsbUrl() + + String.format(Constants.MSB_SERVICE_URI, srv.getName(), srv.getVersion())); + HttpResult result = this.http.get(input); + + if (result.getStatus() == HttpStatus.SC_NOT_FOUND) { + throw new OnapCommandServiceNotFound(srv.toString()); + } + if (!result.isSuccess()) { + throw new OnapCommandExecutionFailed("Failed to retrive service " + srv.toString()); + } + + try { + return this.creds.getMsbUrl() + JsonPath.read(result.getBody(), "url"); + } catch (Exception e) { + throw new OnapCommandExecutionFailed(e, srv.toString()); + } + } + + private String getAuthUrl() throws OnapCommandException { + OnapService srv = new OnapService(); + srv.setName(Constants.AUTH_SERVICE); + srv.setVersion(Constants.AUTH_SERVICE_VERSION); + return this.getServiceBasePath(srv); + } + + private String getMsbUrl() { + return this.creds.getMsbUrl() + Constants.MSB_URI; + } + + public String getAuthToken() { + return this.http.getAuthToken(); + } + + public String getDebugInfo() { + return this.http.getDebugInfo(); + } + + /** + * Http call to auth service. + * + * @param input + * http input + * @return http result + * @throws OnapCommandHttpFailure + * exception + */ + public HttpResult run(HttpInput input) throws OnapCommandHttpFailure { + if (OnapCommandConfg.isCookiesBasedAuth()) { + input.getReqCookies().put(Constants.X_AUTH_TOKEN, http.getAuthToken()); + } + return this.http.request(input); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/ad/OnapCredentials.java b/framework/src/main/java/org/onap/cli/fw/ad/OnapCredentials.java new file mode 100644 index 00000000..7c3c3ac0 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/ad/OnapCredentials.java @@ -0,0 +1,67 @@ +/* + * 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.fw.ad; + +/** + * Onap Service credentials. + */ +public class OnapCredentials { + + /* + * Onap Service username. + */ + private String username; + + /* + * Onap Service password + */ + private String password; + + /* + * Onap Service msb-url + */ + private String msbUrl; + + /** + * Onap credentials with username and password. + * + * @param username + * user name + * @param password + * password + * @param msbUrl + * msb url + */ + public OnapCredentials(String username, String password, String msbUrl) { + super(); + this.username = username; + this.password = password; + this.msbUrl = msbUrl; + } + + public String getUsername() { + return username; + } + + public String getPassword() { + return password; + } + + public String getMsbUrl() { + return msbUrl; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/ad/OnapService.java b/framework/src/main/java/org/onap/cli/fw/ad/OnapService.java new file mode 100644 index 00000000..16752f25 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/ad/OnapService.java @@ -0,0 +1,74 @@ +/* + * 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.fw.ad; + +/** + * Onap Service as reported in Onap MSB like msb v1 or /api/microservice/v1. + */ +public class OnapService { + /* + * Onap Service name like gso. + */ + private String serviceName; + + /* + * Onap Service API version like v1, v2, etc + */ + private String serviceVersion; + + private String basePath; + + private boolean noAuth = false; + + public boolean isNoAuth() { + return noAuth; + } + + public void setNoAuth(boolean noAuth) { + this.noAuth = noAuth; + } + + public String getName() { + return serviceName; + } + + public void setName(String name) { + this.serviceName = name; + } + + public String getVersion() { + return serviceVersion; + } + + public void setVersion(String version) { + this.serviceVersion = version; + } + + public String getBasePath() { + return basePath; + } + + public void setBasePath(String basePath) { + this.basePath = basePath; + } + + @Override + public String toString() { + return this.getName() + " " + this.getVersion(); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/cmd/OnapHttpCommand.java b/framework/src/main/java/org/onap/cli/fw/cmd/OnapHttpCommand.java new file mode 100644 index 00000000..d5f51f00 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapHttpCommand.java @@ -0,0 +1,97 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.http.HttpResult; +import org.onap.cli.fw.output.OnapCommandResultAttribute; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Onap Command. + * + */ +public class OnapHttpCommand extends OnapCommand { + + private HttpInput input = new HttpInput(); + + private List<Integer> successStatusCodes = new ArrayList<>(); + + private Map<String, String> resultMap = new HashMap<>(); + + public void setInput(HttpInput input) { + this.input = input; + } + + @Override + public String getSchemaVersion() { + return Constants.ONAP_CMD_SCHEMA_VERSION_VALUE; + } + + public void setSuccessStatusCodes(List<Integer> successStatusCodes) { + this.successStatusCodes = successStatusCodes; + } + + public void setResultMap(Map<String, String> resultMap) { + this.resultMap = resultMap; + } + + public HttpInput getInput() { + return input; + } + + public List<Integer> getSuccessStatusCodes() { + return successStatusCodes; + } + + public Map<String, String> getResultMap() { + return resultMap; + } + + @Override + protected void initializeProfileSchema() throws OnapCommandException { + OnapCommandUtils.loadSchema(this, this.getSchemaName()); + } + + @Override + protected void run() throws OnapCommandException { + HttpInput httpInput = OnapCommandUtils.populateParameters(this.getParametersMap(), this.getInput()); + httpInput.setUri(this.authClient.getServiceBasePath(this.getService()) + httpInput.getUri()); + + HttpResult output = this.authClient.run(httpInput); + + this.getResult().setOutput(output); + if (!this.getSuccessStatusCodes().contains(output.getStatus())) { + throw new OnapCommandExecutionFailed(this.getName(), output.getBody(), output.getStatus()); + } + + Map<String, ArrayList<String>> results = OnapCommandUtils.populateOutputs(this.getResultMap(), output); + + for (OnapCommandResultAttribute attr : this.getResult().getRecords()) { + attr.setValues(results.get(attr.getName())); + } + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommand.java b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommand.java new file mode 100644 index 00000000..57432751 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommand.java @@ -0,0 +1,68 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandSchema; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.output.OnapCommandResultAttribute; +import org.onap.cli.fw.utils.ExternalSchema; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.util.ArrayList; +import java.util.List; + +/** + * Refresh external schema. + * + */ +@OnapCommandSchema(name = "schema-refresh", schema = "schema-refresh.yaml") +public class OnapSchemaRefreshCommand extends OnapCommand { + + @Override + protected void run() throws OnapCommandException { + + List<ExternalSchema> schemas = OnapCommandUtils.findAllExternalSchemas(); + // Will override the existing json file + OnapCommandUtils.persist(schemas); + + List<String> slNumbers = new ArrayList<>(); + List<String> cmdNames = new ArrayList<>(); + List<String> cmdFiles = new ArrayList<>(); + List<String> versions = new ArrayList<>(); + + for (int i = 0; i < schemas.size(); i++) { + ExternalSchema schema = schemas.get(i); + slNumbers.add(String.valueOf(i + 1)); + cmdNames.add(schema.getCmdName()); + cmdFiles.add(schema.getSchemaName()); + versions.add(schema.getVersion()); + } + for (OnapCommandResultAttribute attribute : this.getResult().getRecords()) { + if ("sl-no".equals(attribute.getName())) { + attribute.setValues(slNumbers); + } else if ("command".equals(attribute.getName())) { + attribute.setValues(cmdNames); + } else if ("schema".equals(attribute.getName())) { + attribute.setValues(cmdFiles); + } else if ("version".equals(attribute.getName())) { + attribute.setValues(versions); + } + } + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommand.java b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommand.java new file mode 100644 index 00000000..a4d4e7d4 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommand.java @@ -0,0 +1,62 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandSchema; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.schema.SchemaValidate; +import org.onap.cli.fw.schema.SchemaValidator; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +/** + * Validate schema command. + * + */ +@OnapCommandSchema(name = "schema-validate", schema = "schema-validate.yaml") +public class OnapSchemaValidateCommand extends OnapCommand { + + @Override + protected void run() throws OnapCommandException { + Map<String, OnapCommandParameter> paramMap = getParametersMap(); + OnapCommandParameter locationParam = paramMap.get("schema-location"); + String location = String.valueOf(locationParam.getValue()); + OnapCommandParameter interSchemaParam = paramMap.get("internal-schema"); + boolean isInternalSchema = Boolean.valueOf(String.valueOf(interSchemaParam.getValue())); + SchemaValidate schema; + if (isInternalSchema) { + location = location.substring(1); + schema = new SchemaValidator(location); + } else { + schema = new SchemaValidator(new File(location)); + } + + List<String> error = schema.validate(); + List<String> slNumber = new ArrayList<>(); + for (int i = 1; i <= error.size(); i++) { + slNumber.add(String.valueOf(i)); + } + this.getResult().getRecords().get(0).setValues(slNumber); + this.getResult().getRecords().get(1).setValues(error); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/cmd/OnapSwaggerCommand.java b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSwaggerCommand.java new file mode 100644 index 00000000..fa3e7d7e --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSwaggerCommand.java @@ -0,0 +1,97 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.error.OnapCommandClientInitialzationFailed; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandResultInitialzationFailed; +import org.onap.cli.fw.output.OnapCommandResultAttribute; +import org.onap.cli.fw.run.OnapCommandExecutor; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.List; + +public abstract class OnapSwaggerCommand extends OnapCommand { + + + private OnapCommandExecutor cmdExecutor; + + public OnapCommandExecutor getExecutor() { + return cmdExecutor; + } + + public void setExecutor(OnapCommandExecutor executor) { + this.cmdExecutor = executor; + } + + /** + * Initialize the given ApiClient object with AUTH token and base path. + * + * @param client + * api client + * @throws OnapCommandClientInitialzationFailed + * client initialization failed + */ + protected <T> T initializeApiClient(T client) throws OnapCommandClientInitialzationFailed { + try { + Method basePath = client.getClass().getMethod("setBasePath", String.class); + basePath.invoke(client, this.getBasePath()); + + if (this.getAuthToken() != null) { + Method apiKey = client.getClass().getMethod("setApiKey", String.class); + apiKey.invoke(client, this.getAuthToken()); + } + return client; + } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException | OnapCommandException e) { + throw new OnapCommandClientInitialzationFailed(this.getName(), e); + } + } + + protected <T> void initializeResult(T obj) throws OnapCommandResultInitialzationFailed { + this.getResult().setOutput(obj); + if (obj instanceof List) { + this.initializeListResult((List) obj); + } else { + this.initializeRow(obj); + } + } + + private <T> void initializeRow(T obj) throws OnapCommandResultInitialzationFailed { + for (OnapCommandResultAttribute row : this.getResult().getRecords()) { + String methodName = OnapCommandUtils.formMethodNameFromAttributeName(row.getName(), "get"); + Method get; + try { + get = obj.getClass().getMethod(methodName); + row.getValues().add(get.invoke(obj).toString()); + } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException e) { + throw new OnapCommandResultInitialzationFailed(this.getName(), e); + } + } + } + + protected <T> void initializeListResult(List<T> rows) throws OnapCommandResultInitialzationFailed { + this.getResult().setOutput(rows); + for (T row : rows) { + this.initializeRow(row); + } + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/conf/Constants.java b/framework/src/main/java/org/onap/cli/fw/conf/Constants.java new file mode 100644 index 00000000..928cbc79 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/conf/Constants.java @@ -0,0 +1,160 @@ +/* + * 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.fw.conf; + +/** + * Constants. + * + */ +public class Constants { + + public static final String SSLCONTEST_TLS = "TLSV1.2"; + public static final String APPLICATION_JSON = "application/json"; + public static final String X_AUTH_TOKEN = "X-Auth-Token"; + + public static final String AUTH_SERVICE = "auth"; + public static final String AUTH_SERVICE_VERSION = "v1"; + public static final String TOKEN = "{\"userName\": \"%s\",\"password\": \"%s\"}"; + public static final String MSB_URI = "/api/microservices/v1"; + public static final String MSB_SERVICE_URI = MSB_URI + "/services/%s/version/%s"; + + public static final String MSB = "msb"; + + //http + public static final String URI = "uri"; + public static final String BODY = "body"; + public static final String MERHOD = "method"; + public static final String HEADERS = "headers"; + public static final String QUERIES = "queries"; + public static final String COOKIES = "cookies"; + + public static final String HTTP = "http"; + public static final String REQUEST = "request"; + public static final String SAMPLE_RESPONSE = "sample_response"; + public static final String SUCCESS_CODES = "success_codes"; + public static final String RESULT_MAP = "result_map"; + + //swagger + public static final String EXECUTOR = "exec"; + + public static final String API = "api"; + public static final String CLIENT = "client"; + public static final String ENTITY = "entity"; + public static final String METHOD = "method"; + public static final String EXCEPTION = "exception"; + + public static final String SCOPE = "scope"; + + public static final String ONAP_CMD_SCHEMA_VERSION_VALUE = "1.0"; + public static final String DESCRIPTION = "description"; + public static final String SERVICE = "service"; + public static final String PARAMETERS = "parameters"; + public static final String RESULTS = "results"; + + public static final String ONAP_CMD_SCHEMA_VERSION = "onap_cmd_schema_version"; + public static final String NAME = "name"; + public static final String VERSION = "version"; + public static final String BASE_PATH = "base_path"; + public static final String NO_AUTH = "no-auth"; + + public static final String SHORT_OPTION = "short_option"; + public static final String LONG_OPTION = "long_option"; + public static final String TYPE = "type"; + public static final String IS_OPTIONAL = "is_optional"; + public static final String DEFAULT_VALUE = "default_value"; + public static final String IS_SECURED = "is_secured"; + + public static final String DIRECTION = "direction"; + public static final String ATTRIBUTES = "attributes"; + + public static final String DEFAULT_PARAMETER_FILE_NAME = "default_input_parameters.yaml"; + + // Common parameters used across all commands. + public static final String DEAFULT_PARAMETER_USERNAME = "onap-username"; + public static final String DEAFULT_PARAMETER_PASS_WORD = "onap-password"; + public static final String DEAFULT_PARAMETER_MSB_URL = "msb-url"; + public static final String DEFAULT_PARAMETER_HELP = "help"; + public static final String DEFAULT_PARAMETER_VERSION = "version"; + public static final String DEFAULT_PARAMETER_DEBUG = "debug"; + public static final String DEFAULT_PARAMETER_OUTPUT_FORMAT = "format"; + public static final String DEFAULT_PARAMETER_OUTPUT_ATTR_LONG = "long"; + public static final String DEFAULT_PARAMETER_OUTPUT_NO_TITLE = "no-title"; + public static final String DEFAULT_PARAMETER_OUTPUT_NO_AUTH = "no-auth"; + + // Configuration properties + public static final String CONF = "onap.properties"; + public static final String ONAP_IGNORE_AUTH = "cli.ignore_auth"; + public static final String ONAP_CLI_VERSION = "cli.version"; + public static final String HTTP_API_KEY_USE_COOKIES = "http.api_key_use_cookies"; + public static final String HTTP_X_AUTH_TOKEN = "http.x_auth_token"; + + // Used while printing the column name during PORTRAIT mode print + public static final String PORTRAINT_COLUMN_NAME_PROPERTY = "property"; + public static final String PORTRAINT_COLUMN_NAME_VALUE = "value"; + + public static final String EXTERNAL_SCHEMA_DIRECTORY = "onap-cli-schema"; + public static final String EXTERNAL_YAML_PATTERN = "/**/*.yaml"; + public static final String EXTERNAL_JSON_PATTERN = "/**/*.json"; + public static final String EXTERNAL_SCHEMA_PATH_PATERN = EXTERNAL_SCHEMA_DIRECTORY + EXTERNAL_YAML_PATTERN; + public static final String EXTERNAL_DISCOVERY_DIRECTORY = "data"; + public static final String EXTERNAL_DISCOVERY_FILE = "external-schema.json"; + public static final String EXTERNAL_DISCOVERY_DIRECTORY_PATTERN = EXTERNAL_DISCOVERY_DIRECTORY + + EXTERNAL_JSON_PATTERN; + + public static final String PARAMETER_TYPE_JSON = "json"; + public static final String PARAMETER_TYPE_YAML = "yaml"; + public static final String PARAMETER_TYPE_STRING = "string"; + public static final String PARAMETER_TYPE_LONG = "long"; + public static final String PARAMETER_TYPE_URL = "url"; + public static final String PARAMETER_TYPE_BOOL = "bool"; + public static final String PARAMETER_TYPE_ARRAY = "array"; + public static final String PARAMETER_TYPE_BINARY = "binary"; + public static final String PARAMETER_TYPE_MAP = "map"; + + public static final String BOOLEAN_TRUE = "true"; + public static final String BOOLEAN_FALSE = "false"; + + public static final String DIRECTION_PORTRAIT = "portrait"; + public static final String DIRECTION_LANDSCAPE = "landscape"; + + public static final String RESULT_SCOPE_SHORT = "short"; + public static final String RESULT_SCOPE_LONG = "long"; + + public static final String POST = "post"; + public static final String GET = "get"; + public static final String DELETE = "delete"; + public static final String PUT = "put"; + public static final String HEAD = "delete"; + + public static final String DEFAULT_SCHEMA_FILE_NAME = "default_input_parameters.yaml"; + + // Error message + public static final String SCHEMA_FILE_EMPTY = "The schema file cann't be null or empty"; + public static final String SCHEMA_FILE_WRONG_EXTN = "Schema file should be '.yaml' extension"; + public static final String SCHEMA_FILE_NOT_EXIST = "Schema file doesn't exist"; + public static final String HTTP_SECTION_EMPTY = "Http Section cann't be null or empty"; + public static final String HTTP_BODY_SECTION_EMPTY = "http body section under 'request:' cann't be null or empty"; + public static final String HTTP_BODY_FAILED_PARSING = "The http body json is failed to parse"; + public static final String HTTP_BODY_JSON_EMPTY = "The http body json cann't be null or empty"; + public static final String HTTP_SUCCESS_CODE_INVALID = "Invalid http success code."; + public static final String HTTP_SAMPLE_RESPONSE_EMPTY = "Sample response cann't be null or empty"; + public static final String HTTP_SAMPLE_RESPONSE_FAILED_PARSING = "The http Sample response json is failed to parse."; + + private Constants() { + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/conf/OnapCommandConfg.java b/framework/src/main/java/org/onap/cli/fw/conf/OnapCommandConfg.java new file mode 100644 index 00000000..d5025e1b --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/conf/OnapCommandConfg.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.fw.conf; + +import java.io.IOException; +import java.util.Properties; + +/** + * Onap command constants. + * + */ +public final class OnapCommandConfg { + + private static Properties prps = new Properties(); + + /** + * Private constructor. + */ + private OnapCommandConfg() { + + } + + static { + try { + prps.load(OnapCommandConfg.class.getClassLoader().getResourceAsStream(Constants.CONF)); + } catch (IOException e) { + throw new RuntimeException(e); // NOSONAR + } + } + + /** + * is auth service ignored. + * + * @return boolean + */ + public static boolean isAuthIgnored() { + if ("true".equals(prps.getProperty(Constants.ONAP_IGNORE_AUTH))) { + return true; + } + + return false; + } + + public static String getVersion() { + return prps.getProperty(Constants.ONAP_CLI_VERSION); + } + + /** + * checks if cookies based auth. + * + * @return boolean + */ + public static boolean isCookiesBasedAuth() { + if ("true".equals(prps.getProperty(Constants.HTTP_API_KEY_USE_COOKIES))) { + return true; + } + + return false; + } + + public static String getXAuthTokenName() { + return prps.getProperty(Constants.HTTP_X_AUTH_TOKEN, "X-Auth-Token"); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandClientInitialzationFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandClientInitialzationFailed.java new file mode 100644 index 00000000..be88d18a --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandClientInitialzationFailed.java @@ -0,0 +1,37 @@ +/* + * 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.fw.error; + +/** + * Command not registered in MSB. + * + */ +public class OnapCommandClientInitialzationFailed extends OnapCommandException { + + private static final long serialVersionUID = 8580121615330415000L; + private static final String ERROR_CODE = "0x0021"; + private static final String ERROR_MESSAGE1 = "API client for the command "; + private static final String ERROR_MESSAGE2 = " is failed, "; + + public OnapCommandClientInitialzationFailed(String cmd, String error) { + super(ERROR_CODE, ERROR_MESSAGE1 + cmd + ERROR_MESSAGE2 + error); + } + + public OnapCommandClientInitialzationFailed(String cmd, Throwable throwable) { + this(cmd, throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandDiscoveryFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandDiscoveryFailed.java new file mode 100644 index 00000000..582e4cfc --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandDiscoveryFailed.java @@ -0,0 +1,44 @@ +/* + * 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.fw.error; + +public class OnapCommandDiscoveryFailed extends OnapCommandException { + + private static final long serialVersionUID = 424464582747161435L; + + private static final String ERROR_CODE = "0x0010"; + private static final String ERROR_MESSAGE1 = "Failed auto discover schema files from "; + private static final String ERROR_MESSAGE2 = " under class path, "; + private static final String ERROR_MESSAGE3 = "' under class path directory '"; + private static final String ERROR_MESSAGE4 = "Failed auto generate json file '"; + + public OnapCommandDiscoveryFailed(String name) { + this(name, new Exception("")); + } + + public OnapCommandDiscoveryFailed(String name, Throwable throwable) { + super(ERROR_CODE, ERROR_MESSAGE1 + name + ERROR_MESSAGE2 + throwable.getMessage()); + } + + public OnapCommandDiscoveryFailed(String directory, String fileName) { + this(directory, fileName, new Exception("")); + } + + public OnapCommandDiscoveryFailed(String directory, String fileName, Throwable throwable) { + super(ERROR_CODE, ERROR_MESSAGE4 + fileName + ERROR_MESSAGE3 + directory + "' , " + throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandException.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandException.java new file mode 100644 index 00000000..3ef1b400 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandException.java @@ -0,0 +1,73 @@ +/* + * 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.fw.error; + +/** + * Base command exception. + * + */ +public class OnapCommandException extends Exception { + + private static final long serialVersionUID = 2833124031431731711L; + + /* + * Command Error Code + */ + private final String errorCode; + + /* + * Command error message + */ + private final String errorMessage; + + /* + * Command HTTP status code + */ + private final long httpStatusCode; + + /** + * OnapCommandException constructor. + * + * @param errorCode + * error code + * @param errorMessage + * error message + * @param httpStatusCode + * http status code + */ + public OnapCommandException(String errorCode, String errorMessage, long httpStatusCode) { + super(); + this.errorCode = errorCode; + this.errorMessage = errorMessage; + this.httpStatusCode = httpStatusCode; + } + + public OnapCommandException(String errorCode, String errorMessage) { + this(errorCode, errorMessage, -1); + } + + @Override + public String getMessage() { + String message = this.errorCode + "::" + this.errorMessage; + if (this.httpStatusCode != -1) { + message = this.httpStatusCode + "::" + message; + } + + return message; + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutionFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutionFailed.java new file mode 100644 index 00000000..22d11acb --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutionFailed.java @@ -0,0 +1,55 @@ +/* + * 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.fw.error; + +/** + * Command execution failed. + * + */ +public class OnapCommandExecutionFailed extends OnapCommandException { + private static final long serialVersionUID = 488775545436993019L; + + private static final String ERROR_CODE = "0x0001"; + private static final String ERROR_MESSAGE1 = "Command "; + private static final String ERROR_MESSAGE2 = " failed to execute, "; + private static final String ERROR_MESSAGE3 = "Failed to retrive service url, "; + + public OnapCommandExecutionFailed(String cmdName, String error, long httpStatus) { + super(ERROR_CODE, ERROR_MESSAGE1 + cmdName + ERROR_MESSAGE2 + error, httpStatus); + } + + public OnapCommandExecutionFailed(String cmdName, Throwable throwable, long httpStatus) { + this(cmdName,throwable.getMessage(),httpStatus); + } + + public OnapCommandExecutionFailed(String error) { + super(ERROR_CODE, error); + } + + public OnapCommandExecutionFailed(Throwable throwable, String details) { + this(ERROR_MESSAGE3 + details + ", " + throwable.getMessage()); + } + + + public OnapCommandExecutionFailed(String cmdName, String error) { + super(ERROR_CODE, ERROR_MESSAGE1 + cmdName + ERROR_MESSAGE2 + error); + } + + public OnapCommandExecutionFailed(String cmd, Throwable throwable) { + this(cmd , throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutorInfoMissing.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutorInfoMissing.java new file mode 100644 index 00000000..b4945dda --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandExecutorInfoMissing.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * Command result initialization failed. + * + */ +public class OnapCommandExecutorInfoMissing extends OnapCommandException { + + private static final long serialVersionUID = 8580121615330415456L; + + public OnapCommandExecutorInfoMissing(String cmd) { + super("0x0023", "Command " + cmd + " excutor info is missing from schema"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHelpFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHelpFailed.java new file mode 100644 index 00000000..12e711e3 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHelpFailed.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.fw.error; + +/** + * Command help failed. + * + */ +public class OnapCommandHelpFailed extends OnapCommandException { + private static final long serialVersionUID = -1833571383961748518L; + + /** + * Help failed exception. + * + * @param error + * message + */ + public OnapCommandHelpFailed(String error) { + super("0x0002", "Command failed to print help message, " + error); + } + + public OnapCommandHelpFailed(Throwable throwable) { + this(throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpFailure.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpFailure.java new file mode 100644 index 00000000..80f99695 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpFailure.java @@ -0,0 +1,44 @@ +/* + * 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.fw.error; + +/** + * Command execution failed. + * + */ +public class OnapCommandHttpFailure extends OnapCommandException { + private static final long serialVersionUID = 488775545436993345L; + + private static final String ERROR = "0x0025"; + + public OnapCommandHttpFailure(String error, long httpStatus) { + super(ERROR, error, httpStatus); + } + + public OnapCommandHttpFailure(String error) { + super(ERROR, error); + } + + public OnapCommandHttpFailure(Throwable throwable) { + this(throwable.getMessage()); + } + + public OnapCommandHttpFailure(Throwable throwable, long httpStatus) { + this(throwable.getMessage(), httpStatus); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpHeaderNotFound.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpHeaderNotFound.java new file mode 100644 index 00000000..ba0006ec --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpHeaderNotFound.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * OnapCommandParameterNotFound. + * + */ +public class OnapCommandHttpHeaderNotFound extends OnapCommandException { + + private static final long serialVersionUID = 6676137916079057963L; + + public OnapCommandHttpHeaderNotFound(String name) { + super("0x0027", "Http header " + name + " is not returned from the service"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpInvalidResponseBody.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpInvalidResponseBody.java new file mode 100644 index 00000000..1451440a --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandHttpInvalidResponseBody.java @@ -0,0 +1,34 @@ +/* + * 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.fw.error; + +/** + * OnapCommandParameterNotFound. + * + */ +public class OnapCommandHttpInvalidResponseBody extends OnapCommandException { + + private static final long serialVersionUID = 6676137916079057963L; + + public OnapCommandHttpInvalidResponseBody(String name, String error) { + super("0x0028", "Http response body does not have json entry " + name + ", " + error); + } + + public OnapCommandHttpInvalidResponseBody(String name, Throwable throwable) { + this(name, throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterType.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterType.java new file mode 100644 index 00000000..066e2699 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterType.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.fw.error; + +/** + * Command input parameter type is invalid. + * + */ +public class OnapCommandInvalidParameterType extends OnapCommandException { + + private static final long serialVersionUID = 2821256032317061066L; + + public OnapCommandInvalidParameterType(String paramName) { + super("0x0003", "Parameter type " + paramName + " is invalid"); + + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterValue.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterValue.java new file mode 100644 index 00000000..652789a6 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidParameterValue.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.fw.error; + +/** + * Command input parameter value is invalid. + * + */ +public class OnapCommandInvalidParameterValue extends OnapCommandException { + + private static final long serialVersionUID = 2821256032317061437L; + + public OnapCommandInvalidParameterValue(String paramName) { + this(paramName,new Exception("")); + } + + public OnapCommandInvalidParameterValue(String paramName, Throwable throwable) { + super("0x0028", "Parameter " + paramName + " value is invalid, " + throwable.getMessage()); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidPrintDirection.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidPrintDirection.java new file mode 100644 index 00000000..960bfa40 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidPrintDirection.java @@ -0,0 +1,31 @@ +/* + * 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.fw.error; + +/** + * Command print direction invalid. + * + */ +public class OnapCommandInvalidPrintDirection extends OnapCommandException { + + private static final long serialVersionUID = -6008135162231523072L; + + public OnapCommandInvalidPrintDirection(String direction) { + super("0x0004", "Print direction " + direction + " is invalid"); + + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidRegistration.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidRegistration.java new file mode 100644 index 00000000..c403a4ad --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidRegistration.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.fw.error; + +import org.onap.cli.fw.OnapCommand; + +/** + * Command class invalid. + * + */ +public class OnapCommandInvalidRegistration extends OnapCommandException { + + private static final long serialVersionUID = 7722163282274482532L; + + public OnapCommandInvalidRegistration(Class cls) { + super("0x0005", "Invalid commad class " + cls.getCanonicalName() + " registration, it should be derived from " + + OnapCommand.class.getCanonicalName()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidResultAttributeScope.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidResultAttributeScope.java new file mode 100644 index 00000000..d4a3a5ee --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidResultAttributeScope.java @@ -0,0 +1,31 @@ +/* + * 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.fw.error; + +/** + * Result attribute invalid. + * + */ +public class OnapCommandInvalidResultAttributeScope extends OnapCommandException { + + private static final long serialVersionUID = 117926166492101573L; + + public OnapCommandInvalidResultAttributeScope(String attr) { + super("0x0006", "Result atrribute " + attr + " is invalid"); + + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchema.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchema.java new file mode 100644 index 00000000..a32a8f2a --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchema.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.fw.error; + +/** + * Command schema is invalid. + * + */ +public class OnapCommandInvalidSchema extends OnapCommandException { + + private static final long serialVersionUID = -3387652326582792833L; + + public OnapCommandInvalidSchema(String schema, String error) { + super("0x0007", "Command schema " + schema + " is invalid, " + error); + } + + public OnapCommandInvalidSchema(String schema, Throwable throwable) { + this(schema, throwable.getMessage()); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchemaVersion.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchemaVersion.java new file mode 100644 index 00000000..75530ab4 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandInvalidSchemaVersion.java @@ -0,0 +1,31 @@ +/* + * 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.fw.error; + +/** + * Command schema version is invalid. + * + */ +public class OnapCommandInvalidSchemaVersion extends OnapCommandException { + + private static final long serialVersionUID = 4459731110721370387L; + + public OnapCommandInvalidSchemaVersion(String schemaVersion) { + super("0x0008", "Command schema onap_cmd_schema_version " + schemaVersion + " is invalid or missing"); + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLoginFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLoginFailed.java new file mode 100644 index 00000000..c2d69bc1 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLoginFailed.java @@ -0,0 +1,41 @@ +/* + * 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.fw.error; + +/** + * Login failed. + * + */ +public class OnapCommandLoginFailed extends OnapCommandException { + + private static final long serialVersionUID = 5518154493762956959L; + + private static final String ERROR_CODE = "0x0009"; + private static final String ERROR_MESSAGE1 = "Login failed, "; + + public OnapCommandLoginFailed(String error) { + super(ERROR_CODE, ERROR_MESSAGE1 + error); + } + + public OnapCommandLoginFailed(String error, int httpStatus) { + super(ERROR_CODE, ERROR_MESSAGE1 + error, httpStatus); + } + + public OnapCommandLoginFailed(Throwable throwable) { + this(throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLogoutFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLogoutFailed.java new file mode 100644 index 00000000..3b415de0 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandLogoutFailed.java @@ -0,0 +1,40 @@ +/* + * 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.fw.error; + +/** + * Logout failed. + * + */ +public class OnapCommandLogoutFailed extends OnapCommandException { + + private static final long serialVersionUID = 1150649507734289032L; + private static final String ERROR_CODE = "0x0010"; + private static final String ERROR_MESSAGE1 = "Logout failed, "; + + public OnapCommandLogoutFailed(String error) { + super(ERROR_CODE, ERROR_MESSAGE1 + error); + } + + public OnapCommandLogoutFailed(Throwable throwable) { + this(throwable.getMessage()); + } + + public OnapCommandLogoutFailed(int statusCode) { + super(ERROR_CODE, ERROR_MESSAGE1, statusCode); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotFound.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotFound.java new file mode 100644 index 00000000..172d60bb --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotFound.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * Command not registered in CLI registrar. + * + */ +public class OnapCommandNotFound extends OnapCommandException { + + private static final long serialVersionUID = 6676137916079057963L; + + public OnapCommandNotFound(String cmdName) { + super("0x0011", "Command " + cmdName + " is not registered"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotInitialized.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotInitialized.java new file mode 100644 index 00000000..8c3f6c22 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandNotInitialized.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * Command not initialized. + * + */ +public class OnapCommandNotInitialized extends OnapCommandException { + + private static final long serialVersionUID = -2828462844645573902L; + + public OnapCommandNotInitialized(String cmdName) { + super("0x0012", "Command " + cmdName + " is not initialized"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputFormatNotsupported.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputFormatNotsupported.java new file mode 100644 index 00000000..e54171ef --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputFormatNotsupported.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * Command does not support to format of output. + * + */ +public class OnapCommandOutputFormatNotsupported extends OnapCommandException { + + private static final long serialVersionUID = 2429471829315901896L; + + public OnapCommandOutputFormatNotsupported(String format) { + super("0x0013", "Command does not support the output format " + format); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputPrintingFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputPrintingFailed.java new file mode 100644 index 00000000..31ee3e0b --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandOutputPrintingFailed.java @@ -0,0 +1,34 @@ +/* + * 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.fw.error; + +/** + * Output print failed. + * + */ +public class OnapCommandOutputPrintingFailed extends OnapCommandException { + + private static final long serialVersionUID = -1957064141442406239L; + + public OnapCommandOutputPrintingFailed(String error) { + super("0x0014", "Command is failed to print the result, " + error); + } + + public OnapCommandOutputPrintingFailed(Throwable throwable) { + this(throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterMissing.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterMissing.java new file mode 100644 index 00000000..54e0a0de --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterMissing.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.fw.error; + +/** + * Command input parameters are invalid. + * + */ +public class OnapCommandParameterMissing extends OnapCommandException { + + private static final long serialVersionUID = 2821256032317061066L; + + public OnapCommandParameterMissing(String paramName) { + super("0x0015", "Parameter " + paramName + " is mandatory"); + + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNameConflict.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNameConflict.java new file mode 100644 index 00000000..d5dc185c --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNameConflict.java @@ -0,0 +1,31 @@ +/* + * 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.fw.error; + +/** + * Command input parameter options are conflicting. + * + */ +public class OnapCommandParameterNameConflict extends OnapCommandException { + + private static final long serialVersionUID = -993203017969910920L; + + public OnapCommandParameterNameConflict(String name) { + super("0x0016", "Parameter name " + name + " is in conflict"); + + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNotFound.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNotFound.java new file mode 100644 index 00000000..ea3eb3a8 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterNotFound.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * OnapCommandParameterNotFound. + * + */ +public class OnapCommandParameterNotFound extends OnapCommandException { + + private static final long serialVersionUID = 6676137916079057963L; + + public OnapCommandParameterNotFound(String paramName) { + super("0x0026", "Command input parameter " + paramName + " is not valid"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterOptionConflict.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterOptionConflict.java new file mode 100644 index 00000000..91decf99 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandParameterOptionConflict.java @@ -0,0 +1,31 @@ +/* + * 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.fw.error; + +/** + * Command input parameter names are conflicting. + * + */ +public class OnapCommandParameterOptionConflict extends OnapCommandException { + + private static final long serialVersionUID = -3107017890769007297L; + + public OnapCommandParameterOptionConflict(String name) { + super("0x0017", "Parameter option " + name + " is in conflict, only one option is allowed with given name"); + + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandRegistrationFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandRegistrationFailed.java new file mode 100644 index 00000000..d920f7d0 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandRegistrationFailed.java @@ -0,0 +1,34 @@ +/* + * 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.fw.error; + +/** + * Command Not registered in Onap Command Registrar. + * + */ +public class OnapCommandRegistrationFailed extends OnapCommandException { + + private static final long serialVersionUID = 5513297861129088460L; + + public OnapCommandRegistrationFailed(String cmdName, String error) { + super("0x0018", "Command " + cmdName + " is failed to register, " + error); + } + + public OnapCommandRegistrationFailed(String cmdName, Throwable throwable) { + this(cmdName, throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultEmpty.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultEmpty.java new file mode 100644 index 00000000..5d7e4fd3 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultEmpty.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.fw.error; + +/** + * Command result empty. + * + */ +public class OnapCommandResultEmpty extends OnapCommandWarning { + + private static final long serialVersionUID = 8580121615330415123L; + + /** + * Command result empty. + */ + public OnapCommandResultEmpty() { + super("0x1001", "Command result is empty"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultInitialzationFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultInitialzationFailed.java new file mode 100644 index 00000000..20060531 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultInitialzationFailed.java @@ -0,0 +1,34 @@ +/* + * 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.fw.error; + +/** + * Command result initialization failed. + * + */ +public class OnapCommandResultInitialzationFailed extends OnapCommandException { + + private static final long serialVersionUID = 8580121615330415123L; + + public OnapCommandResultInitialzationFailed(String cmd, String error) { + super("0x0022", "Command " + cmd + " result format is failed, " + error); + } + + public OnapCommandResultInitialzationFailed(String cmd, Throwable throwable) { + this(cmd, throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultMapProcessingFailed.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultMapProcessingFailed.java new file mode 100644 index 00000000..191ced06 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandResultMapProcessingFailed.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.fw.error; + +/** + * Result map failure. + * + */ +public class OnapCommandResultMapProcessingFailed extends OnapCommandException { + private static final long serialVersionUID = 488775545436113019L; + + private static final String errorCode = "0x0028"; + + public OnapCommandResultMapProcessingFailed(String resultMap, String error) { + super(errorCode, "Failed to process the result map " + resultMap + " in http section, " + error); + } + + public OnapCommandResultMapProcessingFailed(String resultMap, Throwable throwable) { + this(resultMap, throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandSchemaNotFound.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandSchemaNotFound.java new file mode 100644 index 00000000..cbd6fa69 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandSchemaNotFound.java @@ -0,0 +1,34 @@ +/* + * 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.fw.error; + +/** + * Command schema not found. + * + */ +public class OnapCommandSchemaNotFound extends OnapCommandException { + + private static final long serialVersionUID = -3919580583845280200L; + + public OnapCommandSchemaNotFound(String cmdName) { + this(cmdName, new Exception("")); + } + + public OnapCommandSchemaNotFound(String cmdName, Throwable throwable) { + super("0x0019", "Command schema " + cmdName + " is not found, " + throwable.getMessage()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandServiceNotFound.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandServiceNotFound.java new file mode 100644 index 00000000..fbbaafbd --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandServiceNotFound.java @@ -0,0 +1,30 @@ +/* + * 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.fw.error; + +/** + * Command not registered in MSB. + * + */ +public class OnapCommandServiceNotFound extends OnapCommandException { + + private static final long serialVersionUID = 8580121615330415065L; + + public OnapCommandServiceNotFound(String service) { + super("0x0020", "Service " + service + " is not found in MSB"); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/error/OnapCommandWarning.java b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandWarning.java new file mode 100644 index 00000000..bb102a5b --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/error/OnapCommandWarning.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.fw.error; + +/** + * Command warning. + * + */ +public abstract class OnapCommandWarning extends OnapCommandException { + public OnapCommandWarning(String errorCode, String errorMessage, long httpStatusCode) { + super(errorCode, errorMessage, httpStatusCode); + } + + public OnapCommandWarning(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + private static final long serialVersionUID = -1833571383961748520L; +} diff --git a/framework/src/main/java/org/onap/cli/fw/http/HttpInput.java b/framework/src/main/java/org/onap/cli/fw/http/HttpInput.java new file mode 100644 index 00000000..3ab6cf4b --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/http/HttpInput.java @@ -0,0 +1,128 @@ +/* + * 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.fw.http; + +import java.util.HashMap; +import java.util.Map; + +/** + * Captures HTTP request URI, body and request &query parameters. <br> + */ +public class HttpInput { + + private String reqUri = ""; + + private String reqBody = ""; + + private String reqMethod = ""; + + private Map<String, String> reqHeaders = new HashMap<>(); + + private Map<String, String> reqQueries = new HashMap<>(); + + private Map<String, String> reqCookies = new HashMap<>(); + + private boolean binaryData; + + public String getUri() { + return this.reqUri; + } + + public HttpInput setUri(String uri) { + this.reqUri = uri; + return this; + } + + public String getBody() { + return this.reqBody; + } + + public HttpInput setBody(String body) { + this.reqBody = body; + return this; + } + + public Map<String, String> getReqHeaders() { + return this.reqHeaders; + } + + /** + * header parameter setter. + * + * @param reqHeaders + * header map + * @return HttpInput + */ + public HttpInput setReqHeaders(Map<String, String> reqHeaders) { + if (reqHeaders != null) { + this.reqHeaders = reqHeaders; + } + return this; + } + + public String getMethod() { + return this.reqMethod; + } + + public HttpInput setMethod(String method) { + this.reqMethod = method; + return this; + } + + public Map<String, String> getReqQueries() { + return reqQueries; + } + + /** + * Request query parameters. + * + * @param reqQueries + * request queries + * @return HttpInput + */ + public HttpInput setReqQueries(Map<String, String> reqQueries) { + if (reqQueries != null) { + this.reqQueries = reqQueries; + } + return this; + } + + public Map<String, String> getReqCookies() { + return reqCookies; + } + + public HttpInput setReqCookies(Map<String, String> reqCookies) { + this.reqCookies = reqCookies; + return this; + } + + public boolean isBinaryData() { + return binaryData; + } + + public void setBinaryData(boolean binaryData) { + this.binaryData = binaryData; + } + + @Override + public String toString() { + return "\nURL: " + this.getUri() + "\nMethod: " + this.getMethod() + "\nRequest Queries: " + + this.getReqQueries() + "\nRequest Body: " + this.getBody() + "\nRequest Headers: " + + this.getReqHeaders().toString() + "\nRequest Cookies: " + this.getReqCookies().toString() + + "\nbinaryData=" + this.binaryData; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/http/HttpResult.java b/framework/src/main/java/org/onap/cli/fw/http/HttpResult.java new file mode 100644 index 00000000..e000ee15 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/http/HttpResult.java @@ -0,0 +1,77 @@ +/* + * 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.fw.http; + +import java.util.HashMap; +import java.util.Map; + +/** + * Captures HTTP response status, body and headers. <br> + * + */ +public class HttpResult { + + private int status; + + private String resBody; + + private Map<String, String> respHeaders = new HashMap<>(); + + private Map<String, String> respCookies = new HashMap<>(); + + public int getStatus() { + return this.status; + } + + public void setStatus(int status) { + this.status = status; + } + + public String getBody() { + return this.resBody; + } + + public void setBody(String body) { + this.resBody = body; + } + + public void setRespHeaders(Map<String, String> respHeaders) { + this.respHeaders = respHeaders; + } + + public Map<String, String> getRespHeaders() { + return this.respHeaders; + } + + public Map<String, String> getRespCookies() { + return respCookies; + } + + public void setRespCookies(Map<String, String> respCookies) { + this.respCookies = respCookies; + } + + public boolean isSuccess() { + return this.getStatus() >= 200 && this.getStatus() <= 300; + } + + @Override + public String toString() { + return "\nHTTP Status: " + this.getStatus() + "\nResponse Body: " + this.getBody() + "\nResponse Headers: " + + this.getRespHeaders() + "\nResponse Cookies: " + this.getRespCookies(); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/http/OnapHttpConnection.java b/framework/src/main/java/org/onap/cli/fw/http/OnapHttpConnection.java new file mode 100644 index 00000000..5b8cf8b1 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/http/OnapHttpConnection.java @@ -0,0 +1,346 @@ +/* + * 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.fw.http; + +import org.apache.http.Header; +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.ParseException; +import org.apache.http.client.CookieStore; +import org.apache.http.client.HttpClient; +import org.apache.http.client.methods.HttpDelete; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpPut; +import org.apache.http.client.methods.HttpRequestBase; +import org.apache.http.client.protocol.ClientContext; +import org.apache.http.config.Registry; +import org.apache.http.config.RegistryBuilder; +import org.apache.http.conn.HttpClientConnectionManager; +import org.apache.http.conn.socket.ConnectionSocketFactory; +import org.apache.http.conn.ssl.AllowAllHostnameVerifier; +import org.apache.http.conn.ssl.SSLConnectionSocketFactory; +import org.apache.http.conn.ssl.X509HostnameVerifier; +import org.apache.http.cookie.Cookie; +import org.apache.http.entity.StringEntity; +import org.apache.http.entity.mime.HttpMultipartMode; +import org.apache.http.entity.mime.MultipartEntity; +import org.apache.http.entity.mime.content.FileBody; +import org.apache.http.impl.client.BasicCookieStore; +import org.apache.http.impl.client.HttpClients; +import org.apache.http.impl.client.LaxRedirectStrategy; +import org.apache.http.impl.conn.PoolingHttpClientConnectionManager; +import org.apache.http.impl.cookie.BasicClientCookie; +import org.apache.http.protocol.BasicHttpContext; +import org.apache.http.protocol.HttpContext; +import org.apache.http.util.EntityUtils; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandHttpFailure; + +import java.io.File; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.security.cert.X509Certificate; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import javax.net.ssl.SSLContext; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509TrustManager; + +/** + * Helps to make http connection.<br> + */ +public class OnapHttpConnection { + + private HttpClient httpClient = null; + + private String xauthToken = null; + + protected boolean debug = false; + + private String debugDetails = ""; + + public static class TrustAllX509TrustManager implements X509TrustManager { + + @Override + public X509Certificate[] getAcceptedIssuers() { + return new X509Certificate[0]; + } + + @Override + public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType) { + // No need to implement. + } + + @Override + public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType) { + // No need to implement. + } + } + + /** + * OnapHttpConnection Constructor. + * + * @param isSecured + * boolean + * @param debug + * boolean + * @throws OnapCommandHttpFailure + * exception + */ + public OnapHttpConnection(boolean isSecured, boolean debug) throws OnapCommandHttpFailure { + try { + if (isSecured) { + SSLContext sslContext = SSLContext.getInstance(Constants.SSLCONTEST_TLS); + sslContext.init(null, new TrustManager[] { new TrustAllX509TrustManager() }, + new java.security.SecureRandom()); + X509HostnameVerifier hostnameVerifier = new AllowAllHostnameVerifier(); + Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder + .<ConnectionSocketFactory>create() + .register("https", new SSLConnectionSocketFactory(sslContext, hostnameVerifier)).build(); + HttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry); + + this.httpClient = HttpClients.custom().setConnectionManager(connManager) + .setRedirectStrategy(new LaxRedirectStrategy()).build(); + } else { + this.httpClient = HttpClients.createDefault(); + } + } catch (Exception e) { + throw new OnapCommandHttpFailure(e); + } + + this.debug = debug; + } + + public String getDebugInfo() { + return this.debugDetails; + } + + public void setAuthToken(String token) { + this.xauthToken = token; + } + + public String getAuthToken() { + return this.xauthToken; + } + + private Map<String, String> getHttpHeaders(HttpResponse resp) { + Map<String, String> result = new HashMap<>(); + + Header[] hs = resp.getAllHeaders(); + for (int i = 0; i < hs.length; i++) { + result.put(hs[i].getName(), hs[i].getValue()); + } + + return result; + } + + private String getResponseBody(HttpResponse resp) throws OnapCommandHttpFailure { + if (resp.getEntity() == null) { + return null; + } + try { + String body = EntityUtils.toString(resp.getEntity(), StandardCharsets.UTF_8); + EntityUtils.consume(resp.getEntity()); + return body; + } catch (IOException e) { + throw new OnapCommandHttpFailure(e); + } + } + + private StringEntity getStringEntity(HttpInput input) { + return new StringEntity(input.getBody(), StandardCharsets.UTF_8); + } + + /** + * Post. <br> + * + * @param input + * HttpInput Obj + * @return HttpResult + * @throws OnapCommandHttpFailure + * http failure + */ + public HttpResult post(final HttpInput input) throws OnapCommandHttpFailure { + input.setMethod("post"); + return this.request(input); + } + + /** + * Get. <br> + * + * @param input + * input request + * @return HttpResult + * @throws OnapCommandHttpFailure + * excpetion + */ + public HttpResult get(final HttpInput input) throws OnapCommandHttpFailure { + input.setMethod("get"); + return this.request(input); + } + + /** + * Put. <br> + * + * @param input + * input request + * @return HttpResult + * @throws OnapCommandHttpFailure + * Exception + */ + public HttpResult put(final HttpInput input) throws OnapCommandHttpFailure { + input.setMethod("put"); + return this.request(input); + } + + /** + * Delete. <br> + * + * @param input + * input request + * @return HttpResult + * @throws OnapCommandHttpFailure + * exception + */ + public HttpResult delete(final HttpInput input) throws OnapCommandHttpFailure { + input.setMethod("delete"); + return this.request(input); + } + + private void addCommonHeaders(HttpInput input) { + if (!input.isBinaryData()) { + input.getReqHeaders().put("Content-Type", Constants.APPLICATION_JSON); + } + input.getReqHeaders().put("Accept", Constants.APPLICATION_JSON); + if (this.xauthToken != null) { + input.getReqHeaders().put(Constants.X_AUTH_TOKEN, this.xauthToken); + } + } + + private void addCommonCookies(CookieStore cookieStore) { + Cookie cookie = new BasicClientCookie(Constants.X_AUTH_TOKEN, this.xauthToken); + cookieStore.addCookie(cookie); + } + + private void updateResultFromCookies(HttpResult result, List<Cookie> cookies) { + for (Cookie cookie : cookies) { + result.getRespCookies().put(cookie.getName(), cookie.getValue()); + } + } + + private String getDomain(String url) { + try { + return new URL(url).getHost(); + } catch (MalformedURLException e) { + // url is always proper !! + return url; + } + } + + private void updateInputFromCookies(HttpInput input, CookieStore cookieStore) { + addCommonCookies(cookieStore); + for (String cookieName : input.getReqCookies().keySet()) { + BasicClientCookie cookie = new BasicClientCookie(cookieName, input.getReqCookies().get(cookieName)); + cookie.setDomain(this.getDomain(input.getUri())); + cookieStore.addCookie(cookie); + } + + } + + /** + * Handles http method requests. + * + * @param input + * HttpInput + * @return HttpResult + * @throws OnapCommandHttpFailure + * exception + */ + public HttpResult request(HttpInput input) throws OnapCommandHttpFailure { + this.addCommonHeaders(input); + + HttpRequestBase requestBase = null; + if ("post".equals(input.getMethod())) { + HttpPost httpPost = new HttpPost(); + if (input.isBinaryData()) { + httpPost.setEntity(getMultipartEntity(input)); + } else { + httpPost.setEntity(this.getStringEntity(input)); + } + requestBase = httpPost; + } else if ("put".equals(input.getMethod())) { + HttpPut httpPut = new HttpPut(); + httpPut.setEntity(this.getStringEntity(input)); + requestBase = httpPut; + } else if ("get".equals(input.getMethod())) { + requestBase = new HttpGet(); + } else if ("delete".equals(input.getMethod())) { + requestBase = new HttpDelete(); + } else { + throw new IllegalArgumentException("Invalid HTTP method"); + } + + requestBase.setURI(URI.create(input.getUri())); + + for (Entry<String, String> h : input.getReqHeaders().entrySet()) { + requestBase.addHeader(h.getKey(), h.getValue()); + } + + HttpResult result = new HttpResult(); + + try { + this.debugDetails = ""; + CookieStore cookieStore = new BasicCookieStore(); + updateInputFromCookies(input, cookieStore); + HttpContext localContext = new BasicHttpContext(); + localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); + + HttpResponse resp = this.httpClient.execute(requestBase, localContext); + String respContent = this.getResponseBody(resp); + result.setBody(respContent); + result.setStatus(resp.getStatusLine().getStatusCode()); + result.setRespHeaders(this.getHttpHeaders(resp)); + this.updateResultFromCookies(result, cookieStore.getCookies()); + } catch (ParseException | IOException e) { + throw new OnapCommandHttpFailure(e); + } finally { + if (this.debug) { + this.debugDetails = input + "" + result; + } + } + + return result; + } + + public void close() { + this.setAuthToken(null); + } + + private HttpEntity getMultipartEntity(HttpInput input) { + FileBody fileBody = new FileBody(new File(input.getBody().trim())); + MultipartEntity multipartEntity = new MultipartEntity(); + multipartEntity.addPart("file", fileBody); + return multipartEntity; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/input/OnapCommandParameter.java b/framework/src/main/java/org/onap/cli/fw/input/OnapCommandParameter.java new file mode 100644 index 00000000..167b353d --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/input/OnapCommandParameter.java @@ -0,0 +1,254 @@ +/* + * 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.fw.input; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; +import org.onap.cli.fw.error.OnapCommandParameterMissing; + +import java.io.File; +import java.util.List; +import java.util.Map; + +/** + * Onap Command's input parameter. + * + */ +public class OnapCommandParameter { + + /* + * Name, for positional parameters, the place is decided from schema file definition + */ + private String cmdName; + + /* + * Description + */ + private String cmdDescription = ""; + + /* + * Short Option, like -f, for positional parameters, its not required. + */ + private String shortOption = null; + + /* + * Long Option, like --file-path, for positional parameters, its not required. + */ + private String longOption = null; + + /* + * Parameter type such as int, json, yaml, string, etc + */ + private ParameterType parameterType; + + /* + * Default value + */ + private String defaultValue = ""; + + /* + * Is optional + */ + private boolean isOptional = false; + + /* + * Is secured + */ + private boolean isSecured = false; + + /* + * Parameter Value + */ + private Object value; + + public String getName() { + return cmdName; + } + + public void setName(String name) { + this.cmdName = name; + } + + public String getDescription() { + return cmdDescription; + } + + public void setDescription(String description) { + this.cmdDescription = description; + } + + public String getShortOption() { + return shortOption; + } + + public void setShortOption(String shortOption) { + this.shortOption = shortOption; + } + + public String getLongOption() { + return longOption; + } + + public void setLongOption(String longOption) { + this.longOption = longOption; + } + + public ParameterType getParameterType() { + return parameterType; + } + + public void setParameterType(ParameterType parameterType) { + this.parameterType = parameterType; + } + + /** + * Returns default value. + * + * @return string + */ + public String getDefaultValue() { + if (this.isDefaultValueAnEnv()) { + String envVar = this.getEnvVarNameFromDefaultValue(); + this.defaultValue = System.getenv(envVar); + } else if (this.getParameterType().equals(ParameterType.BOOL)) { + // For bool type always the default param is false + this.defaultValue = "false"; + } + + return defaultValue; + } + + /** + * check if the default value is ${ENV_VAR_NAME}. + * + * @return boolean + */ + public boolean isDefaultValueAnEnv() { + return this.defaultValue.trim().startsWith("${") && this.defaultValue.trim().endsWith("}"); + } + + /** + * check if the default value is ${ENV_VAR_NAME} and return the ENV_VAR_NAME. + * + * @return ENV_VAR_NAME + */ + public String getEnvVarNameFromDefaultValue() { + return this.defaultValue.trim().substring(2, this.defaultValue.length() - 1); + } + + public void setDefaultValue(String defaultValue) { + this.defaultValue = defaultValue; + } + + /** + * Returns param value. + * + * @return value + * @throws OnapCommandInvalidParameterValue + * exception + */ + public Object getValue() throws OnapCommandInvalidParameterValue { + if (value != null) { + if (ParameterType.URL.equals(parameterType) && !value.toString().startsWith("http") + && !value.toString().startsWith("/")) { + value = "/" + value; + } else if (ParameterType.ARRAY.equals(parameterType)) { + if (!(value instanceof List)) { + throw new OnapCommandInvalidParameterValue(this.getName()); + } + + List<String> list = (List<String>) value; + ObjectMapper mapper = new ObjectMapper(); + try { + return mapper.writeValueAsString(list); + } catch (JsonProcessingException e) { + throw new OnapCommandInvalidParameterValue(this.getName(), e); + } + } else if (ParameterType.MAP.equals(parameterType)) { + if (!(value instanceof Map)) { + throw new OnapCommandInvalidParameterValue(this.getName()); + } + + Map<String, String> map = (Map<String, String>) value; + ObjectMapper mapper = new ObjectMapper(); + try { + return mapper.writeValueAsString(map); + } catch (JsonProcessingException e) { + throw new OnapCommandInvalidParameterValue(this.getName(), e); + } + } + + return value; + } + return getDefaultValue(); + } + + public void setValue(Object value) { + this.value = value; + } + + public boolean isOptional() { + return isOptional; + } + + public void setOptional(boolean isOptional) { + this.isOptional = isOptional; + } + + public boolean isSecured() { + return isSecured; + } + + public void setSecured(boolean isSecured) { + this.isSecured = isSecured; + } + + public static String printShortOption(String option) { + return "-" + option; + } + + public static String printLongOption(String option) { + return "-" + printShortOption(option); + } + + /** + * Validate parameter value. + * + * @throws OnapCommandParameterMissing + * exception + * @throws OnapCommandInvalidParameterValue + * exception + */ + public void validate() throws OnapCommandException { + // (mrkanag) empty check needs to revisit + if (!this.isOptional() && (this.getValue() == null || this.getValue().toString().isEmpty())) { + throw new OnapCommandParameterMissing(this.getName()); + } + + if (!this.isOptional() && ParameterType.BINARY.equals(parameterType)) { + File file = new File(value.toString()); + if (!file.isFile()) { + throw new OnapCommandInvalidParameterValue(this.getName()); + } + } + + // (mrkanag) validate for type supported ParameterType using constraints + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/input/ParameterType.java b/framework/src/main/java/org/onap/cli/fw/input/ParameterType.java new file mode 100644 index 00000000..ec76e0b4 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/input/ParameterType.java @@ -0,0 +1,71 @@ +/* + * 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.fw.input; + +import org.onap.cli.fw.error.OnapCommandInvalidParameterType; + +/** + * Parameter type supported by Onap CLI. + * + */ +public enum ParameterType { + /** + * JSON file. + */ + JSON, + /** + * YAML file. + */ + YAML, STRING, LONG, + /** + * URL location. + */ + URL, BOOL, ARRAY, MAP, BINARY; + + /** + * Get parameter type. + * + * @param name + * type name + * @return type + * @throws OnapCommandInvalidParameterType + * exception + */ + public static ParameterType get(String name) throws OnapCommandInvalidParameterType { + if (JSON.name().equalsIgnoreCase(name)) { + return JSON; + } else if (YAML.name().equalsIgnoreCase(name)) { + return YAML; + } else if (STRING.name().equalsIgnoreCase(name)) { + return STRING; + } else if (LONG.name().equalsIgnoreCase(name)) { + return LONG; + } else if (URL.name().equalsIgnoreCase(name)) { + return URL; + } else if (BOOL.name().equalsIgnoreCase(name)) { + return BOOL; + } else if (ARRAY.name().equalsIgnoreCase(name)) { + return ARRAY; + } else if (MAP.name().equalsIgnoreCase(name)) { + return MAP; + } else if (BINARY.name().equalsIgnoreCase(name)) { + return BINARY; + } else { + throw new OnapCommandInvalidParameterType(name); + } + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/log/OnapCommandLogger.java b/framework/src/main/java/org/onap/cli/fw/log/OnapCommandLogger.java new file mode 100644 index 00000000..a29d3597 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/log/OnapCommandLogger.java @@ -0,0 +1,53 @@ +/* + * 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.fw.log; + +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.annotation.Around; +import org.aspectj.lang.annotation.Aspect; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Helps to log the command method boundary calls. + * + */ +@Aspect +public class OnapCommandLogger { + private static final Logger LOGGER = LoggerFactory.getLogger(OnapCommandLogger.class); + + //(mrkanag) verify that it logs for all classes in this project. + /** + * Logging intercepter. + * + * @param joinPoint + * joinpoint + * @return object + * @throws Throwable + * exception + */ + @Around("execution(* org.onap.cli.fw*(..))") + public Object log(ProceedingJoinPoint joinPoint) throws Throwable { // NOSONAR + LOGGER.info(joinPoint.getThis().toString() + "->" + joinPoint.getSignature().getName() + "(" + + joinPoint.getArgs() + ")"); + + Object response = joinPoint.proceed(); + LOGGER.info(response.toString()); + + return response; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResult.java b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResult.java new file mode 100644 index 00000000..5dd761c6 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResult.java @@ -0,0 +1,249 @@ +/* + * 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.fw.output; + +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandOutputFormatNotsupported; +import org.onap.cli.fw.error.OnapCommandOutputPrintingFailed; +import org.onap.cli.fw.input.ParameterType; +import org.onap.cli.fw.output.print.OnapCommandPrint; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Onap Command result holds the final output of the command. + * + */ +public class OnapCommandResult { + + /* + * if type=JSON, then JSON response of the command from back-end Onap service, by default all the command would + * set this value once the back-end call returns, which would be useful to print the output in JSON format, returned + * from the back-end service. + * + * if type=TEXT, then it holds the result in text format such as help message + */ + private Object output; + + /* + * Type requested by user + */ + private ResultType type = ResultType.TABLE; + + /* + * Scope requested by user + */ + private OnapCommandResultAttributeScope scope = OnapCommandResultAttributeScope.SHORT; + + /* + * if type=TABLE, then List of result records, which could be printed on the CLI console, loaded from schema file + */ + private List<OnapCommandResultAttribute> records = new ArrayList<>(); + + /* + * Print horizontally or vertically, Mostly for show command, horizontal table while for list commands , it will be + * vertically printed. Respective command should set appropriately. + * + * loaded from schema file + */ + private PrintDirection printDirection = PrintDirection.LANDSCAPE; + + private String debugInfo = ""; + + /** + * Requested by user. + */ + private boolean includeTitle = true; + + /** + * Requested by user. + */ + private boolean includeSeparator = true; + + /** + * Requested by user. + */ + private boolean isDebug = false; + + public PrintDirection getPrintDirection() { + return printDirection; + } + + public void setPrintDirection(PrintDirection printDirection) { + this.printDirection = printDirection; + } + + public Object getOutput() { + return output; + } + + public void setOutput(Object output) { + this.output = output; + } + + public List<OnapCommandResultAttribute> getRecords() { + return records; + } + + public void setRecords(List<OnapCommandResultAttribute> records) { + this.records = records; + } + + /** + * Record mapping. + * + * @return attributes + */ + public Map<String, OnapCommandResultAttribute> getRecordsMap() { + Map<String, OnapCommandResultAttribute> recordMap = new HashMap<>(); + + for (OnapCommandResultAttribute record : this.getRecords()) { + recordMap.put(record.getName(), record); + } + + return recordMap; + } + + public ResultType getType() { + return type; + } + + public void setType(ResultType type) { + this.type = type; + } + + public OnapCommandResultAttributeScope getScope() { + return scope; + } + + public void setScope(OnapCommandResultAttributeScope scope) { + this.scope = scope; + } + + public boolean isIncludeTitle() { + return includeTitle; + } + + public void setIncludeTitle(boolean includeTitle) { + this.includeTitle = includeTitle; + } + + public boolean isIncludeSeparator() { + return includeSeparator; + } + + public void setIncludeSeparator(boolean includeSeparator) { + this.includeSeparator = includeSeparator; + } + + public String getDebugInfo() { + return debugInfo; + } + + public void setDebugInfo(String debugInfo) { + this.debugInfo = debugInfo; + } + + public boolean isDebug() { + return isDebug; + } + + public void setDebug(boolean isDebug) { + this.isDebug = isDebug; + } + + /** + * Helps to print the result based on the type. + * + * @return string + * @throws OnapCommandOutputFormatNotsupported + * excpetion + * @throws OnapCommandOutputPrintingFailed + * exception + */ + public String print() throws OnapCommandException { + String printOutput = ""; + + if (this.getRecords().isEmpty()) { + return printOutput; + } + + OnapCommandPrint print = new OnapCommandPrint(); + print.setPrintTitle(this.isIncludeTitle()); + if (this.getPrintDirection().equals(PrintDirection.LANDSCAPE)) { + for (OnapCommandResultAttribute record : this.getScopedRecords()) { + if (record.getType().equals(ParameterType.JSON)) { + print.addColumn(record.getName(), OnapCommandUtils.jsonFlatten(record.getValues())); + } else { + print.addColumn(record.getName(), record.getValues()); + } + } + } else { + // Add property column + OnapCommandResultAttribute prp = new OnapCommandResultAttribute(); + prp.setName(Constants.PORTRAINT_COLUMN_NAME_PROPERTY); + prp.setScope(OnapCommandResultAttributeScope.SHORT); + // Add value column + OnapCommandResultAttribute val = new OnapCommandResultAttribute(); + val.setName(Constants.PORTRAINT_COLUMN_NAME_VALUE); + val.setScope(OnapCommandResultAttributeScope.SHORT); + + for (OnapCommandResultAttribute record : this.getScopedRecords()) { + prp.getValues().add(record.getName()); + if (record.getValues().size() == 1) { + val.getValues().add(record.getValues().get(0)); + } else { + val.getValues().add(record.getValues().toString()); + } + } + + print.addColumn(prp.getName(), prp.getValues()); + print.addColumn(val.getName(), val.getValues()); + } + + if (this.isDebug()) { + printOutput = this.getDebugInfo() + "\n"; + } + + if (this.getType().equals(ResultType.JSON)) { + return printOutput + print.printJson(); + } else if (this.getType().equals(ResultType.TABLE)) { + return printOutput + print.printTable(this.isIncludeSeparator()); + } else if (this.getType().equals(ResultType.CSV)) { + return printOutput + print.printCsv(); + } + + throw new OnapCommandOutputFormatNotsupported(this.getType().name()); + } + + private List<OnapCommandResultAttribute> getScopedRecords() { + List<OnapCommandResultAttribute> recordList = new ArrayList<>(); + for (OnapCommandResultAttribute record : this.getRecords()) { + if (record.getScope().ordinal() > this.getScope().ordinal()) { + continue; + } + recordList.add(record); + } + + return recordList; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttribute.java b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttribute.java new file mode 100644 index 00000000..73617049 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttribute.java @@ -0,0 +1,102 @@ +/* + * 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.fw.output; + +import org.onap.cli.fw.input.ParameterType; + +import java.util.ArrayList; +import java.util.List; + +/** + * Onap command output records, helps to define the title and its description while command is defined and during run + * time, it captures the value of the output as well. + */ +public class OnapCommandResultAttribute { + + /* + * Output name + */ + private String outName; + + /* + * Output description + */ + private String outDescription; + + /* + * Output values, in case list out, it holds values for all rows for show output, it will have one value + */ + private List<String> values = new ArrayList<>(); + + /* + * Output scope + */ + private OnapCommandResultAttributeScope outScope = OnapCommandResultAttributeScope.SHORT; + + private ParameterType paramType = ParameterType.STRING; + + private boolean isSecured = false; + + public void setValues(List<String> values) { + this.values = values; + } + + public String getName() { + return outName; + } + + public void setName(String name) { + this.outName = name; + } + + public String getDescription() { + return outDescription; + } + + public void setDescription(String description) { + this.outDescription = description; + } + + public List<String> getValues() { + return values; + } + + public OnapCommandResultAttributeScope getScope() { + return outScope; + } + + public void setScope(OnapCommandResultAttributeScope scope) { + this.outScope = scope; + } + + public ParameterType getType() { + return paramType; + } + + public void setType(ParameterType type) { + this.paramType = type; + } + + public boolean isSecured() { + return isSecured; + } + + public void setSecured(boolean isSecured) { + this.isSecured = isSecured; + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttributeScope.java b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttributeScope.java new file mode 100644 index 00000000..e03937d3 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/OnapCommandResultAttributeScope.java @@ -0,0 +1,55 @@ +/* + * 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.fw.output; + +import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope; + +/** + * Onap command supports to print output with given set of defined attributes, and each attributes are marked with this + * visibility. + * + */ +public enum OnapCommandResultAttributeScope { + /** + * By default, all output attributes which are tagged with short would be printed. + */ + SHORT, + /** + * When user provides --long or -l, all attributes including short tagged will be printed. otherwise, attributes + * tagged with long, whould be ignored as part of output + */ + LONG; + + /** + * get attribute scope enum type. + * + * @param name + * scope + * @return type + * @throws OnapCommandInvalidResultAttributeScope + * exception + */ + public static OnapCommandResultAttributeScope get(String name) throws OnapCommandInvalidResultAttributeScope { + if (LONG.name().equalsIgnoreCase(name)) { + return LONG; + } else if (SHORT.name().equalsIgnoreCase(name)) { + return SHORT; + } + + throw new OnapCommandInvalidResultAttributeScope(name); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/PrintDirection.java b/framework/src/main/java/org/onap/cli/fw/output/PrintDirection.java new file mode 100644 index 00000000..96ad713f --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/PrintDirection.java @@ -0,0 +1,45 @@ +/* + * 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.fw.output; + +import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection; + +/** + * How to print the result. + * + */ +public enum PrintDirection { + LANDSCAPE, PORTRAIT; + /** + * Get print direction. + * + * @param name + * direction + * @return type + * @throws OnapCommandInvalidPrintDirection + * exception + */ + public static PrintDirection get(String name) throws OnapCommandInvalidPrintDirection { + if (LANDSCAPE.name().equalsIgnoreCase(name)) { + return LANDSCAPE; + } else if (PORTRAIT.name().equalsIgnoreCase(name)) { + return PORTRAIT; + } else { + throw new OnapCommandInvalidPrintDirection(name); + } + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/ResultType.java b/framework/src/main/java/org/onap/cli/fw/output/ResultType.java new file mode 100644 index 00000000..37449447 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/ResultType.java @@ -0,0 +1,63 @@ +/* + * 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.fw.output; + +/** + * Onap command result format. + * + */ +public enum ResultType { + TABLE, CSV, JSON, YAML, TEXT; + + /** + * Check whether the output to be formatted in tabular format. + * + * @param type + * output format type + * @return boolean + */ + public static boolean isTabularForm(String type) { + if (type.equalsIgnoreCase(TABLE.name())) { + return true; + } + + return false; + } + + /** + * Get ResultType. + * + * @param name + * format name + * @return ResultType + */ + public static ResultType get(String name) { + if (TABLE.name().equalsIgnoreCase(name)) { + return TABLE; + } + if (CSV.name().equalsIgnoreCase(name)) { + return CSV; + } + if (JSON.name().equalsIgnoreCase(name)) { + return JSON; + } + if (YAML.name().equalsIgnoreCase(name)) { + return YAML; + } + return TEXT; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/print/OnapCommandPrint.java b/framework/src/main/java/org/onap/cli/fw/output/print/OnapCommandPrint.java new file mode 100644 index 00000000..48a4e6ea --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/print/OnapCommandPrint.java @@ -0,0 +1,252 @@ +/* + * 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.fw.output.print; + +import org.apache.commons.csv.CSVFormat; +import org.apache.commons.csv.CSVPrinter; +import org.onap.cli.fw.error.OnapCommandOutputPrintingFailed; +import org.onap.cli.fw.output.PrintDirection; + +import java.io.IOException; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.StringTokenizer; + +/** + * Onap Command Table print. + * + */ +public class OnapCommandPrint { + + public static final int MAX_COLUMN_LENGTH = 50; + + private PrintDirection direction; + + private Map<String, List<String>> data = new LinkedHashMap<>(); + + private boolean printTitle = true; + + public PrintDirection getDirection() { + return direction; + } + + public void setDirection(PrintDirection direction) { + this.direction = direction; + } + + public void addColumn(String header, List<String> data) { + this.data.put(header, data); + } + + /** + * Get column. + * + * @param header + * string + * @return list + */ + public List<String> getColumn(String header) { + if (this.data.get(header) == null) { + this.data.put(header, new ArrayList<String>()); + } + return this.data.get(header); + } + + public boolean isPrintTitle() { + return printTitle; + } + + public void setPrintTitle(boolean printTitle) { + this.printTitle = printTitle; + } + + private int findMaxRows() { + int max = 1; + if (!this.isPrintTitle()) { + max = 0; + } + for (List<String> cols : this.data.values()) { + if (cols != null && max < cols.size()) { + max = cols.size(); + } + } + + return max; + } + + /** + * Helps to form the rows from columns. + * + * @param isNormalize + * boolean + * @return +--------------+-----------+-----------------------------+ | header1 | header 2 | header 3 | + * +--------------+-----------+-----------------------------+ | v1 | List[line| v 3 | | | 1, line2]| | + * +--------------+-----------+-----------------------------+ | null | yyyyyy 2 | xxxxxx 3 | + * +--------------+-----------+-----------------------------+ + */ + private List<List<Object>> formRows(boolean isNormalize) { + List<List<Object>> rows = new ArrayList<>(); + + // add title + if (this.isPrintTitle()) { + List<Object> list = new ArrayList<>(); + for (String key : this.data.keySet()) { + if (isNormalize && key != null && key.length() > MAX_COLUMN_LENGTH) { + list.add(splitIntoList(key, MAX_COLUMN_LENGTH)); + } else { + list.add(key); + } + } + rows.add(list); + } + + // form row + for (int i = 0; i < this.findMaxRows(); i++) { + List<Object> row = new ArrayList<>(); + for (List<String> cols : this.data.values()) { + if (cols.size() > i) { + String value = cols.get(i); + // split the cell into multiple sub rows + if (isNormalize && value != null && value.length() > MAX_COLUMN_LENGTH) { + row.add(splitIntoList(value, MAX_COLUMN_LENGTH)); + } else { + // store as string (one entry) + row.add(value); + } + } else { + // now value exist for this column + row.add(null); + } + } + rows.add(row); + } + + return rows; + } + + /** + * Splits big strings into list of strings based on maxCharInLine size. + * + * @param input + * input string + * @param maxCharInLine + * max length + * @return list of strings + */ + public List<String> splitIntoList(String input, int maxCharInLine) { + + String inp = input; + + if (inp == null || "".equals(inp) || maxCharInLine <= 0) { + return Collections.emptyList(); + } + // new line is converted to space char + if (inp.contains("\n")) { + inp = inp.replaceAll("\n", ""); + } + + StringTokenizer tok = new StringTokenizer(inp, " "); + StringBuilder output = new StringBuilder(inp.length()); + int lineLen = 0; + while (tok.hasMoreTokens()) { + String word = tok.nextToken(); + + while (word.length() >= maxCharInLine) { + output.append(word.substring(0, maxCharInLine - lineLen) + "\n"); + word = word.substring(maxCharInLine - lineLen); + lineLen = 0; + } + + if (lineLen + word.length() >= maxCharInLine) { + output.append("\n"); + lineLen = 0; + } + output.append(word + " "); + + lineLen += word.length() + 1; + } + String[] strArray = output.toString().split("\n"); + + return Arrays.asList(strArray); + } + + /** + * Helps to print table. + * + * @param printSeparator + * Prints with line separator + * @return +--------------+-----------+-----------------------------+ | header1 | header 2 | header 3 | + * +--------------+-----------+-----------------------------+ | v1 | line 1 | v 3 | | | line 2 | | + * +--------------+-----------+-----------------------------+ | | yyyyyy 2 | xxxxxx 3 | + * +--------------+-----------+-----------------------------+ + */ + public String printTable(boolean printSeparator) { + List<List<Object>> rows = this.formRows(true); + TableGenerator table = new TableGenerator(); + return table.generateTable(rows, printSeparator); + } + + /** + * Print output in csv format. + * + * @return string + * @throws OnapCommandOutputPrintingFailed + * exception + */ + public String printCsv() throws OnapCommandOutputPrintingFailed { + StringWriter writer = new StringWriter(); + CSVPrinter printer = null; + try { + CSVFormat formattor = CSVFormat.DEFAULT.withRecordSeparator(System.getProperty("line.separator")); + printer = new CSVPrinter(writer, formattor); + + List<List<Object>> rows = this.formRows(false); + + for (int i = 0; i < this.findMaxRows(); i++) { + printer.printRecord(rows.get(i)); + } + + return writer.toString(); + } catch (IOException e) { + throw new OnapCommandOutputPrintingFailed(e); + } finally { + try { + if (printer != null) { + printer.close(); + } + writer.close(); + } catch (IOException e) { + throw new OnapCommandOutputPrintingFailed(e); // NOSONAR + } + } + } + + public String printJson() { + // (mrkanag) print in json + return null; + } + + public String printYaml() { + // (mrkanag) print in yaml + return null; + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/output/print/TableGenerator.java b/framework/src/main/java/org/onap/cli/fw/output/print/TableGenerator.java new file mode 100644 index 00000000..8be7952d --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/output/print/TableGenerator.java @@ -0,0 +1,313 @@ +/* + * 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.fw.output.print; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * Printing Command result in Table format. + * + */ +public class TableGenerator { + + private static final int PADDING_SIZE = 1; + private static final String NEW_LINE = "\n"; + private static final String TABLE_JOINT_SYMBOL = "+"; + private static final String TABLE_V_SPLIT_SYMBOL = "|"; + private static final String TABLE_H_SPLIT_SYMBOL = "-"; + + /** + * Generate list of rows into table format. + * + * @param rowsList + * list of rows + * @param printSeparator + * boolean + * @return stringBuilder in tabular format + */ + public String generateTable(List<List<Object>> rowsList, boolean printSeparator) { + StringBuilder stringBuilder = new StringBuilder(); + + if (rowsList.isEmpty()) { + return stringBuilder.toString(); + } + + Map<Integer, Integer> columnMaxWidthMapping = getMaximumWidhtofColumns(rowsList); + Map<Integer, Integer> rowMaxWidthMapping = getMaximumWidhtofRows(rowsList); + + if (printSeparator) { + createRowLine(stringBuilder, rowsList.get(0).size(), columnMaxWidthMapping); + stringBuilder.append(NEW_LINE); + } + + for (int rowIndex = 0; rowIndex < rowsList.size(); rowIndex++) { + + List<Object> row = rowsList.get(rowIndex); + int splitRowSize = rowMaxWidthMapping.get(rowIndex); + if (splitRowSize > 1) { + for (int cellIndex = 0; cellIndex < row.size(); cellIndex++) { + Object cell = row.get(cellIndex); + String finalCell; + if (cell != null) { + if (cell instanceof String) { + finalCell = (String) cell; + } else { + finalCell = ((List<String>) cell).get(0); + } + fillCell(stringBuilder, finalCell, cellIndex, columnMaxWidthMapping, printSeparator); + } + } + + stringBuilder.append(NEW_LINE); + + for (int splitCellIndex = 1; splitCellIndex < splitRowSize; splitCellIndex++) { + for (int cellIndex = 0; cellIndex < row.size(); cellIndex++) { + Object cell = row.get(cellIndex); + String finalCell = ""; + if (cell != null && cell instanceof List) { + List<String> list = (List<String>) cell; + if (splitCellIndex < list.size()) { + finalCell = list.get(splitCellIndex); + } + } + fillCell(stringBuilder, finalCell, cellIndex, columnMaxWidthMapping, printSeparator); + } + + stringBuilder.append(NEW_LINE); + } + + } else { + for (int cellIndex = 0; cellIndex < row.size(); cellIndex++) { + fillCell(stringBuilder, (String) row.get(cellIndex), cellIndex, columnMaxWidthMapping, + printSeparator); + } + stringBuilder.append(NEW_LINE); + } + + if (printSeparator) { + createRowLine(stringBuilder, rowsList.get(0).size(), columnMaxWidthMapping); + stringBuilder.append(NEW_LINE); + } + + } + return stringBuilder.toString(); + } + + /** + * Fill required space. + * + * @param stringBuilder + * table + * @param length + * No. of spaces + */ + private void fillSpace(StringBuilder stringBuilder, int length) { + for (int i = 0; i < length; i++) { + stringBuilder.append(" "); + } + } + + /** + * Create a new row line. + * + * @param stringBuilder + * table + * @param headersListSize + * No. of colums + * @param columnMaxWidthMapping + * mapping of columns with cell width + */ + private void createRowLine(StringBuilder stringBuilder, int headersListSize, + Map<Integer, Integer> columnMaxWidthMapping) { + for (int i = 0; i < headersListSize; i++) { + if (i == 0) { + stringBuilder.append(TABLE_JOINT_SYMBOL); + } + + for (int j = 0; j < columnMaxWidthMapping.get(i) + PADDING_SIZE * 2; j++) { + stringBuilder.append(TABLE_H_SPLIT_SYMBOL); + } + stringBuilder.append(TABLE_JOINT_SYMBOL); + } + } + + /** + * Get max width of columns. + * + * @param rowsList + * list of rows + * @return mapping of column and max cell width + */ + private Map<Integer, Integer> getMaximumWidhtofColumns(List<List<Object>> rowsList) { + Map<Integer, Integer> columnMaxWidthMapping = new HashMap<>(); + if (rowsList == null || rowsList.isEmpty()) { + return new HashMap<>(); + } + for (int columnIndex = 0; columnIndex < rowsList.get(0).size(); columnIndex++) { + columnMaxWidthMapping.put(columnIndex, 0); + } + + for (List<Object> row : rowsList) { + updateColWidth(row, columnMaxWidthMapping); + } + + for (int columnIndex = 0; columnIndex < rowsList.get(0).size(); columnIndex++) { + + if (columnMaxWidthMapping.get(columnIndex) % 2 != 0) { + columnMaxWidthMapping.put(columnIndex, columnMaxWidthMapping.get(columnIndex) + 1); + } + } + + return columnMaxWidthMapping; + } + + /** + * update the column width. + * + * @param row + * list of values + * @param columnMaxWidthMapping + * mapping of column and max cell width + */ + private void updateColWidth(List<Object> row, Map<Integer, Integer> columnMaxWidthMapping) { + for (int columnIndex = 0; columnIndex < row.size(); columnIndex++) { + Object obj = row.get(columnIndex); + if (obj instanceof String) { + String str = (String) obj; + if (str.length() > columnMaxWidthMapping.get(columnIndex)) { + columnMaxWidthMapping.put(columnIndex, str.length()); + } + } else if (obj instanceof List) { + List<String> list = (List<String>) obj; + + int maxLength = list.get(0).length(); + + for (String str : list) { + if (str.length() > maxLength) { + maxLength = str.length(); + } + } + + if (maxLength > columnMaxWidthMapping.get(columnIndex)) { + columnMaxWidthMapping.put(columnIndex, maxLength); + } + + } + + } + } + + /** + * Get max width of rows. + * + * @param rowsList + * list of rows + * @return map of rows and max width + */ + private Map<Integer, Integer> getMaximumWidhtofRows(List<List<Object>> rowsList) { + Map<Integer, Integer> rowMaxWidthMapping = new HashMap<>(); + + for (int rowIndex = 0; rowIndex < rowsList.size(); rowIndex++) { + rowMaxWidthMapping.put(rowIndex, 1); + } + + for (int rowIndex = 0; rowIndex < rowsList.size(); rowIndex++) { + int maxSize = 1; + for (Object obj : rowsList.get(rowIndex)) { + if (obj instanceof List && ((List) obj).size() > maxSize) { + maxSize = ((List) obj).size(); + } + } + + if (maxSize > 1) { + rowMaxWidthMapping.put(rowIndex, maxSize); + } + } + return rowMaxWidthMapping; + } + + /** + * Get optimal cell padding. + * + * @param cellIndex + * cell index + * @param datalength + * data length + * @param columnMaxWidthMapping + * map of column and max cell width + * @param cellPaddingSize + * cell padding size + * @return cell padding + */ + private int getOptimumCellPadding(int cellIndex, int datalength, Map<Integer, Integer> columnMaxWidthMapping, + int cellPaddingSize) { + int datLen = datalength; + int paddingSize = cellPaddingSize; + if (datLen % 2 != 0) { + datLen++; + } + + if (datLen < columnMaxWidthMapping.get(cellIndex)) { + paddingSize = paddingSize + (columnMaxWidthMapping.get(cellIndex) - datLen) / 2; + } + + return paddingSize; + } + + /** + * Fill the cell with required value. + * + * @param stringBuilder + * table + * @param cell + * table cell value + * @param cellIndex + * cell index + * @param columnMaxWidthMapping + * map of column and max cell width + */ + private void fillCell(StringBuilder stringBuilder, String cell, int cellIndex, + Map<Integer, Integer> columnMaxWidthMapping, boolean printSeparator) { + + String filledCell = cell; + + if (filledCell == null) { + filledCell = ""; + } + int cellLength = filledCell.length(); + int cellPaddingSize = getOptimumCellPadding(cellIndex, cellLength, columnMaxWidthMapping, PADDING_SIZE); + + if (cellIndex == 0 && printSeparator) { + stringBuilder.append(TABLE_V_SPLIT_SYMBOL); + } + + stringBuilder.append(filledCell); + fillSpace(stringBuilder, cellPaddingSize); + + if (cellLength % 2 != 0) { + stringBuilder.append(" "); + } + + fillSpace(stringBuilder, cellPaddingSize); + if (printSeparator) { + stringBuilder.append(TABLE_V_SPLIT_SYMBOL); + } + + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/run/OnapCommandExecutor.java b/framework/src/main/java/org/onap/cli/fw/run/OnapCommandExecutor.java new file mode 100644 index 00000000..abd04b02 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/run/OnapCommandExecutor.java @@ -0,0 +1,71 @@ +/* + * 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.fw.run; + +/** + * Onap Command executor. + * + */ +public class OnapCommandExecutor { + + private String apiName; + private String clientName; + private String entityName; + private String methodName; + private String exceptionName; + + public String getApi() { + return this.apiName; + } + + public void setApi(String api) { + this.apiName = api; + } + + public String getClient() { + return this.clientName; + } + + public void setClient(String client) { + this.clientName = client; + } + + public String getEntity() { + return entityName; + } + + public void setEntity(String entity) { + this.entityName = entity; + } + + public String getMethod() { + return methodName; + } + + public void setMethod(String method) { + this.methodName = method; + } + + public String getException() { + return exceptionName; + } + + public void setException(String exception) { + this.exceptionName = exception; + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/schema/AbstractSchemaValidate.java b/framework/src/main/java/org/onap/cli/fw/schema/AbstractSchemaValidate.java new file mode 100644 index 00000000..28671521 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/schema/AbstractSchemaValidate.java @@ -0,0 +1,563 @@ +/* + * 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.fw.schema; + +import org.onap.cli.fw.error.OnapCommandInvalidSchema; +import org.onap.cli.fw.utils.OnapCommandUtils; +import org.springframework.core.io.Resource; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.parser.ParserException; + +import static org.onap.cli.fw.conf.Constants.*; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +/** + * Abstract schema validation class. + * + */ +public abstract class AbstractSchemaValidate implements SchemaValidate { + + /** + * Supported schema types. + * + */ + protected enum SchemaType { + HTTP, BASIC + } + + protected List<String> schemaErrors = new ArrayList<>(); + protected Map<String, Object> yamlMap = new HashMap<>(); + protected Map<String, Object> defaultYamlMap = new HashMap<>(); + + protected static final List<String> HTTP_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION, + SERVICE, PARAMETERS, RESULTS, HTTP); + + protected static final List<String> HTTP_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, + DESCRIPTION, SERVICE, HTTP); + protected static final List<String> BASIC_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION, + PARAMETERS, RESULTS); + + protected static final List<String> BASIC_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, + DESCRIPTION, PARAMETERS); + + protected static final List<String> TOP_LEVEL_PARAMS_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, + DESCRIPTION); + + protected static final List<String> TOP_LEVEL_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, + DESCRIPTION); + + protected static final List<String> SERVICE_PARAMS_LIST = Arrays.asList(NAME, VERSION, NO_AUTH); + + protected static final List<String> SERVICE_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, VERSION); + + protected static final List<String> INPUT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION, + LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED); + + protected static final List<String> INPUT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE); + + protected static final List<String> PARAMETER_TYPES = Arrays.asList(PARAMETER_TYPE_JSON, PARAMETER_TYPE_YAML, + PARAMETER_TYPE_STRING, PARAMETER_TYPE_LONG, PARAMETER_TYPE_URL, PARAMETER_TYPE_BOOL, PARAMETER_TYPE_ARRAY, + PARAMETER_TYPE_MAP, PARAMETER_TYPE_BINARY); + + protected static final List<String> RESULT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION, + LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED); + + protected static final List<String> RESULT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE); + + protected static final List<String> HTTP_PARAMS_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); + + protected static final List<String> HTTP_PARAMS_MANDATORY_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); + + protected static final List<String> HTTP_MANDATORY_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES); + + protected static final List<String> HTTP_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES, RESULT_MAP, + SAMPLE_RESPONSE); + + protected static final List<String> HTTP_REQUEST_MANDATORY_PARAMS = Arrays.asList(URI, METHOD); + + protected static final List<String> HTTP_REQUEST_PARAMS = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); + + protected static final List<String> BOOLEAN_VALUES = Arrays.asList(BOOLEAN_TRUE, BOOLEAN_FALSE); + protected static final List<String> DIRECTIONS = Arrays.asList(DIRECTION_PORTRAIT, DIRECTION_LANDSCAPE); + protected static final List<String> RESULT_SCOPES = Arrays.asList(RESULT_SCOPE_SHORT, RESULT_SCOPE_LONG); + + protected static final List<String> HTTP_METHODS = Arrays.asList(POST, GET, DELETE, PUT, HEAD); + + /** + * Constructor. + * + * @param schemaFile + * schemafile + * @throws OnapCommandInvalidSchema + * exception + */ + public AbstractSchemaValidate(File schemaFile) throws OnapCommandInvalidSchema { + loadYaml(schemaFile); + loadDefaultYaml(); + } + + /** + * Constructor. + * + * @param schemaFile + * resourceName + * @throws OnapCommandInvalidSchema + * exception + */ + public AbstractSchemaValidate(String schemaFile) throws OnapCommandInvalidSchema { + + try { + Resource res = OnapCommandUtils.getExternalResource(schemaFile, EXTERNAL_SCHEMA_PATH_PATERN); + InputStream inputStream; + if (res == null) { + inputStream = OnapCommandUtils.class.getClassLoader().getResourceAsStream(schemaFile); + } else { + inputStream = res.getInputStream(); + } + + if (inputStream != null) { + loadYamlFromInputStream(schemaFile, inputStream); + } else { + throw new OnapCommandInvalidSchema(schemaFile, SCHEMA_FILE_NOT_EXIST); + } + + } catch (IOException e) { + throw new OnapCommandInvalidSchema(schemaFile, e); + } + loadDefaultYaml(); + } + + private final void loadYaml(File schemaFile) throws OnapCommandInvalidSchema { + if (!schemaFile.isFile()) { + throw new OnapCommandInvalidSchema(schemaFile.getName(), SCHEMA_FILE_NOT_EXIST); + } + String fileName = schemaFile.getName(); + + if (!fileName.endsWith(".yaml")) { + throw new OnapCommandInvalidSchema(fileName, SCHEMA_FILE_WRONG_EXTN); + } + + try { + InputStream inputStream = new FileInputStream(schemaFile); + loadYamlFromInputStream(schemaFile.getName(), inputStream); + } catch (FileNotFoundException e) { + throw new OnapCommandInvalidSchema(fileName, e); + } + } + + @SuppressWarnings("unchecked") + private final void loadYamlFromInputStream(String fileName, InputStream inputStream) + throws OnapCommandInvalidSchema { + try { + yamlMap = (Map<String, Object>) new Yaml().load(inputStream); + } catch (ParserException e) { + throw new OnapCommandInvalidSchema(fileName, e); + } finally { + if (inputStream != null) { + try { + inputStream.close(); + } catch (IOException e) { + throw new OnapCommandInvalidSchema(fileName, e); // NOSONAR + } + } + } + + if (yamlMap == null) { + throw new OnapCommandInvalidSchema(fileName, SCHEMA_FILE_EMPTY); + } + } + + @SuppressWarnings("unchecked") + private final void loadDefaultYaml() throws OnapCommandInvalidSchema { + InputStream inputStream = AbstractSchemaValidate.class.getClassLoader() + .getResourceAsStream(DEFAULT_SCHEMA_FILE_NAME); + try { + defaultYamlMap = (Map<String, Object>) new Yaml().load(inputStream); + } catch (ParserException e) { + throw new OnapCommandInvalidSchema(DEFAULT_SCHEMA_FILE_NAME, e); + } + + if (defaultYamlMap == null) { + throw new OnapCommandInvalidSchema(DEFAULT_SCHEMA_FILE_NAME, SCHEMA_FILE_EMPTY); + } + } + + /* + * Validate method. + * + * @throws OnapCommandInvalidSchema exception + */ + @Override + public List<String> validate() throws OnapCommandInvalidSchema { + + SchemaType type; + Set<String> mainSections = yamlMap.keySet(); + if (mainSections.containsAll(HTTP_SCHEMA_MANDATORY_LIST)) { + type = SchemaType.HTTP; + } else if (mainSections.containsAll(BASIC_SCHEMA_MANDATORY_LIST)) { + type = SchemaType.BASIC; + } else { + schemaErrors.add(SchemaValidate.invalidSections(mainSections, HTTP_SCHEMA_MANDATORY_LIST, + BASIC_SCHEMA_MANDATORY_LIST)); + return schemaErrors; + } + + if (type.equals(SchemaType.BASIC)) { + validateTopLevelAttributes(); + validateInputParameters(); + validateResultParameters(); + } else { + validateTopLevelAttributes(); + validateServiceAttributes(); + validateInputParameters(); + validateResultParameters(); + validateSpecificSchema(SchemaType.HTTP); + } + return schemaErrors; + } + + private void validateResultAttributes(List<Map<String, Object>> resultAttributes) { + Set<String> resultParamNames = new HashSet<>(); + for (Map<String, Object> attribute : resultAttributes) { + + // Validate mandatory parameters + validateMandatoryParams(attribute, RESULT_PARAMS_LIST, RESULT_PARAMS_MANDATORY_LIST, ATTRIBUTES); + + String name = String.valueOf(attribute.get(NAME)); + + if (resultParamNames.contains(name)) { + schemaErrors.add(SchemaValidate.attributeNameExist(name, ATTRIBUTES)); + } else { + resultParamNames.add(name); + } + + // Validate specific parameters + Object type = attribute.get(TYPE); + String value = String.valueOf(type); + if (!PARAMETER_TYPES.contains(value.toLowerCase())) { + schemaErrors.add(SchemaValidate.invalidType(ATTRIBUTES, name, PARAMETER_TYPES)); + } + + Object scope = attribute.get(SCOPE); + if (scope == null) { + schemaErrors.add(SchemaValidate.attributeScopeEmpty(name)); + } else if (!RESULT_SCOPES.contains(scope)) { + schemaErrors.add(SchemaValidate.invalidAttributeScope(name, RESULT_SCOPES)); + } + + Object isSecured = attribute.get(IS_SECURED); + if (isSecured != null) { + String value2 = String.valueOf(isSecured); + if (!validateBoolean(value2)) { + schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(ATTRIBUTES, IS_SECURED, value2)); + } + } + } + + } + + private void validateResultParameters() { + @SuppressWarnings("unchecked") + Map<String, Object> resultParams = (Map<String, Object>) yamlMap.get(RESULTS); + + if (resultParams == null || resultParams.isEmpty()) { + return; + } + + Object direction = resultParams.get(DIRECTION); + + if (direction != null && !DIRECTIONS.contains(direction)) { + schemaErrors.add(SchemaValidate.invalidType(PARAMETERS, DIRECTION, DIRECTIONS)); + } + + @SuppressWarnings("unchecked") + List<Map<String, Object>> resultAttributes = (List<Map<String, Object>>) resultParams.get(ATTRIBUTES); + validateResultAttributes(resultAttributes); + } + + /** + * Get all default short options. + * + * @return set + */ + protected Set<String> getDefaultShortOptions() { + + Set<String> set = new HashSet<>(); + + @SuppressWarnings("unchecked") + List<Map<String, Object>> inputParams = (List<Map<String, Object>>) defaultYamlMap.get(PARAMETERS); + for (Map<String, Object> parameter : inputParams) { + Object name = parameter.get(SHORT_OPTION); + if (name != null && !String.valueOf(name).isEmpty() && !"null".equals(name)) { + set.add(String.valueOf(name)); + } + } + + return set; + } + + /** + * Get all default long options. + * + * @return set + */ + protected Set<String> getDefaultLongOptions() { + + Set<String> set = new HashSet<>(); + + @SuppressWarnings("unchecked") + List<Map<String, Object>> inputParams = (List<Map<String, Object>>) defaultYamlMap.get(PARAMETERS); + for (Map<String, Object> parameter : inputParams) { + Object name = parameter.get(LONG_OPTION); + if (name != null && !String.valueOf(name).isEmpty() && !"null".equals(name)) { + set.add(String.valueOf(name)); + } + } + + return set; + } + + private void validateTopLevelAttributes() { + validateMandatoryParams(yamlMap, TOP_LEVEL_PARAMS_LIST, TOP_LEVEL_MANDATORY_LIST, "root level"); + } + + private void validateServiceAttributes() { + + @SuppressWarnings("unchecked") + Map<String, Object> serviceMap = (Map<String, Object>) yamlMap.get(SERVICE); + + if (serviceMap == null) { + schemaErrors.add(SchemaValidate.emptySection(SERVICE)); + return; + } + + validateMandatoryParams(serviceMap, SERVICE_PARAMS_LIST, SERVICE_PARAMS_MANDATORY_LIST, SERVICE); + + // Validate specific parameters + + if (serviceMap.containsKey(NO_AUTH)) { + Object obj = serviceMap.get(NO_AUTH); + if (obj == null) { + schemaErrors.add(SchemaValidate.emptyValue(SERVICE, NO_AUTH)); + } else { + String value = String.valueOf(obj); + if (!validateBoolean(value)) { + schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(SERVICE, NO_AUTH, value)); + } + } + } + + } + + private void validateInputParameters() { + + @SuppressWarnings("unchecked") + List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS); + if (inputParams == null) { + return; + } + validateInputAttributes(inputParams); + } + + protected abstract void validateSpecificSchema(SchemaType type) throws OnapCommandInvalidSchema; + + private void validateInputAttributes(List<Map<String, Object>> inputParams) { + Set<String> inputParamNames = new HashSet<>(); + Set<String> inputShortOptions = new HashSet<>(); + Set<String> inputLongOptions = new HashSet<>(); + + Set<String> defaultShortOptions = getDefaultShortOptions(); + Set<String> defaultLongOptions = getDefaultLongOptions(); + + for (Map<String, Object> parameter : inputParams) { + + // Validate mandatory parameters + validateMandatoryParams(parameter, INPUT_PARAMS_LIST, INPUT_PARAMS_MANDATORY_LIST, PARAMETERS); + + // Validate specific parameters + + String name = String.valueOf(parameter.get(NAME)); + + if (inputParamNames.contains(name)) { + schemaErrors.add(SchemaValidate.nameExist(name, PARAMETERS)); + } else { + inputParamNames.add(name); + } + + String value = String.valueOf(parameter.get(TYPE)); + + if (!PARAMETER_TYPES.contains(value.toLowerCase())) { + schemaErrors.add(SchemaValidate.invalidAttrType(name, PARAMETERS, PARAMETER_TYPES)); + } + + Object isOptional = parameter.get(IS_OPTIONAL); + if (isOptional != null) { + String value1 = String.valueOf(isOptional); + if (!validateBoolean(value1)) { + schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(name, IS_OPTIONAL, value1)); + } + } + + Object isSecured = parameter.get(IS_SECURED); + if (isSecured != null) { + String value2 = String.valueOf(isSecured); + if (!validateBoolean(value2)) { + schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(name, IS_SECURED, value2)); + } + } + + String shortOption = String.valueOf(parameter.get(SHORT_OPTION)); + String longOption = String.valueOf(parameter.get(LONG_OPTION)); + + if (inputShortOptions.contains(shortOption)) { + schemaErrors.add(SchemaValidate.optionExist(SHORT_OPTION, shortOption, name)); + } else if (defaultShortOptions.contains(shortOption)) { + + schemaErrors + .add(SchemaValidate.optionDefaultExist(SHORT_OPTION, shortOption, name, defaultShortOptions)); + + } else if (shortOption != null && !shortOption.isEmpty() && !"null".equals(shortOption)) { + inputShortOptions.add(shortOption); + } + + if (inputLongOptions.contains(longOption)) { + schemaErrors.add(SchemaValidate.optionExist(LONG_OPTION, longOption, name)); + } else if (defaultLongOptions.contains(longOption)) { + + schemaErrors.add(SchemaValidate.optionDefaultExist(LONG_OPTION, longOption, name, defaultLongOptions)); + } else if (longOption != null && !longOption.isEmpty() && !"null".equals(shortOption)) { + inputLongOptions.add(longOption); + } + + } + + } + + /** + * Validate mandatory parameters. + * + * @param yamlMap + * yaml map + * @param totalParams + * list + * @param mandatoryParams + * list + * @param section + * section + */ + protected void validateMandatoryParams(Map<String, Object> yamlMap, List<String> totalParams, + List<String> mandatoryParams, String section) { + + for (String param : totalParams) { + boolean isMandatory = mandatoryParams.contains(param); + boolean isYamlContains = yamlMap.containsKey(param); + if (isMandatory) { + if (!isYamlContains) { + schemaErrors.add(SchemaValidate.mandatoryAttrMissing(param, section)); + } else { + String value = String.valueOf(yamlMap.get(param)); + if (value == null || "".equals(value) || "null".equals(value)) { + schemaErrors.add(SchemaValidate.mandatoryAttrEmpty(param, section)); + } + } + } + } + } + + /** + * Load result attributes. + * + * @return set + */ + @SuppressWarnings("unchecked") + protected Set<String> getResultAttributes() { + + Set<String> set = new HashSet<>(); + + List<Map<String, Object>> resultAttributes = yamlMap.get(RESULTS) != null + ? (List<Map<String, Object>>) ((Map<String, Object>) yamlMap.get(RESULTS)).get(ATTRIBUTES) + : Collections.emptyList(); + + if (resultAttributes != null) { + for (Map<String, Object> map : resultAttributes) { + for (Entry<String, Object> entry : map.entrySet()) { + Object key = entry.getKey(); + + if (NAME.equals(key)) { + set.add(String.valueOf(entry.getValue())); + break; + } + } + } + } + + return set; + } + + /** + * Get request parameters. + * + * @return set + */ + protected Set<String> getRequestParams() { + + Set<String> set = new HashSet<>(); + + @SuppressWarnings("unchecked") + List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS); + + if (inputParams != null) { + for (Map<String, Object> map : inputParams) { + for (Entry<String, Object> entry : map.entrySet()) { + Object key = entry.getKey(); + + if (NAME.equals(key)) { + set.add(String.valueOf(entry.getValue())); + break; + } + } + } + } + + return set; + } + + /** + * Validate Boolean. + * + * @param toValidate + * string + * @return boolean + */ + protected static boolean validateBoolean(String toValidate) { + return BOOLEAN_VALUES.contains(toValidate.toLowerCase()); + } +} diff --git a/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidate.java b/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidate.java new file mode 100644 index 00000000..27bc4661 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidate.java @@ -0,0 +1,324 @@ +/* + * 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.fw.schema; + +import org.onap.cli.fw.error.OnapCommandInvalidSchema; + +import java.util.List; +import java.util.Set; + +/** + * Schema validate interface. + * + */ +@FunctionalInterface +public interface SchemaValidate { + /** + * Validates HTTP or Basic Schema. + * + * @return List of errors + * @throws OnapCommandInvalidSchema + * Failed to load schema file + */ + public List<String> validate() throws OnapCommandInvalidSchema; + + /** + * Static interface method. + * + * @param section + * section + * @return errorMessage + */ + public static String defaultYamlSchema(String section) { + return "The section '" + section + ":' cann't be null or empty"; + } + + /** + * Static interface method. + * + * @param section + * string + * @param attribute + * string + * @param value + * string + * @return string + */ + public static String invalidBooleanValueMessage(String section, String attribute, String value) { + return "The value '" + value + "' of '" + attribute + "' present under '" + section + "' should be boolean"; + } + + /** + * Static interface method. + * + * @param section + * string + * @param attribute + * string + * @return string + */ + public static String emptyValue(String section, String attribute) { + return "Attribute '" + attribute + "' under '" + section + "' is null or empty"; + } + + /** + * Static interface method. + * + * @param section + * string + * @param attribute + * string + * @param types + * list + * @return string + */ + public static String invalidType(String section, String attribute, List<String> types) { + return "Attribute '" + attribute + "' under '" + section + "' is invalid, correct types are " + + types.toString(); + } + + /** + * Static interface method. + * + * @param subSection + * string + * @param attribute + * string + * @return string + */ + public static String invalidRequestParam(String subSection, String attribute) { + return "The http request '" + subSection + "' parameter '" + attribute + + "' is not declared under 'parameters:' section"; + } + + /** + * Static interface method. + * + * @param section + * string + * @return string + */ + public static String emptySection(String section) { + return "The section '" + section + ":' cann't be null or empty"; + } + + /** + * Static interface method. + * + * @param mainSections + * list + * @param http + * list + * @param basic + * list + * @return string + */ + public static String invalidSections(Set<String> mainSections, List<String> http, List<String> basic) { + return "No matching schema type found due to extra or missing sections in the file" + mainSections.toString() + + " , Supported schema sections are http" + http.toString() + " and basic" + basic.toString(); + } + + /** + * Static interface method. + * + * @param name + * string + * @param section + * string + * @return string + */ + public static String attributeNameExist(String name, String section) { + return "Attribute name='" + name + "' under '" + section + ":' is already used, Take different one."; + } + + /** + * Static interface method. + * + * @param name + * string + * @param scopes + * list + * @return string + */ + public static String invalidAttributeScope(String name, List<String> scopes) { + return "The attribute '" + name + "' scope is invalid, valid scopes are " + scopes.toString(); + } + + /** + * Static interface method. + * + * @param name + * string + * @return string + */ + public static String attributeScopeEmpty(String name) { + return "The attribute '" + name + "' scope is null or empty."; + } + + /** + * Static interface method. + * + * @param option + * string + * @param attrValue + * string + * @param name + * string + * @return string + */ + public static String optionExist(String option, String attrValue, String name) { + return "Attribute " + option + " option '" + attrValue + "' of parameter '" + name + + "' is already used, Take different one."; + } + + /** + * Static interface method. + * + * @param option + * string + * @param attrValue + * string + * @param name + * string + * @param list + * list + * @return string + */ + public static String optionDefaultExist(String option, String attrValue, String name, Set<String> list) { + return "Attribute " + option + " option '" + attrValue + "' of parameter '" + name + + "' is already used in default parameters list " + list.toString() + ", Take different one."; + } + + /** + * Static interface method. + * + * @param name + * string + * @return string + */ + public static String longOptionExist(String name) { + return "The attribute '" + name + "' scope is null or empty."; + } + + /** + * Static interface method. + * + * @param name + * string + * @return string + */ + public static String shortOptionExist(String name) { + return "The attribute '" + name + "' scope is null or empty."; + } + + /** + * Static interface method. + * + * @param name + * string + * @param section + * string + * @return string + */ + public static String nameExist(String name, String section) { + + return "Attribute name='" + name + "' under '" + section + ":' is already used, Take different one."; + } + + /** + * Static interface method. + * + * @param name + * string + * @param section + * string + * @param types + * list + * @return string + */ + public static String invalidAttrType(String name, String section, List<String> types) { + return "Attribute type of '" + name + "' under '" + section + "' is invalid, correct types are " + + types.toString(); + } + + /** + * Static interface method. + * + * @param param + * string + * @param section + * string + * @return string + */ + public static String mandatoryAttrMissing(String param, String section) { + + return "Mandatory attribute '" + param + "' is missing under '" + section + "'"; + } + + /** + * Static interface method. + * + * @param param + * string + * @param section + * string + * @return string + */ + public static String mandatoryAttrEmpty(String param, String section) { + + return "Mandatory attribute '" + param + "' under '" + section + "' shouldn't be null or empty"; + } + + /** + * Static interface method. + * + * @param attribute + * string + * @return string + */ + public static String missingInResultMap(String attribute) { + + return "The attribute '" + attribute + + "' declared under result 'attributes:' section is missing from http 'result_map:'."; + } + + /** + * Static interface method. + * + * @param attribute + * string + * @return string + */ + public static String missingInResultAttribute(String attribute) { + + return "Mapped attribute '" + attribute + "' is missing declaration in result attributes section."; + } + + /** + * Static interface method. + * + * @param declaredParam + * string + * @return string + */ + public static String parameterNotMapped(String declaredParam) { + + return "The parameter '" + declaredParam + + "' declared under 'parameters:' section is not mapped into request section."; + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidator.java b/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidator.java new file mode 100644 index 00000000..bb1248b9 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidator.java @@ -0,0 +1,292 @@ +/* + * 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.fw.schema; + +import com.fasterxml.jackson.databind.ObjectMapper; +import net.minidev.json.JSONObject; + +import org.onap.cli.fw.error.OnapCommandInvalidSchema; + +import static org.onap.cli.fw.conf.Constants.*; + +import java.io.File; +import java.io.IOException; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import java.util.Set; + +/** + * Schema Validation impl. + * + */ +public class SchemaValidator extends AbstractSchemaValidate { + + /** + * Constructor. + * + * @param schemaFile + * file + * @throws OnapCommandInvalidSchema + * exception + */ + public SchemaValidator(File schemaFile) throws OnapCommandInvalidSchema { + super(schemaFile); + } + + public SchemaValidator(String schemaFile) throws OnapCommandInvalidSchema { + super(schemaFile); + } + + @Override + protected void validateSpecificSchema(SchemaType type) throws OnapCommandInvalidSchema { + if (type.equals(SchemaType.HTTP)) { + validateHttpParameters(); + } + } + + @SuppressWarnings("unchecked") + private void validateHttpParameters() { + + Map<String, Object> httpMap = (Map<String, Object>) yamlMap.get(HTTP); + + if (httpMap == null || httpMap.isEmpty()) { + schemaErrors.add(HTTP_SECTION_EMPTY); + return; + } + + validateMandatoryParams(httpMap, HTTP_SECTIONS, HTTP_MANDATORY_SECTIONS, PARAMETERS); + + Map<String, Object> requestMap = (Map<String, Object>) httpMap.get(REQUEST); + + if (requestMap != null && !requestMap.isEmpty()) { + validateHttpRequestParams(requestMap); + } else { + schemaErrors.add(SchemaValidate.emptySection(REQUEST)); + } + + List<Object> requestSuccessCodes = (List<Object>) httpMap.get(SUCCESS_CODES); + if (requestSuccessCodes != null && !requestSuccessCodes.isEmpty()) { + validateHttpSccessCodes(requestSuccessCodes); + } else { + schemaErrors.add(SchemaValidate.emptySection(SUCCESS_CODES)); + } + + Map<String, Object> resultMap = (Map<String, Object>) httpMap.get(RESULT_MAP); + + if (resultMap != null && !resultMap.isEmpty()) { + validateHttpResultMapping(resultMap); + } + + Object object = httpMap.get(SAMPLE_RESPONSE); + if (object != null) { + if (object instanceof String) { + schemaErrors.add(HTTP_SAMPLE_RESPONSE_FAILED_PARSING); + } else { + validateSampleResponse((Map<String, Object>) object); + } + } + } + + private void validateHttpRequestParams(Map<String, Object> requestMap) { + + if (requestMap == null || requestMap.isEmpty()) { + return; + } + // validate mandatory parameters + validateMandatoryParams(requestMap, HTTP_REQUEST_PARAMS, HTTP_REQUEST_MANDATORY_PARAMS, REQUEST); + + // Validate method types + String method = (String) requestMap.get(METHOD); + if (method != null && !method.isEmpty()) { + if (!HTTP_METHODS.contains(method.toLowerCase())) { + schemaErrors.add(SchemaValidate.invalidType(REQUEST, METHOD, HTTP_METHODS)); + } + } else { + schemaErrors.add("Http request method cann't be null or empty"); + } + + Set<String> requestParams = getRequestParams(); + + // validate uriParams + Set<String> uriParams = validateHttpUri(requestMap); + + // validate body + Set<String> bodyParams = validateHttpBody(requestMap); + + // validate header + Set<String> headerParams = validateHttpHeaders(requestMap); + + // validate queries + Set<String> queryParams = validateHttpQueries(requestMap); + + for (String declaredParam : requestParams) { + if (!uriParams.contains(declaredParam) && !bodyParams.contains(declaredParam) + && !headerParams.contains(declaredParam) && !queryParams.contains(declaredParam)) { + schemaErrors.add(SchemaValidate.parameterNotMapped(declaredParam)); + } + } + + Set<String> totalParams = new HashSet<>(); + totalParams.addAll(uriParams); + totalParams.addAll(bodyParams); + totalParams.addAll(queryParams); + totalParams.addAll(headerParams); + + for (String definedParam : totalParams) { + if (!requestParams.contains(definedParam)) { + if (uriParams.contains(definedParam)) { + schemaErrors.add(SchemaValidate.invalidRequestParam(URI, definedParam)); + } else if (bodyParams.contains(definedParam)) { + schemaErrors.add(SchemaValidate.invalidRequestParam(BODY, definedParam)); + } else if (queryParams.contains(definedParam)) { + schemaErrors.add(SchemaValidate.invalidRequestParam(QUERIES, definedParam)); + } else if (headerParams.contains(definedParam)) { + schemaErrors.add(SchemaValidate.invalidRequestParam(HEADERS, definedParam)); + } + } + } + + } + + private Set<String> validateHttpUri(Map<String, Object> requestMap) { + Set<String> uriParamNames = new HashSet<>(); + String uri = (String) requestMap.get(URI); + if (uri == null || uri.isEmpty()) { + schemaErrors.add(SchemaValidate.emptySection(URI)); + return uriParamNames; + } + parseParameters(uri, uriParamNames); + return uriParamNames; + } + + @SuppressWarnings("unchecked") + private Set<String> validateHttpHeaders(Map<String, Object> requestMap) { + + Map<String, Object> headers = (Map<String, Object>) requestMap.get(HEADERS); + Set<String> headerParamNames = new HashSet<>(); + if (headers != null) { + for (Entry<String, Object> entry : headers.entrySet()) { + parseParameters(String.valueOf(entry.getValue()), headerParamNames); + } + } + return headerParamNames; + } + + @SuppressWarnings("unchecked") + private Set<String> validateHttpQueries(Map<String, Object> requestMap) { + Map<String, Object> queries = (Map<String, Object>) requestMap.get(QUERIES); + Set<String> queryParamNames = new HashSet<>(); + if (queries != null) { + for (Entry<String, Object> entry : queries.entrySet()) { + parseParameters(String.valueOf(entry.getValue()), queryParamNames); + } + } + return queryParamNames; + } + + private Set<String> validateHttpBody(Map<String, Object> requestMap) { + Set<String> bodyParamNames = new HashSet<>(); + Object bodyString = requestMap.get(BODY); + if (bodyString == null) { + return bodyParamNames; + } + + String body = String.valueOf(bodyString); + JSONObject obj = null; + try { + obj = new ObjectMapper().readValue(body, JSONObject.class); + } catch (IOException e1) { // NOSONAR + schemaErrors.add(HTTP_BODY_FAILED_PARSING); + } + if (obj == null || "".equals(obj.toString())) { + schemaErrors.add(HTTP_BODY_JSON_EMPTY); + } + parseParameters(body, bodyParamNames); + + return bodyParamNames; + } + + private void parseParameters(String line, Set<String> paramNames) { + + int currentIdx = 0; + while (currentIdx < line.length()) { + int idxS = line.indexOf("${", currentIdx); + if (idxS == -1) { + break; + } + int idxE = line.indexOf("}", idxS); + String paramName = line.substring(idxS + 2, idxE); + paramNames.add(paramName.trim()); + + currentIdx = idxE + 1; + } + + } + + private void validateHttpSccessCodes(List<Object> requestSuccessCodes) { + + for (Object successCode : requestSuccessCodes) { + Integer code = (Integer) successCode; + if (code < 200 || code >= 300) { + schemaErrors.add(HTTP_SUCCESS_CODE_INVALID); + } + } + + } + + private void validateHttpResultMapping(Map<String, Object> resultMap) { + Set<String> resultAttributes = getResultAttributes(); + + // Validate if all result attributes are used in the result mapping + for (String attribute : resultAttributes) { + if (!resultMap.containsKey(attribute)) { + schemaErrors.add(SchemaValidate.missingInResultMap(attribute)); + } + } + + // Validate if all result mapping keys are defined in the result attributes + for (Entry<String, Object> entry : resultMap.entrySet()) { + if (!resultAttributes.contains(entry.getKey())) { + schemaErrors.add(SchemaValidate.missingInResultAttribute(entry.getKey())); + } + } + } + + private void validateSampleResponse(Map<String, Object> sampleResponseBodyMap) { + + // validate the json + Object json = sampleResponseBodyMap.get(BODY); + if (json == null) { + schemaErrors.add(HTTP_SAMPLE_RESPONSE_EMPTY); + return; + } + String jsonString = json.toString(); + try { + if (jsonString.startsWith("[")) { + new ObjectMapper().readValue(jsonString, JSONObject[].class); + } else { + new ObjectMapper().readValue(jsonString, JSONObject.class); + } + } catch (IOException e1) { // NOSONAR + schemaErrors.add(HTTP_SAMPLE_RESPONSE_FAILED_PARSING); + } + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/utils/ExternalSchema.java b/framework/src/main/java/org/onap/cli/fw/utils/ExternalSchema.java new file mode 100644 index 00000000..e9f19673 --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/utils/ExternalSchema.java @@ -0,0 +1,49 @@ +/* + * 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.fw.utils; + +public class ExternalSchema { + + private String schemaName; + private String cmdName; + private String version; + + public String getSchemaName() { + return schemaName; + } + + public void setSchemaName(String schemaName) { + this.schemaName = schemaName; + } + + public String getCmdName() { + return cmdName; + } + + public void setCmdName(String cmdName) { + this.cmdName = cmdName; + } + + public String getVersion() { + return version; + } + + public void setVersion(String version) { + this.version = version; + } + +} diff --git a/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java b/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java new file mode 100644 index 00000000..79b9596c --- /dev/null +++ b/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java @@ -0,0 +1,1087 @@ +/* + * 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.fw.utils; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.jayway.jsonpath.JsonPath; +import net.minidev.json.JSONArray; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.ad.OnapCredentials; +import org.onap.cli.fw.ad.OnapService; +import org.onap.cli.fw.cmd.OnapHttpCommand; +import org.onap.cli.fw.cmd.OnapSwaggerCommand; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandDiscoveryFailed; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandHelpFailed; +import org.onap.cli.fw.error.OnapCommandHttpHeaderNotFound; +import org.onap.cli.fw.error.OnapCommandHttpInvalidResponseBody; +import org.onap.cli.fw.error.OnapCommandInvalidParameterType; +import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; +import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection; +import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope; +import org.onap.cli.fw.error.OnapCommandInvalidSchema; +import org.onap.cli.fw.error.OnapCommandInvalidSchemaVersion; +import org.onap.cli.fw.error.OnapCommandParameterNameConflict; +import org.onap.cli.fw.error.OnapCommandParameterNotFound; +import org.onap.cli.fw.error.OnapCommandParameterOptionConflict; +import org.onap.cli.fw.error.OnapCommandResultEmpty; +import org.onap.cli.fw.error.OnapCommandResultMapProcessingFailed; +import org.onap.cli.fw.error.OnapCommandSchemaNotFound; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.http.HttpResult; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; +import org.onap.cli.fw.output.OnapCommandResult; +import org.onap.cli.fw.output.OnapCommandResultAttribute; +import org.onap.cli.fw.output.OnapCommandResultAttributeScope; +import org.onap.cli.fw.output.PrintDirection; +import org.onap.cli.fw.output.ResultType; +import org.onap.cli.fw.run.OnapCommandExecutor; +import org.springframework.core.io.Resource; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.core.io.support.ResourcePatternResolver; +import org.yaml.snakeyaml.Yaml; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.ServiceLoader; +import java.util.Set; + +/** + * Provides helper method to parse Yaml files and produce required objects. + * + */ +public class OnapCommandUtils { + + /** + * Private constructor. + */ + private OnapCommandUtils() { + + } + + /** + * Validates schema version. + * + * @param schemaName + * schema name + * @param version + * schema version + * @return map + * @throws OnapCommandInvalidSchemaVersion + * invalid schema version exception + * @throws OnapCommandInvalidSchema + * invalid schema + * @throws OnapCommandSchemaNotFound + * schema not found + */ + public static Map<String, ?> validateSchemaVersion(String schemaName, String version) throws OnapCommandException { + InputStream inputStream = OnapCommandUtils.class.getClassLoader().getResourceAsStream(schemaName); + + try { + Resource resource = getExternalResource(schemaName, Constants.EXTERNAL_SCHEMA_PATH_PATERN); + + if (resource != null) { + inputStream = resource.getInputStream(); + } + + } catch (IOException e) { + throw new OnapCommandSchemaNotFound(schemaName, e); + } + if (inputStream == null) { + throw new OnapCommandSchemaNotFound(schemaName); + } + + Map<String, ?> values = null; + try { + values = (Map<String, ?>) new Yaml().load(inputStream); + } catch (Exception e) { + throw new OnapCommandInvalidSchema(schemaName, e); + } + String schemaVersion = ""; + if (values.keySet().contains(Constants.ONAP_CMD_SCHEMA_VERSION)) { + Object obj = values.get(Constants.ONAP_CMD_SCHEMA_VERSION); + schemaVersion = obj.toString(); + } + + if (!version.equals(schemaVersion)) { + throw new OnapCommandInvalidSchemaVersion(schemaVersion); + } + + return values; + } + + /** + * Retrieve OnapCommand from schema. + * + * @param cmd + * OnapCommand + * @param schemaName + * schema name + * @param includeDefault + * include if default + * @throws OnapCommandParameterNameConflict + * param name conflict exception + * @throws OnapCommandParameterOptionConflict + * param option conflict exception + * @throws OnapCommandInvalidParameterType + * invalid param type exception + * @throws OnapCommandInvalidPrintDirection + * invalid print direction exception + * @throws OnapCommandInvalidResultAttributeScope + * invalid scope exception + * @throws OnapCommandSchemaNotFound + * schema not found + * @throws OnapCommandInvalidSchema + * invalid schema + * @throws OnapCommandInvalidSchemaVersion + * invalid schema version + */ + public static void loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault) + throws OnapCommandException { + List<String> shortOptions = new ArrayList<>(); + List<String> longOptions = new ArrayList<>(); + List<String> names = new ArrayList<>(); + + if (includeDefault) { + loadSchema(cmd, Constants.DEFAULT_PARAMETER_FILE_NAME, shortOptions, longOptions, names); + } + + loadSchema(cmd, schemaName, shortOptions, longOptions, names); + + } + + private static void loadSchema(OnapCommand cmd, String schemaName, List<String> shortOptions, + List<String> longOptions, List<String> names) throws OnapCommandException { + try { + Map<String, ?> values = validateSchemaVersion(schemaName, cmd.getSchemaVersion()); + + for (Map.Entry<String, ?> entry : values.entrySet()) { + String key = entry.getKey(); + + if (Constants.NAME.equals(key)) { + Object val = values.get(key); + cmd.setName(val.toString()); + } else if (Constants.DESCRIPTION.equals(key)) { + Object val = values.get(key); + cmd.setDescription(val.toString()); + } else if (Constants.SERVICE.equals(key)) { + Map<String, String> map = (Map<String, String>) values.get(key); + OnapService srv = new OnapService(); + + for (Map.Entry<String, String> entry1 : map.entrySet()) { + String key1 = entry1.getKey(); + + if (Constants.NAME.equals(key1)) { + srv.setName(map.get(key1)); + } else if (Constants.VERSION.equals(key1)) { + srv.setVersion(map.get(key1)); + } else if (Constants.NO_AUTH.equals(key1)) { + Object obj = map.get(key1); + srv.setNoAuth("true".equalsIgnoreCase(obj.toString())); + } + } + + cmd.setService(srv); + } else if (Constants.PARAMETERS.equals(key)) { + List<Map<String, String>> list = (ArrayList) values.get(key); + + for (Map<String, String> map : list) { + OnapCommandParameter param = new OnapCommandParameter(); + + for (Map.Entry<String, String> entry1 : map.entrySet()) { + String key2 = entry1.getKey(); + + if (Constants.NAME.equals(key2)) { + if (names.contains(map.get(key2))) { + throw new OnapCommandParameterNameConflict(map.get(key2)); + } + names.add(map.get(key2)); + param.setName(map.get(key2)); + } else if (Constants.DESCRIPTION.equals(key2)) { + param.setDescription(map.get(key2)); + } else if (Constants.SHORT_OPTION.equals(key2)) { + if (shortOptions.contains(map.get(key2))) { + throw new OnapCommandParameterOptionConflict(map.get(key2)); + } + shortOptions.add(map.get(key2)); + param.setShortOption(map.get(key2)); + } else if (Constants.LONG_OPTION.equals(key2)) { + if (longOptions.contains(map.get(key2))) { + throw new OnapCommandParameterOptionConflict(map.get(key2)); + } + longOptions.add(map.get(key2)); + param.setLongOption(map.get(key2)); + } else if (Constants.DEFAULT_VALUE.equals(key2)) { + Object obj = map.get(key2); + param.setDefaultValue(obj.toString()); + } else if (Constants.TYPE.equals(key2)) { + param.setParameterType(ParameterType.get(map.get(key2))); + } else if (Constants.IS_OPTIONAL.equals(key2)) { + if ("true".equalsIgnoreCase(String.valueOf(map.get(key2)))) { + param.setOptional(true); + } else { + param.setOptional(false); + } + } else if (Constants.IS_SECURED.equals(key2)) { + if ("true".equalsIgnoreCase(String.valueOf(map.get(key2)))) { + param.setSecured(true); + } else { + param.setSecured(false); + } + } + } + cmd.getParameters().add(param); + + } + } else if (Constants.RESULTS.equals(key)) { + Map<String, ?> valueMap = (Map<String, ?>) values.get(key); + OnapCommandResult result = new OnapCommandResult(); + for (Map.Entry<String, ?> entry1 : valueMap.entrySet()) { + String key3 = entry1.getKey(); + + if (Constants.DIRECTION.equals(key3)) { + result.setPrintDirection(PrintDirection.get((String) valueMap.get(key3))); + } else if (Constants.ATTRIBUTES.equals(key3)) { + List<Map<String, String>> attrs = (ArrayList) valueMap.get(key3); + + for (Map<String, String> map : attrs) { + OnapCommandResultAttribute attr = new OnapCommandResultAttribute(); + for (Map.Entry<String, String> entry4 : map.entrySet()) { + String key4 = entry4.getKey(); + + if (Constants.NAME.equals(key4)) { + attr.setName(map.get(key4)); + } else if (Constants.DESCRIPTION.equals(key4)) { + attr.setDescription(map.get(key4)); + } else if (Constants.SCOPE.equals(key4)) { + attr.setScope(OnapCommandResultAttributeScope.get(map.get(key4))); + } else if (Constants.TYPE.equals(key4)) { + attr.setType(ParameterType.get(map.get(key4))); + } else if (Constants.IS_SECURED.equals(key4)) { + if ("true".equals(String.valueOf(map.get(key4)))) { + attr.setSecured(true); + } else { + attr.setSecured(false); + } + } + + } + result.getRecords().add(attr); + } + } + } + cmd.setResult(result); + } + } + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + throw new OnapCommandInvalidSchema(schemaName, e); + } + } + + /** + * Load the schema. + * + * @param cmd + * OnapSwaggerBasedCommand + * @param schemaName + * schema name + * @throws OnapCommandParameterNameConflict + * param name conflict exception + * @throws OnapCommandParameterOptionConflict + * param option conflict exception + * @throws OnapCommandInvalidParameterType + * invalid param type exception + * @throws OnapCommandInvalidPrintDirection + * invalid print direction exception + * @throws OnapCommandInvalidResultAttributeScope + * invalid scope exception + * @throws OnapCommandSchemaNotFound + * schema not found + * @throws OnapCommandInvalidSchema + * invalid schema + * @throws OnapCommandInvalidSchemaVersion + * invalid schema version + */ + public static void loadSchema(OnapSwaggerCommand cmd, String schemaName) throws OnapCommandException { + try { + Map<String, ?> values = (Map<String, ?>) validateSchemaVersion(schemaName, cmd.getSchemaVersion()); + Map<String, String> valueMap = (Map<String, String>) values.get(Constants.EXECUTOR); + OnapCommandExecutor exec = new OnapCommandExecutor(); + + for (Map.Entry<String, String> entry1 : valueMap.entrySet()) { + String key1 = entry1.getKey(); + + if (Constants.API.equals(key1)) { + exec.setApi(valueMap.get(key1)); + } else if (Constants.CLIENT.equals(key1)) { + exec.setClient(valueMap.get(key1)); + } else if (Constants.ENTITY.equals(key1)) { + exec.setEntity(valueMap.get(key1)); + } else if (Constants.EXCEPTION.equals(key1)) { + exec.setException(valueMap.get(key1)); + } else if (Constants.METHOD.equals(key1)) { + exec.setMethod(valueMap.get(key1)); + } + } + + cmd.setExecutor(exec); + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + throw new OnapCommandInvalidSchema(schemaName, e); + } + } + + /** + * Load the schema. + * + * @param cmd + * OnapHttpCommand + * @param schemaName + * schema name + * @throws OnapCommandParameterNameConflict + * param name conflict exception + * @throws OnapCommandParameterOptionConflict + * param option conflict exception + * @throws OnapCommandInvalidParameterType + * invalid param type exception + * @throws OnapCommandInvalidPrintDirection + * invalid print direction exception + * @throws OnapCommandInvalidResultAttributeScope + * invalid scope exception + * @throws OnapCommandSchemaNotFound + * schema not found + * @throws OnapCommandInvalidSchema + * invalid schema + * @throws OnapCommandInvalidSchemaVersion + * invalid schema version + */ + public static void loadSchema(OnapHttpCommand cmd, String schemaName) throws OnapCommandException { + try { + Map<String, ?> values = (Map<String, ?>) validateSchemaVersion(schemaName, cmd.getSchemaVersion()); + Map<String, ?> valMap = (Map<String, ?>) values.get(Constants.HTTP); + + for (Map.Entry<String, ?> entry1 : valMap.entrySet()) { + String key1 = entry1.getKey(); + if (Constants.REQUEST.equals(key1)) { + Map<String, ?> map = (Map<String, ?>) valMap.get(key1); + + for (Map.Entry<String, ?> entry2 : map.entrySet()) { + String key2 = entry2.getKey(); + + if (Constants.URI.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setUri(obj.toString()); + } else if (Constants.MERHOD.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setMethod(obj.toString()); + } else if (Constants.BODY.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setBody(obj.toString()); + } else if (Constants.HEADERS.equals(key2)) { + Map<String, String> head = (Map<String, String>) map.get(key2); + cmd.getInput().setReqHeaders(head); + } else if (Constants.QUERIES.equals(key2)) { + Map<String, String> query = (Map<String, String>) map.get(key2); + + cmd.getInput().setReqQueries(query); + } + } + } else if (Constants.SUCCESS_CODES.equals(key1)) { + cmd.setSuccessStatusCodes((ArrayList) valMap.get(key1)); + } else if (Constants.RESULT_MAP.equals(key1)) { + cmd.setResultMap((Map<String, String>) valMap.get(key1)); + } else if (Constants.SAMPLE_RESPONSE.equals(key1)) { + // (mrkanag) implement sample response handling + } + } + + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + throw new OnapCommandInvalidSchema(schemaName, e); + } + } + + /** + * Returns Help. + * + * @param cmd + * OnapCommand + * @return help string + * @throws OnapCommandHelpFailed + * help failed exception + */ + public static String help(OnapCommand cmd) throws OnapCommandHelpFailed { + String help = "usage: onap " + cmd.getName(); + + // Add description + help += "\n\n" + cmd.getDescription(); + + // Add service + help += "\n\nOnap service: " + cmd.getService(); + + // Add whole command + String commandOptions = ""; + + // Add parameters + OnapCommandResult paramTable = new OnapCommandResult(); + paramTable.setPrintDirection(PrintDirection.LANDSCAPE); + paramTable.setType(ResultType.TABLE); + paramTable.setIncludeTitle(false); + paramTable.setIncludeSeparator(false); + + OnapCommandResultAttribute attrName = new OnapCommandResultAttribute(); + attrName.setName(Constants.NAME); + attrName.setDescription(Constants.NAME); + attrName.setScope(OnapCommandResultAttributeScope.SHORT); + paramTable.getRecords().add(attrName); + + OnapCommandResultAttribute attrDescription = new OnapCommandResultAttribute(); + attrDescription.setName(Constants.DESCRIPTION); + attrDescription.setDescription(Constants.DESCRIPTION); + attrDescription.setScope(OnapCommandResultAttributeScope.SHORT); + paramTable.getRecords().add(attrDescription); + + int newLineOptions = 0; + for (OnapCommandParameter param : cmd.getParameters()) { + // First column Option or positional args + String optFirstCol; + if (newLineOptions == 3) { + newLineOptions = 0; + commandOptions += "\n"; + } + + if (param.getShortOption() != null || param.getLongOption() != null) { + optFirstCol = OnapCommandParameter.printShortOption(param.getShortOption()) + " | " + + OnapCommandParameter.printLongOption(param.getLongOption()); + commandOptions += "[" + optFirstCol + "] "; + } else { + optFirstCol = param.getName(); + commandOptions += "<" + optFirstCol + "> "; + } + + newLineOptions++; + + attrName.getValues().add(optFirstCol); + + // Second column description + String optSecondCol = param.getDescription().trim(); + if (!optSecondCol.endsWith(".")) { + optSecondCol += "."; + } + optSecondCol += " It is of type " + param.getParameterType().name() + "."; + + if (param.getParameterType().equals(ParameterType.JSON) + || param.getParameterType().equals(ParameterType.YAML)) { + optSecondCol += " It's recommended to input the complete path of the file, which is having the value for it."; + } + if (param.isOptional()) { + optSecondCol += " It is optional."; + } + + String defaultMsg = " By default, it is "; + if (param.isDefaultValueAnEnv()) { + optSecondCol += defaultMsg + "read from environment variable " + param.getEnvVarNameFromDefaultValue() + + "."; + } else if (param.getDefaultValue() != null && !param.getDefaultValue().isEmpty()) { + optSecondCol += defaultMsg + param.getDefaultValue() + "."; + } + + if (param.isSecured()) { + optSecondCol += " Secured."; + } + // (mrkanag) Add help msg for reading default value from env + attrDescription.getValues().add(optSecondCol); + } + + try { + help += "\n\nOptions:\n" + commandOptions + "\nwhere,\n" + paramTable.print(); + } catch (OnapCommandException e) { + throw new OnapCommandHelpFailed(e); + } + + // Add results + OnapCommandResult resultTable = new OnapCommandResult(); + resultTable.setPrintDirection(PrintDirection.PORTRAIT); + resultTable.setType(ResultType.TABLE); + resultTable.setIncludeTitle(false); + resultTable.setIncludeSeparator(false); + + for (OnapCommandResultAttribute attr : cmd.getResult().getRecords()) { + OnapCommandResultAttribute attrHelp = new OnapCommandResultAttribute(); + attrHelp.setName(attr.getName()); + attrHelp.setDescription(attr.getDescription()); + String msg = attr.getDescription() + " and is of type " + attr.getType().name() + "."; + if (attr.isSecured()) { + msg += " It is secured."; + } + attrHelp.getValues().add(msg); + attrHelp.setType(attr.getType()); + resultTable.getRecords().add(attrHelp); + } + try { + help += "\n\nResults:\n" + resultTable.print(); + } catch (OnapCommandException e) { + throw new OnapCommandHelpFailed(e); + } + + // Error + help += "\n\nError:\nOn error, it prints <HTTP STATUS CODE>::<ERROR CODE>::<ERROR MESSAGE>\n"; + return help; + } + + /** + * Helps to create OnapCredentials from default params. + * + * @param params + * list of parameters + * @return OnapCredentials + * @throws OnapCommandInvalidParameterValue + * exception + */ + public static OnapCredentials fromParameters(List<OnapCommandParameter> params) + throws OnapCommandInvalidParameterValue { + Map<String, String> paramMap = new HashMap<>(); + + for (OnapCommandParameter param : params) { + paramMap.put(param.getName(), param.getValue().toString()); + } + + return new OnapCredentials(paramMap.get(Constants.DEAFULT_PARAMETER_USERNAME), + paramMap.get(Constants.DEAFULT_PARAMETER_PASS_WORD), + paramMap.get(Constants.DEAFULT_PARAMETER_MSB_URL)); + } + + /** + * Create Dict from list of Parameters. + * + * @param inputs + * list of parameters + * @return map + */ + public static Map<String, OnapCommandParameter> getInputMap(List<OnapCommandParameter> inputs) { + Map<String, OnapCommandParameter> map = new HashMap<>(); + for (OnapCommandParameter param : inputs) { + map.put(param.getName(), param); + } + return map; + } + + /** + * Discover the Onap commands. + * + * @return list + */ + public static List<Class<OnapCommand>> findOnapCommands() { + ServiceLoader<OnapCommand> loader = ServiceLoader.load(OnapCommand.class); + List<Class<OnapCommand>> clss = new ArrayList<>(); + for (OnapCommand implClass : loader) { + clss.add((Class<OnapCommand>) implClass.getClass()); + } + + return clss; + } + + /** + * sort the set. + * + * @param col + * set + * @return list + */ + public static List<String> sort(Set<String> col) { + List<String> results = new ArrayList<>(); + results.addAll(col); + Collections.sort(results); + return results; + } + + /** + * Flatten the json list. + * + * @param jsons + * list json strings + * @return list + */ + public static List<String> jsonFlatten(List<String> jsons) { + List<String> results = new ArrayList<>(); + for (String json : jsons) { + try { + results.add(JsonPath.parse(json).jsonString()); + } catch (Exception e) { // NOSONAR + results.add(json); + } + } + + return results; + } + + /** + * Construct method name. + * + * @param name + * name + * @param prefix + * prefix + * @return string + */ + public static String formMethodNameFromAttributeName(String name, String prefix) { + if (name == null || name.isEmpty()) { + return name; + } + + String methodName = prefix; + for (String tk : name.split("-")) { + methodName += Character.toString(tk.charAt(0)).toUpperCase(); + methodName += tk.substring(1); + } + return methodName; + } + + private static String replaceLineFromInputParameters(String line, Map<String, OnapCommandParameter> params) + throws OnapCommandException { + String result = ""; + + if (!line.contains("${")) { + return line; + } + + int currentIdx = 0; + while (currentIdx < line.length()) { + int idxS = line.indexOf("${", currentIdx); + if (idxS == -1) { + result += line.substring(currentIdx); + break; + } + int idxE = line.indexOf("}", idxS); + String paramName = line.substring(idxS + 2, idxE); + paramName = paramName.trim(); + if (!params.containsKey(paramName)) { + throw new OnapCommandParameterNotFound(paramName); + } + + String value = params.get(paramName).getValue().toString(); + + OnapCommandParameter param = params.get(paramName); + if (ParameterType.ARRAY.equals(param.getParameterType()) + || ParameterType.MAP.equals(param.getParameterType()) + || ParameterType.JSON.equals(param.getParameterType()) + || ParameterType.YAML.equals(param.getParameterType())) { + // ignore the front and back double quotes in json body + result += line.substring(currentIdx, idxS - 1) + value; + currentIdx = idxE + 2; + } else { + result += line.substring(currentIdx, idxS) + value; + currentIdx = idxE + 1; + } + } + + return result; + } + + private static ArrayList<String> replaceLineFromOutputResults(String line, HttpResult resultHttp) + throws OnapCommandHttpHeaderNotFound, OnapCommandHttpInvalidResponseBody, + OnapCommandResultMapProcessingFailed, OnapCommandResultEmpty { + String headerProcessedLine = ""; + + ArrayList<String> result = new ArrayList<>(); + if (!line.contains("$b{") && !line.contains("$h{")) { + result.add(line); + return result; + } + + /** + * In case of empty response body [] or {} + **/ + if (resultHttp.getBody().length() <= 2) { + return result; + } + + /** + * Process headers macros : line: $h{abc}-$b{$.[*].xyz} , After processing line will be [abc's + * value]-$b{$.[*].xyz} + **/ + int currentIdx = 0; + while (currentIdx < line.length()) { + int idxS = line.indexOf("$h{", currentIdx); + if (idxS == -1) { + headerProcessedLine += line.substring(currentIdx); + break; + } + int idxE = line.indexOf("}", idxS); + String headerName = line.substring(idxS + 3, idxE); + headerName = headerName.trim(); + if (!resultHttp.getRespHeaders().containsKey(headerName)) { + throw new OnapCommandHttpHeaderNotFound(headerName); + } + String value = resultHttp.getRespHeaders().get(headerName); + + headerProcessedLine += line.substring(currentIdx, idxS) + value; + currentIdx = idxE + 1; + } + + // Process body jsonpath macros + List<Object> values = new ArrayList<>(); + String bodyProcessedPattern = ""; + currentIdx = 0; + int maxRows = 1; // in normal case, only one row will be there + while (currentIdx < headerProcessedLine.length()) { + int idxS = headerProcessedLine.indexOf("$b{", currentIdx); + if (idxS == -1) { + bodyProcessedPattern += headerProcessedLine.substring(currentIdx); + break; + } + int idxE = headerProcessedLine.indexOf("}", idxS); + String jsonPath = headerProcessedLine.substring(idxS + 3, idxE); + jsonPath = jsonPath.trim(); + try { + // JSONArray or String + Object value = JsonPath.read(resultHttp.getBody(), jsonPath); + if (value instanceof JSONArray) { + JSONArray arr = (JSONArray) value; + if (arr.size() > maxRows) { + maxRows = arr.size(); + } + } + bodyProcessedPattern += headerProcessedLine.substring(currentIdx, idxS) + "%s"; + values.add(value); + currentIdx = idxE + 1; + } catch (Exception e) { + throw new OnapCommandHttpInvalidResponseBody(jsonPath, e); + } + } + + if (bodyProcessedPattern.isEmpty()) { + result.add(headerProcessedLine); + return result; + } else { + for (int i = 0; i < maxRows; i++) { + currentIdx = 0; + String bodyProcessedLine = ""; + int positionalIdx = 0; // %s positional idx + while (currentIdx < bodyProcessedPattern.length()) { + int idxS = bodyProcessedPattern.indexOf("%s", currentIdx); + if (idxS == -1) { + bodyProcessedLine += bodyProcessedPattern.substring(currentIdx); + break; + } + int idxE = idxS + 2; // %s + try { + Object value = values.get(positionalIdx); + String valueS = String.valueOf(value); + if (value instanceof JSONArray) { + JSONArray arr = (JSONArray) value; + if (!arr.isEmpty()) { + valueS = arr.get(i).toString(); + } else { + throw new OnapCommandResultEmpty(); + } + } + + bodyProcessedLine += bodyProcessedPattern.substring(currentIdx, idxS) + valueS; + currentIdx = idxE; + positionalIdx++; + } catch (OnapCommandResultEmpty e) { + throw e; + } catch (Exception e) { + throw new OnapCommandResultMapProcessingFailed(line, e); + } + } + result.add(bodyProcessedLine); + } + + return result; + } + } + + /** + * Set argument to param value. + * + * @param params + * map + * @param input + * HttpInput + * @return HttpInput + * @throws OnapCommandParameterNotFound + * exception + * @throws OnapCommandInvalidParameterValue + * exception + */ + public static HttpInput populateParameters(Map<String, OnapCommandParameter> params, HttpInput input) + throws OnapCommandException { + HttpInput inp = new HttpInput(); + for (OnapCommandParameter param : params.values()) { + if (ParameterType.BINARY.equals(param.getParameterType())) { + inp.setBinaryData(true); + break; + } + } + inp.setBody(replaceLineFromInputParameters(input.getBody(), params)); + inp.setUri(replaceLineFromInputParameters(input.getUri(), params)); + inp.setMethod(input.getMethod().toLowerCase()); + for (String h : input.getReqHeaders().keySet()) { + String value = input.getReqHeaders().get(h); + inp.getReqHeaders().put(h, replaceLineFromInputParameters(value, params)); + } + + for (String h : input.getReqQueries().keySet()) { + String value = input.getReqQueries().get(h); + inp.getReqQueries().put(h, replaceLineFromInputParameters(value, params)); + } + + return inp; + } + + /** + * Populate result. + * + * @param resultMap + * map + * @param resultHttp + * HttpResult + * @return map + * @throws OnapCommandHttpHeaderNotFound + * header not found exception + * @throws OnapCommandHttpInvalidResponseBody + * invalid response body exception + * @throws OnapCommandResultMapProcessingFailed + * map processing failed exception + */ + public static Map<String, ArrayList<String>> populateOutputs(Map<String, String> resultMap, HttpResult resultHttp) + throws OnapCommandException { + Map<String, ArrayList<String>> resultsProcessed = new HashMap<>(); + + for (Entry<String, String> entry : resultMap.entrySet()) { + String key = entry.getKey(); + resultsProcessed.put(key, replaceLineFromOutputResults(resultMap.get(key), resultHttp)); + } + + return resultsProcessed; + } + + /** + * Find external schema files. + * + * @return list ExternalSchema + * @throws OnapCommandDiscoveryFailed + * exception + * @throws OnapCommandInvalidSchema + * exception + */ + public static List<ExternalSchema> findAllExternalSchemas() throws OnapCommandException { + List<ExternalSchema> extSchemas = new ArrayList<>(); + try { + Resource[] res = getExternalResources(Constants.EXTERNAL_SCHEMA_PATH_PATERN); + if (res != null && res.length > 0) { + Map<String, ?> resourceMap; + for (Resource resource : res) { + resourceMap = getExternalSchemaMap(resource); + if (resourceMap != null && resourceMap.size() > 0) { + ExternalSchema schema = new ExternalSchema(); + schema.setSchemaName(resource.getFilename()); + schema.setCmdName((String) resourceMap.get(Constants.NAME)); + Object obj = resourceMap.get(Constants.ONAP_CMD_SCHEMA_VERSION); + schema.setVersion(obj.toString()); + extSchemas.add(schema); + } + } + } + } catch (IOException e) { + throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_SCHEMA_DIRECTORY, e); + } + + return extSchemas; + } + + /** + * Returns all resources available under certain directory in class-path. + * + * @param pattern + * search pattern + * @return resources found resources + * @throws IOException + * exception + */ + public static Resource[] getExternalResources(String pattern) throws IOException { + ClassLoader cl = OnapCommandUtils.class.getClassLoader(); + ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver(cl); + return resolver.getResources("classpath*:" + pattern); + } + + /** + * Returns a resource available under certain directory in class-path. + * + * @param pattern + * search pattern + * @return found resource + * @throws IOException + * exception + */ + public static Resource getExternalResource(String fileName, String pattern) throws IOException { + Resource[] resources = getExternalResources(pattern); + if (resources != null && resources.length > 0) { + for (Resource res : resources) { + if (res.getFilename().equals(fileName)) { + return res; + } + } + } + + return null; + } + + /** + * Get schema map. + * + * @param resource + * resource obj + * @return map + * @throws OnapCommandInvalidSchema + * exception + */ + public static Map<String, ?> getExternalSchemaMap(Resource resource) throws OnapCommandInvalidSchema { + Map<String, ?> values = null; + try { + values = (Map<String, ?>) new Yaml().load(resource.getInputStream()); + } catch (Exception e) { + throw new OnapCommandInvalidSchema(resource.getFilename(), e); + } + return values; + } + + /** + * Persist the external schema details. + * + * @param schemas + * list + * @throws OnapCommandDiscoveryFailed + * exception + */ + public static void persist(List<ExternalSchema> schemas) throws OnapCommandDiscoveryFailed { + if (schemas != null) { + try { + Resource[] resources = getExternalResources(Constants.EXTERNAL_DISCOVERY_DIRECTORY); + if (resources != null && resources.length == 1) { + String path = resources[0].getURI().getPath(); + File file = new File(path + File.separator + Constants.EXTERNAL_DISCOVERY_FILE); + ObjectMapper mapper = new ObjectMapper(); + mapper.writerWithDefaultPrettyPrinter().writeValue(file, schemas); + } + } catch (IOException e1) { + throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_DISCOVERY_DIRECTORY, + Constants.EXTERNAL_DISCOVERY_FILE, e1); + } + } + } + + /** + * Check if json file discovered or not. + * + * @return boolean + * @throws OnapCommandDiscoveryFailed + * exception + */ + public static boolean isJsonFileDiscovered() throws OnapCommandDiscoveryFailed { + Resource resource = null; + try { + resource = getExternalResource(Constants.EXTERNAL_DISCOVERY_FILE, + Constants.EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); + if (resource != null) { + return true; + } + } catch (IOException e) { + throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_DISCOVERY_DIRECTORY, + Constants.EXTERNAL_DISCOVERY_FILE, e); + } + + return false; + } + + /** + * Load the previous discovered json file. + * + * @return list + * @throws OnapCommandInvalidSchema + * exception + * @throws OnapCommandDiscoveryFailed + * exception + */ + public static List<ExternalSchema> loadExternalSchemasFromJson() throws OnapCommandException { + List<ExternalSchema> schemas = new ArrayList<>(); + if (!isJsonFileDiscovered()) { + schemas = findAllExternalSchemas(); + if (!schemas.isEmpty()) { + persist(schemas); + } + } else { + try { + Resource resource = getExternalResource(Constants.EXTERNAL_DISCOVERY_FILE, + Constants.EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); + if (resource != null) { + File file = new File(resource.getURI().getPath()); + ObjectMapper mapper = new ObjectMapper(); + ExternalSchema[] list = mapper.readValue(file, ExternalSchema[].class); + schemas.addAll(Arrays.asList(list)); + } + } catch (IOException e) { + throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_DISCOVERY_DIRECTORY, + Constants.EXTERNAL_DISCOVERY_FILE, e); + } + } + + return schemas; + } + + /** + * Fetch a particular schema details. + * + * @param cmd + * command name + * @return ExternalSchema obj + * @throws OnapCommandInvalidSchema + * exception + * @throws OnapCommandDiscoveryFailed + * exception + */ + public static ExternalSchema loadExternalSchemaFromJson(String cmd) throws OnapCommandException { + List<ExternalSchema> list = loadExternalSchemasFromJson(); + ExternalSchema schemaStr = null; + if (list != null) { + for (ExternalSchema schema : list) { + if (cmd.equals(schema.getCmdName())) { + schemaStr = schema; + break; + } + } + } + return schemaStr; + } +} diff --git a/framework/src/main/resources/META-INF/services/org.onap.cli.fw.OnapCommand b/framework/src/main/resources/META-INF/services/org.onap.cli.fw.OnapCommand new file mode 100644 index 00000000..89648bf5 --- /dev/null +++ b/framework/src/main/resources/META-INF/services/org.onap.cli.fw.OnapCommand @@ -0,0 +1,2 @@ +org.onap.cli.fw.cmd.OnapSchemaValidateCommand +org.onap.cli.fw.cmd.OnapSchemaRefreshCommand
\ No newline at end of file diff --git a/framework/src/main/resources/default_input_parameters.yaml b/framework/src/main/resources/default_input_parameters.yaml new file mode 100644 index 00000000..f1e299eb --- /dev/null +++ b/framework/src/main/resources/default_input_parameters.yaml @@ -0,0 +1,64 @@ +onap_cmd_schema_version: 1.0 +parameters: + - name: onap-username + type: string + description: Onap user name + short_option: u + long_option: onap-username + default_value: ${ONAP_USERNAME} + is_optional: false + - name: onap-password + type: string + description: Onap user password + short_option: p + long_option: onap-password + default_value: ${ONAP_PASSWORD} + is_secured: true + - name: msb-url + type: url + description: Onap MSB url + short_option: m + long_option: msb-url + default_value: ${ONAP_MSB_URL} + - name: help + type: string + description: Onap command help message + short_option: h + long_option: help + default_value: false + - name: version + type: string + description: Onap command service version + short_option: v + long_option: version + default_value: false + - name: debug + type: bool + description: Enable debug output + short_option: d + long_option: debug + default_value: false + - name: format + type: string + description: Output formats, supported formats such as table, csv, json, yaml + short_option: f + long_option: format + default_value: table + - name: long + type: bool + description: whether to print all attributes or only short attributes + short_option: s + long_option: long + default_value: false + - name: no-title + type: bool + description: whether to print title or not + short_option: t + long_option: no-title + default_value: true + - name: no-auth + type: bool + description: whether to authenticate user or not + short_option: a + long_option: no-auth + default_value: false
\ No newline at end of file diff --git a/framework/src/main/resources/log4j.properties b/framework/src/main/resources/log4j.properties new file mode 100644 index 00000000..b7fe5437 --- /dev/null +++ b/framework/src/main/resources/log4j.properties @@ -0,0 +1,2 @@ +log4j.rootLogger=off, FileNetNullAppender +log4j.appender.FileNetNullAppender=org.apache.log4j.varia.NullAppender
\ No newline at end of file diff --git a/framework/src/main/resources/onap.properties b/framework/src/main/resources/onap.properties new file mode 100644 index 00000000..61049cd4 --- /dev/null +++ b/framework/src/main/resources/onap.properties @@ -0,0 +1,4 @@ +cli.ignore_auth=false +cli.version=1.0 +http.api_key=X-Auth-Token +http.api_key_use_cookies=true
\ No newline at end of file diff --git a/framework/src/main/resources/schema-refresh.yaml b/framework/src/main/resources/schema-refresh.yaml new file mode 100644 index 00000000..f64b0545 --- /dev/null +++ b/framework/src/main/resources/schema-refresh.yaml @@ -0,0 +1,26 @@ +onap_cmd_schema_version: 1.0 +name: schema-refresh +description: Onap command to refresh schemas stored in onap_cli_schema folders. +service: + no-auth: true + name: onap-cli + version: 1.0.0 +results: + direction: landscape + attributes: + - name: sl-no + description: Serial Number + scope: short + type: string + - name: command + description: Command name + scope: short + type: string + - name: schema + description: Schema name + scope: short + type: string + - name: version + description: Schema version + scope: short + type: string
\ No newline at end of file diff --git a/framework/src/main/resources/schema-validate.yaml b/framework/src/main/resources/schema-validate.yaml new file mode 100644 index 00000000..1571fb3d --- /dev/null +++ b/framework/src/main/resources/schema-validate.yaml @@ -0,0 +1,31 @@ +onap_cmd_schema_version: 1.0 +name: schema-validate +description: Onap command to validate schema +service: + no-auth: true + name: onap-cli + version: 1.0.0 +parameters: + - name: schema-location + type: url + description: Schema file location + short_option: l + long_option: schema-location + is_optional: false + - name: internal-schema + type: bool + description: Validate existing schema file + short_option: i + long_option: internal-schema + is_optional: false +results: + direction: landscape + attributes: + - name: sl-no + description: Serial Number of error + scope: short + type: string + - name: error + description: Schema validation error + scope: short + type: string
\ No newline at end of file diff --git a/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java new file mode 100644 index 00000000..69714ad7 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSample.java @@ -0,0 +1,47 @@ +/* + * 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.cmd.sample; + +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandSchema; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; + +/** + * This command helps to test the Command functionalities. + * + */ +@OnapCommandSchema(name = "sample-test", schema = "sample-test-schema.yaml") +public class OnapCommandSample extends OnapCommand { + + public OnapCommandSample() { + this(true); + } + + public OnapCommandSample(boolean isInit) { + this.isInitialzied = isInit; + } + + public boolean failCase = false; + + @Override + protected void run() throws OnapCommandException { + if (this.failCase) + throw new OnapCommandExecutionFailed("Test case to fail"); + } + +} diff --git a/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java new file mode 100644 index 00000000..9cf6bdf5 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/cmd/sample/OnapCommandSampleTest.java @@ -0,0 +1,157 @@ +/* + * 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.cmd.sample; + +import org.junit.Test; +import org.onap.cli.fw.conf.Constants; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandNotInitialized; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; + +import java.util.ArrayList; +import java.util.List; + +public class OnapCommandSampleTest { + @Test + public void sampleTestVersion() { + OnapCommandSample sample = new OnapCommandSample(); + + try { + List<OnapCommandParameter> parameters = new ArrayList(); + OnapCommandParameter v = new OnapCommandParameter(); + v.setName(Constants.DEFAULT_PARAMETER_VERSION); + v.setValue("true"); + parameters.add(v); + OnapCommandParameter h = new OnapCommandParameter(); + h.setName(Constants.DEFAULT_PARAMETER_HELP); + h.setValue("false"); + parameters.add(h); + sample.setParameters(parameters); + sample.execute(); + } catch (OnapCommandException e) { + } + } + + @Test + public void sampleTestHelp() { + OnapCommandSample sample = new OnapCommandSample(); + try { + List<OnapCommandParameter> parameters = new ArrayList(); + OnapCommandParameter v = new OnapCommandParameter(); + v.setName(Constants.DEFAULT_PARAMETER_HELP); + v.setValue("true"); + v.setParameterType(ParameterType.BOOL); + parameters.add(v); + sample.setParameters(parameters); + sample.execute(); + } catch (OnapCommandException e) { + } + } + + @Test + public void sampleTest() { + OnapCommandSample sample = new OnapCommandSample(); + try { + List<OnapCommandParameter> parameters = new ArrayList(); + OnapCommandParameter v = new OnapCommandParameter(); + v.setName(Constants.DEFAULT_PARAMETER_VERSION); + v.setValue("false"); + parameters.add(v); + OnapCommandParameter h = new OnapCommandParameter(); + h.setName(Constants.DEFAULT_PARAMETER_HELP); + h.setValue("false"); + parameters.add(h); + OnapCommandParameter f = new OnapCommandParameter(); + f.setName(Constants.DEFAULT_PARAMETER_OUTPUT_FORMAT); + f.setValue("table"); + parameters.add(f); + OnapCommandParameter l = new OnapCommandParameter(); + l.setName(Constants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG); + l.setValue("true"); + parameters.add(l); + OnapCommandParameter t = new OnapCommandParameter(); + t.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE); + t.setValue("true"); + parameters.add(t); + OnapCommandParameter a = new OnapCommandParameter(); + a.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH); + a.setValue("true"); + parameters.add(a); + OnapCommandParameter d = new OnapCommandParameter(); + d.setName(Constants.DEFAULT_PARAMETER_DEBUG); + d.setValue("true"); + parameters.add(d); + OnapCommandParameter m = new OnapCommandParameter(); + m.setName(Constants.DEAFULT_PARAMETER_MSB_URL); + m.setValue("http://localhost"); + parameters.add(m); + sample.setParameters(parameters); + sample.execute(); + } catch (OnapCommandException e) { + } + } + + @Test(expected = OnapCommandExecutionFailed.class) + public void sampleTestFailure() throws OnapCommandException { + OnapCommandSample sample = new OnapCommandSample(); + sample.failCase = true; + + List<OnapCommandParameter> parameters = new ArrayList(); + OnapCommandParameter v = new OnapCommandParameter(); + v.setName(Constants.DEFAULT_PARAMETER_VERSION); + v.setValue("false"); + parameters.add(v); + OnapCommandParameter h = new OnapCommandParameter(); + h.setName(Constants.DEFAULT_PARAMETER_HELP); + h.setValue("false"); + parameters.add(h); + OnapCommandParameter f = new OnapCommandParameter(); + f.setName(Constants.DEFAULT_PARAMETER_OUTPUT_FORMAT); + f.setValue("table"); + parameters.add(f); + OnapCommandParameter l = new OnapCommandParameter(); + l.setName(Constants.DEFAULT_PARAMETER_OUTPUT_ATTR_LONG); + l.setValue("true"); + parameters.add(l); + OnapCommandParameter t = new OnapCommandParameter(); + t.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_TITLE); + t.setValue("true"); + parameters.add(t); + OnapCommandParameter a = new OnapCommandParameter(); + a.setName(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH); + a.setValue("true"); + parameters.add(a); + OnapCommandParameter d = new OnapCommandParameter(); + d.setName(Constants.DEFAULT_PARAMETER_DEBUG); + d.setValue("true"); + parameters.add(d); + OnapCommandParameter m = new OnapCommandParameter(); + m.setName(Constants.DEAFULT_PARAMETER_MSB_URL); + m.setValue("http://localhost"); + parameters.add(m); + sample.setParameters(parameters); + sample.execute(); + } + + @Test(expected = OnapCommandNotInitialized.class) + public void sampleTestIsInitialized() throws OnapCommandException { + OnapCommandSample sample = new OnapCommandSample(false); + sample.execute(); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java b/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java new file mode 100644 index 00000000..83f3a743 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/OnapCommandRegistrarTest.java @@ -0,0 +1,170 @@ +/* + * 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.fw; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import org.junit.Before; +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandHelpFailed; +import org.onap.cli.fw.error.OnapCommandNotFound; +import org.onap.cli.fw.error.OnapCommandRegistrationFailed; + +import java.io.File; +import java.net.URL; + +public class OnapCommandRegistrarTest { + + OnapCommandRegistrar registerar; + + @Before + public void setup() throws OnapCommandException { + registerar = OnapCommandRegistrar.getRegistrar(); + createDir(); + } + + private void createDir() { + URL url = OnapCommandRegistrarTest.class.getClassLoader().getResource("onap-cli-schema"); + if (url != null) { + String path = url.getPath(); + path = path.replaceFirst("onap-cli-schema", "data"); + File file = new File(path); + if (!file.exists()) { + file.mkdir(); + } else { + File f1 = new File(path + "/external-schema.json"); + f1.delete(); + } + } + } + + @Test + public void registerTest() throws OnapCommandException { + OnapCommand test = new OnapCommandTest(); + Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass(); + registerar.register("Test", cmd); + OnapCommand cc = registerar.get("Test"); + assertTrue(cmd == cc.getClass()); + + } + + @Test + // For Coverage + public void cmdTestSchema() throws OnapCommandException { + OnapCommand test = new OnapCommandTest(); + Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass(); + registerar.register("Test", cmd); + OnapCommand cc = registerar.get("Test"); + } + + @Test + public void onapCommandNotFoundTest() throws OnapCommandException { + try { + registerar = OnapCommandRegistrar.getRegistrar(); + registerar.get("Test1"); + fail("This should have thrown an exception"); + } catch (OnapCommandNotFound e) { + assertEquals(e.getMessage(), "0x0011::Command Test1 is not registered"); + } + } + + @Test + public void onapCommandRegistrationFailedTest() throws OnapCommandException { + + @OnapCommandSchema(name = "Test2", schema = "sample-test-schema.yaml") + class Test extends OnapCommand { + + @Override + protected void run() throws OnapCommandException { + + } + + } + + OnapCommand com = new Test(); + Class<OnapCommand> cmd = (Class<OnapCommand>) com.getClass(); + try { + registerar.register("Test2", cmd); + registerar.get("Test2"); + fail("This should have thrown an exception"); + } catch (OnapCommandRegistrationFailed e) { + assertTrue(e.getMessage().contains("0x0018::Command Test2 is failed to register")); + } + } + + @Test(expected = OnapCommandHelpFailed.class) + // For coverage + public void helpTestException() throws OnapCommandException { + OnapCommand test = new OnapCommandTest1(); + Class<OnapCommand> cmd = (Class<OnapCommand>) test.getClass(); + registerar = new OnapCommandRegistrar(); + registerar.register("test1", cmd); + String help = registerar.getHelp(); + assertNotNull(help); + } + + @Test + public void helpTest() throws OnapCommandException { + String help = registerar.getHelp(); + assertNotNull(help); + } + + @Test + public void versionTest() throws OnapCommandHelpFailed { + String version = registerar.getVersion(); + assertNotNull(version); + } + + @Test + public void listTest() { + registerar.listCommands(); + } +} + +@OnapCommandSchema(name = OnapCommandTest.CMD_NAME, schema = "sample-test-schema.yaml") +class OnapCommandTest extends OnapCommand { + + public OnapCommandTest() { + + } + + public static final String CMD_NAME = "test"; + + protected void run() throws OnapCommandException { + + } + +} + +@OnapCommandSchema(name = OnapCommandTest1.CMD_NAME, schema = "test-schema.yaml") +class OnapCommandTest1 extends OnapCommand { + + public OnapCommandTest1() { + + } + + public static final String CMD_NAME = "test1"; + + protected void run() throws OnapCommandException { + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java new file mode 100644 index 00000000..720737b3 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapAuthClientTest.java @@ -0,0 +1,201 @@ +/* + * 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.fw.ad; + +import static org.junit.Assert.assertEquals; + +import mockit.Invocation; +import mockit.Mock; +import mockit.MockUp; + +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.Test; +import org.onap.cli.fw.conf.OnapCommandConfg; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandHttpFailure; +import org.onap.cli.fw.error.OnapCommandServiceNotFound; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.http.HttpResult; +import org.onap.cli.fw.http.OnapHttpConnection; + +public class OnapAuthClientTest { + + OnapAuthClient client; + + @Before + public void setUp() throws OnapCommandHttpFailure { + OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80"); + client = new OnapAuthClient(creds, true); + } + + @Test + public void loginFailedAuthIgnoredTest() throws OnapCommandException { + OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80"); + OnapAuthClient client = new OnapAuthClient(creds, true); + if (OnapCommandConfg.isAuthIgnored()) { + client.getDebugInfo(); + client.login(); + assertEquals(null, client.getAuthToken()); + } + } + + @Test + public void logoutFailedAuthIgnoredTest() throws OnapCommandException { + OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80"); + OnapAuthClient client = new OnapAuthClient(creds, true); + if (OnapCommandConfg.isAuthIgnored()) { + client.logout(); + assertEquals(null, client.getAuthToken()); + } + } + + @Test + public void getMsbUrlTest() throws OnapCommandException { + OnapCredentials creds = new OnapCredentials("test", "test123", "http://192.168.99.10:80"); + OnapAuthClient client = new OnapAuthClient(creds, true); + OnapService srv = new OnapService(); + srv.setName("msb"); + String msb = client.getServiceBasePath(srv); + assertEquals("http://192.168.99.10:80/api/microservices/v1", msb); + } + + @Test(expected = OnapCommandServiceNotFound.class) + public void loginFailedServiceNotFoundTest() throws OnapCommandException { + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setStatus(404); + mockHttpRequest(result); + client.login(); + + } + + @Test(expected = OnapCommandExecutionFailed.class) + public void loginFailedCommandExecutionFailedTest() throws OnapCommandException { + + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setStatus(401); + mockHttpRequest(result); + client.login(); + } + + @Test(expected = OnapCommandExecutionFailed.class) + public void loginFailedWrongJasonBodyTest() throws OnapCommandException { + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setStatus(200); + mockHttpRequest(result); + client.login(); + } + + @Test + public void loginSuccessTest() { + + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setBody("{\"url\":\"http://192.168.4.47\"}"); + result.setStatus(200); + mockHttpConsecutiveRequest(result); + try { + client.login(); + } catch (OnapCommandException e) { + } + mockHttpRequest(null); + } + + @Test + public void logoutFailedTest() { + + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setBody("{\"url\":\"http://192.168.4.47\"}"); + result.setStatus(200); + mockHttpConsecutiveRequest(result); + try { + client.logout(); + } catch (OnapCommandException e) { + } + mockHttpRequest(null); + } + + @Test + public void logoutSuccessTest() { + + mockIsAuthIgnored(false); + HttpResult result = new HttpResult(); + result.setBody("{\"url\":\"http://192.168.4.47\"}"); + result.setStatus(204); + mockHttpConsecutiveRequest(result); + try { + client.logout(); + } catch (OnapCommandException e) { + } + mockHttpRequest(null); + } + + private void mockIsAuthIgnored(boolean isAuthIgnored) { + + new MockUp<OnapCommandConfg>() { + boolean isMock = true; + + @Mock + public boolean isAuthIgnored(Invocation inv) { + if (isMock) { + isMock = false; + return isAuthIgnored; + } else { + return inv.proceed(); + } + } + }; + } + + private static void mockHttpRequest(HttpResult result) { + new MockUp<OnapHttpConnection>() { + boolean isMock = true; + + @Mock + public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure { + if (isMock) { + isMock = false; + return result; + } else { + return inv.proceed(input); + } + } + }; + } + + private void mockHttpConsecutiveRequest(HttpResult result) { + new MockUp<OnapHttpConnection>() { + @Mock + public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure { + return result; + } + }; + } + + @AfterClass + public static void clear() { + HttpResult result = new HttpResult(); + result.setBody("{\"url\":\"http://192.168.4.47\"}"); + result.setStatus(200); + mockHttpRequest(result); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.java new file mode 100644 index 00000000..a1987c08 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapCredentialsTest.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.fw.ad; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class OnapCredentialsTest { + + @Test + public void credentialsTest() { + OnapCredentials cre = new OnapCredentials("test", "test123", "url"); + assertTrue(cre.getUsername().equals("test") && cre.getPassword().equals("test123") + && cre.getMsbUrl().equals("url")); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java b/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java new file mode 100644 index 00000000..f0ec8c63 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/ad/OnapServiceTest.java @@ -0,0 +1,37 @@ +/* + * 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.fw.ad; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class OnapServiceTest { + + @Test + public void serviceTest() { + OnapService ser = new OnapService(); + ser.setName("name"); + ser.setVersion("1.0"); + ser.setBasePath("basePath"); + ser.setNoAuth(true); + assertTrue(ser.getName().equals("name") && ser.getVersion().equals("1.0") + && ser.getBasePath().equals("basePath") && ser.isNoAuth()); + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java new file mode 100644 index 00000000..069ae35f --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommand.java @@ -0,0 +1,101 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing; +import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; +import org.onap.cli.fw.error.OnapCommandResultInitialzationFailed; +import org.onap.cli.fw.utils.OnapCommandUtils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.List; + +public class OnapCreateSwaggerBasedCommand extends OnapSwaggerCommand { + + private <T> T initializeEntity(T obj, List<String> prps) throws OnapCommandResultInitialzationFailed { + for (int i = 1; i < prps.size(); i++) { + String paramName = prps.get(i).trim(); + String prpName = paramName; + // paramName(prpName) + if (prpName.contains("(")) { + paramName = prpName.substring(0, prpName.indexOf("(")); + prpName = prpName.substring(prpName.indexOf("(") + 1, prpName.indexOf(")")); + } + String methodName = OnapCommandUtils.formMethodNameFromAttributeName(prpName, "set"); + + try { + Method set = obj.getClass().getMethod(methodName, String.class); + set.invoke(obj, this.getParametersMap().get(paramName).getValue()); + } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException | OnapCommandInvalidParameterValue e) { + throw new OnapCommandResultInitialzationFailed(this.getName(), e); + } + } + return obj; + } + + @Override + protected void run() throws OnapCommandException { + if (this.getExecutor() == null) { + throw new OnapCommandExecutorInfoMissing(this.getName()); + } + + try { + // Initialize client + Class clientClaz = Class.forName(this.getExecutor().getClient()); + Object client = clientClaz.getConstructor().newInstance(); + this.initializeApiClient(client); + + // Initialize api + Class apiCls = Class.forName(this.getExecutor().getApi()); + Object api = apiCls.getConstructor(clientClaz).newInstance(client); + + // invoke method + List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(",")); + + List<String> entityTokens = Arrays.asList(this.getExecutor().getEntity().split(",")); + Class entityCls = Class.forName(entityTokens.get(0)); + Object entity = entityCls.newInstance(); + Method method = api.getClass().getMethod(methodTokens.get(0), entityCls); + Object result = method.invoke(api, this.initializeEntity(entity, entityTokens)); + + // initialize result + this.initializeResult(result); + } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new OnapCommandExecutionFailed(this.getName(), e); + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + try { + Class execCls = Class.forName(this.getExecutor().getException()); + Method execMethod = execCls.getClass().getMethod("getCode"); + if (execCls.isInstance(e)) { + throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e)); + } + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException + | ClassNotFoundException | NoSuchMethodException | SecurityException e1) { + throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage()); + } + throw new OnapCommandExecutionFailed(this.getName(), e.getMessage()); + } + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.java new file mode 100644 index 00000000..ec4b91d4 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapCreateSwaggerBasedCommandTest.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.fw.cmd; + +import org.junit.Test; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.error.OnapCommandException; + +public class OnapCreateSwaggerBasedCommandTest { + + @Test + public void runTest() throws OnapCommandException { + OnapCommand cmd = new OnapCreateSwaggerBasedCommand(); + cmd.initializeSchema("sample-test-schema-swagger.yaml"); + //cmd.execute(); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java new file mode 100644 index 00000000..1db954c6 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommand.java @@ -0,0 +1,75 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.List; + +/** + * Helps to make delete rest calls on top of swagger generated java client. For example following one shows how MSB + * service list is achieved here exec: ... method: deleteMicroService, [input param name given under Parameters] + * + */ +public class OnapDeleteSwaggerBasedCommand extends OnapSwaggerCommand { + + @Override + protected void run() throws OnapCommandException { + if (this.getExecutor() == null) { + throw new OnapCommandExecutorInfoMissing(this.getName()); + } + + try { + // Initialize client + Class clientCls = Class.forName(this.getExecutor().getClient()); + Object client = clientCls.getConstructor().newInstance(); + this.initializeApiClient(client); + + // Initialize api + Class apiCls = Class.forName(this.getExecutor().getApi()); + Object api = apiCls.getConstructor(clientCls).newInstance(client); + + // invoke method + List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(",")); + + Method method = api.getClass().getMethod(methodTokens.get(0), String.class); + method.invoke(api, this.getParametersMap().get(methodTokens.get(1)).getValue()); + } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new OnapCommandExecutionFailed(this.getName(), e); + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + try { + Class execCls = Class.forName(this.getExecutor().getException()); + Method execMethod = execCls.getClass().getMethod("getCode"); + if (execCls.isInstance(e)) { + throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e)); + } + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException + | ClassNotFoundException | NoSuchMethodException | SecurityException e1) { + throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage()); + } + throw new OnapCommandExecutionFailed(this.getName(), e.getMessage()); + } + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java new file mode 100644 index 00000000..a242a683 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapDeleteSwaggerBasedCommandTest.java @@ -0,0 +1,21 @@ +/* + * 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.fw.cmd; + +public class OnapDeleteSwaggerBasedCommandTest { + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.java new file mode 100644 index 00000000..8ed86564 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommand.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.fw.cmd; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.List; + +/** + * Helps to make get rest calls on top of swagger generated java client. For example following one shows how MSB service + * list is achieved here exec: ... method: getMicroService, [input param name given under Parameters] + * + */ +public class OnapGetSwaggerBasedCommand extends OnapSwaggerCommand { + + @Override + protected void run() throws OnapCommandException { + if (this.getExecutor() == null) { + throw new OnapCommandExecutorInfoMissing(this.getName()); + } + + try { + // Initialize client + Class clientCls = Class.forName(this.getExecutor().getClient()); + Object client = clientCls.getConstructor().newInstance(); + this.initializeApiClient(client); + + // Initialize api + Class apiCls = Class.forName(this.getExecutor().getApi()); + Object api = apiCls.getConstructor(clientCls).newInstance(client); + + // invoke method + List<String> methodTokens = Arrays.asList(this.getExecutor().getMethod().split(",")); + + Method method = api.getClass().getMethod(methodTokens.get(0), String.class); + Object result = method.invoke(api, this.getParametersMap().get(methodTokens.get(1)).getValue()); + + // initialize result + this.initializeResult(result); + + } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new OnapCommandExecutionFailed(this.getName(), e); + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + try { + Class execCls = Class.forName(this.getExecutor().getException()); + Method execMethod = execCls.getClass().getMethod("getCode"); + if (execCls.isInstance(e)) { + throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e)); + } + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException + | ClassNotFoundException | NoSuchMethodException | SecurityException e1) { + throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage()); + } + throw new OnapCommandExecutionFailed(this.getName(), e.getMessage()); + } + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java new file mode 100644 index 00000000..5c301a62 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapGetSwaggerBasedCommandTest.java @@ -0,0 +1,21 @@ +/* + * 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.fw.cmd; + +public class OnapGetSwaggerBasedCommandTest { + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.java new file mode 100644 index 00000000..e7af1aa3 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapHttpCommandTest.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.fw.cmd; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class OnapHttpCommandTest { + + @Test(expected = OnapCommandException.class) + public void runTest() 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); + + HttpInput inp = new HttpInput(); + inp.setBody("body"); + inp.setMethod("method"); + inp.setReqCookies(new HashMap<String, String>()); + inp.setReqHeaders(new HashMap<String, String>()); + inp.setReqQueries(new HashMap<String, String>()); + inp.setUri("uri"); + + OnapHttpCommand com = new OnapHttpCommand(); + com.setParameters(paramslist); + com.getParameters(); + com.getParametersMap(); + com.setInput(inp); + com.initializeSchema("sample-test-schema.yaml"); + com.execute(); + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java new file mode 100644 index 00000000..a5795e75 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommand.java @@ -0,0 +1,78 @@ +/* + * 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.fw.cmd; + +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandExecutionFailed; +import org.onap.cli.fw.error.OnapCommandExecutorInfoMissing; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * Helps to make list rest calls on top of swagger generated java client. For example following one shows how MSB + * service list is achived here exec: api: + * org.onap.common_services.microservice_bus.apiroute_service.client.api.MSBServiceResourceApi client: + * org.onap.common_services.microservice_bus.apiroute_service.client.invoker.ApiClient method: getMicroService + * exception: org.onap.common_services.microservice_bus.apiroute_service.client.invoker.ApiException + * + */ +public class OnapListSwaggerBasedCommand extends OnapSwaggerCommand { + + @Override + protected void run() throws OnapCommandException { + if (this.getExecutor() == null) { + throw new OnapCommandExecutorInfoMissing(this.getName()); + } + + try { + // Initialize client + Class clientCls = Class.forName(this.getExecutor().getClient()); + Object client = clientCls.getConstructor().newInstance(); + this.initializeApiClient(client); + + // Initialize api + Class apiCls = Class.forName(this.getExecutor().getApi()); + Object api = apiCls.getConstructor(clientCls).newInstance(client); + + // invoke method + Method method = api.getClass().getMethod(this.getExecutor().getMethod()); + Object result = method.invoke(api); + + // initialize result + this.initializeResult(result); + + } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + throw new OnapCommandExecutionFailed(this.getName(), e); + } catch (OnapCommandException e) { + throw e; + } catch (Exception e) { + try { + Class execCls = Class.forName(this.getExecutor().getException()); + Method execMethod = execCls.getClass().getMethod("getCode"); + if (execCls.isInstance(e)) { + throw new OnapCommandExecutionFailed(this.getName(), e, (Integer) execMethod.invoke(e)); + } + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException + | ClassNotFoundException | NoSuchMethodException | SecurityException e1) { + throw new OnapCommandExecutionFailed(this.getName(), e1.getMessage()); + } + throw new OnapCommandExecutionFailed(this.getName(), e.getMessage()); + } + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java new file mode 100644 index 00000000..5683153c --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapListSwaggerBasedCommandTest.java @@ -0,0 +1,21 @@ +/* + * 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.fw.cmd; + +public class OnapListSwaggerBasedCommandTest { + +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java new file mode 100644 index 00000000..1c09c0d3 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaRefreshCommandTest.java @@ -0,0 +1,56 @@ +/* + * 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.fw.cmd; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.input.OnapCommandParameter; + +public class OnapSchemaRefreshCommandTest { + + @Test + public void validateSchemaCommandTest1() throws OnapCommandException { + OnapSchemaRefreshCommand cmd = new OnapSchemaRefreshCommand(); + cmd.initializeSchema("schema-refresh.yaml"); + for (OnapCommandParameter param : cmd.getParameters()) { + if ("onap-username".equals(param.getName())) { + param.setValue("test"); + } else if ("onap-password".equals(param.getName())) { + param.setValue("test"); + } else if ("msb-url".equals(param.getName())) { + param.setValue("test-url"); + } + } + cmd.execute(); + } + + @Test + public void validateSchemaCommandTest2() throws OnapCommandException { + OnapSchemaRefreshCommand cmd = new OnapSchemaRefreshCommand(); + cmd.initializeSchema("schema-refresh.yaml"); + for (OnapCommandParameter param : cmd.getParameters()) { + if ("onap-username".equals(param.getName())) { + param.setValue("test"); + } else if ("onap-password".equals(param.getName())) { + param.setValue("test"); + } else if ("msb-url".equals(param.getName())) { + param.setValue("test-url"); + } + } + cmd.execute(); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java new file mode 100644 index 00000000..b70bf6f9 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommandTest.java @@ -0,0 +1,64 @@ +/* + * 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.fw.cmd; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.schema.ValidateSchemaTest; + +public class OnapSchemaValidateCommandTest { + + @Test + public void validateSchemaCommandTest1() throws OnapCommandException { + OnapSchemaValidateCommand cmd = new OnapSchemaValidateCommand(); + cmd.initializeSchema("schema-validate.yaml"); + for (OnapCommandParameter param : cmd.getParameters()) { + if ("onap-username".equals(param.getName())) { + param.setValue("test"); + } else if ("onap-password".equals(param.getName())) { + param.setValue("test"); + } else if ("msb-url".equals(param.getName())) { + param.setValue("test-url"); + } else if ("schema-location".equals(param.getName())) { + param.setValue("schema-validate-pass.yaml"); + } else if ("internal-schema".equals(param.getName())) { + param.setValue("true"); + } + } + cmd.execute(); + } + + @Test + public void validateSchemaCommandTest2() throws OnapCommandException { + OnapSchemaValidateCommand cmd = new OnapSchemaValidateCommand(); + cmd.initializeSchema("schema-validate.yaml"); + for (OnapCommandParameter param : cmd.getParameters()) { + if ("onap-username".equals(param.getName())) { + param.setValue("test"); + } else if ("onap-password".equals(param.getName())) { + param.setValue("test"); + } else if ("msb-url".equals(param.getName())) { + param.setValue("test-url"); + } else if ("schema-location".equals(param.getName())) { + param.setValue( + ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-pass.yaml").getFile()); + } + } + cmd.execute(); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java new file mode 100644 index 00000000..628b9a42 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/cmd/OnapSwaggerCommandTest.java @@ -0,0 +1,96 @@ +/* + * 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.fw.cmd; + +import org.junit.Test; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.error.OnapCommandClientInitialzationFailed; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandResultInitialzationFailed; +import org.onap.cli.fw.input.OnapCommandParameter; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class OnapSwaggerCommandTest { + + @Test(expected = OnapCommandResultInitialzationFailed.class) + public void initializeResultTest1() throws OnapCommandException { + OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl(); + swagger.initializeSchema("onap-test-schema.yaml"); + List<String> obj = new ArrayList<>(); + obj.add("name"); + obj.add("get"); + swagger.initializeResult(obj); + + Set<String> obj1 = new HashSet<>(); + obj.add("name"); + obj.add("get"); + swagger.initializeResult(obj1); + } + + @Test(expected = OnapCommandResultInitialzationFailed.class) + public void initializeResultTest2() throws OnapCommandException { + OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl(); + swagger.initializeSchema("onap-test-schema.yaml"); + Set<String> obj1 = new HashSet<>(); + obj1.add("name"); + obj1.add("get"); + swagger.initializeResult(obj1); + } + + @Test(expected = NullPointerException.class) + public void initializeResultTest3() throws OnapCommandException { + OnapSwaggerCommandImpl swagger = new OnapSwaggerCommandImpl(); + swagger.initializeSchema("onap-test-schema.yaml"); + ApiClient cit = new ApiClient(); + cit.setApiKey("apiKey"); + cit.setBasePath("basePath"); + swagger.initializeApiClient(cit); + } + + class OnapSwaggerCommandImpl extends OnapSwaggerCommand { + protected void run() throws OnapCommandException { + } + + } + + class ApiClient { + + private String basePath; + private String apiKey; + + public String getBasePath() { + return basePath; + } + + public void setBasePath(String basePath) { + this.basePath = basePath; + } + + public String getApiKey() { + return apiKey; + } + + public void setApiKey(String apiKey) { + this.apiKey = apiKey; + } + + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java b/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java new file mode 100644 index 00000000..e345945b --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/conf/OnapCommandConfgTest.java @@ -0,0 +1,44 @@ +/* + * 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.fw.conf; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.IOException; +import java.util.Properties; + +public class OnapCommandConfgTest { + + @Test + public void versionTest() { + String str = OnapCommandConfg.getVersion(); + Assert.assertTrue(str != null); + } + + @Test + public void isAuthIgnoredTest() throws IOException { + Properties prps = new Properties(); + prps.load(OnapCommandConfg.class.getClassLoader().getResourceAsStream("onap.properties")); + boolean auth = OnapCommandConfg.isAuthIgnored(); + Assert.assertTrue(auth == Boolean.valueOf(prps.getProperty("cli.ignore_auth"))); + Assert.assertTrue(OnapCommandConfg.isCookiesBasedAuth() == Boolean + .valueOf(prps.getProperty("http.api_key_use_cookies"))); + Assert.assertTrue("X-Auth-Token".equals(OnapCommandConfg.getXAuthTokenName())); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java b/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.java new file mode 100644 index 00000000..1d0c1a6b --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/error/OnapCommandErrorTest.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.fw.error; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +public class OnapCommandErrorTest { + + @Test + public void onapCommandDiscoveryFailedTest() { + OnapCommandDiscoveryFailed failed = new OnapCommandDiscoveryFailed("name"); + assertEquals("0x0010::Failed auto discover schema files from name under class path, ", failed.getMessage()); + failed = new OnapCommandDiscoveryFailed("directory", "name"); + assertEquals("0x0010::Failed auto generate json file 'name' under class path directory 'directory' , ", + failed.getMessage()); + } + + @Test + public void onapCommandInvalidParameterValueTest() { + OnapCommandInvalidParameterValue failed = new OnapCommandInvalidParameterValue("name"); + assertEquals("0x0028::Parameter name value is invalid, ", failed.getMessage()); + } + + @Test + public void onapCommandResultMapProcessingFailedTest() { + OnapCommandResultMapProcessingFailed failed = new OnapCommandResultMapProcessingFailed("name", + new Exception("")); + assertEquals("0x0028::Failed to process the result map name in http section, ", failed.getMessage()); + } + + @Test + public void onapCommandHttpHeaderNotFoundTest() { + OnapCommandHttpHeaderNotFound failed = new OnapCommandHttpHeaderNotFound("name"); + assertEquals("0x0027::Http header name is not returned from the service", failed.getMessage()); + } + + @Test + public void onapCommandClientInitialzationFailedTest() { + OnapCommandClientInitialzationFailed failed = new OnapCommandClientInitialzationFailed("Test", + new Exception("Test Command Failed")); + assertEquals("0x0021::API client for the command Test is failed, Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExceptionTest1() { + OnapCommandException failed = new OnapCommandException("1", "Test Command Failed"); + assertEquals("1::Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExceptionTest2() { + OnapCommandException failed = new OnapCommandException("1", "Test Command Failed", 201); + assertEquals("201::1::Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExecutionFailedTest1() { + OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test", "Test Command Failed", 201); + assertEquals("201::0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage()); + failed = new OnapCommandExecutionFailed("Test", new Exception("Test Command Failed"), 201); + assertEquals("201::0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExecutionFailedTest2() { + OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test Command Failed"); + assertEquals("0x0001::Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExecutionFailedTest3() { + OnapCommandExecutionFailed failed = new OnapCommandExecutionFailed("Test", "Test Command Failed"); + assertEquals("0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage()); + + failed = new OnapCommandExecutionFailed("Test", new Exception("Test Command Failed")); + assertEquals("0x0001::Command Test failed to execute, Test Command Failed", failed.getMessage()); + } + + @Test + public void onapCommandExecutorInfoMissingTest() { + OnapCommandExecutorInfoMissing failed = new OnapCommandExecutorInfoMissing("Test"); + + assertEquals("0x0023::Command Test excutor info is missing from schema", failed.getMessage()); + } + + @Test + public void onapCommandHelpFailedTest() { + OnapCommandHelpFailed failed = new OnapCommandHelpFailed(new Exception("Failed")); + + assertEquals("0x0002::Command failed to print help message, Failed", failed.getMessage()); + } + + @Test + public void onapCommandHttpFailureTest1() { + OnapCommandHttpFailure failed = new OnapCommandHttpFailure("Failed"); + assertEquals("0x0025::Failed", failed.getMessage()); + + failed = new OnapCommandHttpFailure(new Exception("failed"), 201); + assertEquals("201::0x0025::failed", failed.getMessage()); + } + + @Test + public void onapCommandHttpFailureTest2() { + OnapCommandHttpFailure failed = new OnapCommandHttpFailure("Failed", 203); + + assertEquals("203::0x0025::Failed", failed.getMessage()); + } + + @Test + public void onapCommandInvalidParameterTypeTest() { + OnapCommandInvalidParameterType failed = new OnapCommandInvalidParameterType("Failed"); + + assertEquals("0x0003::Parameter type Failed is invalid", failed.getMessage()); + } + + @Test + public void onapCommandInvalidPrintDirectionTest() { + OnapCommandInvalidPrintDirection failed = new OnapCommandInvalidPrintDirection("Direction"); + + assertEquals("0x0004::Print direction Direction is invalid", failed.getMessage()); + } + + @Test + public void onapCommandInvalidRegistrationTest() { + OnapCommandInvalidRegistration failed = new OnapCommandInvalidRegistration(OnapCommandErrorTest.class); + + assertEquals("0x0005::Invalid commad class org.onap.cli.fw.error.OnapCommandErrorTest registration, " + + "it should be derived from org.onap.cli.fw.OnapCommand", failed.getMessage()); + } + + @Test + public void onapCommandInvalidResultAttributeScopeTest() { + OnapCommandInvalidResultAttributeScope failed = new OnapCommandInvalidResultAttributeScope("Attribute"); + + assertEquals("0x0006::Result atrribute Attribute is invalid", failed.getMessage()); + } + + @Test + public void onapCommandInvalidSchemaTest() { + OnapCommandInvalidSchema failed = new OnapCommandInvalidSchema("Schema", "Failed"); + + assertEquals("0x0007::Command schema Schema is invalid, Failed", failed.getMessage()); + } + + @Test + public void onapCommandInvalidSchemaVersionTest() { + OnapCommandInvalidSchemaVersion failed = new OnapCommandInvalidSchemaVersion("1.0"); + + assertEquals("0x0008::Command schema onap_cmd_schema_version 1.0 is invalid or missing", failed.getMessage()); + } + + @Test + public void onapCommandLoginFailedTest1() { + OnapCommandLoginFailed failed = new OnapCommandLoginFailed(new Exception("Failed")); + + assertEquals("0x0009::Login failed, Failed", failed.getMessage()); + } + + @Test + public void onapCommandLoginFailedTest2() { + OnapCommandLoginFailed failed = new OnapCommandLoginFailed("Failed", 201); + + assertEquals("201::0x0009::Login failed, Failed", failed.getMessage()); + } + + @Test + public void onapCommandLogoutFailedTest() { + OnapCommandLogoutFailed failed = new OnapCommandLogoutFailed(new Exception("Failed")); + assertEquals("0x0010::Logout failed, Failed", failed.getMessage()); + + failed = new OnapCommandLogoutFailed(200); + assertEquals("200::0x0010::Logout failed, ", failed.getMessage()); + } + + @Test + public void onapCommandNotFoundTest() { + OnapCommandNotFound failed = new OnapCommandNotFound("Test"); + + assertEquals("0x0011::Command Test is not registered", failed.getMessage()); + } + + @Test + public void onapCommandNotInitializedTest() { + OnapCommandNotInitialized failed = new OnapCommandNotInitialized("Test"); + + assertEquals("0x0012::Command Test is not initialized", failed.getMessage()); + } + + @Test + public void onapCommandOutputPrintingFailedTest() { + OnapCommandOutputPrintingFailed failed = new OnapCommandOutputPrintingFailed(new Exception("error")); + + assertEquals("0x0014::Command is failed to print the result, error", failed.getMessage()); + } + + @Test + public void onapCommandParameterMissingTest() { + OnapCommandParameterMissing failed = new OnapCommandParameterMissing("paramName"); + + assertEquals("0x0015::Parameter paramName is mandatory", failed.getMessage()); + } + + @Test + public void onapCommandParameterNameConflictTest() { + OnapCommandParameterNameConflict failed = new OnapCommandParameterNameConflict("paramName"); + + assertEquals("0x0016::Parameter name paramName is in conflict", failed.getMessage()); + } + + @Test + public void onapCommandParameterOptionConflictTest() { + OnapCommandParameterOptionConflict failed = new OnapCommandParameterOptionConflict("option"); + + assertEquals("0x0017::Parameter option option is in conflict, only one option is allowed with given name", + failed.getMessage()); + } + + @Test + public void onapCommandRegistrationFailedTest() { + OnapCommandRegistrationFailed failed = new OnapCommandRegistrationFailed("Test", "error"); + + assertEquals("0x0018::Command Test is failed to register, error", failed.getMessage()); + } + + @Test + public void onapCommandResultInitialzationFailedTest() { + OnapCommandResultInitialzationFailed failed = new OnapCommandResultInitialzationFailed("Test", + new Exception("error")); + + assertEquals("0x0022::Command Test result format is failed, error", failed.getMessage()); + } + + @Test + public void onapCommandSchemaNotFoundTest() { + OnapCommandSchemaNotFound failed = new OnapCommandSchemaNotFound("Test"); + + assertEquals("0x0019::Command schema Test is not found, ", failed.getMessage()); + } + + @Test + public void onapCommandServiceNotFoundTest() { + OnapCommandServiceNotFound failed = new OnapCommandServiceNotFound("Service"); + + assertEquals("0x0020::Service Service is not found in MSB", failed.getMessage()); + } + + @Test + public void onapCommandOutputFormatNotsupportedTest() { + OnapCommandOutputFormatNotsupported failed = new OnapCommandOutputFormatNotsupported("Format"); + + assertEquals("0x0013::Command does not support the output format Format", failed.getMessage()); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java b/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java new file mode 100644 index 00000000..900d72e8 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/http/HttpInputOutputTest.java @@ -0,0 +1,67 @@ +/* + * Copyright 2016-17 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.fw.http; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import java.util.HashMap; + +public class HttpInputOutputTest { + + @Test + public void httpInputTest() { + HttpInput inp = new HttpInput(); + inp.setBody("body"); + inp.setMethod("method"); + inp.setReqCookies(null); + inp.setReqHeaders(null); + inp.setReqQueries(null); + inp.setUri("uri"); + + assertTrue("body".equals(inp.getBody()) && "method".equals(inp.getMethod()) && null == inp.getReqCookies() + && inp.getReqHeaders().isEmpty() && inp.getReqQueries().isEmpty() && "uri".equals(inp.getUri())); + + inp.setReqCookies(new HashMap<String, String>()); + inp.setReqHeaders(new HashMap<String, String>()); + inp.setReqQueries(new HashMap<String, String>()); + + assertTrue( + "\nURL: uri\nMethod: method\nRequest Queries: {}\nRequest Body: body\nRequest Headers: {}\nRequest Cookies: {}\nbinaryData=false" + .equals(inp.toString())); + } + + @Test + public void httpResultTest() { + HttpResult out = new HttpResult(); + out.setBody("body"); + out.setRespCookies(null); + out.setRespHeaders(null); + out.setStatus(205); + + assertTrue("body".equals(out.getBody()) && null == out.getRespCookies() && null == out.getRespHeaders() + && 205 == out.getStatus()); + + out.setRespCookies(new HashMap<String, String>()); + out.setRespHeaders(new HashMap<String, String>()); + out.setStatus(200); + assertTrue("\nHTTP Status: 200\nResponse Body: body\nResponse Headers: {}\nResponse Cookies: {}" + .equals(out.toString())); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java b/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java new file mode 100644 index 00000000..cf6d73c1 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/http/OnapHttpConnectionTest.java @@ -0,0 +1,207 @@ +/* + * 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.fw.http; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import mockit.Invocation; +import mockit.Mock; +import mockit.MockUp; +import org.apache.http.client.ClientProtocolException; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.impl.client.CloseableHttpClient; +import org.apache.http.protocol.HttpContext; +import org.junit.Before; +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandHttpFailure; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +public class OnapHttpConnectionTest { + HttpInput inp = null; + OnapHttpConnection con = null; + + @Before + public void setup() { + mockHttpRequest(null); + inp = new HttpInput(); + inp.setMethod("get"); + inp.setBody("body"); + Map<String, String> map1 = new HashMap<>(); + map1.put("header1", "value1"); + inp.setReqHeaders(map1); + Map<String, String> map2 = new HashMap<>(); + map2.put("query1", "value1"); + inp.setReqQueries(map2); + Map<String, String> map = new HashMap<>(); + map.put("cookie1", "value1"); + inp.setReqCookies(map); + inp.setUri("http://192.168.99.10:80"); + } + + @Test(expected = OnapCommandHttpFailure.class) + public void httpUnSecuredGetExceptionTest() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + inp.setMethod("get"); + con = new OnapHttpConnection(false, true); + con.getDebugInfo(); + con.setAuthToken("fdsfdsfs"); + assertTrue("fdsfdsfs".equals(con.getAuthToken())); + con.get(inp); + + } + + @Test(expected = OnapCommandHttpFailure.class) + public void httpUnSecuredPostExceptionTest() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + + inp.setMethod("post"); + con = new OnapHttpConnection(false, true); + con.post(inp); + } + + + @Test(expected = OnapCommandHttpFailure.class) + public void httpUnSecuredPostExceptionTest1() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + + inp.setMethod("post"); + inp.setBinaryData(true); + con = new OnapHttpConnection(false, true); + con.post(inp); + } + + @Test(expected = OnapCommandHttpFailure.class) + public void httpUnSecuredPutExceptionTest() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + inp.setMethod("put"); + con = new OnapHttpConnection(false, true); + con.put(inp); + } + + @Test(expected = OnapCommandHttpFailure.class) + public void httpUnSecuredDeleteExceptionTest() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + inp.setMethod("delete"); + con = new OnapHttpConnection(false, true); + con.delete(inp); + } + + @Test(expected = IllegalArgumentException.class) + public void httpUnSecuredOtherExceptionTest() throws OnapCommandHttpFailure { + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + inp.setMethod("other"); + con = new OnapHttpConnection(false, true); + con.request(inp); + } + + @Test() + public void httpUnSecuredCloseExceptionTest() throws OnapCommandHttpFailure { + inp.setMethod("other"); + con = new OnapHttpConnection(false, true); + con.close(); + } + + @Test + public void httpSecuredGetExceptionTest() { + + // ProtocolVersion p = new ProtocolVersion("http",1,0); + // HttpResponse hr = DefaultHttpResponseFactory.INSTANCE.newHttpResponse(p, 200 , null) ; + + new MockUp<CloseableHttpClient>() { + @Mock + public CloseableHttpResponse execute(HttpUriRequest request, HttpContext context) + throws IOException, ClientProtocolException { + + throw new IOException("IO Exception"); + } + }; + try { + HttpInput inp = new HttpInput(); + inp.setMethod("get"); + inp.setBody("body"); + inp.setReqHeaders(new HashMap<String, String>()); + inp.setReqQueries(new HashMap<String, String>()); + inp.setUri("http://192.168.99.10:80"); + OnapHttpConnection con = new OnapHttpConnection(true, false); + con.get(inp); + } catch (OnapCommandHttpFailure e) { + assertEquals("0x0025::IO Exception", e.getMessage()); + } + } + + private static void mockHttpRequest(HttpResult result) { + new MockUp<OnapHttpConnection>() { + boolean isMock = false; + + @Mock + public HttpResult request(Invocation inv, HttpInput input) throws OnapCommandHttpFailure { + if (isMock) { + return result; + } else { + return inv.proceed(input); + } + } + }; + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java b/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java new file mode 100644 index 00000000..40b07861 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/input/OnapCommandParameterTest.java @@ -0,0 +1,121 @@ +/* + * 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.fw.input; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +public class OnapCommandParameterTest { + + @Test + public void parameterObjTest() throws OnapCommandInvalidParameterValue { + OnapCommandParameter param = new OnapCommandParameter(); + param.setDefaultValue("defaultValue"); + param.setDescription("description"); + param.setLongOption("longOption"); + param.setName("name"); + param.setOptional(true); + param.setParameterType(ParameterType.JSON); + param.setSecured(false); + param.setShortOption("shortOption"); + param.setValue("value"); + + assertTrue(param.getDefaultValue().equals("defaultValue") && param.getDescription().equals("description") + && param.getLongOption().equals("longOption") && param.getName().equals("name") + && param.getShortOption().equals("shortOption") && param.getValue().equals("value") + && param.isOptional() && !param.isSecured() && param.getParameterType().equals(ParameterType.JSON)); + + assertTrue("value".equals(param.getValue())); + + param.setParameterType(ParameterType.ARRAY); + param.setValue(Arrays.asList("1", "2", "3")); + assertTrue("[\"1\",\"2\",\"3\"]".equals(param.getValue())); + + param.setParameterType(ParameterType.MAP); + Map<String, String> map = new HashMap<>(); + map.put("One", "1"); + map.put("Two", "2"); + map.put("Three", "3"); + param.setValue(map); + assertTrue("{\"One\":\"1\",\"Two\":\"2\",\"Three\":\"3\"}".equals(param.getValue())); + + param.setDefaultValue("${defaultValue}"); + assertTrue(null == param.getDefaultValue()); + } + + @Test + public void parameterEnvDefaultValueObjTest() { + OnapCommandParameter param = new OnapCommandParameter(); + param.setDefaultValue("${DAFAULT_VALUE}"); + boolean isDefaultValueAnEnv = param.isDefaultValueAnEnv(); + assertTrue(isDefaultValueAnEnv); + + String envValue = param.getEnvVarNameFromDefaultValue(); + + assertTrue("DAFAULT_VALUE".equals(envValue)); + } + + @Test + public void parameterValidateTest() { + OnapCommandParameter param = new OnapCommandParameter(); + param.setOptional(false); + param.setValue(""); + param.setDefaultValue(""); + param.setParameterType(ParameterType.STRING); + try { + param.validate(); + } catch (OnapCommandException e) { + assertTrue("0x0015::Parameter null is mandatory".equals(e.getMessage())); + } + } + + @Test(expected = OnapCommandInvalidParameterValue.class) + public void onapCommandInvalidParameterValueArrayExeceptionTest() throws OnapCommandInvalidParameterValue { + OnapCommandParameter param = new OnapCommandParameter(); + param.setName("name"); + param.setParameterType(ParameterType.ARRAY); + param.setValue("value"); + assertTrue("[\"1\",\"2\",\"3\"]".equals(param.getValue())); + + } + + @Test(expected = OnapCommandInvalidParameterValue.class) + public void onapCommandInvalidParameterValueMapExeceptionTest() throws OnapCommandInvalidParameterValue { + OnapCommandParameter param = new OnapCommandParameter(); + param.setName("name"); + param.setParameterType(ParameterType.MAP); + param.setValue("value"); + assertTrue("{\"One\":\"1\",\"Two\":\"2\",\"Three\":\"3\"}".equals(param.getValue())); + } + + @Test(expected = OnapCommandInvalidParameterValue.class) + public void onapCommandInvalidParameterValueBinaryExeceptionTest() throws OnapCommandException { + OnapCommandParameter param = new OnapCommandParameter(); + param.setName("name"); + param.setParameterType(ParameterType.BINARY); + param.setValue("value"); + param.validate(); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java b/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java new file mode 100644 index 00000000..eef49ad8 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/input/ParameterTypeTest.java @@ -0,0 +1,51 @@ +/* + * 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.fw.input; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandInvalidParameterType; + +public class ParameterTypeTest { + @Test + public void paramTypeGetTest() { + + try { + assertTrue(ParameterType.JSON.equals(ParameterType.get("json")) + && ParameterType.YAML.equals(ParameterType.get("yaml")) + && ParameterType.STRING.equals(ParameterType.get("string")) + && ParameterType.LONG.equals(ParameterType.get("long")) + && ParameterType.URL.equals(ParameterType.get("url")) + && ParameterType.BOOL.equals(ParameterType.get("bool")) + && ParameterType.MAP.equals(ParameterType.get("map")) + && ParameterType.BINARY.equals(ParameterType.get("binary")) + && ParameterType.ARRAY.equals(ParameterType.get("array"))); + } catch (OnapCommandInvalidParameterType e) { + fail("Shouldn't have thrown this exception : " + e.getMessage()); + } + + try { + ParameterType.get("name"); + } catch (OnapCommandInvalidParameterType e) { + assertTrue("0x0003::Parameter type name is invalid".equals(e.getMessage())); + } + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java b/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java new file mode 100644 index 00000000..4b675edc --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/log/OnapCommandLoggerTest.java @@ -0,0 +1,134 @@ +/* + * Copyright 2016-17 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.fw.log; + +import org.aspectj.lang.ProceedingJoinPoint; +import org.aspectj.lang.Signature; +import org.aspectj.lang.reflect.SourceLocation; +import org.aspectj.runtime.internal.AroundClosure; +import org.junit.Test; + +public class OnapCommandLoggerTest { + + @Test + public void logTest() throws Throwable { + + + ProceedingJoinPoint point = new ProceedingJoinPoint() { + @Override + public String toShortString() { + return null; + } + + @Override + public String toLongString() { + return null; + } + + @Override + public Object getThis() { + return new Object(); + } + + @Override + public Object getTarget() { + return null; + } + + @Override + public StaticPart getStaticPart() { + return null; + } + + @Override + public SourceLocation getSourceLocation() { + return null; + } + + @Override + public Signature getSignature() { + return new Signature(){ + + @Override + public Class getDeclaringType() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String getDeclaringTypeName() { + // TODO Auto-generated method stub + return null; + } + + @Override + public int getModifiers() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public String getName() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String toLongString() { + // TODO Auto-generated method stub + return null; + } + + @Override + public String toShortString() { + // TODO Auto-generated method stub + return null; + } + + }; + } + + @Override + public String getKind() { + return null; + } + + @Override + public Object[] getArgs() { + return null; + } + + @Override + public void set$AroundClosure(AroundClosure arg0) { + } + + @Override + public Object proceed(Object[] arg0) throws Throwable { + return null; + } + + @Override + public Object proceed() throws Throwable { + return new Object(); + } + }; + + OnapCommandLogger log = new OnapCommandLogger(); + log.log(point); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java new file mode 100644 index 00000000..ac1a6d33 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeScopeTest.java @@ -0,0 +1,41 @@ +/* + * 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.fw.output; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; +import org.onap.cli.fw.input.ParameterType; + +import java.util.Collections; + +public class OnapCommandResultAttributeScopeTest { + @Test + public void onapCommandResultAttributeTest() { + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setDescription("description"); + att.setName("name"); + att.setScope(OnapCommandResultAttributeScope.LONG); + att.setSecured(true); + att.setType(ParameterType.LONG); + att.setValues(Collections.emptyList()); + assertTrue("description".equals(att.getDescription()) && "name".equals(att.getName()) + && OnapCommandResultAttributeScope.LONG.equals(att.getScope()) + && ParameterType.LONG.equals(att.getType()) && att.getValues().isEmpty()); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java new file mode 100644 index 00000000..6d2612f9 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultAttributeTest.java @@ -0,0 +1,44 @@ +/* + * 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.fw.output; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope; + +public class OnapCommandResultAttributeTest { + @Test + public void paramTypeGetTest() { + + try { + assertTrue(OnapCommandResultAttributeScope.LONG.equals(OnapCommandResultAttributeScope.get("long")) + && OnapCommandResultAttributeScope.SHORT.equals(OnapCommandResultAttributeScope.get("short"))); + } catch (OnapCommandInvalidResultAttributeScope e) { + fail("Shouldn't have thrown this exception : " + e.getMessage()); + } + + try { + OnapCommandResultAttributeScope.get("name"); + } catch (OnapCommandInvalidResultAttributeScope e) { + assertTrue("0x0006::Result atrribute name is invalid".equals(e.getMessage())); + } + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java new file mode 100644 index 00000000..dddab1bc --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/OnapCommandResultTest.java @@ -0,0 +1,208 @@ +/* + * 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.fw.output; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import org.junit.Ignore; +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.input.ParameterType; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class OnapCommandResultTest { + + @Test + public void commandResultObjTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.LANDSCAPE); + res.setRecords(new ArrayList<OnapCommandResultAttribute>()); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.TABLE); + res.setDebug(true); + + assertTrue("debugInfo".equals(res.getDebugInfo()) && res.isIncludeSeparator() + && "Output".equals(res.getOutput()) && PrintDirection.LANDSCAPE.equals(res.getPrintDirection()) + && res.getRecords().isEmpty() && OnapCommandResultAttributeScope.LONG.equals(res.getScope()) + && ResultType.TABLE.equals(res.getType())); + + String help = res.print(); + + assertTrue("".equals(help)); + + } + + @Test + public void commandResultPrintLandscapeTableTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.LANDSCAPE); + + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setName("param"); + att.setDescription("description"); + att.setType(ParameterType.STRING); + att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" }))); + List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>(); + list.add(att); + res.setRecords(list); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.TABLE); + res.getRecordsMap(); + String expRes = "+--------+\n|param |\n+--------+\n|value |\n+--------+\n"; + String result = res.print(); + + assertEquals(expRes, result); + + } + + @Test + public void commandResultPrintLandscapeJsonTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.LANDSCAPE); + + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setName("param"); + att.setDescription("description"); + att.setType(ParameterType.JSON); + att.setValues( + new ArrayList<String>(Arrays.asList(new String[] { "{\"id\": \"0001\",\"value\": \"result\"}" }))); + List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>(); + list.add(att); + res.setRecords(list); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.JSON); + + // Will be handled after the json print is implemented + String result = res.print(); + // String expRes = "+--------+\n|param |\n+--------+\n|value + // |\n+--------+\n"; + // assertEquals(expRes,result); + + } + + @Test + @Ignore + public void commandResultPrintLandscapeCsvTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.LANDSCAPE); + + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setName("param"); + att.setDescription("description"); + att.setType(ParameterType.STRING); + att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" }))); + List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>(); + list.add(att); + OnapCommandResultAttribute a1 = new OnapCommandResultAttribute(); + a1.setName("param1"); + a1.setDescription("description1"); + a1.setType(ParameterType.STRING); + a1.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value1" }))); + + list.add(a1); + res.setRecords(list); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.CSV); + + String expRes = "param,param1\r\n"; + String result = res.print(); + assertEquals(expRes, result); + + } + + @Test + @Ignore + public void commandResultPrintPortraitCsvTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.PORTRAIT); + + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setName("param"); + att.setDescription("description"); + att.setType(ParameterType.STRING); + att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" }))); + List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>(); + list.add(att); + OnapCommandResultAttribute a1 = new OnapCommandResultAttribute(); + a1.setName("param1"); + a1.setDescription("description1"); + a1.setType(ParameterType.STRING); + a1.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value1" }))); + + list.add(a1); + res.setRecords(list); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.CSV); + String expRes = "property,value\r\nparam,value\r\n"; + String result = res.print(); + assertEquals(expRes, result); + } + + @Test + public void commandResultPrintPortraitTableTest() throws OnapCommandException { + OnapCommandResult res = new OnapCommandResult(); + res.setDebugInfo("debugInfo"); + res.setIncludeSeparator(true); + res.setIncludeTitle(true); + res.setOutput("Output"); + res.setPrintDirection(PrintDirection.PORTRAIT); + + OnapCommandResultAttribute att = new OnapCommandResultAttribute(); + att.setName("param"); + att.setDescription("description"); + att.setType(ParameterType.STRING); + att.setValues(new ArrayList<String>(Arrays.asList(new String[] { "value" }))); + + List<OnapCommandResultAttribute> list = new ArrayList<OnapCommandResultAttribute>(); + list.add(att); + res.setRecords(list); + res.setScope(OnapCommandResultAttributeScope.LONG); + res.setType(ResultType.TABLE); + String expRes = "+----------+--------+\n|property |value |\n+----------+--------+" + + "\n|param |value |\n+----------+--------+\n"; + + String result = res.print(); + + assertEquals(expRes, result); + + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java b/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java new file mode 100644 index 00000000..0aa82979 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/PrintDirectionTest.java @@ -0,0 +1,43 @@ +/* + * 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.fw.output; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection; + +public class PrintDirectionTest { + @Test + public void printDirectionGetTest() { + + try { + assertTrue(PrintDirection.LANDSCAPE.equals(PrintDirection.get("landscape")) + && PrintDirection.PORTRAIT.equals(PrintDirection.get("portrait"))); + } catch (OnapCommandInvalidPrintDirection e) { + fail("Shouldn't have thrown this exception : " + e.getMessage()); + } + + try { + PrintDirection.get("name"); + } catch (OnapCommandInvalidPrintDirection e) { + assertTrue("0x0004::Print direction name is invalid".equals(e.getMessage())); + } + + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java b/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.java new file mode 100644 index 00000000..3c4c5665 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/ResultTypeTest.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.fw.output; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class ResultTypeTest { + @Test + public void resultTypeGetTest() { + assertTrue(ResultType.TABLE.equals(ResultType.get("table")) && ResultType.CSV.equals(ResultType.get("csv")) + && ResultType.JSON.equals(ResultType.get("json")) && ResultType.YAML.equals(ResultType.get("yaml")) + && ResultType.TEXT.equals(ResultType.get("text"))); + + } + + @Test + public void isTabularFormTest() { + assertTrue(ResultType.isTabularForm("table")); + } + + @Test + public void isTabularFormNotTest() { + assertFalse(ResultType.isTabularForm("text")); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java b/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java new file mode 100644 index 00000000..ae17d6d4 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/print/OnapCommandPrintTest.java @@ -0,0 +1,82 @@ +/* + * 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.fw.output.print; + +import static org.junit.Assert.assertEquals; + +import org.junit.Ignore; +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandOutputPrintingFailed; +import org.onap.cli.fw.output.PrintDirection; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class OnapCommandPrintTest { + + @Test + @Ignore + public void printCsvTest() throws OnapCommandOutputPrintingFailed { + OnapCommandPrint pr = new OnapCommandPrint(); + pr.setDirection(PrintDirection.LANDSCAPE); + pr.setPrintTitle(true); + pr.addColumn("name1", new ArrayList<String>(Arrays.asList(new String[] { "value1" }))); + String exp = "name1\r\n"; + String result = pr.printCsv(); + assertEquals(exp, result); + } + + @Test + public void printTableTest() throws OnapCommandOutputPrintingFailed { + OnapCommandPrint pr = new OnapCommandPrint(); + List<String> getColumnsData = new ArrayList<String>(); + pr.setDirection(PrintDirection.LANDSCAPE); + pr.setPrintTitle(true); + pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "value2" }))); + String exp = "+--------+\n|name2 |\n+--------+\n|value2 |\n+--------+\n"; + String result = pr.printTable(true); + getColumnsData = pr.getColumn("name2"); + assertEquals(exp, result); + } + + @Test + public void printTableNullColumnHeaderTest() throws OnapCommandOutputPrintingFailed { + OnapCommandPrint pr = new OnapCommandPrint(); + List<String> getColumnsData = new ArrayList<String>(); + pr.setDirection(PrintDirection.LANDSCAPE); + pr.setPrintTitle(true); + pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "value2" }))); + String exp = "+--------+\n|name2 |\n+--------+\n|value2 |\n+--------+\n"; + String result = pr.printTable(true); + getColumnsData = pr.getColumn(null); + assertEquals(exp, result); + } + + @Test + public void printTableEmptyColumnValuesTest() throws OnapCommandOutputPrintingFailed { + OnapCommandPrint pr = new OnapCommandPrint(); + List<String> getColumnsData = new ArrayList<String>(); + pr.setDirection(PrintDirection.LANDSCAPE); + pr.setPrintTitle(true); + pr.addColumn("name2", new ArrayList<String>(Arrays.asList(new String[] { "" }))); + String exp = "+--------+\n|name2 |\n+--------+\n| |\n+--------+\n"; + String result = pr.printTable(true); + getColumnsData = pr.getColumn("name2"); + assertEquals(exp, result); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java b/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java new file mode 100644 index 00000000..f9ae0717 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/output/print/TableGeneratorTest.java @@ -0,0 +1,185 @@ +/* + * 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.fw.output.print; + +import static org.junit.Assert.assertEquals; + +import org.junit.Before; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class TableGeneratorTest { + private TableGenerator table; + + @Before + public void setUp() throws Exception { + this.table = new TableGenerator(); + } + + @Test + public void printTableNoColumnTest() { + System.out.println("printTableNoColumnTest..."); + List<Object> row = new ArrayList<Object>(); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(row); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "\n\n\n"; + assertEquals(expected, result); + } + + @Test + public void printTableNoCellTest() { + System.out.println("printTableNoCellTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+----------+----------+\n|column1 |column2 |\n+----------+----------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableNullCellTest() { + + System.out.println("printTableNullCellTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + rows.add(Arrays.asList(new Object[] { "value1", null })); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n" + + "|value1 | |\n" + "+----------+----------+\n"; + assertEquals(expected, result); + + } + + @Test + public void printTableEmptyCellTest() { + System.out.println("printTableEmptyCellTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + rows.add(Arrays.asList(new Object[] { "value1", "" })); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n" + + "|value1 | |\n" + "+----------+----------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableNoCellBreakTest() { + System.out.println("printTableNoCellBreakTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + rows.add(Arrays.asList(new Object[] { "value1", "value2" })); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+----------+----------+\n" + "|column1 |column2 |\n" + "+----------+----------+\n" + + "|value1 |value2 |\n" + "+----------+----------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableCellBreakTest() { + System.out.println("printTableCellBreakTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + List<Object> list = new ArrayList<Object>(); + list.add("value1"); + list.add(new ArrayList<Object>( + Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" }))); + rows.add(list); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+----------+------------------------------------------+\n" + + "|column1 |column2 |\n" + + "+----------+------------------------------------------+\n" + + "|value1 |1234567891234567891234567891234567891234 |\n" + + "| |56789 |\n" + + "+----------+------------------------------------------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableTwoCellBreakInSameRowTest() { + System.out.println("printTableTwoCellBreakInSameRowTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + List<Object> list = new ArrayList<Object>(); + list.add(new ArrayList<Object>( + Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" }))); + list.add(new ArrayList<Object>( + Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789", "00" }))); + rows.add(list); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+------------------------------------------+------------------------------------------+\n" + + "|column1 |column2 |\n" + + "+------------------------------------------+------------------------------------------+\n" + + "|1234567891234567891234567891234567891234 |1234567891234567891234567891234567891234 |\n" + + "|56789 |56789 |\n" + + "| |00 |\n" + + "+------------------------------------------+------------------------------------------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableTwoCellBreakInDifferentRowTest() { + System.out.println("printTableTwoCellBreakInSameRowTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + List<Object> list1 = new ArrayList<Object>(); + list1.add("value1"); + list1.add(new ArrayList<Object>( + Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "56789" }))); + rows.add(list1); + List<Object> list2 = new ArrayList<Object>(); + list2.add(new ArrayList<Object>( + Arrays.asList(new Object[] { "1234567891234567891234567891234567891234", "hi" }))); + + list2.add("value2"); + rows.add(list2); + String result = table.generateTable(rows, true); + System.out.println(result); + String expected = "+------------------------------------------+------------------------------------------+\n" + + "|column1 |column2 |\n" + + "+------------------------------------------+------------------------------------------+\n" + + "|value1 |1234567891234567891234567891234567891234 |\n" + + "| |56789 |\n" + + "+------------------------------------------+------------------------------------------+\n" + + "|1234567891234567891234567891234567891234 |value2 |\n" + + "|hi | |\n" + + "+------------------------------------------+------------------------------------------+\n"; + assertEquals(expected, result); + } + + @Test + public void printTableWithoutPrintSeparatorTest() { + System.out.println("printTableWithoutPrintSeparatorTest..."); + List<List<Object>> rows = new ArrayList<List<Object>>(); + rows.add(Arrays.asList(new Object[] { "column1", "column2" })); + rows.add(Arrays.asList(new Object[] { "value1", "value2" })); + String result = table.generateTable(rows, false); + System.out.println(result); + String expected = "column1 column2 \nvalue1 value2 \n"; + assertEquals(expected, result); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java b/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java new file mode 100644 index 00000000..1236365c --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/run/OnapCommandExecutorTest.java @@ -0,0 +1,38 @@ +/* + * 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.fw.run; + +import org.junit.Assert; +import org.junit.Test; + +public class OnapCommandExecutorTest { + + @Test + public void commandExecutorTest() { + OnapCommandExecutor exec = new OnapCommandExecutor(); + exec.setApi("api"); + exec.setClient("client"); + exec.setEntity("entity"); + exec.setException("exception"); + exec.setMethod("method"); + + Assert.assertTrue( + exec.getApi().equals("api") && exec.getClient().equals("client") && exec.getEntity().equals("entity") + && exec.getMethod().equals("method") && exec.getException().equals("exception")); + } + +} diff --git a/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java b/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java new file mode 100644 index 00000000..4c48683b --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java @@ -0,0 +1,103 @@ +/* + * 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.fw.schema; + +import org.junit.Test; +import org.onap.cli.fw.error.OnapCommandInvalidSchema; +import org.yaml.snakeyaml.scanner.ScannerException; + +import java.io.File; +import java.util.ArrayList; +import java.util.HashSet; + +public class ValidateSchemaTest { + + @Test(expected = OnapCommandInvalidSchema.class) + public void invalidateTest1() throws OnapCommandInvalidSchema { + new SchemaValidator(new File("fdsfds")); + new SchemaValidator(new File("fdsfds.yaml")); + } + + @Test(expected = OnapCommandInvalidSchema.class) + public void invalidateTest2() throws OnapCommandInvalidSchema { + new SchemaValidator(new File("fdsfds")); + } + + @Test(expected = OnapCommandInvalidSchema.class) + public void invalidateTest4() throws OnapCommandInvalidSchema { + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("onap.properties").getFile())); + } + + @Test(expected = OnapCommandInvalidSchema.class) + public void invalidateTest5() throws OnapCommandInvalidSchema { + new SchemaValidator(new File( + ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file-null.yaml").getFile())); + } + + @Test + public void invalidate1Test5() throws OnapCommandInvalidSchema { + new SchemaValidator("schema-validate-pass.yaml"); + } + + @Test(expected = ScannerException.class) + public void invalidateTest3() throws OnapCommandInvalidSchema { + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file.yaml").getFile())); + } + + @Test + public void validateTest() throws OnapCommandInvalidSchema { + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-http.yaml").getFile())) + .validate(); + + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-basic.yaml").getFile())) + .validate(); + new SchemaValidator(new File(ValidateSchemaTest.class.getClassLoader() + .getResource("schema-validate-invalidschematype.yaml").getFile())).validate(); + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-invalid.yaml").getFile())) + .validate(); + new SchemaValidator( + new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-validate-pass.yaml").getFile())) + .validate(); + + } + + @Test + public void schemaValidateInterfaceTest() throws OnapCommandInvalidSchema { + SchemaValidate.attributeNameExist("name", "section"); + SchemaValidate.emptyValue("section", "attribute"); + SchemaValidate.defaultYamlSchema("section"); + SchemaValidate.emptySection("section"); + SchemaValidate.invalidAttributeScope("name", new ArrayList<String>()); + SchemaValidate.invalidAttrType("name", "section", new ArrayList<String>()); + SchemaValidate.invalidBooleanValueMessage("section", "attribute", "value"); + SchemaValidate.invalidRequestParam("subSection", "attribute"); + SchemaValidate.invalidSections(new HashSet<String>(), new ArrayList<String>(), new ArrayList<String>()); + SchemaValidate.attributeScopeEmpty("fsdf"); + SchemaValidate.invalidType("section", "attribute", new ArrayList<String>()); + SchemaValidate.longOptionExist("name"); + SchemaValidate.shortOptionExist("name"); + SchemaValidate.optionExist("option", "attrValue", "name"); + SchemaValidate.optionDefaultExist("option", "attrValue", "name", new HashSet<String>()); + SchemaValidate.nameExist("name", "section"); + SchemaValidate.mandatoryAttrEmpty("param", "section"); + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java b/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java new file mode 100644 index 00000000..7da6230f --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/utils/FileUtil.java @@ -0,0 +1,55 @@ +/* + * 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.fw.utils; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; + +public class FileUtil { + + /** + * Load file. + * @param srcName dir + * @return string + * @throws IOException exception + */ + public static String loadResource(String srcName) throws IOException { + ClassLoader classLoader = FileUtil.class.getClassLoader(); + File file = new File(classLoader.getResource(srcName).getFile()); + BufferedReader br = new BufferedReader(new FileReader(file)); + StringBuilder sb = new StringBuilder(""); + if (br != null) { + try { + + String line = br.readLine(); + + while (line != null) { + sb.append(line); + sb.append("\n"); + line = br.readLine(); + } + } finally { + br.close(); + } + } + + return sb.toString(); + + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java b/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java new file mode 100644 index 00000000..b74027a0 --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java @@ -0,0 +1,481 @@ +/* + * 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.fw.utils; + + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import mockit.Invocation; +import mockit.Mock; +import mockit.MockUp; + +import org.junit.FixMethodOrder; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runners.MethodSorters; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandSchema; +import org.onap.cli.fw.ad.OnapCredentials; +import org.onap.cli.fw.cmd.OnapHttpCommand; +import org.onap.cli.fw.cmd.OnapSwaggerCommand; +import org.onap.cli.fw.error.OnapCommandException; +import org.onap.cli.fw.error.OnapCommandHelpFailed; +import org.onap.cli.fw.error.OnapCommandHttpHeaderNotFound; +import org.onap.cli.fw.error.OnapCommandHttpInvalidResponseBody; +import org.onap.cli.fw.error.OnapCommandInvalidParameterType; +import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection; +import org.onap.cli.fw.error.OnapCommandInvalidResultAttributeScope; +import org.onap.cli.fw.error.OnapCommandInvalidSchema; +import org.onap.cli.fw.error.OnapCommandInvalidSchemaVersion; +import org.onap.cli.fw.error.OnapCommandParameterNameConflict; +import org.onap.cli.fw.error.OnapCommandParameterNotFound; +import org.onap.cli.fw.error.OnapCommandParameterOptionConflict; +import org.onap.cli.fw.error.OnapCommandSchemaNotFound; +import org.onap.cli.fw.http.HttpInput; +import org.onap.cli.fw.http.HttpResult; +import org.onap.cli.fw.input.OnapCommandParameter; +import org.onap.cli.fw.input.ParameterType; +import org.onap.cli.fw.output.OnapCommandResult; +import org.onap.cli.fw.run.OnapCommandExecutor; +import org.springframework.core.io.Resource; + + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class OnapCommandUtilsTest { + + @Test(expected = OnapCommandSchemaNotFound.class) + public void onapCommandUtilsInputStreamNullTest() throws OnapCommandException { + OnapCommandUtils.validateSchemaVersion("sample-test1-schema-http1.yaml", "1.0"); + } + + @Test + public void onapCommandUtilsInputStreamNotNullTest() throws OnapCommandException { + Map<String, ?> map = OnapCommandUtils.validateSchemaVersion("sample-test1-schema-http.yaml", "1.0"); + assertTrue(map != null); + } + + @Test + public void externalSchemaTest() { + ExternalSchema schema = new ExternalSchema(); + schema.setCmdName("cmdName"); + schema.setSchemaName("schemaName"); + schema.setVersion("version"); + + assertTrue("cmdName".equals(schema.getCmdName()) && "schemaName".equals(schema.getSchemaName()) + && "version".equals(schema.getVersion())); + } + + @Test + public void schemaFileNotFoundTest() throws OnapCommandException { + + Map<String, ?> map = OnapCommandUtils.validateSchemaVersion("sample-test-schema.yaml", "1.0"); + assertTrue(map.size() > 0); + } + + @Test + @Ignore + public void invalidSchemaFileTest() throws OnapCommandException { + Map<String, ?> map = null; + try { + map = OnapCommandUtils.validateSchemaVersion("sample-test-schema1.yaml", "1.0"); + } catch (OnapCommandInvalidSchemaVersion e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } catch (OnapCommandInvalidSchema e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } catch (OnapCommandSchemaNotFound e) { + assertEquals("0x0019::Command schema sample-test-schema1.yaml is not found", e.getMessage()); + } + } + + @Test + public void validateWrongSchemaVersionTest() throws OnapCommandException { + Map<String, ?> map = null; + try { + map = OnapCommandUtils.validateSchemaVersion("sample-test-invalid-schema.yaml", "1.0"); + } catch (OnapCommandInvalidSchemaVersion e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } catch (OnapCommandInvalidSchema e) { + assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-invalid-schema.yaml is invalid")); + } catch (OnapCommandSchemaNotFound e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } + } + + @Test + public void validateSchemaVersionTest() throws OnapCommandException { + Map<String, ?> map = null; + try { + map = OnapCommandUtils.validateSchemaVersion("sample-test-schema.yaml", "1.1"); + } catch (OnapCommandInvalidSchemaVersion e) { + assertEquals("0x0008::Command schema onap_cmd_schema_version 1.0 is invalid or missing", e.getMessage()); + } catch (OnapCommandInvalidSchema e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } catch (OnapCommandSchemaNotFound e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } + } + + @Test + public void loadOnapCommandSchemaWithOutDefaultTest() throws OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", false); + assertTrue("sample-test".equals(cmd.getName()) && cmd.getParameters().size() == 9); + } + + @Test(expected = OnapCommandParameterNameConflict.class) + public void loadOnapCommandSchemaWithDuplicateNameTest() throws OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-name.yaml", false); + } + + @Test(expected = OnapCommandParameterOptionConflict.class) + public void loadOnapCommandSchemaWithDuplicateShortOptionTest() throws OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-shortoption.yaml", false); + } + + @Test(expected = OnapCommandParameterOptionConflict.class) + public void loadOnapCommandSchemaWithDuplicateLongOptionTest() throws OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-longoption.yaml", false); + } + + @Test + public void loadOnapCommandSchemaWithDefaultTest() throws OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + assertTrue("sample-test".equals(cmd.getName()) && cmd.getParameters().size() > 9); + + for (OnapCommandParameter com : cmd.getParameters()) { + com.setValue("value"); + } + + OnapCredentials cre = OnapCommandUtils.fromParameters(cmd.getParameters()); + assertTrue(cre != null); + Map<String, OnapCommandParameter> map = OnapCommandUtils.getInputMap(cmd.getParameters()); + assertTrue(map.size() == 19); + } + + @Test + public void loadSwaggerBasedSchemaExceptionTest() throws OnapCommandException { + OnapSwaggerCommand cmd = new OnapSwaggerBasedCommandSample(); + try { + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml"); + } catch (OnapCommandInvalidSchema e) { + assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid")); + } + } + + @Test + public void loadSwaggerBasedSchemaTest() throws OnapCommandException { + OnapSwaggerCommand cmd = new OnapSwaggerBasedCommandSample(); + try { + OnapCommandUtils.loadSchema(cmd, "sample-test-schema-swagger.yaml"); + OnapCommandExecutor exe = cmd.getExecutor(); + assertTrue(exe != null); + } catch (OnapCommandInvalidSchema e) { + assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid")); + } + } + + @Test + public void loadHttpBasedSchemaExceptionTest() throws OnapCommandException { + OnapHttpCommand cmd = new OnapHttpCommandSample(); + cmd.setName("sample-test-http"); + try { + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml"); + } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict + | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection + | OnapCommandInvalidResultAttributeScope | OnapCommandSchemaNotFound | OnapCommandInvalidSchema + | OnapCommandInvalidSchemaVersion e) { + assertTrue(e.getMessage().contains("0x0007::Command schema sample-test-schema.yaml is invalid")); + } + } + + @Test + public void loadHttpBasedSchemaTest() throws OnapCommandException { + OnapHttpCommand cmd = new OnapHttpCommandSample(); + cmd.setName("sample-create-http"); + try { + OnapCommandUtils.loadSchema(cmd, "sample-test-schema-http.yaml"); + assertTrue(cmd.getSuccessStatusCodes().size() == 2); + } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict + | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection + | OnapCommandInvalidResultAttributeScope | OnapCommandSchemaNotFound | OnapCommandInvalidSchema + | OnapCommandInvalidSchemaVersion e) { + fail("Test should not have thrown this exception : " + e.getMessage()); + } + } + + @Test + public void helpCommandTest() throws IOException, OnapCommandException { + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + + String actualResult = OnapCommandUtils.help(cmd); + + String expectedHelp = FileUtil.loadResource("sample-cmd-test-help.txt"); + } + + @Test + public void findOnapCommandsTest() { + List<Class<OnapCommand>> cmds = OnapCommandUtils.findOnapCommands(); + assertTrue(cmds.size() == 3); + } + + @Test + public void sortTest() { + Set<String> set = new HashSet<String>(); + set.add("dbvc"); + set.add("bbvcb"); + set.add("aaa"); + set.add("c"); + set.add("z"); + List<String> list = OnapCommandUtils.sort(set); + assertEquals("[aaa, bbvcb, c, dbvc, z]", list.toString()); + } + + @Test + public void jsonFlattenTest() { + List<String> list = Arrays.asList(new String[] { "{\"menu1\": {\"id\": \"file1\",\"value\": \"File1\"}}" }); + List<String> list1 = OnapCommandUtils.jsonFlatten(list); + String expected = "[{\"menu1\":{\"id\":\"file1\",\"value\":\"File1\"}}]"; + assertEquals(expected, list1.toString()); + + } + + @Test + public void jsonFlattenExceptionTest() { + List<String> list = Arrays.asList(new String[] { "{\"menu1\"::{\"id\":\"file1\",\"value\":\"File1\"}}" }); + List<String> list1 = OnapCommandUtils.jsonFlatten(list); + String expected = "[{\"menu1\"::{\"id\":\"file1\",\"value\":\"File1\"}}]"; + assertEquals(expected, list1.toString()); + + } + + @Test + public void formMethodNameFromAttributeTest() { + + String str = ""; + String name = OnapCommandUtils.formMethodNameFromAttributeName(str, "test"); + + assertEquals("", name); + + str = null; + name = OnapCommandUtils.formMethodNameFromAttributeName(str, "test"); + + assertEquals(null, name); + + str = "test-get"; + name = OnapCommandUtils.formMethodNameFromAttributeName(str, ""); + assertEquals("TestGet", name); + + } + + @Test + public void populateParametersTest() throws OnapCommandException { + + HttpInput input = new HttpInput(); + input.setBody("body"); + input.setMethod("method"); + Map<String, String> mapHead = new HashMap<>(); + mapHead.put("key2", "${value2}"); + input.setReqHeaders(mapHead); + Map<String, String> query = new HashMap<>(); + query.put("key3", "{${value3}}"); + input.setReqQueries(query); + input.setUri("uri"); + + Map<String, OnapCommandParameter> params = new HashMap<>(); + OnapCommandParameter param = new OnapCommandParameter(); + param.setDefaultValue("defaultValue2"); + param.setParameterType(ParameterType.STRING); + params.put("value2", param); + OnapCommandParameter param1 = new OnapCommandParameter(); + param1.setDefaultValue("{\"defaultValue3\"}"); + param1.setParameterType(ParameterType.JSON); + params.put("value3", param1); + + HttpInput input1 = OnapCommandUtils.populateParameters(params, input); + String expected = "\nURL: uri\nMethod: method\nRequest Queries: {key3={\"defaultValue3\"}}\n" + + "Request Body: body\nRequest Headers: {key2=defaultValue2}\nRequest Cookies: {}\nbinaryData=false"; + assertEquals(expected, input1.toString()); + + input.setBody("${body}"); + + HttpInput input2 = null; + try { + input2 = OnapCommandUtils.populateParameters(params, input); + } catch (OnapCommandParameterNotFound e) { + assertEquals("0x0026::Command input parameter body is not valid", e.getMessage()); + } + + } + + @Test(expected = OnapCommandHttpHeaderNotFound.class) + public void populateOutputsTest() throws OnapCommandException { + HttpResult output = new HttpResult(); + output.setBody( + "{\"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\"}"); + Map<String, String> mapHead = new HashMap<>(); + mapHead.put("head1", "value1"); + output.setRespHeaders(mapHead); + output.setStatus(0); + + Map<String, String> params = new HashMap<>(); + params.put("head", "$h{head1}"); + params.put("body", "$b{$.serviceName}"); + params.put("key", "value"); + + Map<String, ArrayList<String>> input1 = OnapCommandUtils.populateOutputs(params, output); + assertEquals("{head=[value1], body=[test], key=[value]}", input1.toString()); + + params.put("body", "$b{{$.serviceName}"); + try { + input1 = OnapCommandUtils.populateOutputs(params, output); + } catch (OnapCommandHttpInvalidResponseBody e) { + assertEquals( + "0x0028::Http response body does not have json entry {$.serviceName, Missing property in path $['{$']", + e.getMessage()); + } + output.setBody("{}"); + input1 = OnapCommandUtils.populateOutputs(params, output); + params.put("head", "$h{head2}"); + output.setBody("{\"test\"}"); + input1 = OnapCommandUtils.populateOutputs(params, output); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest1() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.loadSchema(new OnapSwaggerBasedCommandSample(), "schemaName"); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest2() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest3() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.validateSchemaVersion("schemaName", "version"); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest4() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.loadExternalSchemasFromJson(); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest5() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.findAllExternalSchemas(); + } + + @Test(expected = OnapCommandException.class) + public void zendExceptionTest6() throws OnapCommandException { + + mockExternalResources(); + OnapCommandUtils.persist(new ArrayList<ExternalSchema>()); + } + + @Test(expected = OnapCommandHelpFailed.class) + public void zendExceptionHelpTest1() throws OnapCommandException { + + mockPrintMethodException(); + OnapCommand cmd = new OnapCommandSample(); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + + OnapCommandUtils.help(cmd); + + } + + @OnapCommandSchema(name = "sample-test", schema = "sample-test-schema.yaml") + class OnapCommandSample extends OnapCommand { + @Override + protected void run() throws OnapCommandException { + } + } + + @OnapCommandSchema(name = "sample-swagger-test", schema = "sample-test-schema-swagger.yaml") + class OnapSwaggerBasedCommandSample extends OnapSwaggerCommand { + + @Override + protected void run() throws OnapCommandException { + } + } + + @OnapCommandSchema(name = "sample-http-test", schema = "sample-test-schema-http.yaml") + class OnapHttpCommandSample extends OnapHttpCommand { + + @Override + protected void run() throws OnapCommandException { + } + } + + private void mockExternalResources() { + new MockUp<OnapCommandUtils>() { + boolean isMock = true; + + @Mock + public Resource[] getExternalResources(Invocation inv, String pattern) throws IOException { + if (isMock) { + isMock = false; + throw new IOException(); + } else { + return inv.proceed(pattern); + } + } + }; + } + + private void mockPrintMethodException() { + new MockUp<OnapCommandResult>() { + boolean isMock = true; + + @Mock + public String print(Invocation inv) throws OnapCommandException { + if (isMock) { + isMock = false; + throw new OnapCommandException("", ""); + } else { + return inv.proceed(); + } + } + }; + } +} diff --git a/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java b/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.java new file mode 100644 index 00000000..fa73ea6e --- /dev/null +++ b/framework/src/test/java/org/onap/cli/fw/utils/OpenCommandRegistrarTest.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.fw.utils; + +import org.junit.Before; +import org.junit.Test; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.OnapCommandRegistrar; +import org.onap.cli.fw.error.OnapCommandException; + + +public class OpenCommandRegistrarTest { + + @Before + public void setUp() throws Exception { + + } + + @Test + public void test() throws OnapCommandException { + OnapCommandRegistrar registrar = OnapCommandRegistrar.getRegistrar(); + OnapCommand cmd = registrar.get("sample-test"); + registrar.listCommands(); + registrar.getAllCommandToSchemaMap(); + cmd.printVersion(); + } + +} diff --git a/framework/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand b/framework/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand new file mode 100644 index 00000000..a01b9d53 --- /dev/null +++ b/framework/src/test/resources/META-INF/services/org.onap.cli.fw.OnapCommand @@ -0,0 +1 @@ +org.onap.cli.cmd.sample.OnapCommandSample
\ No newline at end of file diff --git a/framework/src/test/resources/onap-cli-schema/sample-test1-schema-http.yaml b/framework/src/test/resources/onap-cli-schema/sample-test1-schema-http.yaml new file mode 100644 index 00000000..18a7bb16 --- /dev/null +++ b/framework/src/test/resources/onap-cli-schema/sample-test1-schema-http.yaml @@ -0,0 +1,91 @@ +onap_cmd_schema_version: 1.0 +name: sample-test1 +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} + - 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 +http: + request: + uri: /vims + method: POST + body: '{"name":"${name}","vendor":"${vendor}","version":"${vim-version}","description":"${description}","type":"${type}","url":"${url}","userName":"${username}","password":"${password}","domain":"${domain}","tenant":"${tenant}"}' + headers: + success_codes: + - 201 + - 200 + result_map: + id: $b{$.vimId} + name: $b{$.name} + vendor: $b{$.vendor} + type: $b{$.type} + version: $b{$.version} + url: $b{$.url} + description: $b{$.description} + username: $b{$.userName} + password: $b{$.password} + domain: $b{$.domain} + tenant: $b{$.tenant} + create-time: $b{$.createTime} + sample_response: + body:'{"id":"string","name":"string","vendor":"string","version":"string","description":"string","type":"string","createTime":"string","url":"string","userName":"string","password":"string","domain":"string","tenant":"string"}'
\ No newline at end of file diff --git a/framework/src/test/resources/onap-test-schema.yaml b/framework/src/test/resources/onap-test-schema.yaml new file mode 100644 index 00000000..df260502 --- /dev/null +++ b/framework/src/test/resources/onap-test-schema.yaml @@ -0,0 +1,81 @@ +onap_cmd_schema_version: 1.0 +name: sample-test +description: Onap sample command to test the command features +service: + name: sample + version: v1 + no-auth: true +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} + - 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 + is_secured: true + - name: output-2 + description: Onap output attribute marked in long + scope: short + is_secured: false + type: string
\ No newline at end of file diff --git a/framework/src/test/resources/onap.properties b/framework/src/test/resources/onap.properties new file mode 100644 index 00000000..3b185174 --- /dev/null +++ b/framework/src/test/resources/onap.properties @@ -0,0 +1,4 @@ +cli.ignore_auth=true +cli.version=1.0 +http.api_key=X-Auth-Token +http.api_key_use_cookies=true
\ No newline at end of file diff --git a/framework/src/test/resources/sample-cmd-test-help.txt b/framework/src/test/resources/sample-cmd-test-help.txt new file mode 100644 index 00000000..d8ce1ef5 --- /dev/null +++ b/framework/src/test/resources/sample-cmd-test-help.txt @@ -0,0 +1,72 @@ +usage: onap sample-test + +Onap sample command to test the command features + +Onap service: sample v1 + +Options: +[-u | --onap-username] [-p | --onap-password] [-m | --msb-url] +[-h | --help] [-v | --version] [-d | --debug] +[-f | --format] [-s | --long] [-t | --no-title] +[-a | --no-auth] [-b | --bool] [-x | --secure] +[-c | --string-param] [-y | --yaml-param] [-j | --json-param] +[-l | --long-opt] [-r | --url] [-z | --env] +<positional-args> +where, +-u | --onap-username Onap user name. It is of type STRING. By + default, it is read from environment variable + ONAP_USERNAME. +-p | --onap-password Onap user password. It is of type STRING. By + default, it is read from environment variable + ONAP_PASSWORD. Secured. +-m | --msb-url Onap MSB url. It is of type URL. By default, it + is read from environment variable ONAP_MSB_URL. +-h | --help Onap command help message. It is of type STRING. + By default, it is false. +-v | --version Onap command service version. It is of type + STRING. By default, it is false. +-d | --debug Enable debug output. It is of type BOOL. By + default, it is false. +-f | --format Output formats, supported formats such as table, + csv, json, yaml. It is of type STRING. By default, + it is table. +-s | --long whether to print all attributes or only short + attributes. It is of type BOOL. By default, it is + false. +-t | --no-title whether to print title or not. It is of type BOOL. + By default, it is false. +-a | --no-auth whether to authenticate user or not. It is of type + BOOL. By default, it is false. +-b | --bool Onap boolean param, by default its always false. + It is of type BOOL. It is optional. By default, it + is false. +-x | --secure Onap secure param such as password. It is of + type STRING. Secured. +-c | --string-param Onap string param. It is of type STRING. +-y | --yaml-param Onap yaml file location param. It is of type + JSON. It's recommended to input the complete path + of the file, which is having the value for it. +-j | --json-param Onap json file location param. It is of type + JSON. It's recommended to input the complete path + of the file, which is having the value for it. +-l | --long-opt Onap long param. It is of type LONG. By default, + it is 10. +-r | --url Onap url param. It is of type URL. By default, + it is http://localhost:8082/file.txt. +-z | --env Onap env param. It is of type STRING. By + default, it is read from environment variable + ENV_VAR. +positional-args Onap positional args, if no short option and no + long option given for it. It is of type STRING. By + default, it is http://localhost:8082/file.txt. + + +Results: +output-1 Onap output attribute marked in short and is of + type STRING. It is secured. +output-2 Onap output attribute marked in long and is of + type STRING. + + +Error: +On error, it prints <HTTP STATUS CODE>::<ERROR CODE>::<ERROR MESSAGE> diff --git a/framework/src/test/resources/sample-test-invalid-schema-duplicate-longoption.yaml b/framework/src/test/resources/sample-test-invalid-schema-duplicate-longoption.yaml new file mode 100644 index 00000000..8761bb30 --- /dev/null +++ b/framework/src/test/resources/sample-test-invalid-schema-duplicate-longoption.yaml @@ -0,0 +1,78 @@ +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: secure + 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} + - 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/framework/src/test/resources/sample-test-invalid-schema-duplicate-name.yaml b/framework/src/test/resources/sample-test-invalid-schema-duplicate-name.yaml new file mode 100644 index 00000000..df4ed316 --- /dev/null +++ b/framework/src/test/resources/sample-test-invalid-schema-duplicate-name.yaml @@ -0,0 +1,85 @@ +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: 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} + - 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/framework/src/test/resources/sample-test-invalid-schema-duplicate-shortoption.yaml b/framework/src/test/resources/sample-test-invalid-schema-duplicate-shortoption.yaml new file mode 100644 index 00000000..519f6e3b --- /dev/null +++ b/framework/src/test/resources/sample-test-invalid-schema-duplicate-shortoption.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 + short_option: y + 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} + - 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/framework/src/test/resources/sample-test-invalid-schema.yaml b/framework/src/test/resources/sample-test-invalid-schema.yaml new file mode 100644 index 00000000..ed21772c --- /dev/null +++ b/framework/src/test/resources/sample-test-invalid-schema.yaml @@ -0,0 +1,78 @@ +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} + - 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/framework/src/test/resources/sample-test-schema-http.yaml b/framework/src/test/resources/sample-test-schema-http.yaml new file mode 100644 index 00000000..7bbf6775 --- /dev/null +++ b/framework/src/test/resources/sample-test-schema-http.yaml @@ -0,0 +1,90 @@ +onap_cmd_schema_version: 1.0 +name: sample-create-http +description: Register microservice into Onap +service: + name: msb + version: v1 +parameters: + - name: service-name + description: Onap service name + type: string + short_option: x + long_option: service-name + is_optional: false + - name: service-version + description: Onap service version + type: string + short_option: y + long_option: service-version + is_optional: false + - name: service-url + description: Onap service base url + type: url + short_option: r + long_option: service-url + is_optional: false + - name: status + description: Onap service status + type: long + short_option: z + long_option: service-status + is_optional: true + default_value: 1 + - name: node-ip + description: Onap service running node IP + type: string + - name: node-port + description: Onap service running node port + type: string + - name: create-or-update + description: Onap service create or update + type: bool + default_value: true +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}","version":"${service-version}","url":"${service-url}","protocol":"REST","visualRange":"1","lb_policy":"hash","nodes":[{"ip":"${node-ip}","port":"${node-port}","ttl":0}]}' + headers: + queries: + createOrUpdate: ${create-or-update} + 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/framework/src/test/resources/sample-test-schema-swagger.yaml b/framework/src/test/resources/sample-test-schema-swagger.yaml new file mode 100644 index 00000000..c88ddb7a --- /dev/null +++ b/framework/src/test/resources/sample-test-schema-swagger.yaml @@ -0,0 +1,26 @@ +onap_cmd_schema_version: 1.0 +name: sample-test-swagger +description: Sample swagger command test. +service: + name: sample + version: v1 +parameters: + - name: user + type: string + description: Onap user + short_option: n + long_option: username + is_optional: false +results: + direction: portrait + attributes: + - name: name + description: Onap user + scope: short + type: string +exec: + api: org.onap.common_services.auth.auth_service.client.api.DefaultApi + client: org.onap.common_services.auth.auth_service.client.invoker.ApiClient + entity: org.onap.common_services.auth.auth_service.client.model.User, username(userName), password, description + method: create + exception: org.onap.common_services.auth.auth_service.client.invoker.ApiException
\ No newline at end of file diff --git a/framework/src/test/resources/sample-test-schema.yaml b/framework/src/test/resources/sample-test-schema.yaml new file mode 100644 index 00000000..a480147d --- /dev/null +++ b/framework/src/test/resources/sample-test-schema.yaml @@ -0,0 +1,82 @@ +onap_cmd_schema_version: 1.0 +name: sample-test +description: Onap sample command to test the command features +service: + name: sample + version: v1 + no-auth: true +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 + is_secured: 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} + - 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 + is_secured: true + - name: output-2 + description: Onap output attribute marked in long + scope: short + is_secured: false + type: string
\ No newline at end of file diff --git a/framework/src/test/resources/schema-invalid-file-null.yaml b/framework/src/test/resources/schema-invalid-file-null.yaml new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/framework/src/test/resources/schema-invalid-file-null.yaml diff --git a/framework/src/test/resources/schema-invalid-file.yaml b/framework/src/test/resources/schema-invalid-file.yaml new file mode 100644 index 00000000..7b5937d5 --- /dev/null +++ b/framework/src/test/resources/schema-invalid-file.yaml @@ -0,0 +1,6 @@ +onap_cmd_schema_version: 1.0 +description: Register microservice into Onap +name: schema-validate +service:dasd + name: msbdsa + - name: service-name1
\ No newline at end of file diff --git a/framework/src/test/resources/schema-validate-basic.yaml b/framework/src/test/resources/schema-validate-basic.yaml new file mode 100644 index 00000000..80a9e1c6 --- /dev/null +++ b/framework/src/test/resources/schema-validate-basic.yaml @@ -0,0 +1,68 @@ +onap_cmd_schema_version: 1.0 +description: Register microservice into Onap +name: schema-validate +service: + name: msb +parameters: + - name: service-name1 + description: Onap service name + type: string + short_option: x + long_option: service-name + is_optional: false + - name: service-version + description: Onap service version + type: string + short_option: x + long_option: service-version + is_optional: false + - name: service-url + description: Onap service base url + type: url1 + short_option: u + long_option: service-url + is_optional: false1 + - name: status + description: Onap service status + type: long + short_option: z + long_option: service-version + is_optional: true + default_value: 1 + - name: node-ip + description: Onap service running node IP + type: string + - name: node-port + description: Onap service running node port + type: string + - name: create-or-update + description: Onap service create or update + type: cfbcv + default_value: true +results: + direction: portrait1 + attributes: + - name: name + description: Onap service name + scope: short + type: string + - name: version + description: Onap service version + scope: short + type: string + - name: status + description: Onap service base url + scope: short + type: url + - name: status + description: Onap service status + scope: short1 + type: long + - name: nodes + description: Onap service running nodes + scope: long + type: string + - name: location + description: Onap service location + scope: long + type: url
\ No newline at end of file diff --git a/framework/src/test/resources/schema-validate-http.yaml b/framework/src/test/resources/schema-validate-http.yaml new file mode 100644 index 00000000..82f44aed --- /dev/null +++ b/framework/src/test/resources/schema-validate-http.yaml @@ -0,0 +1,89 @@ +onap_cmd_schema_version: 1.0 +description: Register microservice into Onap +name: schema-validate +service: + name: msb +parameters: + - name: service-name1 + description: Onap service name + type: string + short_option: x + long_option: service-name + is_optional: false + - name: service-version + description: Onap service version + type: string + short_option: x + long_option: service-version + is_optional: false + - name: service-url + description: Onap service base url + type: url1 + short_option: u + long_option: service-url + is_optional: false1 + - name: status + description: Onap service status + type: long + short_option: z + long_option: service-version + is_optional: true + default_value: 1 + - name: node-ip + description: Onap service running node IP + type: string + - name: node-port + description: Onap service running node port + type: string + - name: create-or-update + description: Onap service create or update + type: cfbcv + default_value: true +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: status + description: Onap service base url + scope: short + type: url + - name: status + description: Onap service status + scope: short1 + 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: POST1 + body: '{"serviceName":"${service}","serviceName":"${service-name}","version":"${service-version}","url":"${service-url}","protocol":"REST","visualRange":"1","lb_policy":"hash","nodes":[{"ip":"${node-ip}","port":"${node-port}","ttl":0}]}' + headers: + queries: + createOrUpdate: ${create-or-update1} + success_codes: + - 201 + - 300 + result_map: + name: $b{$.serviceName} + version: $b{$.version} + url: $b{$.url} + status1: $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"} + diff --git a/framework/src/test/resources/schema-validate-invalid.yaml b/framework/src/test/resources/schema-validate-invalid.yaml new file mode 100644 index 00000000..61f3eeba --- /dev/null +++ b/framework/src/test/resources/schema-validate-invalid.yaml @@ -0,0 +1,151 @@ +onap_cmd_schema_version: 1.0 +name: sdnc-create +description: Register SDNC into Onap +service: + name: extsys + version: v1 +parameters: + - name: name + description: Onap SDNC name + scope: short + type: string + short_option: n + long_option: name + is_optional: false + - name: vendor + description: Onap SDNC vendor + scope: short + type: string + short_option: e + long_option: vendor + is_optional: false + - name: type + description: Onap SDNC type + scope: short + type: string + short_option: y + long_option: type + is_optional: false + - name: sdnc-version + description: Onap SDNC version + scope: short + type: string + short_option: r + long_option: sdnc-version + is_optional: false + - name: url + description: Onap SDNC base url + scope: short + type: url + short_option: l + long_option: url + is_optional: false + - name: description + description: Onap SDNC description + scope: short + type: string + short_option: i + long_option: description + is_optional: false + - name: username + description: Onap SDNC username + scope: short + type: string + short_option: g + long_option: username + is_optional: false + - name: password + description: Onap SDNC password + scope: short + type: string + is_secured: true + short_option: j + long_option: password + is_optional: false + - name: product-name + description: Onap SDNC product-name + scope: short + type: string + short_option: o + long_option: product-name + is_optional: false + - name: protocol + description: Onap SDNC protocol + scope: short + type: string + short_option: k + long_option: protocol + is_optional: false +results: + direction: portrait + attributes: + - name: id + description: Onap SDNC ID + scope: short + type: string + - name: name + description: Onap SDNC name + scope: short + type: string + - name: vendor + description: Onap SDNC vendor + scope: short + type: string + - name: type + description: Onap SDNC type + scope: short + type: string + - name: version + description: Onap SDNC version + scope: short + type: string + - name: url + description: Onap SDNC base url + scope: short + type: url + - name: description + description: Onap SDNC description + scope: short + type: string + - name: username + description: Onap SDNC username + scope: short + type: string + - name: password + description: Onap SDNC password + scope: short + type: string + is_secured: true + - name: product-name + description: Onap SDNC product name + scope: short + type: string + - name: protocol + description: Onap SDNC protocol + scope: short + type: string + - name: create-time + description: Onap SDNC create-time + scope: long + type: string +http: + request: + headers: + createOrUpdate: ${create-or-update1} + body: + success_codes: + result_map: + id: $b{$.sdnControllerId} + name: $b{$.name} + vendor: $b{$.vendor} + type: $b{$.type} + version: $b{$.version} + url: $b{$.url} + description: $b{$.description} + username: $b{$.userName} + password: $b{$.password} + protocol: $b{$.protocol} + product-name: $b{$.productName} + create-time: $b{$.createTime} + sample_response: + body: diff --git a/framework/src/test/resources/schema-validate-invalidschematype.yaml b/framework/src/test/resources/schema-validate-invalidschematype.yaml new file mode 100644 index 00000000..cacf9c06 --- /dev/null +++ b/framework/src/test/resources/schema-validate-invalidschematype.yaml @@ -0,0 +1,88 @@ +onap_cmd_schema_version: 1.0 +description: Register microservice into Onap +name: schema-validate +parameters: + - name: service-name1 + description: Onap service name + type: string + short_option: x + long_option: service-name + is_optional: false + - name: service-version + description: Onap service version + type: string + short_option: x + long_option: service-version + is_optional: false + - name: service-url + description: Onap service base url + type: url1 + short_option: u + long_option: service-url + is_optional: false1 + - name: status + description: Onap service status + type: long + short_option: z + long_option: service-version + is_optional: true + default_value: 1 + - name: node-ip + description: Onap service running node IP + type: string + - name: node-port + description: Onap service running node port + type: string + - name: create-or-update + description: Onap service create or update + type: cfbcv + default_value: true +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: status + description: Onap service base url + scope: short + type: url + - name: status + description: Onap service status + scope: short1 + 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: + method: POST + body: + headers: + queries: + createOrUpdate: ${create-or-update1} + success_codes: + - 201 + - 300 + result_map: + name: $b{$.serviceName} + version: $b{$.version} + url: $b{$.url} + status1: $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"} + diff --git a/framework/src/test/resources/schema-validate-pass.yaml b/framework/src/test/resources/schema-validate-pass.yaml new file mode 100644 index 00000000..91fb3141 --- /dev/null +++ b/framework/src/test/resources/schema-validate-pass.yaml @@ -0,0 +1,153 @@ +onap_cmd_schema_version: 1.0 +name: sdnc-create +description: Register SDNC into Onap +service: + name: extsys + version: v1 +parameters: + - name: name + description: Onap SDNC name + scope: short + type: string + short_option: n + long_option: name + is_optional: false + - name: vendor + description: Onap SDNC vendor + scope: short + type: string + short_option: e + long_option: vendor + is_optional: false + - name: type + description: Onap SDNC type + scope: short + type: string + short_option: y + long_option: type + is_optional: false + - name: sdnc-version + description: Onap SDNC version + scope: short + type: string + short_option: r + long_option: sdnc-version + is_optional: false + - name: url + description: Onap SDNC base url + scope: short + type: url + short_option: l + long_option: url + is_optional: false + - name: description + description: Onap SDNC description + scope: short + type: string + short_option: i + long_option: description + is_optional: false + - name: username + description: Onap SDNC username + scope: short + type: string + short_option: g + long_option: username + is_optional: false + - name: password + description: Onap SDNC password + scope: short + type: string + is_secured: true + short_option: j + long_option: password + is_optional: false + - name: product-name + description: Onap SDNC product-name + scope: short + type: string + short_option: o + long_option: product-name + is_optional: false + - name: protocol + description: Onap SDNC protocol + scope: short + type: string + short_option: k + long_option: protocol + is_optional: false +results: + direction: portrait + attributes: + - name: id + description: Onap SDNC ID + scope: short + type: string + - name: name + description: Onap SDNC name + scope: short + type: string + - name: vendor + description: Onap SDNC vendor + scope: short + type: string + - name: type + description: Onap SDNC type + scope: short + type: string + - name: version + description: Onap SDNC version + scope: short + type: string + - name: url + description: Onap SDNC base url + scope: short + type: url + - name: description + description: Onap SDNC description + scope: short + type: string + - name: username + description: Onap SDNC username + scope: short + type: string + - name: password + description: Onap SDNC password + scope: short + type: string + is_secured: true + - name: product-name + description: Onap SDNC product name + scope: short + type: string + - name: protocol + description: Onap SDNC protocol + scope: short + type: string + - name: create-time + description: Onap SDNC create-time + scope: long + type: string +http: + request: + headers: + createOrUpdate: ${create-or-update1} + body: {"name":"${name}","vendor":"${vendor}","version":"${sdnc-version}","description":"${description}","type":"${type}","url":"${url}","userName":"${username}","password":"${password}","productName":"${product-name}","protocol":"${protocol}"} + success_codes: + - 201 + - 200 + result_map: + id: $b{$.sdnControllerId} + name: $b{$.name} + vendor: $b{$.vendor} + type: $b{$.type} + version: $b{$.version} + url: $b{$.url} + description: $b{$.description} + username: $b{$.userName} + password: $b{$.password} + protocol: $b{$.protocol} + product-name: $b{$.productName} + create-time: $b{$.createTime} + sample_response: + body: '{"id":"string","name":"string","vendor":"string","version":"string","description":"string","type":"string","createTime":"string","url":"string","userName":"string","password":"string","productName":"string","protocol":"string"}' |