import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItems;
import static org.hamcrest.Matchers.hasSize;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.when;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIRED;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.STATUS;
+import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
+import com.google.gson.Gson;
+import fj.data.Either;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
import java.util.stream.Collectors;
-
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.BeforeEach;
import org.openecomp.sdc.be.model.InterfaceDefinition;
import org.yaml.snakeyaml.Yaml;
-import fj.data.Either;
-
@ExtendWith(MockitoExtension.class)
class InterfaceDefinitionHandlerTest {
final OperationDataDefinition deleteOperation = actualInterfaceDefinition.getOperations().get(DELETE_OPERATION);
assertOperation("'camunda/serviceDeselect'", deleteOperation);
- final Map<String, String> expectedInputMap = new HashMap<>();
- expectedInputMap.put("action", "org.openecomp.resource.datatypes.Action");
+ final Map<String, Map<String, Object>> startOperationExpectedInputMap = createStartOperationInputMap();
final OperationDataDefinition startOperation = actualInterfaceDefinition.getOperations().get(START_OPERATION);
- assertOperation("'camunda/executeAction'", expectedInputMap, startOperation);
+ assertOperation("'camunda/executeAction'", startOperationExpectedInputMap, startOperation);
+ final Map<String, Map<String, Object>> stopOperationExpectedInputMap = createStopOperationInputMap();
final OperationDataDefinition stopOperation = actualInterfaceDefinition.getOperations().get(STOP_OPERATION);
- assertOperation("'camunda/executeAction'", expectedInputMap, stopOperation);
+ assertOperation("'camunda/executeAction'", stopOperationExpectedInputMap, stopOperation);
+ }
+
+ private Map<String, Map<String, Object>> createStopOperationInputMap() {
+ final Map<String, Map<String, Object>> stopOperationExpectedInputMap = new HashMap<>();
+ final Map<String, Object> actionInput = Map.of(
+ "type", "org.openecomp.resource.datatypes.Action"
+ );
+ stopOperationExpectedInputMap.put("action", actionInput);
+ return stopOperationExpectedInputMap;
+ }
+
+ private Map<String, Map<String, Object>> createStartOperationInputMap() {
+ final Map<String, Map<String, Object>> startOperationExpectedInputMap = new HashMap<>();
+ final Map<String, Object> actionInput = Map.of(
+ "type", "org.openecomp.resource.datatypes.Action"
+ );
+ startOperationExpectedInputMap.put("action", actionInput);
+ final Map<String, Object> stringInput = Map.of(
+ "type", "string",
+ "default", "this is a string"
+ );
+ startOperationExpectedInputMap.put("stringInput", stringInput);
+ final Map<String, Object> booleanInput = Map.of(
+ "type", "boolean",
+ "default", true
+ );
+ startOperationExpectedInputMap.put("booleanInput", booleanInput);
+ final Map<String, Object> integerInput = Map.of(
+ "type", "integer",
+ "description", "an integer",
+ "status", "supported",
+ "required", true,
+ "default", 11
+ );
+ startOperationExpectedInputMap.put("integerInput", integerInput);
+ final Map<String, Object> floatInput = Map.of(
+ "type", "float",
+ "required", false,
+ "default", 11.1
+ );
+ startOperationExpectedInputMap.put("floatInput", floatInput);
+
+ final LinkedHashMap<String, Object> complexInputDefault = new LinkedHashMap<>();
+ complexInputDefault.put("dsl_stability_profile", "dsl_stability_profile_value");
+ complexInputDefault.put("central_splitter", false);
+ complexInputDefault.put("service_restoration_sla", "service_restoration_sla_value");
+ complexInputDefault.put("battery_backup", true);
+ complexInputDefault.put("partner_priorty_assist", false);
+ final Map<String, Object> complexInput = Map.of(
+ "type", "onap.datatypes.partner.access_details",
+ "status", "experimental",
+ "default", complexInputDefault
+ );
+ startOperationExpectedInputMap.put("complexInput", complexInput);
+ return startOperationExpectedInputMap;
}
private void assertOperation(final String implementation, final OperationDataDefinition actualOperation) {
assertOperation(implementation, Collections.emptyMap(), actualOperation);
}
- private void assertOperation(final String implementation, final Map<String, String> inputNameTypeMap,
+ private void assertOperation(final String implementation, final Map<String, Map<String, Object>> inputNameTypeMap,
final OperationDataDefinition actualOperation) {
final ArtifactDataDefinition artifactDefinition = actualOperation.getImplementation();
assertThat("Implementation should be as expected", artifactDefinition.getArtifactName(), equalTo(implementation));
assertThat(String.format(msgFormat, "the expected inputs"), inputNames,
hasItems(inputNameTypeMap.keySet().toArray(new String[0])));
+
+ for (final Entry<String, Map<String, Object>> inputEntry : inputNameTypeMap.entrySet()) {
+ final String expectedInputName = inputEntry.getKey();
+ final Optional<OperationInputDefinition> inputDefinitionOptional = inputList.stream()
+ .filter(operationInputDefinition -> operationInputDefinition.getName().equals(expectedInputName)).findFirst();
+ assertTrue(inputDefinitionOptional.isPresent(), String.format("Input '%s' should be present", expectedInputName));
+ final OperationInputDefinition actualInputDefinition = inputDefinitionOptional.get();
+ final Map<String, Object> expectedInput = inputEntry.getValue();
+
+ assertEquals(expectedInput.get(STATUS.getElementName()), actualInputDefinition.getStatus(),
+ String.format("%s attribute of input %s should be as expected", STATUS.getElementName(), expectedInputName)
+ );
+ assertEquals(expectedInput.get(TYPE.getElementName()), actualInputDefinition.getType(),
+ String.format("%s attribute of input %s should be as expected", TYPE.getElementName(), expectedInputName)
+ );
+ assertEquals(expectedInput.get(DESCRIPTION.getElementName()), actualInputDefinition.getDescription(),
+ String.format("%s attribute of input %s should be as expected", DESCRIPTION.getElementName(), expectedInputName)
+ );
+ final Object expectedRequired =
+ expectedInput.get(REQUIRED.getElementName()) == null ? false : expectedInput.get(REQUIRED.getElementName());
+ assertEquals(expectedRequired, actualInputDefinition.getRequired(),
+ String.format("%s attribute of input %s should be as expected", REQUIRED.getElementName(), expectedInputName)
+ );
+
+ String expectedJson = null;
+ if (expectedInput.get(DEFAULT.getElementName()) != null) {
+ expectedJson = new Gson().toJson(expectedInput.get(DEFAULT.getElementName()));
+ }
+ assertEquals(expectedJson, actualInputDefinition.getToscaDefaultValue(),
+ String.format("%s of input %s should be as expected", DEFAULT.getElementName(), expectedInputName)
+ );
+ }
}
private void assertInput(final String type, final String description, final Boolean required,
private Map<String, Object> loadYaml(final Path filePathFromResource) throws FileNotFoundException {
final Path filePath = Paths.get(TEST_RESOURCE_PATH.toString(), filePathFromResource.toString());
final FileInputStream fileInputStream = new FileInputStream(filePath.toString());
- return (Map<String, Object>) new Yaml().load(fileInputStream);
+ return new Yaml().load(fileInputStream);
}
}
\ No newline at end of file
Code Review / sdc.git / blobdiff