From 8d3d394a5effe4127e8480c812de82d81fe5e5ae Mon Sep 17 00:00:00 2001 From: subhash kumar singh Date: Fri, 18 Aug 2017 12:13:23 +0530 Subject: Move schema validation to load schema Move schema validation to load schema. Issue-Id: CLI-25 Change-Id: I8fdb8450f6f95b7170c10b0ec5883162a4cf406a Signed-off-by: subhash kumar singh --- .../src/main/java/org/onap/cli/fw/OnapCommand.java | 9 +- .../java/org/onap/cli/fw/cmd/OnapHttpCommand.java | 2 +- .../onap/cli/fw/cmd/OnapSchemaValidateCommand.java | 20 +- .../onap/cli/fw/schema/AbstractSchemaValidate.java | 563 ----------------- .../org/onap/cli/fw/schema/SchemaValidate.java | 324 ---------- .../org/onap/cli/fw/schema/SchemaValidator.java | 292 --------- .../org/onap/cli/fw/utils/OnapCommandUtils.java | 685 +++++++++++++++++---- .../java/org/onap/cli/fw/TestCommandValidate.java | 4 +- .../TestDefaultParameterSection.java | 18 +- .../org/onap/cli/fw/schema/ValidateSchemaTest.java | 144 +++-- .../onap/cli/fw/utils/OnapCommandUtilsTest.java | 24 +- 11 files changed, 683 insertions(+), 1402 deletions(-) delete mode 100644 framework/src/main/java/org/onap/cli/fw/schema/AbstractSchemaValidate.java delete mode 100644 framework/src/main/java/org/onap/cli/fw/schema/SchemaValidate.java delete mode 100644 framework/src/main/java/org/onap/cli/fw/schema/SchemaValidator.java (limited to 'framework/src') diff --git a/framework/src/main/java/org/onap/cli/fw/OnapCommand.java b/framework/src/main/java/org/onap/cli/fw/OnapCommand.java index 1cc78f23..78ab5517 100644 --- a/framework/src/main/java/org/onap/cli/fw/OnapCommand.java +++ b/framework/src/main/java/org/onap/cli/fw/OnapCommand.java @@ -43,6 +43,7 @@ import org.onap.cli.fw.utils.OnapCommandUtils; import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; /** @@ -170,7 +171,7 @@ public abstract class OnapCommand { */ public void initializeSchema(String schema) throws OnapCommandException { this.setSchemaName(schema); - OnapCommandUtils.loadSchema(this, schema, true); + OnapCommandUtils.loadSchema(this, schema, true, false); this.initializeProfileSchema(); this.isInitialzied = true; } @@ -190,10 +191,10 @@ public abstract class OnapCommand { param.validate(); } catch (OnapCommandParameterMissing e) { if (OnapCommandConfg.getExcludeParamsForNoAuthEnableExternalCmd().contains(param.getName())) { - OnapCommandParameter noAuthParam = this.getParameters().stream().filter(p -> p.getName() - .equalsIgnoreCase(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH)).findFirst().get(); + Optional noAuthParamOpt = this.getParameters().stream().filter(p -> p.getName() + .equalsIgnoreCase(Constants.DEFAULT_PARAMETER_OUTPUT_NO_AUTH)).findFirst(); - if ("true".equalsIgnoreCase(noAuthParam.getValue().toString())) { + if (noAuthParamOpt.isPresent() && "true".equalsIgnoreCase(noAuthParamOpt.get().getValue().toString())) { continue; } } 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 index d5f51f00..9438102f 100644 --- a/framework/src/main/java/org/onap/cli/fw/cmd/OnapHttpCommand.java +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapHttpCommand.java @@ -73,7 +73,7 @@ public class OnapHttpCommand extends OnapCommand { @Override protected void initializeProfileSchema() throws OnapCommandException { - OnapCommandUtils.loadSchema(this, this.getSchemaName()); + OnapCommandUtils.loadHTTPSchemaSection(this, this.getSchemaName(), false); } @Override 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 index a4d4e7d4..b1811483 100644 --- a/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommand.java +++ b/framework/src/main/java/org/onap/cli/fw/cmd/OnapSchemaValidateCommand.java @@ -20,17 +20,14 @@ 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 org.onap.cli.fw.utils.OnapCommandUtils; -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 { @@ -42,15 +39,20 @@ public class OnapSchemaValidateCommand extends OnapCommand { 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 error = schema.validate(); + List error = OnapCommandUtils.loadSchema(new OnapCommand() { + @Override + protected void run() throws OnapCommandException { + } + }, location, true, true); + + + error.addAll(OnapCommandUtils.loadHTTPSchemaSection(new OnapHttpCommand(), + location, true)); + List slNumber = new ArrayList<>(); for (int i = 1; i <= error.size(); i++) { slNumber.add(String.valueOf(i)); 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 deleted file mode 100644 index 1b0a2beb..00000000 --- a/framework/src/main/java/org/onap/cli/fw/schema/AbstractSchemaValidate.java +++ /dev/null @@ -1,563 +0,0 @@ -/* - * 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 schemaErrors = new ArrayList<>(); - protected Map yamlMap = new HashMap<>(); - protected Map defaultYamlMap = new HashMap<>(); - - protected static final List HTTP_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION, - SERVICE, PARAMETERS, RESULTS, HTTP); - - protected static final List HTTP_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, - DESCRIPTION, SERVICE, HTTP); - protected static final List BASIC_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION, - PARAMETERS, RESULTS); - - protected static final List BASIC_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, - DESCRIPTION, PARAMETERS); - - protected static final List TOP_LEVEL_PARAMS_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, - DESCRIPTION); - - protected static final List TOP_LEVEL_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, - DESCRIPTION); - - protected static final List SERVICE_PARAMS_LIST = Arrays.asList(NAME, VERSION, AUTH); - - protected static final List SERVICE_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, VERSION); - - protected static final List INPUT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION, - LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED); - - protected static final List INPUT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE); - - protected static final List 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 RESULT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION, - LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED); - - protected static final List RESULT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE); - - protected static final List HTTP_PARAMS_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); - - protected static final List HTTP_PARAMS_MANDATORY_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); - - protected static final List HTTP_MANDATORY_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES); - - protected static final List HTTP_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES, RESULT_MAP, - SAMPLE_RESPONSE); - - protected static final List HTTP_REQUEST_MANDATORY_PARAMS = Arrays.asList(URI, METHOD); - - protected static final List HTTP_REQUEST_PARAMS = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES); - - protected static final List BOOLEAN_VALUES = Arrays.asList(BOOLEAN_TRUE, BOOLEAN_FALSE); - protected static final List DIRECTIONS = Arrays.asList(DIRECTION_PORTRAIT, DIRECTION_LANDSCAPE); - protected static final List RESULT_SCOPES = Arrays.asList(RESULT_SCOPE_SHORT, RESULT_SCOPE_LONG); - - protected static final List 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) 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) 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 validate() throws OnapCommandInvalidSchema { - - SchemaType type; - Set 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> resultAttributes) { - Set resultParamNames = new HashSet<>(); - for (Map 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 resultParams = (Map) 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> resultAttributes = (List>) resultParams.get(ATTRIBUTES); - validateResultAttributes(resultAttributes); - } - - /** - * Get all default short options. - * - * @return set - */ - protected Set getDefaultShortOptions() { - - Set set = new HashSet<>(); - - @SuppressWarnings("unchecked") - List> inputParams = (List>) defaultYamlMap.get(PARAMETERS); - for (Map 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 getDefaultLongOptions() { - - Set set = new HashSet<>(); - - @SuppressWarnings("unchecked") - List> inputParams = (List>) defaultYamlMap.get(PARAMETERS); - for (Map 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 serviceMap = (Map) 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(AUTH)) { - Object obj = serviceMap.get(AUTH); - if (obj == null) { - schemaErrors.add(SchemaValidate.emptyValue(SERVICE, AUTH)); - } else { - String value = String.valueOf(obj); - if (validateBoolean(value)) { - schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(SERVICE, AUTH, value)); - } - } - } - - } - - private void validateInputParameters() { - - @SuppressWarnings("unchecked") - List> inputParams = (List>) yamlMap.get(PARAMETERS); - if (inputParams == null) { - return; - } - validateInputAttributes(inputParams); - } - - protected abstract void validateSpecificSchema(SchemaType type) throws OnapCommandInvalidSchema; - - private void validateInputAttributes(List> inputParams) { - Set inputParamNames = new HashSet<>(); - Set inputShortOptions = new HashSet<>(); - Set inputLongOptions = new HashSet<>(); - - Set defaultShortOptions = getDefaultShortOptions(); - Set defaultLongOptions = getDefaultLongOptions(); - - for (Map 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 yamlMap, List totalParams, - List 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 getResultAttributes() { - - Set set = new HashSet<>(); - - List> resultAttributes = yamlMap.get(RESULTS) != null - ? (List>) ((Map) yamlMap.get(RESULTS)).get(ATTRIBUTES) - : Collections.emptyList(); - - if (resultAttributes != null) { - for (Map map : resultAttributes) { - for (Entry 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 getRequestParams() { - - Set set = new HashSet<>(); - - @SuppressWarnings("unchecked") - List> inputParams = (List>) yamlMap.get(PARAMETERS); - - if (inputParams != null) { - for (Map map : inputParams) { - for (Entry 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 deleted file mode 100644 index 27bc4661..00000000 --- a/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidate.java +++ /dev/null @@ -1,324 +0,0 @@ -/* - * 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 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 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 mainSections, List http, List 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 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 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 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 deleted file mode 100644 index bb1248b9..00000000 --- a/framework/src/main/java/org/onap/cli/fw/schema/SchemaValidator.java +++ /dev/null @@ -1,292 +0,0 @@ -/* - * 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 httpMap = (Map) yamlMap.get(HTTP); - - if (httpMap == null || httpMap.isEmpty()) { - schemaErrors.add(HTTP_SECTION_EMPTY); - return; - } - - validateMandatoryParams(httpMap, HTTP_SECTIONS, HTTP_MANDATORY_SECTIONS, PARAMETERS); - - Map requestMap = (Map) httpMap.get(REQUEST); - - if (requestMap != null && !requestMap.isEmpty()) { - validateHttpRequestParams(requestMap); - } else { - schemaErrors.add(SchemaValidate.emptySection(REQUEST)); - } - - List requestSuccessCodes = (List) httpMap.get(SUCCESS_CODES); - if (requestSuccessCodes != null && !requestSuccessCodes.isEmpty()) { - validateHttpSccessCodes(requestSuccessCodes); - } else { - schemaErrors.add(SchemaValidate.emptySection(SUCCESS_CODES)); - } - - Map resultMap = (Map) 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) object); - } - } - } - - private void validateHttpRequestParams(Map 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 requestParams = getRequestParams(); - - // validate uriParams - Set uriParams = validateHttpUri(requestMap); - - // validate body - Set bodyParams = validateHttpBody(requestMap); - - // validate header - Set headerParams = validateHttpHeaders(requestMap); - - // validate queries - Set 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 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 validateHttpUri(Map requestMap) { - Set 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 validateHttpHeaders(Map requestMap) { - - Map headers = (Map) requestMap.get(HEADERS); - Set headerParamNames = new HashSet<>(); - if (headers != null) { - for (Entry entry : headers.entrySet()) { - parseParameters(String.valueOf(entry.getValue()), headerParamNames); - } - } - return headerParamNames; - } - - @SuppressWarnings("unchecked") - private Set validateHttpQueries(Map requestMap) { - Map queries = (Map) requestMap.get(QUERIES); - Set queryParamNames = new HashSet<>(); - if (queries != null) { - for (Entry entry : queries.entrySet()) { - parseParameters(String.valueOf(entry.getValue()), queryParamNames); - } - } - return queryParamNames; - } - - private Set validateHttpBody(Map requestMap) { - Set 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 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 requestSuccessCodes) { - - for (Object successCode : requestSuccessCodes) { - Integer code = (Integer) successCode; - if (code < 200 || code >= 300) { - schemaErrors.add(HTTP_SUCCESS_CODE_INVALID); - } - } - - } - - private void validateHttpResultMapping(Map resultMap) { - Set 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 entry : resultMap.entrySet()) { - if (!resultAttributes.contains(entry.getKey())) { - schemaErrors.add(SchemaValidate.missingInResultAttribute(entry.getKey())); - } - } - } - - private void validateSampleResponse(Map 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/OnapCommandUtils.java b/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java index 512d0b22..b6e64f2a 100644 --- a/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java +++ b/framework/src/main/java/org/onap/cli/fw/utils/OnapCommandUtils.java @@ -19,6 +19,7 @@ package org.onap.cli.fw.utils; import com.fasterxml.jackson.databind.ObjectMapper; import com.jayway.jsonpath.JsonPath; import net.minidev.json.JSONArray; +import net.minidev.json.JSONObject; import org.onap.cli.fw.OnapCommand; import org.onap.cli.fw.ad.OnapCredentials; import org.onap.cli.fw.ad.OnapService; @@ -31,6 +32,7 @@ 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.OnapCommandHttpInvalidResultMap; import org.onap.cli.fw.error.OnapCommandInvalidDefaultParameter; import org.onap.cli.fw.error.OnapCommandInvalidParameterType; import org.onap.cli.fw.error.OnapCommandInvalidParameterValue; @@ -60,6 +62,8 @@ import org.springframework.core.io.support.ResourcePatternResolver; import org.yaml.snakeyaml.Yaml; import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; @@ -75,6 +79,75 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; +import static org.onap.cli.fw.conf.Constants.API; +import static org.onap.cli.fw.conf.Constants.ATTRIBUTES; +import static org.onap.cli.fw.conf.Constants.AUTH; +import static org.onap.cli.fw.conf.Constants.AUTH_VALUES; +import static org.onap.cli.fw.conf.Constants.BODY; +import static org.onap.cli.fw.conf.Constants.BOOLEAN_VALUE; +import static org.onap.cli.fw.conf.Constants.CLIENT; +import static org.onap.cli.fw.conf.Constants.DEAFULT_PARAMETER_HOST_URL; +import static org.onap.cli.fw.conf.Constants.DEAFULT_PARAMETER_PASS_WORD; +import static org.onap.cli.fw.conf.Constants.DEAFULT_PARAMETER_USERNAME; +import static org.onap.cli.fw.conf.Constants.DEFAULT_PARAMETERS; +import static org.onap.cli.fw.conf.Constants.DEFAULT_PARAMETERS_EXCLUDE; +import static org.onap.cli.fw.conf.Constants.DEFAULT_PARAMETERS_INCLUDE; +import static org.onap.cli.fw.conf.Constants.DEFAULT_PARAMETER_FILE_NAME; +import static org.onap.cli.fw.conf.Constants.DEFAULT_VALUE; +import static org.onap.cli.fw.conf.Constants.DESCRIPTION; +import static org.onap.cli.fw.conf.Constants.DIRECTION; +import static org.onap.cli.fw.conf.Constants.ENTITY; +import static org.onap.cli.fw.conf.Constants.EXCEPTION; +import static org.onap.cli.fw.conf.Constants.EXECUTOR; +import static org.onap.cli.fw.conf.Constants.EXTERNAL_DISCOVERY_DIRECTORY; +import static org.onap.cli.fw.conf.Constants.EXTERNAL_DISCOVERY_DIRECTORY_PATTERN; +import static org.onap.cli.fw.conf.Constants.EXTERNAL_DISCOVERY_FILE; +import static org.onap.cli.fw.conf.Constants.EXTERNAL_SCHEMA_DIRECTORY; +import static org.onap.cli.fw.conf.Constants.EXTERNAL_SCHEMA_PATH_PATERN; +import static org.onap.cli.fw.conf.Constants.HEADERS; +import static org.onap.cli.fw.conf.Constants.HTTP; +import static org.onap.cli.fw.conf.Constants.HTTP_BODY_FAILED_PARSING; +import static org.onap.cli.fw.conf.Constants.HTTP_BODY_JSON_EMPTY; +import static org.onap.cli.fw.conf.Constants.HTTP_MANDATORY_SECTIONS; +import static org.onap.cli.fw.conf.Constants.HTTP_METHODS; +import static org.onap.cli.fw.conf.Constants.HTTP_REQUEST_MANDATORY_PARAMS; +import static org.onap.cli.fw.conf.Constants.HTTP_REQUEST_PARAMS; +import static org.onap.cli.fw.conf.Constants.HTTP_SECTIONS; +import static org.onap.cli.fw.conf.Constants.HTTP_SUCCESS_CODE_INVALID; +import static org.onap.cli.fw.conf.Constants.INPUT_PARAMS_LIST; +import static org.onap.cli.fw.conf.Constants.INPUT_PARAMS_MANDATORY_LIST; +import static org.onap.cli.fw.conf.Constants.IS_OPTIONAL; +import static org.onap.cli.fw.conf.Constants.IS_SECURED; +import static org.onap.cli.fw.conf.Constants.LONG_OPTION; +import static org.onap.cli.fw.conf.Constants.MERHOD; +import static org.onap.cli.fw.conf.Constants.METHOD; +import static org.onap.cli.fw.conf.Constants.MODE; +import static org.onap.cli.fw.conf.Constants.MODE_VALUES; +import static org.onap.cli.fw.conf.Constants.NAME; +import static org.onap.cli.fw.conf.Constants.ONAP_CMD_SCHEMA_VERSION; +import static org.onap.cli.fw.conf.Constants.PARAMETERS; +import static org.onap.cli.fw.conf.Constants.QUERIES; +import static org.onap.cli.fw.conf.Constants.REQUEST; +import static org.onap.cli.fw.conf.Constants.RESULTS; +import static org.onap.cli.fw.conf.Constants.RESULT_MAP; +import static org.onap.cli.fw.conf.Constants.RESULT_PARAMS_LIST; +import static org.onap.cli.fw.conf.Constants.RESULT_PARAMS_MANDATORY_LIST; +import static org.onap.cli.fw.conf.Constants.SAMPLE_RESPONSE; +import static org.onap.cli.fw.conf.Constants.SCHEMA_FILE_NOT_EXIST; +import static org.onap.cli.fw.conf.Constants.SCHEMA_FILE_WRONG_EXTN; +import static org.onap.cli.fw.conf.Constants.SCHEMA_INVALID_DEFAULT_PARAMS_SECTION; +import static org.onap.cli.fw.conf.Constants.SCOPE; +import static org.onap.cli.fw.conf.Constants.SERVICE; +import static org.onap.cli.fw.conf.Constants.SERVICE_PARAMS_LIST; +import static org.onap.cli.fw.conf.Constants.SERVICE_PARAMS_MANDATORY_LIST; +import static org.onap.cli.fw.conf.Constants.SHORT_OPTION; +import static org.onap.cli.fw.conf.Constants.SUCCESS_CODES; +import static org.onap.cli.fw.conf.Constants.TOP_LEVEL_MANDATORY_LIST; +import static org.onap.cli.fw.conf.Constants.TOP_LEVEL_PARAMS_LIST; +import static org.onap.cli.fw.conf.Constants.TYPE; +import static org.onap.cli.fw.conf.Constants.URI; +import static org.onap.cli.fw.conf.Constants.VERSION; + /** * Provides helper method to parse Yaml files and produce required objects. * @@ -102,7 +175,7 @@ public class OnapCommandUtils { InputStream inputStream = OnapCommandUtils.class.getClassLoader().getResourceAsStream(schemaName); try { - Resource resource = getExternalResource(schemaName, Constants.EXTERNAL_SCHEMA_PATH_PATERN); + Resource resource = getExternalResource(schemaName, EXTERNAL_SCHEMA_PATH_PATERN); if (resource != null) { inputStream = resource.getInputStream(); @@ -112,7 +185,7 @@ public class OnapCommandUtils { throw new OnapCommandSchemaNotFound(schemaName, e); } if (inputStream == null) { - throw new OnapCommandSchemaNotFound(schemaName); + inputStream = loadSchemaFromFile(schemaName); } Map values = null; @@ -122,8 +195,8 @@ public class OnapCommandUtils { 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); + if (values.keySet().contains(ONAP_CMD_SCHEMA_VERSION)) { + Object obj = values.get(ONAP_CMD_SCHEMA_VERSION); schemaVersion = obj.toString(); } @@ -134,12 +207,30 @@ public class OnapCommandUtils { return values; } + private static InputStream loadSchemaFromFile(String schemaLocation) throws OnapCommandInvalidSchema { + File schemaFile = new File(schemaLocation); + try { + FileInputStream inputFileStream = new FileInputStream(schemaFile); + if (!schemaFile.isFile()) { + throw new OnapCommandInvalidSchema(schemaFile.getName(), SCHEMA_FILE_NOT_EXIST); + } + + if (!schemaFile.getName().endsWith(".yaml")) { + throw new OnapCommandInvalidSchema(schemaFile.getName(), SCHEMA_FILE_WRONG_EXTN); + } + return inputFileStream; + }catch (FileNotFoundException e) { + throw new OnapCommandInvalidSchema(schemaFile.getName(), e); + } + } + /** * Retrieve OnapCommand from schema. * * @param cmd OnapCommand * @param schemaName schema name * @param includeDefault include if default + * @param validateSchema flag to represent validation * @throws OnapCommandParameterNameConflict param name conflict exception * @throws OnapCommandParameterOptionConflict param option conflict exception * @throws OnapCommandInvalidParameterType invalid param type exception @@ -149,26 +240,26 @@ public class OnapCommandUtils { * @throws OnapCommandInvalidSchema invalid schema * @throws OnapCommandInvalidSchemaVersion invalid schema version */ - public static void loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault) - throws OnapCommandException { + public static List loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault, + boolean validateSchema) throws OnapCommandException { try { Map defaultParameterMap = includeDefault ? - validateSchemaVersion(Constants.DEFAULT_PARAMETER_FILE_NAME, cmd.getSchemaVersion()) : new HashMap<>(); + validateSchemaVersion(DEFAULT_PARAMETER_FILE_NAME, cmd.getSchemaVersion()) : new HashMap<>(); Map>> commandYamlMap = (Map>>)validateSchemaVersion(schemaName, cmd.getSchemaVersion()); List defParams = new ArrayList<>(); if (includeDefault) { - if (commandYamlMap.get(Constants.PARAMETERS) == null) { - commandYamlMap.put(Constants.PARAMETERS, (List>) defaultParameterMap.get(Constants.PARAMETERS)); + if (commandYamlMap.get(PARAMETERS) == null) { + commandYamlMap.put(PARAMETERS, (List>) defaultParameterMap.get(PARAMETERS)); } else { - commandYamlMap.get(Constants.PARAMETERS).addAll((List>) defaultParameterMap.get(Constants.PARAMETERS)); + commandYamlMap.get(PARAMETERS).addAll((List>) defaultParameterMap.get(PARAMETERS)); } - defParams = ((List>) defaultParameterMap.get(Constants.PARAMETERS)).stream() - .map(p -> p.get(Constants.NAME)).collect(Collectors.toList()); + defParams = ((List>) defaultParameterMap.get(PARAMETERS)).stream() + .map(p -> p.get(NAME)).collect(Collectors.toList()); } - parseSchema(cmd, commandYamlMap, defParams); + return parseSchema(cmd, commandYamlMap, defParams, validateSchema); } catch (OnapCommandException e) { throw e; } catch (Exception e) { @@ -212,80 +303,152 @@ public class OnapCommandUtils { } } - private static void parseSchema(OnapCommand cmd, - final Map values, - final List defaultParamNames) throws OnapCommandException { + private static void throwOrCollect(OnapCommandException ex, List list, + boolean shouldCollectException) throws OnapCommandException { + if (shouldCollectException) { + list.add(ex.getMessage()); + } else { + throw ex; + } + } + + private static void validateTags(List schemaErrors, Map yamlMap, + List totalParams, List mandatoryParams, + String section) { + for (String param : totalParams) { + boolean isMandatory = mandatoryParams.contains(param); + boolean isYamlContains = yamlMap.containsKey(param); + if (isMandatory) { + if (!isYamlContains) { + schemaErrors.add("Mandatory attribute '" + param + "' is missing under '" + section + "'"); + } else { + String value = String.valueOf(yamlMap.get(param)); + if (value == null || value.isEmpty()) { + schemaErrors.add("Mandatory attribute '" + param + "' under '" + section + + "' shouldn't be null or empty"); + } + } + } + } + } + /** + * Validate Boolean. + * + * @param toValidate + * string + * @return boolean + */ + protected static boolean validateBoolean(String toValidate) { + return OnapCommandConfg.getSchemaAttrInfo(BOOLEAN_VALUE).contains(toValidate.toLowerCase()); + } + + private static List parseSchema(OnapCommand cmd, + final Map values, + final List defaultParamNames, + boolean validate) throws OnapCommandException { + + List exceptionList = new ArrayList<>(); List shortOptions = new ArrayList<>(); List longOptions = new ArrayList<>(); - List names = new ArrayList<>(); Set filteredDefaultParams = new HashSet<>(); - List sections = Arrays.asList(Constants.NAME, Constants.DESCRIPTION, Constants.SERVICE, - Constants.DEFAULT_PARAMETERS, Constants.PARAMETERS, Constants.RESULTS); + if (validate) { + validateTags(exceptionList, (Map) values, OnapCommandConfg.getSchemaAttrInfo(TOP_LEVEL_PARAMS_LIST), + OnapCommandConfg.getSchemaAttrInfo(TOP_LEVEL_MANDATORY_LIST), "root level"); + } + + + List sections = Arrays.asList(NAME, DESCRIPTION, SERVICE, + DEFAULT_PARAMETERS, PARAMETERS, RESULTS); for (String key : sections) { - if (Constants.NAME.equals(key)) { + if (NAME.equals(key) && values.containsKey(key)) { Object val = values.get(key); if (val != null) { cmd.setName(val.toString()); } - } else if (Constants.DESCRIPTION.equals(key)) { + } else if (DESCRIPTION.equals(key) && values.containsKey(key)) { Object val = values.get(key); if (val != null) { cmd.setDescription(val.toString()); } - } else if (Constants.SERVICE.equals(key)) { + } else if (SERVICE.equals(key) && values.containsKey(key)) { Map map = (Map) values.get(key); + + if (validate) { + validateTags(exceptionList, (Map)values.get(key), + OnapCommandConfg.getSchemaAttrInfo(SERVICE_PARAMS_LIST), + OnapCommandConfg.getSchemaAttrInfo(SERVICE_PARAMS_MANDATORY_LIST), SERVICE); + + HashMap validationMap = new HashMap<>(); + validationMap.put(AUTH, AUTH_VALUES); + validationMap.put(MODE, MODE_VALUES); + + for (String secKey : validationMap.keySet()) { + if (map.containsKey(secKey)) { + Object obj = map.get(secKey); + if (obj == null) { + exceptionList.add("Attribute '" + secKey + "' under '" + SERVICE + "' is empty"); + } else { + String value = String.valueOf(obj); + if (!OnapCommandConfg.getSchemaAttrInfo(validationMap.get(secKey)).contains(value)) { + exceptionList.add("Attribute '" + secKey + "' contains invalid value. Valide values are " + + OnapCommandConfg.getSchemaAttrInfo(validationMap.get(key))); // + } + } + } + } + } + if (map != null) { OnapService srv = new OnapService(); for (Map.Entry entry1 : map.entrySet()) { String key1 = entry1.getKey(); - if (Constants.NAME.equals(key1)) { + if (NAME.equals(key1)) { srv.setName(map.get(key1)); - } else if (Constants.VERSION.equals(key1)) { + } else if (VERSION.equals(key1)) { srv.setVersion(map.get(key1)); - } else if (Constants.AUTH.equals(key1)) { + } else if (AUTH.equals(key1)) { Object obj = map.get(key1); - //TODO mrkanag Validate and raise exception for invalid case srv.setAuthType(obj.toString()); } else if (Constants.MODE.equals(key1)) { Object obj = map.get(key1); - //TODO mrkanag Validate and raise exception for invalid case srv.setMode(obj.toString()); } } cmd.setService(srv); } - } else if (Constants.DEFAULT_PARAMETERS.equals(key)) { + } else if (DEFAULT_PARAMETERS.equals(key)) { - Map> defParameters = (Map) values.get(Constants.DEFAULT_PARAMETERS); + Map> defParameters = (Map) values.get(DEFAULT_PARAMETERS); List includeParams = new ArrayList<>(); List excludeParams = new ArrayList<>(); - if (values.containsKey(Constants.DEFAULT_PARAMETERS) && defParameters == null) { + if (values.containsKey(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); + throwOrCollect(new OnapCommandInvalidSchema(SCHEMA_INVALID_DEFAULT_PARAMS_SECTION), + exceptionList, validate); } if (defParameters != null) { // validate default parameters - if (defParameters.containsKey(Constants.DEFAULT_PARAMETERS_INCLUDE)) { - includeParams = defParameters.get(Constants.DEFAULT_PARAMETERS_INCLUDE); + if (defParameters.containsKey(DEFAULT_PARAMETERS_INCLUDE)) { + includeParams = defParameters.get(DEFAULT_PARAMETERS_INCLUDE); } List invInclude = includeParams.stream() .filter(p -> !defaultParamNames.contains(p)) .collect(Collectors.toList()); - if (defParameters.containsKey(Constants.DEFAULT_PARAMETERS_EXCLUDE)) { - excludeParams = defParameters.get(Constants.DEFAULT_PARAMETERS_EXCLUDE); + if (defParameters.containsKey(DEFAULT_PARAMETERS_EXCLUDE)) { + excludeParams = defParameters.get(DEFAULT_PARAMETERS_EXCLUDE); } List invExclude = excludeParams.stream().filter(p -> !defaultParamNames.contains(p)) @@ -293,8 +456,10 @@ public class OnapCommandUtils { if (!invExclude.isEmpty() || !invInclude.isEmpty()) { - throw new OnapCommandInvalidDefaultParameter(Stream.concat(invInclude.stream(), invExclude.stream()) - .collect(Collectors.toList())); + + throwOrCollect(new OnapCommandInvalidDefaultParameter(Stream.concat(invInclude.stream(), + invExclude.stream()).collect(Collectors.toList())), + exceptionList, validate); } if (!includeParams.isEmpty()) { @@ -307,50 +472,80 @@ public class OnapCommandUtils { } else { filteredDefaultParams.addAll(defaultParamNames); } - processNoAuth(filteredDefaultParams, cmd, includeParams, excludeParams); - } else if (Constants.PARAMETERS.equals(key)) { + try { + processNoAuth(filteredDefaultParams, cmd, includeParams, excludeParams); + } catch (OnapCommandException e) { + throwOrCollect(e, exceptionList, validate); + } + } else if (PARAMETERS.equals(key) && values.containsKey(key)) { List> parameters = (List) values.get(key); if (parameters != null) { + Set names = new HashSet<>(); + Set inputShortOptions = new HashSet<>(); + Set inputLongOptions = new HashSet<>(); + for (Map map : parameters) { OnapCommandParameter param = new OnapCommandParameter(); + if (validate) { + validateTags(exceptionList, map, OnapCommandConfg.getSchemaAttrInfo(INPUT_PARAMS_LIST), + OnapCommandConfg.getSchemaAttrInfo(INPUT_PARAMS_MANDATORY_LIST), PARAMETERS); + } + for (Map.Entry entry1 : map.entrySet()) { String key2 = entry1.getKey(); - if (Constants.NAME.equals(key2)) { + if (NAME.equals(key2)) { if (names.contains(map.get(key2))) { - throw new OnapCommandParameterNameConflict(map.get(key2)); + throwOrCollect(new OnapCommandParameterNameConflict(map.get(key2)), exceptionList, validate); } names.add(map.get(key2)); param.setName(map.get(key2)); - } else if (Constants.DESCRIPTION.equals(key2)) { + } else if (DESCRIPTION.equals(key2)) { param.setDescription(map.get(key2)); - } else if (Constants.SHORT_OPTION.equals(key2)) { + } else if (SHORT_OPTION.equals(key2)) { if (shortOptions.contains(map.get(key2))) { - throw new OnapCommandParameterOptionConflict(map.get(key2)); + throwOrCollect(new OnapCommandParameterOptionConflict(map.get(key2)), exceptionList, validate); } shortOptions.add(map.get(key2)); param.setShortOption(map.get(key2)); - } else if (Constants.LONG_OPTION.equals(key2)) { + } else if (LONG_OPTION.equals(key2)) { if (longOptions.contains(map.get(key2))) { - throw new OnapCommandParameterOptionConflict(map.get(key2)); + throwOrCollect(new OnapCommandParameterOptionConflict(map.get(key2)), exceptionList, validate); } longOptions.add(map.get(key2)); param.setLongOption(map.get(key2)); - } else if (Constants.DEFAULT_VALUE.equals(key2)) { + } else if (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)) { + } else if (TYPE.equals(key2)) { + try { + param.setParameterType(ParameterType.get(map.get(key2))); + } catch (OnapCommandException ex) { + throwOrCollect(ex, exceptionList, validate); + } + } else if (IS_OPTIONAL.equals(key2)) { + if (validate) { + if (!validateBoolean(String.valueOf(map.get(key2)))) { + exceptionList.add(invalidBooleanValueMessage(map.get(NAME), + IS_SECURED, map.get(key2))); + } + } if ("true".equalsIgnoreCase(String.valueOf(map.get(key2)))) { param.setOptional(true); } else { param.setOptional(false); } - } else if (Constants.IS_SECURED.equals(key2)) { + } else if (IS_SECURED.equals(key2)) { + if (validate) { + if (!validateBoolean(String.valueOf(map.get(key2)))) { + exceptionList.add(invalidBooleanValueMessage(map.get(NAME), + IS_SECURED, map.get(key2))); + } + } + if ("true".equalsIgnoreCase(String.valueOf(map.get(key2)))) { param.setSecured(true); } else { @@ -367,32 +562,64 @@ public class OnapCommandUtils { } } } - } else if (Constants.RESULTS.equals(key)) { + } else if (RESULTS.equals(key) && values.containsKey(key)) { Map valueMap = (Map) values.get(key); if (valueMap != null) { OnapCommandResult result = new OnapCommandResult(); for (Map.Entry 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)) { + if (DIRECTION.equals(key3)) { + try { + result.setPrintDirection(PrintDirection.get((String) valueMap.get(key3))); + } catch (OnapCommandException ex) { + throwOrCollect(ex, exceptionList, validate); + } + } else if (ATTRIBUTES.equals(key3)) { List> attrs = (ArrayList) valueMap.get(key3); for (Map map : attrs) { OnapCommandResultAttribute attr = new OnapCommandResultAttribute(); + if (validate) { + validateTags(exceptionList, map, OnapCommandConfg.getSchemaAttrInfo(RESULT_PARAMS_LIST), + OnapCommandConfg.getSchemaAttrInfo(RESULT_PARAMS_MANDATORY_LIST), ATTRIBUTES); + } + + Set resultParamNames = new HashSet<>(); + for (Map.Entry entry4 : map.entrySet()) { String key4 = entry4.getKey(); - if (Constants.NAME.equals(key4)) { - attr.setName(map.get(key4)); - } else if (Constants.DESCRIPTION.equals(key4)) { + if (NAME.equals(key4)) { + if (resultParamNames.contains(map.get(key4))) { + exceptionList.add("Attribute name='" + map.get(key4) + "' under '" + + ATTRIBUTES + ":' is already used, Take different one."); + + } else { + attr.setName(map.get(key4)); + resultParamNames.add(map.get(key4)); + } + } else if (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)) { + } else if (SCOPE.equals(key4)) { + try { + attr.setScope(OnapCommandResultAttributeScope.get(map.get(key4))); + } catch (OnapCommandException ex) { + throwOrCollect(ex, exceptionList, validate); + } + } else if (TYPE.equals(key4)) { + try { + attr.setType(ParameterType.get(map.get(key4))); + } catch (OnapCommandException ex) { + throwOrCollect(ex, exceptionList, validate); + } + } else if (IS_SECURED.equals(key4)) { + if (validate) { + if (!validateBoolean(String.valueOf(map.get(key4)))) { + exceptionList.add(invalidBooleanValueMessage(ATTRIBUTES, + IS_SECURED, map.get(key4))); + } + } if ("true".equals(String.valueOf(map.get(key4)))) { attr.setSecured(true); } else { @@ -409,6 +636,112 @@ public class OnapCommandUtils { } } } + return exceptionList; + } + + private static String emptySection(String section) { + return "The section '" + section + ":' cann't be null or empty"; + } + + private static String invalidBooleanValueMessage(String section, String attribute, String value) { + return "The value '" + value + "' of '" + attribute + "' present under '" + section + "' should be boolean"; + } + + private static Set validateHttpQueries(Map requestMap) { + Map queries = (Map) requestMap.get(QUERIES); + Set queryParamNames = new HashSet<>(); + if (queries != null) { + for (Entry entry : queries.entrySet()) { + parseParameters(String.valueOf(entry.getValue()), queryParamNames); + } + } + return queryParamNames; + } + + + private static Set validateHttpHeaders(Map requestMap) { + + Map headers = (Map) requestMap.get(HEADERS); + Set headerParamNames = new HashSet<>(); + if (headers != null) { + for (Entry entry : headers.entrySet()) { + parseParameters(String.valueOf(entry.getValue()), headerParamNames); + } + } + return headerParamNames; + } + + private static Set validateHttpBody(List errorList, Map requestMap) { + Set 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 + errorList.add(HTTP_BODY_FAILED_PARSING); + } + if (obj == null || "".equals(obj.toString())) { + errorList.add(HTTP_BODY_JSON_EMPTY); + } + parseParameters(body, bodyParamNames); + + return bodyParamNames; + } + + private static Set validateHttpUri(List errorList, Map requestMap) { + Set uriParamNames = new HashSet<>(); + String uri = (String) requestMap.get(URI); + if (uri == null || uri.isEmpty()) { + errorList.add(emptySection(URI)); + return uriParamNames; + } + parseParameters(uri, uriParamNames); + return uriParamNames; + } + + private static void parseParameters(String line, Set 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 static Set getRequestParams(Map yamlMap) { + + Set set = new HashSet<>(); + + @SuppressWarnings("unchecked") + List> inputParams = (List>) yamlMap.get(PARAMETERS); + + if (inputParams != null) { + for (Map map : inputParams) { + for (Entry entry : map.entrySet()) { + Object key = entry.getKey(); + + if (NAME.equals(key)) { + set.add(String.valueOf(entry.getValue())); + break; + } + } + } + } + + return set; } /** @@ -438,21 +771,21 @@ public class OnapCommandUtils { public static void loadSchema(OnapSwaggerCommand cmd, String schemaName) throws OnapCommandException { try { Map values = (Map) validateSchemaVersion(schemaName, cmd.getSchemaVersion()); - Map valueMap = (Map) values.get(Constants.EXECUTOR); + Map valueMap = (Map) values.get(EXECUTOR); OnapCommandExecutor exec = new OnapCommandExecutor(); for (Map.Entry entry1 : valueMap.entrySet()) { String key1 = entry1.getKey(); - if (Constants.API.equals(key1)) { + if (API.equals(key1)) { exec.setApi(valueMap.get(key1)); - } else if (Constants.CLIENT.equals(key1)) { + } else if (CLIENT.equals(key1)) { exec.setClient(valueMap.get(key1)); - } else if (Constants.ENTITY.equals(key1)) { + } else if (ENTITY.equals(key1)) { exec.setEntity(valueMap.get(key1)); - } else if (Constants.EXCEPTION.equals(key1)) { + } else if (EXCEPTION.equals(key1)) { exec.setException(valueMap.get(key1)); - } else if (Constants.METHOD.equals(key1)) { + } else if (METHOD.equals(key1)) { exec.setMethod(valueMap.get(key1)); } } @@ -489,53 +822,148 @@ public class OnapCommandUtils { * @throws OnapCommandInvalidSchemaVersion * invalid schema version */ - public static void loadSchema(OnapHttpCommand cmd, String schemaName) throws OnapCommandException { + public static ArrayList loadHTTPSchemaSection(OnapHttpCommand cmd, String schemaName, + boolean validate) throws OnapCommandException { + ArrayList errorList = new ArrayList<>(); try { Map values = (Map) validateSchemaVersion(schemaName, cmd.getSchemaVersion()); - Map valMap = (Map) values.get(Constants.HTTP); + Map valMap = (Map) values.get(HTTP); - for (Map.Entry entry1 : valMap.entrySet()) { - String key1 = entry1.getKey(); - if (Constants.REQUEST.equals(key1)) { - Map map = (Map) valMap.get(key1); - - for (Map.Entry 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 head = (Map) map.get(key2); - cmd.getInput().setReqHeaders(head); - } else if (Constants.QUERIES.equals(key2)) { - Map query = (Map) map.get(key2); - - cmd.getInput().setReqQueries(query); + if (valMap != null) { + if (validate) { + validateTags(errorList, valMap, OnapCommandConfg.getSchemaAttrInfo(HTTP_SECTIONS), + OnapCommandConfg.getSchemaAttrInfo(HTTP_MANDATORY_SECTIONS), PARAMETERS); + errorList.addAll(validateHttpSchemaSection(values)); + } + for (Map.Entry entry1 : valMap.entrySet()) { + String key1 = entry1.getKey(); + if (REQUEST.equals(key1)) { + Map map = (Map) valMap.get(key1); + + for (Map.Entry entry2 : map.entrySet()) { + try { + String key2 = entry2.getKey(); + if (URI.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setUri(obj.toString()); + } else if (MERHOD.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setMethod(obj.toString()); + } else if (BODY.equals(key2)) { + Object obj = map.get(key2); + cmd.getInput().setBody(obj.toString()); + } else if (HEADERS.equals(key2)) { + Map head = (Map) map.get(key2); + cmd.getInput().setReqHeaders(head); + } else if (QUERIES.equals(key2)) { + Map query = (Map) map.get(key2); + + cmd.getInput().setReqQueries(query); + } + }catch (Exception ex) { + throwOrCollect(new OnapCommandInvalidSchema(schemaName, ex), errorList, validate); + } + } + } else if (SUCCESS_CODES.equals(key1)) { + if (validate) { + validateHttpSccessCodes(errorList, (List) valMap.get(key1)); } + cmd.setSuccessStatusCodes((ArrayList) valMap.get(key1)); + } else if (RESULT_MAP.equals(key1)) { + if (validate) { + validateHttpResultMap(errorList, values); + } + cmd.setResultMap((Map) valMap.get(key1)); + } else if (SAMPLE_RESPONSE.equals(key1)) { + // (mrkanag) implement sample response handling } - } else if (Constants.SUCCESS_CODES.equals(key1)) { - cmd.setSuccessStatusCodes((ArrayList) valMap.get(key1)); - } else if (Constants.RESULT_MAP.equals(key1)) { - cmd.setResultMap((Map) valMap.get(key1)); - } else if (Constants.SAMPLE_RESPONSE.equals(key1)) { - // (mrkanag) implement sample response handling } } + }catch (OnapCommandException e) { + throwOrCollect(e, errorList, validate); + } + return errorList; + } - } catch (OnapCommandException e) { - throw e; - } catch (Exception e) { - throw new OnapCommandInvalidSchema(schemaName, e); + private static void validateHttpResultMap(List errorList, Map values) throws OnapCommandException { + Map valMap = (Map) values.get(HTTP); + List> attributes = (List>) ((Map)values.get(RESULTS)).get(ATTRIBUTES); + Set resultMapParams = ((Map) valMap.get(RESULT_MAP)).keySet(); + + Set resultAttNames = attributes.stream().map(map -> map.get(NAME)) + .collect(Collectors.toSet()); + + List invaliResultMapParams = resultMapParams.stream() + .filter(p -> !resultAttNames.contains(p)).collect(Collectors.toList()); + + if (!invaliResultMapParams.isEmpty()) { + throwOrCollect(new OnapCommandHttpInvalidResultMap(invaliResultMapParams), errorList, true); } } + private static void validateHttpSccessCodes(List errorList, List requestSuccessCodes) { + + if (requestSuccessCodes == null || requestSuccessCodes.isEmpty()) { + errorList.add(HTTP_SUCCESS_CODE_INVALID); + return; + } + + for (Object successCode : requestSuccessCodes) { + Integer code = (Integer) successCode; + if (code < 200 || code >= 300) { + errorList.add(HTTP_SUCCESS_CODE_INVALID); + } + } + + } + + + private static ArrayList validateHttpSchemaSection(Map values) { + + ArrayList errorList = new ArrayList<>(); + Map map = (Map) values.get(HTTP); + Map requestMap = (Map) map.get(REQUEST); + + if (requestMap != null && !requestMap.isEmpty()) { + validateTags(errorList, requestMap, OnapCommandConfg.getSchemaAttrInfo(HTTP_REQUEST_PARAMS), + OnapCommandConfg.getSchemaAttrInfo(HTTP_REQUEST_MANDATORY_PARAMS), REQUEST); + String method = (String) requestMap.get(METHOD); + if (method != null && !method.isEmpty()) { + if (!OnapCommandConfg.getSchemaAttrInfo(HTTP_METHODS).contains(method.toLowerCase())) { + errorList.add("Attribute '" + METHOD + "' under '" + REQUEST + "' is invalid, correct types are " + + OnapCommandConfg.getSchemaAttrInfo(HTTP_METHODS).toString()); + } + } else { + errorList.add("Http request method cann't be null or empty"); + } + + Set requestParams = getRequestParams(values); + + Set uriParams = validateHttpUri(errorList, requestMap); + + Set bodyParams = validateHttpBody(errorList, requestMap); + + Set headerParams = validateHttpHeaders(requestMap); + + Set queryParams = validateHttpQueries(requestMap); + + HashSet totoalParams = new HashSet<>(uriParams); + totoalParams.addAll(bodyParams); + totoalParams.addAll(headerParams); + totoalParams.addAll(queryParams); + + List nonDeclaredParams = totoalParams.stream().filter(param -> !requestParams.contains(param)) + .collect(Collectors.toList()); + + nonDeclaredParams.stream().forEach(p -> errorList.add("The parameter '" + p + + "' declared under 'parameters:' section is not mapped into request section.")); + } else { + errorList.add(emptySection(REQUEST)); + } + return errorList; + } + + /** * Returns Help. * @@ -565,14 +993,14 @@ public class OnapCommandUtils { paramTable.setIncludeSeparator(false); OnapCommandResultAttribute attrName = new OnapCommandResultAttribute(); - attrName.setName(Constants.NAME); - attrName.setDescription(Constants.NAME); + attrName.setName(NAME); + attrName.setDescription(NAME); attrName.setScope(OnapCommandResultAttributeScope.SHORT); paramTable.getRecords().add(attrName); OnapCommandResultAttribute attrDescription = new OnapCommandResultAttribute(); - attrDescription.setName(Constants.DESCRIPTION); - attrDescription.setDescription(Constants.DESCRIPTION); + attrDescription.setName(DESCRIPTION); + attrDescription.setDescription(DESCRIPTION); attrDescription.setScope(OnapCommandResultAttributeScope.SHORT); paramTable.getRecords().add(attrDescription); @@ -680,10 +1108,9 @@ public class OnapCommandUtils { 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_HOST_URL)); + return new OnapCredentials(paramMap.get(DEAFULT_PARAMETER_USERNAME), + paramMap.get(DEAFULT_PARAMETER_PASS_WORD), + paramMap.get(DEAFULT_PARAMETER_HOST_URL)); } /** @@ -1005,7 +1432,7 @@ public class OnapCommandUtils { public static List findAllExternalSchemas() throws OnapCommandException { List extSchemas = new ArrayList<>(); try { - Resource[] res = getExternalResources(Constants.EXTERNAL_SCHEMA_PATH_PATERN); + Resource[] res = getExternalResources(EXTERNAL_SCHEMA_PATH_PATERN); if (res != null && res.length > 0) { Map resourceMap; for (Resource resource : res) { @@ -1013,15 +1440,15 @@ public class OnapCommandUtils { 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.setCmdName((String) resourceMap.get(NAME)); + Object obj = resourceMap.get(ONAP_CMD_SCHEMA_VERSION); schema.setVersion(obj.toString()); extSchemas.add(schema); } } } } catch (IOException e) { - throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_SCHEMA_DIRECTORY, e); + throw new OnapCommandDiscoveryFailed(EXTERNAL_SCHEMA_DIRECTORY, e); } return extSchemas; @@ -1094,16 +1521,16 @@ public class OnapCommandUtils { public static void persist(List schemas) throws OnapCommandDiscoveryFailed { if (schemas != null) { try { - Resource[] resources = getExternalResources(Constants.EXTERNAL_DISCOVERY_DIRECTORY); + Resource[] resources = getExternalResources(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); + File file = new File(path + File.separator + 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); + throw new OnapCommandDiscoveryFailed(EXTERNAL_DISCOVERY_DIRECTORY, + EXTERNAL_DISCOVERY_FILE, e1); } } } @@ -1118,14 +1545,14 @@ public class OnapCommandUtils { public static boolean isJsonFileDiscovered() throws OnapCommandDiscoveryFailed { Resource resource = null; try { - resource = getExternalResource(Constants.EXTERNAL_DISCOVERY_FILE, - Constants.EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); + resource = getExternalResource(EXTERNAL_DISCOVERY_FILE, + EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); if (resource != null) { return true; } } catch (IOException e) { - throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_DISCOVERY_DIRECTORY, - Constants.EXTERNAL_DISCOVERY_FILE, e); + throw new OnapCommandDiscoveryFailed(EXTERNAL_DISCOVERY_DIRECTORY, + EXTERNAL_DISCOVERY_FILE, e); } return false; @@ -1149,8 +1576,8 @@ public class OnapCommandUtils { } } else { try { - Resource resource = getExternalResource(Constants.EXTERNAL_DISCOVERY_FILE, - Constants.EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); + Resource resource = getExternalResource(EXTERNAL_DISCOVERY_FILE, + EXTERNAL_DISCOVERY_DIRECTORY_PATTERN); if (resource != null) { File file = new File(resource.getURI().getPath()); ObjectMapper mapper = new ObjectMapper(); @@ -1158,8 +1585,8 @@ public class OnapCommandUtils { schemas.addAll(Arrays.asList(list)); } } catch (IOException e) { - throw new OnapCommandDiscoveryFailed(Constants.EXTERNAL_DISCOVERY_DIRECTORY, - Constants.EXTERNAL_DISCOVERY_FILE, e); + throw new OnapCommandDiscoveryFailed(EXTERNAL_DISCOVERY_DIRECTORY, + EXTERNAL_DISCOVERY_FILE, e); } } diff --git a/framework/src/test/java/org/onap/cli/fw/TestCommandValidate.java b/framework/src/test/java/org/onap/cli/fw/TestCommandValidate.java index 57847254..12ff2085 100644 --- a/framework/src/test/java/org/onap/cli/fw/TestCommandValidate.java +++ b/framework/src/test/java/org/onap/cli/fw/TestCommandValidate.java @@ -38,7 +38,7 @@ public class TestCommandValidate { @Test public void testNoAuthArgumentTrue() throws OnapCommandException { - OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true, false); OnapCommandParameter noAuthParam = cmd.getParameters().stream().filter(p -> p.getName().equalsIgnoreCase("no-auth")).findFirst().get(); noAuthParam.setValue(true); @@ -49,7 +49,7 @@ public class TestCommandValidate { @Test(expected = OnapCommandParameterMissing.class) public void testNoAuthArgFalse() throws OnapCommandException { - OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true, false); cmd.validate(); } } diff --git a/framework/src/test/java/org/onap/cli/fw/defaultParameter/TestDefaultParameterSection.java b/framework/src/test/java/org/onap/cli/fw/defaultParameter/TestDefaultParameterSection.java index da37f6f4..20ca10f7 100644 --- a/framework/src/test/java/org/onap/cli/fw/defaultParameter/TestDefaultParameterSection.java +++ b/framework/src/test/java/org/onap/cli/fw/defaultParameter/TestDefaultParameterSection.java @@ -39,7 +39,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-include-param.yaml", true, false); List parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList()); assertTrue(parameters.contains("onap-username")); assertTrue(parameters.contains("onap-password")); @@ -53,7 +53,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-exclude-param.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-exclude-param.yaml", true, false); List parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList()); assertTrue(parameters.contains("onap-username")); assertTrue(parameters.contains("onap-password")); @@ -70,7 +70,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-include-exclude.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-include-exclude.yaml", true, false); List parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList()); assertTrue(parameters.contains("onap-username")); @@ -85,7 +85,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "onap-test-schema.yaml", true); + OnapCommandUtils.loadSchema(cmd, "onap-test-schema.yaml", true, false); List parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList()); assertFalse(parameters.contains("onap-username")); @@ -103,7 +103,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-parameter.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-parameter.yaml", true, false); } @Test(expected = OnapCommandInvalidDefaultParameter.class) @@ -113,7 +113,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-params-not-exist.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-default-params-not-exist.yaml", true, false); } @Test(expected = OnapCommandInvalidSchema.class) @@ -123,7 +123,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-import-def-param-false.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-import-def-param-false.yaml", true, false); } @Test(expected = OnapCommandInvalidDefaultParameter.class) @@ -133,7 +133,7 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-include-noauth.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-include-noauth.yaml", true, false); } @Test(expected = OnapCommandInvalidDefaultParameter.class) @@ -143,6 +143,6 @@ public class TestDefaultParameterSection { protected void run() throws OnapCommandException {} }; - OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-exclude-noauth.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-exclude-noauth.yaml", true, false); } } 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 index 4c48683b..a8df9979 100644 --- a/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java +++ b/framework/src/test/java/org/onap/cli/fw/schema/ValidateSchemaTest.java @@ -17,87 +17,117 @@ package org.onap.cli.fw.schema; import org.junit.Test; +import org.onap.cli.fw.OnapCommand; +import org.onap.cli.fw.cmd.OnapHttpCommand; +import org.onap.cli.fw.error.OnapCommandException; import org.onap.cli.fw.error.OnapCommandInvalidSchema; -import org.yaml.snakeyaml.scanner.ScannerException; +import org.onap.cli.fw.utils.OnapCommandUtils; -import java.io.File; -import java.util.ArrayList; -import java.util.HashSet; +import java.util.List; + +import static org.junit.Assert.assertTrue; public class ValidateSchemaTest { @Test(expected = OnapCommandInvalidSchema.class) - public void invalidateTest1() throws OnapCommandInvalidSchema { - new SchemaValidator(new File("fdsfds")); - new SchemaValidator(new File("fdsfds.yaml")); + public void invalidateTest1() throws OnapCommandException { + + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, "fdsfds.yaml", true, true); } @Test(expected = OnapCommandInvalidSchema.class) - public void invalidateTest2() throws OnapCommandInvalidSchema { - new SchemaValidator(new File("fdsfds")); + public void invalidateTest2() throws OnapCommandException { + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, "fdsfds", true, true); } @Test(expected = OnapCommandInvalidSchema.class) - public void invalidateTest4() throws OnapCommandInvalidSchema { - new SchemaValidator( - new File(ValidateSchemaTest.class.getClassLoader().getResource("onap.properties").getFile())); + public void invalidateTest4() throws OnapCommandException { + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, + ValidateSchemaTest.class.getClassLoader().getResource("onap.properties").getFile(), + true, true); } @Test(expected = OnapCommandInvalidSchema.class) - public void invalidateTest5() throws OnapCommandInvalidSchema { - new SchemaValidator(new File( - ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file-null.yaml").getFile())); + public void invalidateTest5() throws OnapCommandException { + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, "schema-invalid-file-null.yaml", true, true); } @Test - public void invalidate1Test5() throws OnapCommandInvalidSchema { - new SchemaValidator("schema-validate-pass.yaml"); + public void invalidate1Test5() throws OnapCommandException { + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, "schema-validate-pass.yaml", true, true); + } - @Test(expected = ScannerException.class) - public void invalidateTest3() throws OnapCommandInvalidSchema { - new SchemaValidator( - new File(ValidateSchemaTest.class.getClassLoader().getResource("schema-invalid-file.yaml").getFile())); + @Test(expected = OnapCommandInvalidSchema.class) + public void invalidateTest3() throws OnapCommandException { + OnapCommand cmd = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + OnapCommandUtils.loadSchema(cmd, "schema-invalid-file.yaml", true, true); } @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(); + public void validateTest() throws OnapCommandException { - } + OnapCommand cmd1 = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + List errorList1 = OnapCommandUtils.loadSchema(cmd1, "schema-validate-http.yaml", true, true); + assertTrue(errorList1.size() > 0); + + OnapCommand cmd2 = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + List errorList2 = OnapCommandUtils.loadSchema(cmd2, "schema-validate-basic.yaml", true, true); + assertTrue(errorList2.size() > 0); + + OnapCommand cmd3 = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + List errorList3 = OnapCommandUtils.loadSchema(cmd2, "schema-validate-invalidschematype.yaml", true, true); + assertTrue(errorList3.size() > 0); + + OnapCommand cmd4 = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + List errorList4 = OnapCommandUtils.loadSchema(cmd2, "schema-validate-invalid.yaml", true, true); + + OnapHttpCommand onapHttpCommand = new OnapHttpCommand(); + errorList4.addAll(OnapCommandUtils.loadHTTPSchemaSection(onapHttpCommand, + "schema-validate-invalid.yaml", true)); + assertTrue(errorList4.size() > 0); + + OnapCommand cmd5 = new OnapCommand() { + @Override + protected void run() throws OnapCommandException {} + }; + List errorList5 = OnapCommandUtils.loadSchema(cmd5, "schema-validate-pass.yaml", true, true); + assertTrue(errorList5.size() == 0); - @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()); - SchemaValidate.invalidAttrType("name", "section", new ArrayList()); - SchemaValidate.invalidBooleanValueMessage("section", "attribute", "value"); - SchemaValidate.invalidRequestParam("subSection", "attribute"); - SchemaValidate.invalidSections(new HashSet(), new ArrayList(), new ArrayList()); - SchemaValidate.attributeScopeEmpty("fsdf"); - SchemaValidate.invalidType("section", "attribute", new ArrayList()); - SchemaValidate.longOptionExist("name"); - SchemaValidate.shortOptionExist("name"); - SchemaValidate.optionExist("option", "attrValue", "name"); - SchemaValidate.optionDefaultExist("option", "attrValue", "name", new HashSet()); - SchemaValidate.nameExist("name", "section"); - SchemaValidate.mandatoryAttrEmpty("param", "section"); } } 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 index d01e2e77..064576d8 100644 --- a/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java +++ b/framework/src/test/java/org/onap/cli/fw/utils/OnapCommandUtilsTest.java @@ -69,7 +69,7 @@ import java.util.Set; @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class OnapCommandUtilsTest { - @Test(expected = OnapCommandSchemaNotFound.class) + @Test(expected = OnapCommandInvalidSchema.class) public void onapCommandUtilsInputStreamNullTest() throws OnapCommandException { OnapCommandUtils.validateSchemaVersion("sample-test1-schema-http1.yaml", "1.0"); } @@ -144,32 +144,32 @@ public class OnapCommandUtilsTest { @Test public void loadOnapCommandSchemaWithOutDefaultTest() throws OnapCommandException { OnapCommand cmd = new OnapCommandSample(); - OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", false); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", false, 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); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-name.yaml", false, 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); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-shortoption.yaml", false, 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); + OnapCommandUtils.loadSchema(cmd, "sample-test-invalid-schema-duplicate-longoption.yaml", false, false); } @Test public void loadOnapCommandSchemaWithDefaultTest() throws OnapCommandException { OnapCommand cmd = new OnapCommandSample(); - OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true, false); assertTrue("sample-test".equals(cmd.getName()) && cmd.getParameters().size() > 9); for (OnapCommandParameter com : cmd.getParameters()) { @@ -185,7 +185,7 @@ public class OnapCommandUtilsTest { @Test public void loadOnapCommandSchemaAuthRequiredTest() throws OnapCommandException { OnapCommand cmd = new OnapCommandSample(); - OnapCommandUtils.loadSchema(cmd, "sample-test-schema-auth-required.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema-auth-required.yaml", true, false); assertTrue("sample-test".equals(cmd.getName())); Map map = OnapCommandUtils.getInputMap(cmd.getParameters()); @@ -219,7 +219,7 @@ public class OnapCommandUtilsTest { OnapHttpCommand cmd = new OnapHttpCommandSample(); cmd.setName("sample-test-http"); try { - OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml"); + OnapCommandUtils.loadHTTPSchemaSection(cmd, "sample-test-schema.yaml", false); } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection | OnapCommandInvalidResultAttributeScope | OnapCommandSchemaNotFound | OnapCommandInvalidSchema @@ -233,7 +233,7 @@ public class OnapCommandUtilsTest { OnapHttpCommand cmd = new OnapHttpCommandSample(); cmd.setName("sample-create-http"); try { - OnapCommandUtils.loadSchema(cmd, "sample-test-schema-http.yaml"); + OnapCommandUtils.loadHTTPSchemaSection(cmd, "sample-test-schema-http.yaml", true); assertTrue(cmd.getSuccessStatusCodes().size() == 2); } catch (OnapCommandParameterNameConflict | OnapCommandParameterOptionConflict | OnapCommandInvalidParameterType | OnapCommandInvalidPrintDirection @@ -246,7 +246,7 @@ public class OnapCommandUtilsTest { @Test public void helpCommandTest() throws IOException, OnapCommandException { OnapCommand cmd = new OnapCommandSample(); - OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true, false); String actualResult = OnapCommandUtils.help(cmd); @@ -392,7 +392,7 @@ public class OnapCommandUtilsTest { public void zendExceptionTest2() throws OnapCommandException { mockExternalResources(); - OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false); + OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false, false); } @Test(expected = OnapCommandException.class) @@ -428,7 +428,7 @@ public class OnapCommandUtilsTest { mockPrintMethodException(); OnapCommand cmd = new OnapCommandSample(); - OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true); + OnapCommandUtils.loadSchema(cmd, "sample-test-schema.yaml", true, false); OnapCommandUtils.help(cmd); -- cgit 1.2.3-korg