Move schema validation to load schema.
Issue-Id: CLI-25
Change-Id: I8fdb8450f6f95b7170c10b0ec5883162a4cf406a
Signed-off-by: subhash kumar singh <subhash.kumar.singh@huawei.com>
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
/**
*/
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;
}
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<OnapCommandParameter> 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;
}
}
@Override
protected void initializeProfileSchema() throws OnapCommandException {
- OnapCommandUtils.loadSchema(this, this.getSchemaName());
+ OnapCommandUtils.loadHTTPSchemaSection(this, this.getSchemaName(), false);
}
@Override
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 {
String location = String.valueOf(locationParam.getValue());
OnapCommandParameter interSchemaParam = paramMap.get("internal-schema");
boolean isInternalSchema = Boolean.valueOf(String.valueOf(interSchemaParam.getValue()));
- SchemaValidate schema;
if (isInternalSchema) {
location = location.substring(1);
- schema = new SchemaValidator(location);
- } else {
- schema = new SchemaValidator(new File(location));
}
- List<String> error = schema.validate();
+ List<String> error = OnapCommandUtils.loadSchema(new OnapCommand() {
+ @Override
+ protected void run() throws OnapCommandException {
+ }
+ }, location, true, true);
+
+
+ error.addAll(OnapCommandUtils.loadHTTPSchemaSection(new OnapHttpCommand(),
+ location, true));
+
List<String> slNumber = new ArrayList<>();
for (int i = 1; i <= error.size(); i++) {
slNumber.add(String.valueOf(i));
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.cli.fw.schema;
-
-import org.onap.cli.fw.error.OnapCommandInvalidSchema;
-import org.onap.cli.fw.utils.OnapCommandUtils;
-import org.springframework.core.io.Resource;
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.parser.ParserException;
-
-import static org.onap.cli.fw.conf.Constants.*;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-/**
- * Abstract schema validation class.
- *
- */
-public abstract class AbstractSchemaValidate implements SchemaValidate {
-
- /**
- * Supported schema types.
- *
- */
- protected enum SchemaType {
- HTTP, BASIC
- }
-
- protected List<String> schemaErrors = new ArrayList<>();
- protected Map<String, Object> yamlMap = new HashMap<>();
- protected Map<String, Object> defaultYamlMap = new HashMap<>();
-
- protected static final List<String> HTTP_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION,
- SERVICE, PARAMETERS, RESULTS, HTTP);
-
- protected static final List<String> HTTP_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME,
- DESCRIPTION, SERVICE, HTTP);
- protected static final List<String> BASIC_SCHEMA_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME, DESCRIPTION,
- PARAMETERS, RESULTS);
-
- protected static final List<String> BASIC_SCHEMA_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME,
- DESCRIPTION, PARAMETERS);
-
- protected static final List<String> TOP_LEVEL_PARAMS_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME,
- DESCRIPTION);
-
- protected static final List<String> TOP_LEVEL_MANDATORY_LIST = Arrays.asList(ONAP_CMD_SCHEMA_VERSION, NAME,
- DESCRIPTION);
-
- protected static final List<String> SERVICE_PARAMS_LIST = Arrays.asList(NAME, VERSION, AUTH);
-
- protected static final List<String> SERVICE_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, VERSION);
-
- protected static final List<String> INPUT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION,
- LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED);
-
- protected static final List<String> INPUT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE);
-
- protected static final List<String> PARAMETER_TYPES = Arrays.asList(PARAMETER_TYPE_JSON, PARAMETER_TYPE_YAML,
- PARAMETER_TYPE_STRING, PARAMETER_TYPE_LONG, PARAMETER_TYPE_URL, PARAMETER_TYPE_BOOL, PARAMETER_TYPE_ARRAY,
- PARAMETER_TYPE_MAP, PARAMETER_TYPE_BINARY);
-
- protected static final List<String> RESULT_PARAMS_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE, SHORT_OPTION,
- LONG_OPTION, IS_OPTIONAL, DEFAULT_VALUE, IS_SECURED);
-
- protected static final List<String> RESULT_PARAMS_MANDATORY_LIST = Arrays.asList(NAME, DESCRIPTION, TYPE);
-
- protected static final List<String> HTTP_PARAMS_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES);
-
- protected static final List<String> HTTP_PARAMS_MANDATORY_LIST = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES);
-
- protected static final List<String> HTTP_MANDATORY_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES);
-
- protected static final List<String> HTTP_SECTIONS = Arrays.asList(REQUEST, SUCCESS_CODES, RESULT_MAP,
- SAMPLE_RESPONSE);
-
- protected static final List<String> HTTP_REQUEST_MANDATORY_PARAMS = Arrays.asList(URI, METHOD);
-
- protected static final List<String> HTTP_REQUEST_PARAMS = Arrays.asList(URI, METHOD, BODY, HEADERS, QUERIES);
-
- protected static final List<String> BOOLEAN_VALUES = Arrays.asList(BOOLEAN_TRUE, BOOLEAN_FALSE);
- protected static final List<String> DIRECTIONS = Arrays.asList(DIRECTION_PORTRAIT, DIRECTION_LANDSCAPE);
- protected static final List<String> RESULT_SCOPES = Arrays.asList(RESULT_SCOPE_SHORT, RESULT_SCOPE_LONG);
-
- protected static final List<String> HTTP_METHODS = Arrays.asList(POST, GET, DELETE, PUT, HEAD);
-
- /**
- * Constructor.
- *
- * @param schemaFile
- * schemafile
- * @throws OnapCommandInvalidSchema
- * exception
- */
- public AbstractSchemaValidate(File schemaFile) throws OnapCommandInvalidSchema {
- loadYaml(schemaFile);
- loadDefaultYaml();
- }
-
- /**
- * Constructor.
- *
- * @param schemaFile
- * resourceName
- * @throws OnapCommandInvalidSchema
- * exception
- */
- public AbstractSchemaValidate(String schemaFile) throws OnapCommandInvalidSchema {
-
- try {
- Resource res = OnapCommandUtils.getExternalResource(schemaFile, EXTERNAL_SCHEMA_PATH_PATERN);
- InputStream inputStream;
- if (res == null) {
- inputStream = OnapCommandUtils.class.getClassLoader().getResourceAsStream(schemaFile);
- } else {
- inputStream = res.getInputStream();
- }
-
- if (inputStream != null) {
- loadYamlFromInputStream(schemaFile, inputStream);
- } else {
- throw new OnapCommandInvalidSchema(schemaFile, SCHEMA_FILE_NOT_EXIST);
- }
-
- } catch (IOException e) {
- throw new OnapCommandInvalidSchema(schemaFile, e);
- }
- loadDefaultYaml();
- }
-
- private final void loadYaml(File schemaFile) throws OnapCommandInvalidSchema {
- if (!schemaFile.isFile()) {
- throw new OnapCommandInvalidSchema(schemaFile.getName(), SCHEMA_FILE_NOT_EXIST);
- }
- String fileName = schemaFile.getName();
-
- if (!fileName.endsWith(".yaml")) {
- throw new OnapCommandInvalidSchema(fileName, SCHEMA_FILE_WRONG_EXTN);
- }
-
- try {
- InputStream inputStream = new FileInputStream(schemaFile);
- loadYamlFromInputStream(schemaFile.getName(), inputStream);
- } catch (FileNotFoundException e) {
- throw new OnapCommandInvalidSchema(fileName, e);
- }
- }
-
- @SuppressWarnings("unchecked")
- private final void loadYamlFromInputStream(String fileName, InputStream inputStream)
- throws OnapCommandInvalidSchema {
- try {
- yamlMap = (Map<String, Object>) new Yaml().load(inputStream);
- } catch (ParserException e) {
- throw new OnapCommandInvalidSchema(fileName, e);
- } finally {
- if (inputStream != null) {
- try {
- inputStream.close();
- } catch (IOException e) {
- throw new OnapCommandInvalidSchema(fileName, e); // NOSONAR
- }
- }
- }
-
- if (yamlMap == null) {
- throw new OnapCommandInvalidSchema(fileName, SCHEMA_FILE_EMPTY);
- }
- }
-
- @SuppressWarnings("unchecked")
- private final void loadDefaultYaml() throws OnapCommandInvalidSchema {
- InputStream inputStream = AbstractSchemaValidate.class.getClassLoader()
- .getResourceAsStream(DEFAULT_SCHEMA_FILE_NAME);
- try {
- defaultYamlMap = (Map<String, Object>) new Yaml().load(inputStream);
- } catch (ParserException e) {
- throw new OnapCommandInvalidSchema(DEFAULT_SCHEMA_FILE_NAME, e);
- }
-
- if (defaultYamlMap == null) {
- throw new OnapCommandInvalidSchema(DEFAULT_SCHEMA_FILE_NAME, SCHEMA_FILE_EMPTY);
- }
- }
-
- /*
- * Validate method.
- *
- * @throws OnapCommandInvalidSchema exception
- */
- @Override
- public List<String> validate() throws OnapCommandInvalidSchema {
-
- SchemaType type;
- Set<String> mainSections = yamlMap.keySet();
- if (mainSections.containsAll(HTTP_SCHEMA_MANDATORY_LIST)) {
- type = SchemaType.HTTP;
- } else if (mainSections.containsAll(BASIC_SCHEMA_MANDATORY_LIST)) {
- type = SchemaType.BASIC;
- } else {
- schemaErrors.add(SchemaValidate.invalidSections(mainSections, HTTP_SCHEMA_MANDATORY_LIST,
- BASIC_SCHEMA_MANDATORY_LIST));
- return schemaErrors;
- }
-
- if (type.equals(SchemaType.BASIC)) {
- validateTopLevelAttributes();
- validateInputParameters();
- validateResultParameters();
- } else {
- validateTopLevelAttributes();
- validateServiceAttributes();
- validateInputParameters();
- validateResultParameters();
- validateSpecificSchema(SchemaType.HTTP);
- }
- return schemaErrors;
- }
-
- private void validateResultAttributes(List<Map<String, Object>> resultAttributes) {
- Set<String> resultParamNames = new HashSet<>();
- for (Map<String, Object> attribute : resultAttributes) {
-
- // Validate mandatory parameters
- validateMandatoryParams(attribute, RESULT_PARAMS_LIST, RESULT_PARAMS_MANDATORY_LIST, ATTRIBUTES);
-
- String name = String.valueOf(attribute.get(NAME));
-
- if (resultParamNames.contains(name)) {
- schemaErrors.add(SchemaValidate.attributeNameExist(name, ATTRIBUTES));
- } else {
- resultParamNames.add(name);
- }
-
- // Validate specific parameters
- Object type = attribute.get(TYPE);
- String value = String.valueOf(type);
- if (!PARAMETER_TYPES.contains(value.toLowerCase())) {
- schemaErrors.add(SchemaValidate.invalidType(ATTRIBUTES, name, PARAMETER_TYPES));
- }
-
- Object scope = attribute.get(SCOPE);
- if (scope == null) {
- schemaErrors.add(SchemaValidate.attributeScopeEmpty(name));
- } else if (!RESULT_SCOPES.contains(scope)) {
- schemaErrors.add(SchemaValidate.invalidAttributeScope(name, RESULT_SCOPES));
- }
-
- Object isSecured = attribute.get(IS_SECURED);
- if (isSecured != null) {
- String value2 = String.valueOf(isSecured);
- if (!validateBoolean(value2)) {
- schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(ATTRIBUTES, IS_SECURED, value2));
- }
- }
- }
-
- }
-
- private void validateResultParameters() {
- @SuppressWarnings("unchecked")
- Map<String, Object> resultParams = (Map<String, Object>) yamlMap.get(RESULTS);
-
- if (resultParams == null || resultParams.isEmpty()) {
- return;
- }
-
- Object direction = resultParams.get(DIRECTION);
-
- if (direction != null && !DIRECTIONS.contains(direction)) {
- schemaErrors.add(SchemaValidate.invalidType(PARAMETERS, DIRECTION, DIRECTIONS));
- }
-
- @SuppressWarnings("unchecked")
- List<Map<String, Object>> resultAttributes = (List<Map<String, Object>>) resultParams.get(ATTRIBUTES);
- validateResultAttributes(resultAttributes);
- }
-
- /**
- * Get all default short options.
- *
- * @return set
- */
- protected Set<String> getDefaultShortOptions() {
-
- Set<String> set = new HashSet<>();
-
- @SuppressWarnings("unchecked")
- List<Map<String, Object>> inputParams = (List<Map<String, Object>>) defaultYamlMap.get(PARAMETERS);
- for (Map<String, Object> parameter : inputParams) {
- Object name = parameter.get(SHORT_OPTION);
- if (name != null && !String.valueOf(name).isEmpty() && !"null".equals(name)) {
- set.add(String.valueOf(name));
- }
- }
-
- return set;
- }
-
- /**
- * Get all default long options.
- *
- * @return set
- */
- protected Set<String> getDefaultLongOptions() {
-
- Set<String> set = new HashSet<>();
-
- @SuppressWarnings("unchecked")
- List<Map<String, Object>> inputParams = (List<Map<String, Object>>) defaultYamlMap.get(PARAMETERS);
- for (Map<String, Object> parameter : inputParams) {
- Object name = parameter.get(LONG_OPTION);
- if (name != null && !String.valueOf(name).isEmpty() && !"null".equals(name)) {
- set.add(String.valueOf(name));
- }
- }
-
- return set;
- }
-
- private void validateTopLevelAttributes() {
- validateMandatoryParams(yamlMap, TOP_LEVEL_PARAMS_LIST, TOP_LEVEL_MANDATORY_LIST, "root level");
- }
-
- private void validateServiceAttributes() {
-
- @SuppressWarnings("unchecked")
- Map<String, Object> serviceMap = (Map<String, Object>) yamlMap.get(SERVICE);
-
- if (serviceMap == null) {
- schemaErrors.add(SchemaValidate.emptySection(SERVICE));
- return;
- }
-
- validateMandatoryParams(serviceMap, SERVICE_PARAMS_LIST, SERVICE_PARAMS_MANDATORY_LIST, SERVICE);
-
- // Validate specific parameters
-
- if (serviceMap.containsKey(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<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS);
- if (inputParams == null) {
- return;
- }
- validateInputAttributes(inputParams);
- }
-
- protected abstract void validateSpecificSchema(SchemaType type) throws OnapCommandInvalidSchema;
-
- private void validateInputAttributes(List<Map<String, Object>> inputParams) {
- Set<String> inputParamNames = new HashSet<>();
- Set<String> inputShortOptions = new HashSet<>();
- Set<String> inputLongOptions = new HashSet<>();
-
- Set<String> defaultShortOptions = getDefaultShortOptions();
- Set<String> defaultLongOptions = getDefaultLongOptions();
-
- for (Map<String, Object> parameter : inputParams) {
-
- // Validate mandatory parameters
- validateMandatoryParams(parameter, INPUT_PARAMS_LIST, INPUT_PARAMS_MANDATORY_LIST, PARAMETERS);
-
- // Validate specific parameters
-
- String name = String.valueOf(parameter.get(NAME));
-
- if (inputParamNames.contains(name)) {
- schemaErrors.add(SchemaValidate.nameExist(name, PARAMETERS));
- } else {
- inputParamNames.add(name);
- }
-
- String value = String.valueOf(parameter.get(TYPE));
-
- if (!PARAMETER_TYPES.contains(value.toLowerCase())) {
- schemaErrors.add(SchemaValidate.invalidAttrType(name, PARAMETERS, PARAMETER_TYPES));
- }
-
- Object isOptional = parameter.get(IS_OPTIONAL);
- if (isOptional != null) {
- String value1 = String.valueOf(isOptional);
- if (!validateBoolean(value1)) {
- schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(name, IS_OPTIONAL, value1));
- }
- }
-
- Object isSecured = parameter.get(IS_SECURED);
- if (isSecured != null) {
- String value2 = String.valueOf(isSecured);
- if (!validateBoolean(value2)) {
- schemaErrors.add(SchemaValidate.invalidBooleanValueMessage(name, IS_SECURED, value2));
- }
- }
-
- String shortOption = String.valueOf(parameter.get(SHORT_OPTION));
- String longOption = String.valueOf(parameter.get(LONG_OPTION));
-
- if (inputShortOptions.contains(shortOption)) {
- schemaErrors.add(SchemaValidate.optionExist(SHORT_OPTION, shortOption, name));
- } else if (defaultShortOptions.contains(shortOption)) {
-
- schemaErrors
- .add(SchemaValidate.optionDefaultExist(SHORT_OPTION, shortOption, name, defaultShortOptions));
-
- } else if (shortOption != null && !shortOption.isEmpty() && !"null".equals(shortOption)) {
- inputShortOptions.add(shortOption);
- }
-
- if (inputLongOptions.contains(longOption)) {
- schemaErrors.add(SchemaValidate.optionExist(LONG_OPTION, longOption, name));
- } else if (defaultLongOptions.contains(longOption)) {
-
- schemaErrors.add(SchemaValidate.optionDefaultExist(LONG_OPTION, longOption, name, defaultLongOptions));
- } else if (longOption != null && !longOption.isEmpty() && !"null".equals(shortOption)) {
- inputLongOptions.add(longOption);
- }
-
- }
-
- }
-
- /**
- * Validate mandatory parameters.
- *
- * @param yamlMap
- * yaml map
- * @param totalParams
- * list
- * @param mandatoryParams
- * list
- * @param section
- * section
- */
- protected void validateMandatoryParams(Map<String, Object> yamlMap, List<String> totalParams,
- List<String> mandatoryParams, String section) {
-
- for (String param : totalParams) {
- boolean isMandatory = mandatoryParams.contains(param);
- boolean isYamlContains = yamlMap.containsKey(param);
- if (isMandatory) {
- if (!isYamlContains) {
- schemaErrors.add(SchemaValidate.mandatoryAttrMissing(param, section));
- } else {
- String value = String.valueOf(yamlMap.get(param));
- if (value == null || "".equals(value) || "null".equals(value)) {
- schemaErrors.add(SchemaValidate.mandatoryAttrEmpty(param, section));
- }
- }
- }
- }
- }
-
- /**
- * Load result attributes.
- *
- * @return set
- */
- @SuppressWarnings("unchecked")
- protected Set<String> getResultAttributes() {
-
- Set<String> set = new HashSet<>();
-
- List<Map<String, Object>> resultAttributes = yamlMap.get(RESULTS) != null
- ? (List<Map<String, Object>>) ((Map<String, Object>) yamlMap.get(RESULTS)).get(ATTRIBUTES)
- : Collections.emptyList();
-
- if (resultAttributes != null) {
- for (Map<String, Object> map : resultAttributes) {
- for (Entry<String, Object> entry : map.entrySet()) {
- Object key = entry.getKey();
-
- if (NAME.equals(key)) {
- set.add(String.valueOf(entry.getValue()));
- break;
- }
- }
- }
- }
-
- return set;
- }
-
- /**
- * Get request parameters.
- *
- * @return set
- */
- protected Set<String> getRequestParams() {
-
- Set<String> set = new HashSet<>();
-
- @SuppressWarnings("unchecked")
- List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS);
-
- if (inputParams != null) {
- for (Map<String, Object> map : inputParams) {
- for (Entry<String, Object> entry : map.entrySet()) {
- Object key = entry.getKey();
-
- if (NAME.equals(key)) {
- set.add(String.valueOf(entry.getValue()));
- break;
- }
- }
- }
- }
-
- return set;
- }
-
- /**
- * Validate Boolean.
- *
- * @param toValidate
- * string
- * @return boolean
- */
- protected static boolean validateBoolean(String toValidate) {
- return BOOLEAN_VALUES.contains(toValidate.toLowerCase());
- }
-}
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.cli.fw.schema;
-
-import org.onap.cli.fw.error.OnapCommandInvalidSchema;
-
-import java.util.List;
-import java.util.Set;
-
-/**
- * Schema validate interface.
- *
- */
-@FunctionalInterface
-public interface SchemaValidate {
- /**
- * Validates HTTP or Basic Schema.
- *
- * @return List of errors
- * @throws OnapCommandInvalidSchema
- * Failed to load schema file
- */
- public List<String> validate() throws OnapCommandInvalidSchema;
-
- /**
- * Static interface method.
- *
- * @param section
- * section
- * @return errorMessage
- */
- public static String defaultYamlSchema(String section) {
- return "The section '" + section + ":' cann't be null or empty";
- }
-
- /**
- * Static interface method.
- *
- * @param section
- * string
- * @param attribute
- * string
- * @param value
- * string
- * @return string
- */
- public static String invalidBooleanValueMessage(String section, String attribute, String value) {
- return "The value '" + value + "' of '" + attribute + "' present under '" + section + "' should be boolean";
- }
-
- /**
- * Static interface method.
- *
- * @param section
- * string
- * @param attribute
- * string
- * @return string
- */
- public static String emptyValue(String section, String attribute) {
- return "Attribute '" + attribute + "' under '" + section + "' is null or empty";
- }
-
- /**
- * Static interface method.
- *
- * @param section
- * string
- * @param attribute
- * string
- * @param types
- * list
- * @return string
- */
- public static String invalidType(String section, String attribute, List<String> types) {
- return "Attribute '" + attribute + "' under '" + section + "' is invalid, correct types are "
- + types.toString();
- }
-
- /**
- * Static interface method.
- *
- * @param subSection
- * string
- * @param attribute
- * string
- * @return string
- */
- public static String invalidRequestParam(String subSection, String attribute) {
- return "The http request '" + subSection + "' parameter '" + attribute
- + "' is not declared under 'parameters:' section";
- }
-
- /**
- * Static interface method.
- *
- * @param section
- * string
- * @return string
- */
- public static String emptySection(String section) {
- return "The section '" + section + ":' cann't be null or empty";
- }
-
- /**
- * Static interface method.
- *
- * @param mainSections
- * list
- * @param http
- * list
- * @param basic
- * list
- * @return string
- */
- public static String invalidSections(Set<String> mainSections, List<String> http, List<String> basic) {
- return "No matching schema type found due to extra or missing sections in the file" + mainSections.toString()
- + " , Supported schema sections are http" + http.toString() + " and basic" + basic.toString();
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @param section
- * string
- * @return string
- */
- public static String attributeNameExist(String name, String section) {
- return "Attribute name='" + name + "' under '" + section + ":' is already used, Take different one.";
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @param scopes
- * list
- * @return string
- */
- public static String invalidAttributeScope(String name, List<String> scopes) {
- return "The attribute '" + name + "' scope is invalid, valid scopes are " + scopes.toString();
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @return string
- */
- public static String attributeScopeEmpty(String name) {
- return "The attribute '" + name + "' scope is null or empty.";
- }
-
- /**
- * Static interface method.
- *
- * @param option
- * string
- * @param attrValue
- * string
- * @param name
- * string
- * @return string
- */
- public static String optionExist(String option, String attrValue, String name) {
- return "Attribute " + option + " option '" + attrValue + "' of parameter '" + name
- + "' is already used, Take different one.";
- }
-
- /**
- * Static interface method.
- *
- * @param option
- * string
- * @param attrValue
- * string
- * @param name
- * string
- * @param list
- * list
- * @return string
- */
- public static String optionDefaultExist(String option, String attrValue, String name, Set<String> list) {
- return "Attribute " + option + " option '" + attrValue + "' of parameter '" + name
- + "' is already used in default parameters list " + list.toString() + ", Take different one.";
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @return string
- */
- public static String longOptionExist(String name) {
- return "The attribute '" + name + "' scope is null or empty.";
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @return string
- */
- public static String shortOptionExist(String name) {
- return "The attribute '" + name + "' scope is null or empty.";
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @param section
- * string
- * @return string
- */
- public static String nameExist(String name, String section) {
-
- return "Attribute name='" + name + "' under '" + section + ":' is already used, Take different one.";
- }
-
- /**
- * Static interface method.
- *
- * @param name
- * string
- * @param section
- * string
- * @param types
- * list
- * @return string
- */
- public static String invalidAttrType(String name, String section, List<String> types) {
- return "Attribute type of '" + name + "' under '" + section + "' is invalid, correct types are "
- + types.toString();
- }
-
- /**
- * Static interface method.
- *
- * @param param
- * string
- * @param section
- * string
- * @return string
- */
- public static String mandatoryAttrMissing(String param, String section) {
-
- return "Mandatory attribute '" + param + "' is missing under '" + section + "'";
- }
-
- /**
- * Static interface method.
- *
- * @param param
- * string
- * @param section
- * string
- * @return string
- */
- public static String mandatoryAttrEmpty(String param, String section) {
-
- return "Mandatory attribute '" + param + "' under '" + section + "' shouldn't be null or empty";
- }
-
- /**
- * Static interface method.
- *
- * @param attribute
- * string
- * @return string
- */
- public static String missingInResultMap(String attribute) {
-
- return "The attribute '" + attribute
- + "' declared under result 'attributes:' section is missing from http 'result_map:'.";
- }
-
- /**
- * Static interface method.
- *
- * @param attribute
- * string
- * @return string
- */
- public static String missingInResultAttribute(String attribute) {
-
- return "Mapped attribute '" + attribute + "' is missing declaration in result attributes section.";
- }
-
- /**
- * Static interface method.
- *
- * @param declaredParam
- * string
- * @return string
- */
- public static String parameterNotMapped(String declaredParam) {
-
- return "The parameter '" + declaredParam
- + "' declared under 'parameters:' section is not mapped into request section.";
- }
-
-}
+++ /dev/null
-/*
- * Copyright 2017 Huawei Technologies Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.cli.fw.schema;
-
-import com.fasterxml.jackson.databind.ObjectMapper;
-import net.minidev.json.JSONObject;
-
-import org.onap.cli.fw.error.OnapCommandInvalidSchema;
-
-import static org.onap.cli.fw.conf.Constants.*;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import java.util.Set;
-
-/**
- * Schema Validation impl.
- *
- */
-public class SchemaValidator extends AbstractSchemaValidate {
-
- /**
- * Constructor.
- *
- * @param schemaFile
- * file
- * @throws OnapCommandInvalidSchema
- * exception
- */
- public SchemaValidator(File schemaFile) throws OnapCommandInvalidSchema {
- super(schemaFile);
- }
-
- public SchemaValidator(String schemaFile) throws OnapCommandInvalidSchema {
- super(schemaFile);
- }
-
- @Override
- protected void validateSpecificSchema(SchemaType type) throws OnapCommandInvalidSchema {
- if (type.equals(SchemaType.HTTP)) {
- validateHttpParameters();
- }
- }
-
- @SuppressWarnings("unchecked")
- private void validateHttpParameters() {
-
- Map<String, Object> httpMap = (Map<String, Object>) yamlMap.get(HTTP);
-
- if (httpMap == null || httpMap.isEmpty()) {
- schemaErrors.add(HTTP_SECTION_EMPTY);
- return;
- }
-
- validateMandatoryParams(httpMap, HTTP_SECTIONS, HTTP_MANDATORY_SECTIONS, PARAMETERS);
-
- Map<String, Object> requestMap = (Map<String, Object>) httpMap.get(REQUEST);
-
- if (requestMap != null && !requestMap.isEmpty()) {
- validateHttpRequestParams(requestMap);
- } else {
- schemaErrors.add(SchemaValidate.emptySection(REQUEST));
- }
-
- List<Object> requestSuccessCodes = (List<Object>) httpMap.get(SUCCESS_CODES);
- if (requestSuccessCodes != null && !requestSuccessCodes.isEmpty()) {
- validateHttpSccessCodes(requestSuccessCodes);
- } else {
- schemaErrors.add(SchemaValidate.emptySection(SUCCESS_CODES));
- }
-
- Map<String, Object> resultMap = (Map<String, Object>) httpMap.get(RESULT_MAP);
-
- if (resultMap != null && !resultMap.isEmpty()) {
- validateHttpResultMapping(resultMap);
- }
-
- Object object = httpMap.get(SAMPLE_RESPONSE);
- if (object != null) {
- if (object instanceof String) {
- schemaErrors.add(HTTP_SAMPLE_RESPONSE_FAILED_PARSING);
- } else {
- validateSampleResponse((Map<String, Object>) object);
- }
- }
- }
-
- private void validateHttpRequestParams(Map<String, Object> requestMap) {
-
- if (requestMap == null || requestMap.isEmpty()) {
- return;
- }
- // validate mandatory parameters
- validateMandatoryParams(requestMap, HTTP_REQUEST_PARAMS, HTTP_REQUEST_MANDATORY_PARAMS, REQUEST);
-
- // Validate method types
- String method = (String) requestMap.get(METHOD);
- if (method != null && !method.isEmpty()) {
- if (!HTTP_METHODS.contains(method.toLowerCase())) {
- schemaErrors.add(SchemaValidate.invalidType(REQUEST, METHOD, HTTP_METHODS));
- }
- } else {
- schemaErrors.add("Http request method cann't be null or empty");
- }
-
- Set<String> requestParams = getRequestParams();
-
- // validate uriParams
- Set<String> uriParams = validateHttpUri(requestMap);
-
- // validate body
- Set<String> bodyParams = validateHttpBody(requestMap);
-
- // validate header
- Set<String> headerParams = validateHttpHeaders(requestMap);
-
- // validate queries
- Set<String> queryParams = validateHttpQueries(requestMap);
-
- for (String declaredParam : requestParams) {
- if (!uriParams.contains(declaredParam) && !bodyParams.contains(declaredParam)
- && !headerParams.contains(declaredParam) && !queryParams.contains(declaredParam)) {
- schemaErrors.add(SchemaValidate.parameterNotMapped(declaredParam));
- }
- }
-
- Set<String> totalParams = new HashSet<>();
- totalParams.addAll(uriParams);
- totalParams.addAll(bodyParams);
- totalParams.addAll(queryParams);
- totalParams.addAll(headerParams);
-
- for (String definedParam : totalParams) {
- if (!requestParams.contains(definedParam)) {
- if (uriParams.contains(definedParam)) {
- schemaErrors.add(SchemaValidate.invalidRequestParam(URI, definedParam));
- } else if (bodyParams.contains(definedParam)) {
- schemaErrors.add(SchemaValidate.invalidRequestParam(BODY, definedParam));
- } else if (queryParams.contains(definedParam)) {
- schemaErrors.add(SchemaValidate.invalidRequestParam(QUERIES, definedParam));
- } else if (headerParams.contains(definedParam)) {
- schemaErrors.add(SchemaValidate.invalidRequestParam(HEADERS, definedParam));
- }
- }
- }
-
- }
-
- private Set<String> validateHttpUri(Map<String, Object> requestMap) {
- Set<String> uriParamNames = new HashSet<>();
- String uri = (String) requestMap.get(URI);
- if (uri == null || uri.isEmpty()) {
- schemaErrors.add(SchemaValidate.emptySection(URI));
- return uriParamNames;
- }
- parseParameters(uri, uriParamNames);
- return uriParamNames;
- }
-
- @SuppressWarnings("unchecked")
- private Set<String> validateHttpHeaders(Map<String, Object> requestMap) {
-
- Map<String, Object> headers = (Map<String, Object>) requestMap.get(HEADERS);
- Set<String> headerParamNames = new HashSet<>();
- if (headers != null) {
- for (Entry<String, Object> entry : headers.entrySet()) {
- parseParameters(String.valueOf(entry.getValue()), headerParamNames);
- }
- }
- return headerParamNames;
- }
-
- @SuppressWarnings("unchecked")
- private Set<String> validateHttpQueries(Map<String, Object> requestMap) {
- Map<String, Object> queries = (Map<String, Object>) requestMap.get(QUERIES);
- Set<String> queryParamNames = new HashSet<>();
- if (queries != null) {
- for (Entry<String, Object> entry : queries.entrySet()) {
- parseParameters(String.valueOf(entry.getValue()), queryParamNames);
- }
- }
- return queryParamNames;
- }
-
- private Set<String> validateHttpBody(Map<String, Object> requestMap) {
- Set<String> bodyParamNames = new HashSet<>();
- Object bodyString = requestMap.get(BODY);
- if (bodyString == null) {
- return bodyParamNames;
- }
-
- String body = String.valueOf(bodyString);
- JSONObject obj = null;
- try {
- obj = new ObjectMapper().readValue(body, JSONObject.class);
- } catch (IOException e1) { // NOSONAR
- schemaErrors.add(HTTP_BODY_FAILED_PARSING);
- }
- if (obj == null || "".equals(obj.toString())) {
- schemaErrors.add(HTTP_BODY_JSON_EMPTY);
- }
- parseParameters(body, bodyParamNames);
-
- return bodyParamNames;
- }
-
- private void parseParameters(String line, Set<String> paramNames) {
-
- int currentIdx = 0;
- while (currentIdx < line.length()) {
- int idxS = line.indexOf("${", currentIdx);
- if (idxS == -1) {
- break;
- }
- int idxE = line.indexOf("}", idxS);
- String paramName = line.substring(idxS + 2, idxE);
- paramNames.add(paramName.trim());
-
- currentIdx = idxE + 1;
- }
-
- }
-
- private void validateHttpSccessCodes(List<Object> requestSuccessCodes) {
-
- for (Object successCode : requestSuccessCodes) {
- Integer code = (Integer) successCode;
- if (code < 200 || code >= 300) {
- schemaErrors.add(HTTP_SUCCESS_CODE_INVALID);
- }
- }
-
- }
-
- private void validateHttpResultMapping(Map<String, Object> resultMap) {
- Set<String> resultAttributes = getResultAttributes();
-
- // Validate if all result attributes are used in the result mapping
- for (String attribute : resultAttributes) {
- if (!resultMap.containsKey(attribute)) {
- schemaErrors.add(SchemaValidate.missingInResultMap(attribute));
- }
- }
-
- // Validate if all result mapping keys are defined in the result attributes
- for (Entry<String, Object> entry : resultMap.entrySet()) {
- if (!resultAttributes.contains(entry.getKey())) {
- schemaErrors.add(SchemaValidate.missingInResultAttribute(entry.getKey()));
- }
- }
- }
-
- private void validateSampleResponse(Map<String, Object> sampleResponseBodyMap) {
-
- // validate the json
- Object json = sampleResponseBodyMap.get(BODY);
- if (json == null) {
- schemaErrors.add(HTTP_SAMPLE_RESPONSE_EMPTY);
- return;
- }
- String jsonString = json.toString();
- try {
- if (jsonString.startsWith("[")) {
- new ObjectMapper().readValue(jsonString, JSONObject[].class);
- } else {
- new ObjectMapper().readValue(jsonString, JSONObject.class);
- }
- } catch (IOException e1) { // NOSONAR
- schemaErrors.add(HTTP_SAMPLE_RESPONSE_FAILED_PARSING);
- }
- }
-
-}
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;
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;
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;
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.
*
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();
throw new OnapCommandSchemaNotFound(schemaName, e);
}
if (inputStream == null) {
- throw new OnapCommandSchemaNotFound(schemaName);
+ inputStream = loadSchemaFromFile(schemaName);
}
Map<String, ?> values = null;
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();
}
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
* @throws OnapCommandInvalidSchema invalid schema
* @throws OnapCommandInvalidSchemaVersion invalid schema version
*/
- public static void loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault)
- throws OnapCommandException {
+ public static List<String> loadSchema(OnapCommand cmd, String schemaName, boolean includeDefault,
+ boolean validateSchema) throws OnapCommandException {
try {
Map<String, ?> defaultParameterMap = includeDefault ?
- validateSchemaVersion(Constants.DEFAULT_PARAMETER_FILE_NAME, cmd.getSchemaVersion()) : new HashMap<>();
+ validateSchemaVersion(DEFAULT_PARAMETER_FILE_NAME, cmd.getSchemaVersion()) : new HashMap<>();
Map<String, List<Map<String, String>>> commandYamlMap = (Map<String, List<Map<String, String>>>)validateSchemaVersion(schemaName, cmd.getSchemaVersion());
List<String> defParams = new ArrayList<>();
if (includeDefault) {
- if (commandYamlMap.get(Constants.PARAMETERS) == null) {
- commandYamlMap.put(Constants.PARAMETERS, (List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS));
+ if (commandYamlMap.get(PARAMETERS) == null) {
+ commandYamlMap.put(PARAMETERS, (List<Map<String, String>>) defaultParameterMap.get(PARAMETERS));
} else {
- commandYamlMap.get(Constants.PARAMETERS).addAll((List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS));
+ commandYamlMap.get(PARAMETERS).addAll((List<Map<String, String>>) defaultParameterMap.get(PARAMETERS));
}
- defParams = ((List<Map<String, String>>) defaultParameterMap.get(Constants.PARAMETERS)).stream()
- .map(p -> p.get(Constants.NAME)).collect(Collectors.toList());
+ defParams = ((List<Map<String, String>>) 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) {
}
}
- private static void parseSchema(OnapCommand cmd,
- final Map<String, ?> values,
- final List<String> defaultParamNames) throws OnapCommandException {
+ private static void throwOrCollect(OnapCommandException ex, List<String> list,
+ boolean shouldCollectException) throws OnapCommandException {
+ if (shouldCollectException) {
+ list.add(ex.getMessage());
+ } else {
+ throw ex;
+ }
+ }
+
+ private static void validateTags(List<String> schemaErrors, Map<String, ?> yamlMap,
+ List<String> totalParams, List<String> mandatoryParams,
+ String section) {
+ for (String param : totalParams) {
+ boolean isMandatory = mandatoryParams.contains(param);
+ boolean isYamlContains = yamlMap.containsKey(param);
+ if (isMandatory) {
+ if (!isYamlContains) {
+ schemaErrors.add("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<String> parseSchema(OnapCommand cmd,
+ final Map<String, ?> values,
+ final List<String> defaultParamNames,
+ boolean validate) throws OnapCommandException {
+
+ List<String> exceptionList = new ArrayList<>();
List<String> shortOptions = new ArrayList<>();
List<String> longOptions = new ArrayList<>();
- List<String> names = new ArrayList<>();
Set<String> filteredDefaultParams = new HashSet<>();
- List<String> sections = Arrays.asList(Constants.NAME, Constants.DESCRIPTION, Constants.SERVICE,
- Constants.DEFAULT_PARAMETERS, Constants.PARAMETERS, Constants.RESULTS);
+ if (validate) {
+ validateTags(exceptionList, (Map<String, Object>) values, OnapCommandConfg.getSchemaAttrInfo(TOP_LEVEL_PARAMS_LIST),
+ OnapCommandConfg.getSchemaAttrInfo(TOP_LEVEL_MANDATORY_LIST), "root level");
+ }
+
+
+ List<String> 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<String, String> map = (Map<String, String>) values.get(key);
+
+ if (validate) {
+ validateTags(exceptionList, (Map<String, Object>)values.get(key),
+ OnapCommandConfg.getSchemaAttrInfo(SERVICE_PARAMS_LIST),
+ OnapCommandConfg.getSchemaAttrInfo(SERVICE_PARAMS_MANDATORY_LIST), SERVICE);
+
+ HashMap<String, String> 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<String, String> 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<String, List<String>> defParameters = (Map) values.get(Constants.DEFAULT_PARAMETERS);
+ Map<String, List<String>> defParameters = (Map) values.get(DEFAULT_PARAMETERS);
List<String> includeParams = new ArrayList<>();
List<String> 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<String> 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<String> invExclude = excludeParams.stream().filter(p -> !defaultParamNames.contains(p))
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()) {
} 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<Map<String, String>> parameters = (List) values.get(key);
if (parameters != null) {
+ Set<String> names = new HashSet<>();
+ Set<String> inputShortOptions = new HashSet<>();
+ Set<String> inputLongOptions = new HashSet<>();
+
for (Map<String, String> 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<String, String> 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 {
}
}
}
- } else if (Constants.RESULTS.equals(key)) {
+ } else if (RESULTS.equals(key) && values.containsKey(key)) {
Map<String, ?> valueMap = (Map<String, ?>) values.get(key);
if (valueMap != null) {
OnapCommandResult result = new OnapCommandResult();
for (Map.Entry<String, ?> entry1 : valueMap.entrySet()) {
String key3 = entry1.getKey();
- 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<Map<String, String>> attrs = (ArrayList) valueMap.get(key3);
for (Map<String, String> map : attrs) {
OnapCommandResultAttribute attr = new OnapCommandResultAttribute();
+ if (validate) {
+ validateTags(exceptionList, map, OnapCommandConfg.getSchemaAttrInfo(RESULT_PARAMS_LIST),
+ OnapCommandConfg.getSchemaAttrInfo(RESULT_PARAMS_MANDATORY_LIST), ATTRIBUTES);
+ }
+
+ Set<String> resultParamNames = new HashSet<>();
+
for (Map.Entry<String, String> entry4 : map.entrySet()) {
String key4 = entry4.getKey();
- if (Constants.NAME.equals(key4)) {
- attr.setName(map.get(key4));
- } else if (Constants.DESCRIPTION.equals(key4)) {
+ 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 {
}
}
}
+ 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<String> validateHttpQueries(Map<String, Object> requestMap) {
+ Map<String, Object> queries = (Map<String, Object>) requestMap.get(QUERIES);
+ Set<String> queryParamNames = new HashSet<>();
+ if (queries != null) {
+ for (Entry<String, Object> entry : queries.entrySet()) {
+ parseParameters(String.valueOf(entry.getValue()), queryParamNames);
+ }
+ }
+ return queryParamNames;
+ }
+
+
+ private static Set<String> validateHttpHeaders(Map<String, Object> requestMap) {
+
+ Map<String, Object> headers = (Map<String, Object>) requestMap.get(HEADERS);
+ Set<String> headerParamNames = new HashSet<>();
+ if (headers != null) {
+ for (Entry<String, Object> entry : headers.entrySet()) {
+ parseParameters(String.valueOf(entry.getValue()), headerParamNames);
+ }
+ }
+ return headerParamNames;
+ }
+
+ private static Set<String> validateHttpBody(List<String> errorList, Map<String, Object> requestMap) {
+ Set<String> bodyParamNames = new HashSet<>();
+ Object bodyString = requestMap.get(BODY);
+ if (bodyString == null) {
+ return bodyParamNames;
+ }
+
+ String body = String.valueOf(bodyString);
+ JSONObject obj = null;
+ try {
+ obj = new ObjectMapper().readValue(body, JSONObject.class);
+ } catch (IOException e1) { // NOSONAR
+ 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<String> validateHttpUri(List<String> errorList, Map<String, Object> requestMap) {
+ Set<String> 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<String> paramNames) {
+
+ int currentIdx = 0;
+ while (currentIdx < line.length()) {
+ int idxS = line.indexOf("${", currentIdx);
+ if (idxS == -1) {
+ break;
+ }
+ int idxE = line.indexOf("}", idxS);
+ String paramName = line.substring(idxS + 2, idxE);
+ paramNames.add(paramName.trim());
+
+ currentIdx = idxE + 1;
+ }
+
+ }
+
+ private static Set<String> getRequestParams(Map<String, ?> yamlMap) {
+
+ Set<String> set = new HashSet<>();
+
+ @SuppressWarnings("unchecked")
+ List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(PARAMETERS);
+
+ if (inputParams != null) {
+ for (Map<String, Object> map : inputParams) {
+ for (Entry<String, Object> entry : map.entrySet()) {
+ Object key = entry.getKey();
+
+ if (NAME.equals(key)) {
+ set.add(String.valueOf(entry.getValue()));
+ break;
+ }
+ }
+ }
+ }
+
+ return set;
}
/**
public static void loadSchema(OnapSwaggerCommand cmd, String schemaName) throws OnapCommandException {
try {
Map<String, ?> values = (Map<String, ?>) validateSchemaVersion(schemaName, cmd.getSchemaVersion());
- Map<String, String> valueMap = (Map<String, String>) values.get(Constants.EXECUTOR);
+ Map<String, String> valueMap = (Map<String, String>) values.get(EXECUTOR);
OnapCommandExecutor exec = new OnapCommandExecutor();
for (Map.Entry<String, String> 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));
}
}
* @throws OnapCommandInvalidSchemaVersion
* invalid schema version
*/
- public static void loadSchema(OnapHttpCommand cmd, String schemaName) throws OnapCommandException {
+ public static ArrayList<String> loadHTTPSchemaSection(OnapHttpCommand cmd, String schemaName,
+ boolean validate) throws OnapCommandException {
+ ArrayList<String> errorList = new ArrayList<>();
try {
Map<String, ?> values = (Map<String, ?>) validateSchemaVersion(schemaName, cmd.getSchemaVersion());
- Map<String, ?> valMap = (Map<String, ?>) values.get(Constants.HTTP);
+ Map<String, ?> valMap = (Map<String, ?>) values.get(HTTP);
- for (Map.Entry<String, ?> entry1 : valMap.entrySet()) {
- String key1 = entry1.getKey();
- if (Constants.REQUEST.equals(key1)) {
- Map<String, ?> map = (Map<String, ?>) valMap.get(key1);
-
- for (Map.Entry<String, ?> entry2 : map.entrySet()) {
- String key2 = entry2.getKey();
-
- if (Constants.URI.equals(key2)) {
- Object obj = map.get(key2);
- cmd.getInput().setUri(obj.toString());
- } else if (Constants.MERHOD.equals(key2)) {
- Object obj = map.get(key2);
- cmd.getInput().setMethod(obj.toString());
- } else if (Constants.BODY.equals(key2)) {
- Object obj = map.get(key2);
- cmd.getInput().setBody(obj.toString());
- } else if (Constants.HEADERS.equals(key2)) {
- Map<String, String> head = (Map<String, String>) map.get(key2);
- cmd.getInput().setReqHeaders(head);
- } else if (Constants.QUERIES.equals(key2)) {
- Map<String, String> query = (Map<String, String>) map.get(key2);
-
- cmd.getInput().setReqQueries(query);
+ 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<String, ?> entry1 : valMap.entrySet()) {
+ String key1 = entry1.getKey();
+ if (REQUEST.equals(key1)) {
+ Map<String, ?> map = (Map<String, ?>) valMap.get(key1);
+
+ for (Map.Entry<String, ?> 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<String, String> head = (Map<String, String>) map.get(key2);
+ cmd.getInput().setReqHeaders(head);
+ } else if (QUERIES.equals(key2)) {
+ Map<String, String> query = (Map<String, String>) 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<Object>) valMap.get(key1));
}
+ cmd.setSuccessStatusCodes((ArrayList) valMap.get(key1));
+ } else if (RESULT_MAP.equals(key1)) {
+ if (validate) {
+ validateHttpResultMap(errorList, values);
+ }
+ cmd.setResultMap((Map<String, String>) 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<String, String>) 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<String> errorList, Map<String, ?> values) throws OnapCommandException {
+ Map<String, ?> valMap = (Map<String, ?>) values.get(HTTP);
+ List<Map<String, String>> attributes = (List<Map<String, String>>) ((Map<String, ?>)values.get(RESULTS)).get(ATTRIBUTES);
+ Set<String> resultMapParams = ((Map<String, String>) valMap.get(RESULT_MAP)).keySet();
+
+ Set<String> resultAttNames = attributes.stream().map(map -> map.get(NAME))
+ .collect(Collectors.toSet());
+
+ List<String> 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<String> errorList, List<Object> 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<String> validateHttpSchemaSection(Map<String, ?> values) {
+
+ ArrayList<String> errorList = new ArrayList<>();
+ Map<String, ?> map = (Map<String, ?>) values.get(HTTP);
+ Map<String, Object> requestMap = (Map<String, Object>) 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<String> requestParams = getRequestParams(values);
+
+ Set<String> uriParams = validateHttpUri(errorList, requestMap);
+
+ Set<String> bodyParams = validateHttpBody(errorList, requestMap);
+
+ Set<String> headerParams = validateHttpHeaders(requestMap);
+
+ Set<String> queryParams = validateHttpQueries(requestMap);
+
+ HashSet<String> totoalParams = new HashSet<>(uriParams);
+ totoalParams.addAll(bodyParams);
+ totoalParams.addAll(headerParams);
+ totoalParams.addAll(queryParams);
+
+ List<String> 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.
*
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);
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));
}
/**
public static List<ExternalSchema> findAllExternalSchemas() throws OnapCommandException {
List<ExternalSchema> 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<String, ?> resourceMap;
for (Resource resource : res) {
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;
public static void persist(List<ExternalSchema> 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);
}
}
}
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;
}
} 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();
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);
}
}
@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);
@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();
}
}
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<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
assertTrue(parameters.contains("onap-username"));
assertTrue(parameters.contains("onap-password"));
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<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
assertTrue(parameters.contains("onap-username"));
assertTrue(parameters.contains("onap-password"));
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<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
assertTrue(parameters.contains("onap-username"));
protected void run() throws OnapCommandException {}
};
- OnapCommandUtils.loadSchema(cmd, "onap-test-schema.yaml", true);
+ OnapCommandUtils.loadSchema(cmd, "onap-test-schema.yaml", true, false);
List<String> parameters = cmd.getParameters().stream().map(p -> p.getName()).collect(Collectors.toList());
assertFalse(parameters.contains("onap-username"));
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)
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)
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)
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)
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);
}
}
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<String> 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<String> 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<String> 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<String> 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<String> 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<String>());
- SchemaValidate.invalidAttrType("name", "section", new ArrayList<String>());
- SchemaValidate.invalidBooleanValueMessage("section", "attribute", "value");
- SchemaValidate.invalidRequestParam("subSection", "attribute");
- SchemaValidate.invalidSections(new HashSet<String>(), new ArrayList<String>(), new ArrayList<String>());
- SchemaValidate.attributeScopeEmpty("fsdf");
- SchemaValidate.invalidType("section", "attribute", new ArrayList<String>());
- SchemaValidate.longOptionExist("name");
- SchemaValidate.shortOptionExist("name");
- SchemaValidate.optionExist("option", "attrValue", "name");
- SchemaValidate.optionDefaultExist("option", "attrValue", "name", new HashSet<String>());
- SchemaValidate.nameExist("name", "section");
- SchemaValidate.mandatoryAttrEmpty("param", "section");
}
}
@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");
}
@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()) {
@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<String, OnapCommandParameter> map = OnapCommandUtils.getInputMap(cmd.getParameters());
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
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
@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);
public void zendExceptionTest2() throws OnapCommandException {
mockExternalResources();
- OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false);
+ OnapCommandUtils.loadSchema(new OnapHttpCommandSample(), "schemaName", false, false);
}
@Test(expected = OnapCommandException.class)
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);
Code Review / cli.git / commitdiff