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.conf.OnapCommandConfg;
import org.onap.cli.fw.error.OnapCommandException;
import org.onap.cli.fw.error.OnapCommandHelpFailed;
import org.onap.cli.fw.error.OnapCommandInvalidParameterType;
this.cmdName = name;
}
+ public boolean isCommandInternal() {
+ return onapService.getName() != null
+ && onapService.getName().equalsIgnoreCase(OnapCommandConfg.getInternalCmd());
+ }
+
/*
* Onap service, this command uses to execute it. , defined by derived command
*/
* Any additional profile based such as http/swagger schema could be initialized.
*/
protected void initializeProfileSchema() throws OnapCommandException {
-
}
/*
try {
// login
OnapCredentials creds = OnapCommandUtils.fromParameters(this.getParameters());
- this.authClient = new OnapAuthClient(creds, this.getResult().isDebug());
+ boolean isAuthRequired = !this.onapService.isNoAuth()
+ && "true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue());
+
+ if (!isCommandInternal()) {
+ this.authClient = new OnapAuthClient(creds, this.getResult().isDebug());
+ }
- if (!this.onapService.isNoAuth()
- && !"true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue())) {
+ if (isAuthRequired) {
this.authClient.login();
}
this.run();
// logout
- if (!this.onapService.isNoAuth()
- && !"true".equals(paramMap.get(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH).getValue())) {
+ if (isAuthRequired) {
this.authClient.logout();
}
- if (this.cmdResult.isDebug()) {
+ if (this.cmdResult.isDebug() && authClient != null) {
this.cmdResult.setDebugInfo(this.authClient.getDebugInfo());
}
} catch (OnapCommandException e) {
- if (this.cmdResult.isDebug()) {
+ if (this.cmdResult.isDebug() && authClient != null) {
this.cmdResult.setDebugInfo(this.authClient.getDebugInfo());
}
throw e;
* http request failed
*/
public String getServiceBasePath(OnapService srv) throws OnapCommandException {
- if (srv.getName().equals(Constants.MSB)) {
+ if (srv.getName().equals(OnapCommandConfg.getApiGateway())) {
return this.getMsbUrl();
}
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 = "cli.auth_service";
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";
+ public static final String API_GATEWAY = "cli.api_gateway";
+ public static final String SERVICE_NAME = "cli.service_name";
//http
public static final String URI = "uri";
public static final String DESCRIPTION = "description";
public static final String SERVICE = "service";
public static final String PARAMETERS = "parameters";
+ public static final String DEFAULT_PARAMETERS = "default_parameters";
+ public static final String DEFAULT_PARAMETERS_INCLUDE = "include";
+ public static final String DEFAULT_PARAMETERS_EXCLUDE = "exclude";
+
public static final String RESULTS = "results";
public static final String ONAP_CMD_SCHEMA_VERSION = "onap_cmd_schema_version";
public static final String DEFAULT_SCHEMA_FILE_NAME = "default_input_parameters.yaml";
// Error message
+ public static final String SCHEMA_INVALID_DEFAULT_PARAMS_SECTION = "Invalid default parameter section";
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";
return prps.getProperty(Constants.HTTP_X_AUTH_TOKEN, "X-Auth-Token");
}
+ public static String getInternalCmd() {
+ return prps.getProperty(Constants.SERVICE_NAME);
+ }
+
+ public static String getApiGateway() {
+ return prps.getProperty(Constants.API_GATEWAY);
+ }
+
+ public static String getAuthService() {
+ return prps.getProperty(Constants.AUTH_SERVICE);
+ }
+
}
--- /dev/null
+/*
+ * 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 java.util.List;
+
+/**
+ * Invalid default parameter exception.
+ */
+public class OnapCommandInvalidDefaultParameter extends OnapCommandException {
+ private static final long serialVersionUID = -1833571383961748514L;
+
+ /**
+ * Invalid default argument exception.
+ *
+ * @param invalidParamsList message
+ */
+ public OnapCommandInvalidDefaultParameter(List<String> invalidParamsList) {
+ super("0x0024", "Invalid default parameter: " + invalidParamsList.toString());
+ }
+}
private static final long serialVersionUID = -3387652326582792833L;
+ public OnapCommandInvalidSchema(String error) {
+ this("", error);
+ }
+
public OnapCommandInvalidSchema(String schema, String error) {
super("0x0007", "Command schema " + schema + " is invalid, " + error);
}
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.error.OnapCommandHelpFailed;
import org.onap.cli.fw.error.OnapCommandHttpHeaderNotFound;
import org.onap.cli.fw.error.OnapCommandHttpInvalidResponseBody;
+import org.onap.cli.fw.error.OnapCommandInvalidDefaultParameter;
import org.onap.cli.fw.error.OnapCommandInvalidParameterType;
import org.onap.cli.fw.error.OnapCommandInvalidParameterValue;
import org.onap.cli.fw.error.OnapCommandInvalidPrintDirection;
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.ServiceLoader;
import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
/**
* Provides helper method to parse Yaml files and produce required objects.
/**
* Validates schema version.
*
- * @param schemaName
- * schema name
- * @param version
- * 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
+ * @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);
/**
* 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
+ * @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<>();
+ try {
+ Map<String, ?> defaultParameterMap = includeDefault ?
+ validateSchemaVersion(Constants.DEFAULT_PARAMETER_FILE_NAME, cmd.getSchemaVersion()) : new HashMap<>();
+ Map<String, List<Map<String, String>>> commandYamlMap = (Map<String, List<Map<String, String>>>)validateSchemaVersion(schemaName, cmd.getSchemaVersion());
- if (includeDefault) {
- loadSchema(cmd, Constants.DEFAULT_PARAMETER_FILE_NAME, shortOptions, longOptions, names);
- }
+ List<String> defParams = new ArrayList<>();
- loadSchema(cmd, schemaName, shortOptions, longOptions, names);
+ if (includeDefault) {
+ if (commandYamlMap.get(Constants.PARAMETERS) == null) {
+ commandYamlMap.put(Constants.PARAMETERS, (List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS));
+ } else {
+ commandYamlMap.get(Constants.PARAMETERS).addAll((List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS));
+ }
+ defParams = ((List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS)).stream()
+ .map(p -> p.get(Constants.NAME)).collect(Collectors.toList());
+ }
+ parseSchema(cmd, commandYamlMap, defParams);
+ } catch (OnapCommandException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new OnapCommandInvalidSchema(schemaName, e);
+ }
}
- 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());
+ private static void parseSchema(OnapCommand cmd,
+ final Map<String, ?> values,
+ final List<String> defaultParamNames) throws OnapCommandException {
+
+ List<String> shortOptions = new ArrayList<>();
+ List<String> longOptions = new ArrayList<>();
+ List<String> names = new ArrayList<>();
+ Set<String> filteredDefaultParams = new HashSet<>();
+
+ List<String> sections = Arrays.asList(Constants.NAME, Constants.DESCRIPTION, Constants.SERVICE,
+ Constants.DEFAULT_PARAMETERS, Constants.PARAMETERS, Constants.RESULTS);
- for (Map.Entry<String, ?> entry : values.entrySet()) {
- String key = entry.getKey();
+ for (String key : sections) {
- if (Constants.NAME.equals(key)) {
- Object val = values.get(key);
+ if (Constants.NAME.equals(key)) {
+ Object val = values.get(key);
+ if (val != null) {
cmd.setName(val.toString());
- } else if (Constants.DESCRIPTION.equals(key)) {
- Object val = values.get(key);
+ }
+ } else if (Constants.DESCRIPTION.equals(key)) {
+ Object val = values.get(key);
+ if (val != null) {
cmd.setDescription(val.toString());
- } else if (Constants.SERVICE.equals(key)) {
- Map<String, String> map = (Map<String, String>) values.get(key);
+ }
+ } else if (Constants.SERVICE.equals(key)) {
+ Map<String, String> map = (Map<String, String>) values.get(key);
+ if (map != null) {
OnapService srv = new OnapService();
for (Map.Entry<String, String> entry1 : map.entrySet()) {
}
cmd.setService(srv);
- } else if (Constants.PARAMETERS.equals(key)) {
- List<Map<String, String>> list = (ArrayList) values.get(key);
+ }
+ } else if (Constants.DEFAULT_PARAMETERS.equals(key)) {
+
+ Map<String, List<String>> defParameters = (Map) values.get(Constants.DEFAULT_PARAMETERS);
+
+ if (values.containsKey(Constants.DEFAULT_PARAMETERS) && defParameters == null) {
+ // if default parameter section is available then it must have either include
+ // or exclude sub-section.
+ throw new OnapCommandInvalidSchema(Constants.SCHEMA_INVALID_DEFAULT_PARAMS_SECTION);
+ }
+
+ if (defParameters != null) {
+ // validate default parameters
+ List<String> includeParams = defParameters.containsKey(Constants.DEFAULT_PARAMETERS_INCLUDE) ?
+ defParameters.get(Constants.DEFAULT_PARAMETERS_INCLUDE) : new ArrayList<>();
- for (Map<String, String> map : list) {
+ List<String> invInclude = includeParams.stream()
+ .filter(p -> !defaultParamNames.contains(p))
+ .collect(Collectors.toList());
+
+ List<String> excludeParams = defParameters.containsKey(Constants.DEFAULT_PARAMETERS_EXCLUDE) ?
+ defParameters.get(Constants.DEFAULT_PARAMETERS_EXCLUDE) : new ArrayList<>();
+
+ List<String> invExclude = excludeParams.stream()
+ .filter(p -> !defaultParamNames.contains(p))
+ .collect(Collectors.toList());
+
+ if (!invExclude.isEmpty() || !invInclude.isEmpty()) {
+ throw new OnapCommandInvalidDefaultParameter(Stream.concat(invInclude.stream(), invExclude.stream())
+ .collect(Collectors.toList()));
+ }
+
+ if (!includeParams.isEmpty()) {
+ filteredDefaultParams.addAll(includeParams);
+ } else if (!excludeParams.isEmpty()) {
+ defaultParamNames.stream().filter(p -> !excludeParams.contains(p))
+ .forEach(filteredDefaultParams::add);
+ }
+ } else {
+ filteredDefaultParams.addAll(defaultParamNames);
+
+ }
+
+ } else if (Constants.PARAMETERS.equals(key)) {
+
+ List<Map<String, String>> parameters = (List) values.get(key);
+
+ if (parameters != null) {
+ for (Map<String, String> map : parameters) {
OnapCommandParameter param = new OnapCommandParameter();
for (Map.Entry<String, String> entry1 : map.entrySet()) {
}
}
}
- cmd.getParameters().add(param);
+ // Add the element to command :
+ // 1. if parameter is available in filtered parameter list.
+ // 2. otherwise, parameter p is available in command yaml file.
+ if (filteredDefaultParams.contains(param.getName()) || !defaultParamNames.contains(param.getName())) {
+ cmd.getParameters().add(param);
+ }
}
- } else if (Constants.RESULTS.equals(key)) {
- Map<String, ?> valueMap = (Map<String, ?>) values.get(key);
+ }
+ } else if (Constants.RESULTS.equals(key)) {
+ Map<String, ?> valueMap = (Map<String, ?>) values.get(key);
+ if (valueMap != null) {
OnapCommandResult result = new OnapCommandResult();
for (Map.Entry<String, ?> entry1 : valueMap.entrySet()) {
String key3 = entry1.getKey();
cmd.setResult(result);
}
}
- } catch (OnapCommandException e) {
- throw e;
- } catch (Exception e) {
- throw new OnapCommandInvalidSchema(schemaName, e);
}
}
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
+http.api_key_use_cookies=true
+
+cli.service_name=onap-cli
+cli.api_gateway=msb
+cli.auth_service=auth
\ No newline at end of file
no-auth: true
name: onap-cli
version: 1.0.0
+default_parameters:
+ exclude:
+ - onap-username
+ - onap-password
+ - msb-url
+ - no-auth
results:
direction: landscape
attributes:
no-auth: true
name: onap-cli
version: 1.0.0
+default_parameters:
+ exclude:
+ - onap-username
+ - onap-password
+ - msb-url
+ - no-auth
parameters:
- name: schema-location
type: url
import org.junit.Test;
import org.onap.cli.fw.error.OnapCommandException;
-import org.onap.cli.fw.input.OnapCommandParameter;
+import org.onap.cli.fw.output.OnapCommandResultAttribute;
+
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
public class OnapSchemaRefreshCommandTest {
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();
+ List<OnapCommandResultAttribute> onapCommandResultAttribute = cmd.getResult()
+ .getRecords();
+
+ String s1Number = onapCommandResultAttribute.get(0).getValues().get(0);
+ String cmdName = onapCommandResultAttribute.get(1).getValues().get(0);
+ String cmdFile = onapCommandResultAttribute.get(2).getValues().get(0);
+ String version = onapCommandResultAttribute.get(3).getValues().get(0);
+
+ assertTrue(s1Number.equalsIgnoreCase("1"));
+ assertTrue(cmdName.equalsIgnoreCase("sample-test1"));
+ assertTrue(cmdFile.equalsIgnoreCase("sample-test1-schema-http.yaml"));
+ assertTrue(version.equalsIgnoreCase("1.0"));
+
}
}
--- /dev/null
+/*
+ * 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.defaultParameter;
+
+import org.junit.Test;
+import org.onap.cli.fw.OnapCommand;
+import org.onap.cli.fw.error.OnapCommandException;
+import org.onap.cli.fw.error.OnapCommandInvalidDefaultParameter;
+import org.onap.cli.fw.error.OnapCommandInvalidSchema;
+import org.onap.cli.fw.utils.OnapCommandUtils;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class TestDefaultParameterSection {
+ @Test
+ public void checkOnlyInclude() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true);
+ List<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
+ assertTrue(parameters.contains("onap-username"));
+ assertTrue(parameters.contains("onap-password"));
+ assertTrue(parameters.contains("msb-url"));
+ }
+
+ @Test
+ public void checkOnlyExclude() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-exclude-param.yaml", true);
+ List<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
+ assertFalse(parameters.contains("onap-username"));
+ assertTrue(parameters.contains("onap-password"));
+ assertFalse(parameters.contains("msb-url"));
+ }
+
+ @Test
+ public void checkBothIncludeAndExclude() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-include-exclude.yaml", true);
+ List<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
+
+ assertTrue(parameters.contains("onap-username"));
+ assertFalse(parameters.contains("onap-password"));
+ assertFalse(parameters.contains("msb-url"));
+ }
+
+ @Test
+ public void checkDefaultSectionAbsent() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "onap-test-schema.yaml", true);
+ List<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
+
+ assertTrue(parameters.contains("onap-username"));
+ assertTrue(parameters.contains("onap-password"));
+ assertTrue(parameters.contains("msb-url"));
+ }
+
+ @Test(expected = OnapCommandInvalidDefaultParameter.class)
+ public void checkInvalidDefaultArgument() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-parameter.yaml", true);
+ }
+
+ @Test(expected = OnapCommandInvalidDefaultParameter.class)
+ public void checkInvalidDefaultArgumentNotExist() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-params-not-exist.yaml", true);
+ }
+
+ @Test(expected = OnapCommandInvalidSchema.class)
+ public void checkDefaltwithNoExcludeAndInclude() throws OnapCommandException {
+ OnapCommand cmd = new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {}
+ };
+
+ OnapCommandUtils.loadSchema(cmd, "sample-test-import-def-param-false.yaml", true);
+ }
+}
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
+http.api_key_use_cookies=true
+
+cli.service_name=onap-cli
+cli.api_gateway=msb
+cli.auth_service=auth
\ No newline at end of file
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
+ exclude:
+ - onap-username
+ - msb-url
\ No newline at end of file
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
+ include:
+ - onap-username
+ exclude:
+ - msb-url
\ No newline at end of file
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
+ include:
+ - onap-username
+ - onap-password
+ - msb-url
\ No newline at end of file
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
+ exclude:
+ - invalid-param
+parameters:
+ - name: invalid-param
+ type: bool
+ description: Onap boolean param, by default its always false.
+ short_option: b
+ long_option: bool
+ is_optional: true
+ default_value: false
\ No newline at end of file
--- /dev/null
+onap_cmd_schema_version: 1.0
+default_parameters:
+ exclude:
+ - invalid-param-1
\ No newline at end of file
for (String cmdName : cmdSchemaMap.keySet()) {
System.out.println(
"************************* '" + cmdSchemaMap.get(cmdName) + "' *******************************");
- this.handle(new String[] { "schema-validate", "-l", cmdSchemaMap.get(cmdName), "-i", "true", "-m",
- "http://192.168.4.47:80", "-u", "root1", "-p", "root123" });
+ this.handle(new String[] { "schema-validate", "-l", cmdSchemaMap.get(cmdName), "-i"});
}
}
Code Review / cli.git / commitdiff