propertyConstraint.initialize(toscaType);
propertyConstraint.validate(toscaType, propertyDefinition.getValue());
} catch (ConstraintValueDoNotMatchPropertyTypeException | ConstraintViolationException exception) {
- errorMessages.add("\n" + propertyConstraint.getErrorMessage(toscaType, exception, getCompletePropertyName(propertyDefinition)));
+ errorMessages.add(propertyConstraint.getErrorMessage(toscaType, exception, getCompletePropertyName(propertyDefinition)));
}
}
} else if (isPropertyNotMappedAsInput(propertyDefinition) && ToscaType.isPrimitiveType(propertyDefinition.getType()) && !toscaType
*/
package org.openecomp.sdc.be.model.tosca;
+import lombok.Getter;
import org.openecomp.sdc.be.model.tosca.converters.BooleanConverter;
import org.openecomp.sdc.be.model.tosca.converters.DefaultConverter;
import org.openecomp.sdc.be.model.tosca.converters.FloatConverter;
*
* @author esofer
*/
+@Getter
public enum ToscaPropertyType {
// @formatter:off
ROOT("tosca.datatypes.Root", null, null, null, true),
SCALAR_UNIT_SIZE("scalar-unit.size", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
SCALAR_UNIT_TIME("scalar-unit.time", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
SCALAR_UNIT_FREQUENCY("scalar-unit.frequency", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
+ SCALAR_UNIT_BITRATE("scalar-unit.bitrate", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
RANGE("range", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
TIMESTAMP("timestamp", StringValidator.getInstance(), DefaultConverter.getInstance(), ToscaValueDefaultConverter.getInstance()),
MAP("map", MapValidator.getInstance(), MapConverter.getInstance(), ToscaMapValueConverter.getInstance()),
}
}
- public String getType() {
- return type;
- }
-
- public PropertyTypeValidator getValidator() {
- return validator;
- }
-
- public PropertyValueConverter getConverter() {
- return converter;
- }
-
public boolean isAbstract() {
return isAbstract;
}
- public ToscaValueConverter getValueConverter() {
- return valueConverter;
- }
-
@Override
public String toString() {
return name().toLowerCase();
import java.util.List;
import java.util.Locale;
import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.openecomp.sdc.be.model.tosca.constraints.ConstraintUtil;
SCALAR_UNIT("scalar-unit"),
SCALAR_UNIT_SIZE("scalar-unit.size"),
SCALAR_UNIT_TIME("scalar-unit.time"),
+ SCALAR_UNIT_BITRATE("scalar-unit.bitrate"),
SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
// @formatter:on
+ private static final String SCALAR_UNIT_BITRATE_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([TtGgMmKk]?i?[Bb]ps)$";
+ private static final String SCALAR_UNIT_TIME_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([mun]?[dhms])$";
+ private static final String SCALAR_UNIT_SIZE_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([TtGgMmKk]?i?[Bb])$";
+ private static final String SCALAR_UNIT_FREQUENCY_PATTERN = "(^[0-9]+\\.?[0-9]*) ?([kMG]?Hz)$";
+ private static final double B_IN_TiB = Math.pow(1024, 4);
+ private static final double B_IN_GiB = Math.pow(1024, 3);
+ private static final double B_IN_MiB = Math.pow(1024, 2);
+ private static final double B_IN_KiB = Math.pow(1024, 1);
+ private static final double B_IN_TB = Math.pow(1000, 4);
+ private static final double B_IN_GB = Math.pow(1000, 3);
+ private static final double B_IN_MB = Math.pow(1000, 2);
+ private static final double B_IN_KB = Math.pow(1000, 1);
+
@Getter
private final String type;
return ToscaPropertyType.MAP.getType().equals(type) || ToscaPropertyType.LIST.getType().equals(type);
}
- public Boolean isValueTypeValid(Object value) {
+ public boolean isValueTypeValid(Object value) {
switch (this) {
case BOOLEAN:
return value.equals(true) || value.equals(false);
case RANGE:
return value instanceof Integer;
case STRING:
- case SCALAR_UNIT:
case SCALAR_UNIT_SIZE:
case SCALAR_UNIT_TIME:
+ case SCALAR_UNIT_BITRATE:
case SCALAR_UNIT_FREQUENCY:
case TIMESTAMP:
case VERSION:
case LIST:
case MAP:
return true;
+ case SCALAR_UNIT:
default:
return false;
}
return isFloat(value);
case INTEGER:
return isInteger(value);
- case STRING:
- case SCALAR_UNIT:
case SCALAR_UNIT_SIZE:
+ return isScalarUnitSize(value);
case SCALAR_UNIT_TIME:
+ return isScalarUnitTime(value);
+ case SCALAR_UNIT_BITRATE:
+ return isScalarUnitBitrate(value);
case SCALAR_UNIT_FREQUENCY:
+ return isScalarUnitFrequency(value);
+ case STRING:
return true;
case TIMESTAMP:
return TimestampValidator.getInstance().isValid(value, null);
return isList(value);
case MAP:
return isMap(value);
+ case SCALAR_UNIT:
default:
return false;
}
public Object convert(String value) {
switch (this) {
case STRING:
- case SCALAR_UNIT:
- case SCALAR_UNIT_SIZE:
+ return value;
case SCALAR_UNIT_TIME:
+ return convertScalarUnitTime(value);
+ case SCALAR_UNIT_BITRATE:
+ return convertScalarUnitBitrate(value);
+ case SCALAR_UNIT_SIZE:
+ return convertScalarUnitSize(value);
case SCALAR_UNIT_FREQUENCY:
- return value;
+ return convertScalarUnitFrequency(value);
case BOOLEAN:
return Boolean.valueOf(value);
case FLOAT:
} catch (ConstraintValueDoNotMatchPropertyTypeException e) {
throw new IllegalArgumentException("Value must be a valid Map", e);
}
+ case SCALAR_UNIT:
default:
return null;
}
}
- @Override
- public String toString() {
- return name().toLowerCase();
+ private Long convertScalarUnitSize(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_SIZE_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "TiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TiB);
+ case "TB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TB);
+ case "GiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GiB);
+ case "GB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GB);
+ case "MiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MiB);
+ case "MB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MB);
+ case "KiB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KiB);
+ case "kB":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KB);
+ case "B":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.size");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.size");
+ }
+ }
+
+ private Long convertScalarUnitTime(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_TIME_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "d":
+ return (long) (Double.parseDouble(matcher.group(1)) * 24 * 60 * 60 * 1_000_000_000L); // 24hours * 60minutes * 60seconds
+ case "h":
+ return (long) (Double.parseDouble(matcher.group(1)) * 60 * 60 * 1_000_000_000L); // 60minutes * 60seconds
+ case "m":
+ return (long) (Double.parseDouble(matcher.group(1)) * 60 * 1_000_000_000L); // 60seconds
+ case "s":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000_000L);
+ case "ms":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000L);
+ case "us":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000L);
+ case "ns":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.time");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.time");
+ }
+ }
+
+ private Long convertScalarUnitFrequency(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_FREQUENCY_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "GHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000_000L);
+ case "MHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000_000L);
+ case "kHz":
+ return (long) (Double.parseDouble(matcher.group(1)) * 1_000L);
+ case "Hz":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.frequency");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.frequency");
+ }
+ }
+
+ private Long convertScalarUnitBitrate(final String value) {
+ final Matcher matcher = Pattern.compile(SCALAR_UNIT_BITRATE_PATTERN).matcher(value.trim());
+ if (matcher.find()) {
+ switch (matcher.group(2)) {
+ case "TiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_TiB);
+ case "TBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_TB);
+ case "GiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_GiB);
+ case "GBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_GB);
+ case "MiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_MiB);
+ case "MBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_MB);
+ case "KiBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_KiB);
+ case "KBps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8 * B_IN_KB);
+ case "Bps":
+ return (long) (Double.parseDouble(matcher.group(1)) * 8);
+ case "Tibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TiB);
+ case "Tbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_TB);
+ case "Gibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GiB);
+ case "Gbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_GB);
+ case "Mibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MiB);
+ case "Mbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_MB);
+ case "Kibps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KiB);
+ case "Kbps":
+ return (long) (Double.parseDouble(matcher.group(1)) * B_IN_KB);
+ case "bps":
+ return (long) (Double.parseDouble(matcher.group(1)));
+ default:
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.bitrate");
+ }
+ } else {
+ throw new IllegalArgumentException("Value must be a valid scalar-unit.bitrate");
+ }
+ }
+
+ private boolean isScalarUnitBitrate(final String value) {
+ return Pattern.compile(SCALAR_UNIT_BITRATE_PATTERN).matcher(value.trim()).find();
}
+
+ private boolean isScalarUnitSize(final String value) {
+ return Pattern.compile(SCALAR_UNIT_SIZE_PATTERN).matcher(value.trim()).find();
+ }
+
+ private boolean isScalarUnitTime(final String value) {
+ return Pattern.compile(SCALAR_UNIT_TIME_PATTERN).matcher(value.trim()).find();
+ }
+
+ private boolean isScalarUnitFrequency(final String value) {
+ return Pattern.compile(SCALAR_UNIT_FREQUENCY_PATTERN).matcher(value.trim()).find();
+ }
+
}
import java.beans.PropertyDescriptor;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.NoArgsConstructor;
import org.openecomp.sdc.be.model.tosca.ToscaType;
import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
import org.slf4j.Logger;
/**
* Utility class to validate constraints types.
*/
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class ConstraintUtil {
private static final Logger logger = LoggerFactory.getLogger(ConstraintUtil.class);
- private ConstraintUtil() {
- }
-
/**
* Validates that the {@link ToscaType} specified is a {@link ToscaType#STRING}.
*
* @param propertyType the tosca type to check
* @throws ConstraintValueDoNotMatchPropertyTypeException if the property type cannot be compared
*/
- public static void checkComparableType(ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
+ public static void checkComparableType(final ToscaType propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
// The validity of the value is already assured by us with our ToscaType.convert() method
// here we just want to check that the constraint is not used on unsupported type as boolean
- switch (propertyType) {
+ final ToscaType toscaType = ToscaType.getToscaType(propertyType.getType());
+ switch (toscaType) {
case FLOAT:
case INTEGER:
case TIMESTAMP:
case VERSION:
case STRING:
+ case SCALAR_UNIT_SIZE:
+ case SCALAR_UNIT_TIME:
+ case SCALAR_UNIT_BITRATE:
+ case SCALAR_UNIT_FREQUENCY:
break;
case BOOLEAN:
- throw new ConstraintValueDoNotMatchPropertyTypeException("Constraint is invalid for property type <" + propertyType.toString() + ">");
+ case SCALAR_UNIT:
+ throw new ConstraintValueDoNotMatchPropertyTypeException("Constraint is invalid for property type <" + propertyType.getType() + ">");
default:
- throw new ConstraintValueDoNotMatchPropertyTypeException("Invalid property type <" + propertyType.toString() + ">");
+ throw new ConstraintValueDoNotMatchPropertyTypeException("Invalid property type <" + propertyType.getType() + ">");
}
}
*/
@SuppressWarnings("rawtypes")
public static Comparable convertToComparable(ToscaType propertyType, String value) {
- Object comparableObj = propertyType.convert(value);
+ final Object comparableObj = propertyType.convert(value);
if (!(comparableObj instanceof Comparable)) {
throw new IllegalArgumentException("Try to convert a value of a type which is not comparable [" + propertyType + "] to Comparable");
} else {
}
public static ConstraintInformation getConstraintInformation(Object constraint) throws IntrospectionException {
- PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(constraint.getClass()).getPropertyDescriptors();
PropertyDescriptor firstDescriptor = null;
- for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
+ for (final PropertyDescriptor propertyDescriptor : Introspector.getBeanInfo(constraint.getClass()).getPropertyDescriptors()) {
if (propertyDescriptor.getReadMethod() != null && propertyDescriptor.getWriteMethod() != null) {
firstDescriptor = propertyDescriptor;
break;
return objectMap;
}
+ @AllArgsConstructor
public static class ConstraintInformation {
- private String name;
- private Object reference;
- private String value;
- private String type;
-
- public ConstraintInformation(String name, Object reference, String value, String type) {
- this.name = name;
- this.reference = reference;
- this.value = value;
- this.type = type;
- }
+ private final String name;
+ private final Object reference;
+ private final String value;
+ private final String type;
}
}
* 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.
package org.openecomp.sdc.be.model.tosca;
import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Date;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.openecomp.sdc.be.model.tosca.version.Version;
+class ToscaTypeTest {
+
+ @Test
+ void testIsValidValueBoolean() throws Exception {
+ ToscaType toscaType = ToscaType.BOOLEAN;
+
+ assertFalse(toscaType.isValidValue(""));
+ assertTrue(toscaType.isValidValue("false"));
+ assertTrue(toscaType.isValidValue("FalSe"));
+ assertTrue(toscaType.isValidValue("true"));
+ assertTrue(toscaType.isValidValue("TrUe"));
+ }
+
+ @Test
+ void testIsValidValueFloat() throws Exception {
+ ToscaType toscaType = ToscaType.FLOAT;
+
+ assertFalse(toscaType.isValidValue("float"));
+ assertTrue(toscaType.isValidValue("1.2534"));
+ assertTrue(toscaType.isValidValue("1.2534f"));
+ }
+
+ @Test
+ void testIsValidValueString() throws Exception {
+ ToscaType toscaType = ToscaType.STRING;
+
+ assertTrue(toscaType.isValidValue("string"));
+ assertTrue(toscaType.isValidValue("1 string"));
+ assertTrue(toscaType.isValidValue("2 s_t_r_i_n_g"));
+ }
+
+ @Test
+ void testIsValidValueInteger() throws Exception {
+ ToscaType toscaType = ToscaType.INTEGER;
+
+ assertFalse(toscaType.isValidValue("integer"));
+ assertTrue(toscaType.isValidValue("1235"));
+ }
+
+ @Test
+ void testIsValidValueTimestamp() throws Exception {
+ ToscaType toscaType = ToscaType.TIMESTAMP;
+
+ assertFalse(toscaType.isValidValue("timestamp"));
+ assertTrue(toscaType.isValidValue("2001-12-14t21:59:43.10-05:00"));
+ assertFalse(toscaType.isValidValue("30 juin 2009 07:03:47"));
+ }
+
+ @Test
+ void testIsValidValueVersion() throws Exception {
+ ToscaType toscaType = ToscaType.VERSION;
+
+ assertFalse(toscaType.isValidValue("version"));
+ assertTrue(toscaType.isValidValue("1.2"));
+ assertTrue(toscaType.isValidValue("1.2.3"));
+ assertTrue(toscaType.isValidValue("1.2-3"));
+ }
+
+ @Test
+ void testIsValidValueList() throws Exception {
+ ToscaType toscaType = ToscaType.LIST;
+
+ assertFalse(toscaType.isValidValue("list"));
+ assertTrue(toscaType.isValidValue("[\"color\",\"type\"]"));
+ }
+
+ @Test
+ void testIsValidValueMap() throws Exception {
+ ToscaType toscaType = ToscaType.MAP;
+
+ assertFalse(toscaType.isValidValue("map"));
+ assertTrue(toscaType.isValidValue("{\"color\":\"yellow\",\"type\":\"renault\"}"));
+ }
+
+ @Test
+ void testNotValidValueScalarUnit() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT;
+
+ assertFalse(testSubject.isValidValue("5"));
+ }
+
+ @Test
+ void testIsValidValueScalarUnitSize() throws Exception {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_SIZE;
+
+ assertTrue(testSubject.isValidValue("5 TiB"));
+ assertFalse(testSubject.isValidValue("5"));
+ }
+
+ @Test
+ void testIsValidValueScalarUnitTime() throws Exception {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_TIME;
+
+ assertTrue(testSubject.isValidValue("5 d"));
+ assertFalse(testSubject.isValidValue("a5 sz"));
+ }
+
+ @Test
+ void testIsValidValueScalarUnitBitrate() throws Exception {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_BITRATE;
+
+ assertTrue(testSubject.isValidValue("5 TiBps"));
+ assertFalse(testSubject.isValidValue("5 bps5"));
+ }
+
+ @Test
+ void testIsValidValueScalarUnitFrequency() throws Exception {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_FREQUENCY;
+
+ assertTrue(testSubject.isValidValue("5 MHz"));
+ assertFalse(testSubject.isValidValue("5"));
+ }
+
+ @Test
+ void testGetToscaType() throws Exception {
+ ToscaType toscaType = ToscaType.MAP;
+
+ assertEquals(ToscaType.getToscaType("map"), toscaType);
+ assertNull(ToscaType.getToscaType(null));
+ assertNull(ToscaType.getToscaType("InvalidType"));
+ }
+
+ @Test
+ void testIsPrimitiveType() throws Exception {
+ assertFalse(ToscaType.isPrimitiveType(null));
+ assertFalse(ToscaType.isPrimitiveType("map"));
+ assertFalse(ToscaType.isPrimitiveType("list"));
+ assertFalse(ToscaType.isPrimitiveType("String"));
+ assertTrue(ToscaType.isPrimitiveType("string"));
+ assertTrue(ToscaType.isPrimitiveType("integer"));
+ }
+
+ @Test
+ void testIsCollectionType() throws Exception {
+ assertTrue(ToscaType.isCollectionType("map"));
+ assertTrue(ToscaType.isCollectionType("list"));
+ assertFalse(ToscaType.isCollectionType("Map"));
+ assertFalse(ToscaType.isCollectionType("string"));
+ assertFalse(ToscaType.isCollectionType("integer"));
+ }
+
+ @Test
+ void testConvert() throws Exception {
+ ToscaType typeInt = ToscaType.INTEGER;
+ assertEquals(123l, typeInt.convert("123"));
+
+ ToscaType typeBool = ToscaType.BOOLEAN;
+ assertEquals(true, typeBool.convert("true"));
+
+ ToscaType typeStr = ToscaType.STRING;
+ assertEquals("str", typeStr.convert("str"));
+
+ ToscaType typeFloat = ToscaType.FLOAT;
+ assertTrue(typeFloat.convert("1.2357f") instanceof Float);
+
+ ToscaType typeTimestamp = ToscaType.TIMESTAMP;
+ assertTrue(typeTimestamp.convert("Jun 30, 2009 7:03:47 AM") instanceof Date);
+ assertThrows(IllegalArgumentException.class, () -> typeTimestamp.convert(""));
+
+ ToscaType typeVersion = ToscaType.VERSION;
+ assertTrue(typeVersion.convert("1.2.3.5.6") instanceof Version);
+
+ ToscaType typeList = ToscaType.LIST;
+ assertTrue(typeList.convert("[\"str1\",\"str2\"]") instanceof List);
+ assertThrows(IllegalArgumentException.class, () -> typeList.convert(""));
+
+ ToscaType typeMap = ToscaType.MAP;
+ assertTrue(typeMap.convert("{\"color\":\"yellow\",\"type\":\"renault\"}") instanceof Map);
+ assertThrows(IllegalArgumentException.class, () -> typeMap.convert(""));
+
+ ToscaType typeScalarUnit = ToscaType.SCALAR_UNIT;
+ assertNull(typeScalarUnit.convert(""));
+
+ }
+
+ @Test
+ void testConvertScalarUnitTime() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_TIME;
+ assertTrue(testSubject.convert("5d") instanceof Long);
+ assertTrue(testSubject.convert("4 h") instanceof Long);
+ assertTrue(testSubject.convert(" 3 m ") instanceof Long);
+ assertTrue(testSubject.convert("9.5s") instanceof Long);
+ assertTrue(testSubject.convert("90 ms") instanceof Long);
+ assertTrue(testSubject.convert("55.44 us") instanceof Long);
+ assertTrue(testSubject.convert("111ns") instanceof Long);
+
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5z.ms"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("a5 ms"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5 msZ"));
+ }
+
+ @Test
+ void testConvertScalarUnitSize() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_SIZE;
+ assertTrue(testSubject.convert("5 TiB") instanceof Long);
+ assertTrue(testSubject.convert("4 TB") instanceof Long);
+ assertTrue(testSubject.convert("31 GiB") instanceof Long);
+ assertTrue(testSubject.convert("19.5 GB") instanceof Long);
+ assertTrue(testSubject.convert("90 MiB") instanceof Long);
+ assertTrue(testSubject.convert("55.44 MB") instanceof Long);
+ assertTrue(testSubject.convert("111 KiB") instanceof Long);
+ assertTrue(testSubject.convert("123. kB") instanceof Long);
+ assertTrue(testSubject.convert("0.9 B") instanceof Long);
+
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5z.MB"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("a5 TB"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5 TBz"));
+ }
+
+ @Test
+ void testConvertScalarUnitFrequency() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_FREQUENCY;
+ assertTrue(testSubject.convert("5 GHz") instanceof Long);
+ assertTrue(testSubject.convert("41 MHz") instanceof Long);
+ assertTrue(testSubject.convert("319 kHz") instanceof Long);
+ assertTrue(testSubject.convert("19.5 Hz") instanceof Long);
+
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5z.GHz"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("a5 Hz"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5 Hza"));
+ }
+
+ @Test
+ void testConvertScalarUnitBitrate() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_BITRATE;
+ assertTrue(testSubject.convert("5 TiBps") instanceof Long);
+ assertTrue(testSubject.convert("41 TBps") instanceof Long);
+ assertTrue(testSubject.convert("319 GiBps") instanceof Long);
+ assertTrue(testSubject.convert("19.5 GBps") instanceof Long);
+ assertTrue(testSubject.convert("90 MiBps") instanceof Long);
+ assertTrue(testSubject.convert("55.44 MBps") instanceof Long);
+ assertTrue(testSubject.convert("111 KiBps") instanceof Long);
+ assertTrue(testSubject.convert("123. KBps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Bps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Tibps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Tbps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Gibps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Gbps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Mibps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Mbps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Kibps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 Kbps") instanceof Long);
+ assertTrue(testSubject.convert("0.9 bps") instanceof Long);
+
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5z.Mbps"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("a5 MBps"));
+ assertThrows(IllegalArgumentException.class, () -> testSubject.convert("5 bps5"));
+ }
+
+ @Test
+ void testIsValueTypeValid() {
+ ToscaType testSubject = ToscaType.SCALAR_UNIT_BITRATE;
+ assertTrue(testSubject.isValueTypeValid(""));
+
+ testSubject = ToscaType.LIST;
+ assertTrue(testSubject.isValueTypeValid(""));
+
+ testSubject = ToscaType.INTEGER;
+ assertTrue(testSubject.isValueTypeValid(1));
+
+ testSubject = ToscaType.FLOAT;
+ assertTrue(testSubject.isValueTypeValid(2.3f));
+
+ testSubject = ToscaType.BOOLEAN;
+ assertTrue(testSubject.isValueTypeValid(true));
+
+ testSubject = ToscaType.SCALAR_UNIT;
+ assertFalse(testSubject.isValueTypeValid(""));
+
+ }
-public class ToscaTypeTest {
-
- @Test
- public void testIsValidValueBoolean() throws Exception {
- ToscaType toscaType = ToscaType.BOOLEAN;;
-
- assertTrue(!toscaType.isValidValue(""));
- assertTrue(toscaType.isValidValue("false"));
- assertTrue(toscaType.isValidValue("FalSe"));
- assertTrue(toscaType.isValidValue("true"));
- assertTrue(toscaType.isValidValue("TrUe"));
- }
-
- @Test
- public void testIsValidValueFloat() throws Exception {
- ToscaType toscaType = ToscaType.FLOAT;;
-
- assertTrue(!toscaType.isValidValue("float"));
- assertTrue(toscaType.isValidValue("1.2534"));
- assertTrue(toscaType.isValidValue("1.2534f"));
- }
-
- @Test
- public void testIsValidValueInteger() throws Exception {
- ToscaType toscaType = ToscaType.INTEGER;;
-
- assertTrue(!toscaType.isValidValue("integer"));
- assertTrue(toscaType.isValidValue("1235"));
- }
-
- @Test
- public void testIsValidValueTimestamp() throws Exception {
- ToscaType toscaType = ToscaType.TIMESTAMP;;
-
- assertTrue(!toscaType.isValidValue("timestamp"));
- assertTrue(toscaType.isValidValue("2001-12-14t21:59:43.10-05:00"));
- assertTrue(!toscaType.isValidValue("30 juin 2009 07:03:47"));
- }
-
- @Test
- public void testIsValidValueVersion() throws Exception {
- ToscaType toscaType = ToscaType.VERSION;;
-
- assertTrue(!toscaType.isValidValue("version"));
- assertTrue(toscaType.isValidValue("1.2"));
- assertTrue(toscaType.isValidValue("1.2.3"));
- assertTrue(toscaType.isValidValue("1.2-3"));
- }
-
- @Test
- public void testIsValidValueList() throws Exception {
- ToscaType toscaType = ToscaType.LIST;;
-
- assertTrue(!toscaType.isValidValue("list"));
- assertTrue(toscaType.isValidValue("[\"color\",\"type\"]"));
- }
-
- @Test
- public void testIsValidValueMap() throws Exception {
- ToscaType toscaType = ToscaType.MAP;;
-
- assertTrue(!toscaType.isValidValue("map"));
- assertTrue(toscaType.isValidValue("{\"color\":\"yellow\",\"type\":\"renault\"}"));
- }
-
- @Test
- public void testGetToscaType() throws Exception {
- ToscaType toscaType = ToscaType.MAP;;
-
- assertEquals(ToscaType.getToscaType("map"), toscaType);
- assertNull(ToscaType.getToscaType(null));
- assertNull(ToscaType.getToscaType("InvalidType"));
- }
-
- @Test
- public void testIsPrimitiveType() throws Exception {
- assertTrue(!ToscaType.isPrimitiveType("map"));
- assertTrue(!ToscaType.isPrimitiveType("list"));
- assertTrue(!ToscaType.isPrimitiveType("String"));
- assertTrue(ToscaType.isPrimitiveType("string"));
- assertTrue(ToscaType.isPrimitiveType("integer"));
- }
-
- @Test
- public void testIsCollectionType() throws Exception {
- assertTrue(ToscaType.isCollectionType("map"));
- assertTrue(ToscaType.isCollectionType("list"));
- assertTrue(!ToscaType.isCollectionType("Map"));
- assertTrue(!ToscaType.isCollectionType("string"));
- assertTrue(!ToscaType.isCollectionType("integer"));
- }
-
- @Test
- public void testConvert() throws Exception {
- ToscaType typeStr = ToscaType.STRING;
- assertEquals(typeStr.convert("str"), "str");
-
- ToscaType typeFloat = ToscaType.FLOAT;
- assertTrue(typeFloat.convert("1.2357f") instanceof Float);
-
- ToscaType typeTimestamp = ToscaType.TIMESTAMP;
- assertTrue(typeTimestamp.convert("Jun 30, 2009 7:03:47 AM") instanceof Date);
-
- ToscaType typeVersion = ToscaType.VERSION;
- assertTrue(typeVersion.convert("1.2.3.5.6") instanceof Version);
-
- ToscaType typeList = ToscaType.LIST;
- assertTrue(typeList.convert("[\"str1\",\"str2\"]") instanceof List);
-
- ToscaType typeMap = ToscaType.MAP;
- assertTrue(typeMap.convert("{\"color\":\"yellow\",\"type\":\"renault\"}") instanceof Map);
- }
-
- @Test
- public void testToString() throws Exception {
- ToscaType testToscaType = ToscaType.SCALAR_UNIT;
- assertEquals(testToscaType.toString(), "scalar_unit");
- }
}
* 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.
package org.openecomp.sdc.be.model.tosca.constraints;
-import org.junit.Test;
-import org.openecomp.sdc.be.model.tosca.ToscaType;
-
-public class ConstraintUtilTest {
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
- @Test
- public void testCheckStringType() throws Exception {
- ToscaType propertyType = ToscaType.STRING;
+import com.fasterxml.jackson.core.type.TypeReference;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.openecomp.sdc.be.model.tosca.ToscaType;
+import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
- // default test
- ConstraintUtil.checkStringType(propertyType);
- }
+class ConstraintUtilTest {
-
- @Test
- public void testCheckComparableType() throws Exception {
- ToscaType propertyType = ToscaType.INTEGER;
+ @Test
+ void testCheckStringType() throws Exception {
+ assertDoesNotThrow(() -> ConstraintUtil.checkStringType(ToscaType.STRING));
+ assertThrows(ConstraintValueDoNotMatchPropertyTypeException.class, () -> ConstraintUtil.checkStringType(ToscaType.SCALAR_UNIT));
+ }
- // default test
- ConstraintUtil.checkComparableType(propertyType);
- }
+ @Test
+ void testCheckComparableType() throws Exception {
+ assertDoesNotThrow(() -> ConstraintUtil.checkComparableType(ToscaType.INTEGER));
+ assertThrows(ConstraintValueDoNotMatchPropertyTypeException.class, () -> ConstraintUtil.checkComparableType(ToscaType.SCALAR_UNIT));
+ }
-
- @Test
- public void testConvertToComparable() throws Exception {
- ToscaType propertyType = ToscaType.BOOLEAN;
- String value = "";
- Comparable result;
+ @Test
+ void testConvertToComparable() throws Exception {
+ assertTrue(ConstraintUtil.convertToComparable(ToscaType.BOOLEAN, "true") instanceof Comparable);
+ assertThrows(IllegalArgumentException.class, () -> ConstraintUtil.convertToComparable(ToscaType.SCALAR_UNIT, "value"));
+ }
- // default test
- result = ConstraintUtil.convertToComparable(propertyType, value);
- }
+ @Test
+ void testParseToCollection() throws Exception {
+ List<Object> list = ConstraintUtil.parseToCollection("[\"color\",\"type\"]", new TypeReference<List<Object>>() {
+ });
+ assertTrue(list instanceof List);
+ assertEquals(2, list.size());
-
+ assertThrows(ConstraintValueDoNotMatchPropertyTypeException.class,
+ () -> ConstraintUtil.parseToCollection("", new TypeReference<List<Object>>() {
+ }));
+ }
}
import org.junit.jupiter.api.Test;
import org.openecomp.sdc.be.model.tosca.constraints.exception.ConstraintValueDoNotMatchPropertyTypeException;
-
-public class ValidValuesConstraintTest {
+class ValidValuesConstraintTest {
private ValidValuesConstraint createStringTestSubject() {
List<Object> validValues = new ArrayList<>();
}
@Test
- public void testGetValidValues() {
+ void testGetValidValues() {
ValidValuesConstraint testSubject = createStringTestSubject();
List<Object> result = testSubject.getValidValues();
}
@Test
- public void testSetValidValues() {
+ void testSetValidValues() {
ValidValuesConstraint testSubject = createStringTestSubject();
List<Object> validValues = new ArrayList<>();
validValues.add("test5");
}
@Test
- public void testValidateValueTypeStringTrue() throws ConstraintValueDoNotMatchPropertyTypeException {
+ void testValidateValueTypeStringTrue() throws ConstraintValueDoNotMatchPropertyTypeException {
ValidValuesConstraint testSubject = createStringTestSubject();
- Boolean validTypes = testSubject.validateValueType("string");
- assertTrue(validTypes);
+ assertTrue(testSubject.validateValueType("string"));
}
@Test
- public void testValidateValueTypeStringFalse() throws ConstraintValueDoNotMatchPropertyTypeException {
+ void testValidateValueTypeStringFalse() throws ConstraintValueDoNotMatchPropertyTypeException {
ValidValuesConstraint testSubject = createStringTestSubject();
- Boolean validTypes = testSubject.validateValueType("integer");
- assertFalse(validTypes);
+ assertFalse(testSubject.validateValueType("integer"));
}
@Test
- public void testValidateValueTypeIntegerTrue() throws ConstraintValueDoNotMatchPropertyTypeException {
+ void testValidateValueTypeIntegerTrue() throws ConstraintValueDoNotMatchPropertyTypeException {
ValidValuesConstraint testSubject = createIntegerTestSubject();
- Boolean validTypes = testSubject.validateValueType("integer");
- assertTrue(validTypes);
+ assertTrue(testSubject.validateValueType("integer"));
}
@Test
- public void testValidateValueTypeIntegerFalse() throws ConstraintValueDoNotMatchPropertyTypeException {
+ void testValidateValueTypeIntegerFalse() throws ConstraintValueDoNotMatchPropertyTypeException {
ValidValuesConstraint testSubject = createIntegerTestSubject();
- Boolean validTypes = testSubject.validateValueType("string");
- assertFalse(validTypes);
+ assertFalse(testSubject.validateValueType("string"));
}
@Test
- public void testChangeStringConstraintValueTypeToIntegerThrow() {
+ void testChangeStringConstraintValueTypeToIntegerThrow() {
String propertyType = "integer";
ValidValuesConstraint testSubject = createStringTestSubject();
Exception exception = assertThrows(ConstraintValueDoNotMatchPropertyTypeException.class, () -> {
}
@Test
- public void testChangeIntegerConstraintValueTypeToString() throws ConstraintValueDoNotMatchPropertyTypeException {
+ void testChangeIntegerConstraintValueTypeToString() throws ConstraintValueDoNotMatchPropertyTypeException {
ValidValuesConstraint testSubject = createIntegerTestSubject();
testSubject.changeConstraintValueTypeTo("string");
NULL("null"),
MAP("map"),
LIST("list"),
+ SCALAR_UNIT_BITRATE("scalar-unit.bitrate"),
SCALAR_UNIT_SIZE("scalar-unit.size"),
SCALAR_UNIT_TIME("scalar-unit.time"),
SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
private final String displayName;
/**
- * Initilize property type display name mapping.
+ * Initialize property type display name mapping.
*
* @return Map
*/
simplePropertyTypes.add(TIMESTAMP.getDisplayName().toLowerCase());
simplePropertyTypes.add(FLOAT.getDisplayName().toLowerCase());
simplePropertyTypes.add(BOOLEAN.getDisplayName().toLowerCase());
+ simplePropertyTypes.add(SCALAR_UNIT_BITRATE.getDisplayName().toLowerCase());
simplePropertyTypes.add(SCALAR_UNIT_SIZE.getDisplayName().toLowerCase());
simplePropertyTypes.add(SCALAR_UNIT_TIME.getDisplayName().toLowerCase());
simplePropertyTypes.add(SCALAR_UNIT_FREQUENCY.getDisplayName().toLowerCase());
final Map<String, String> propertyMap = new HashMap<>();
propertyMap.put("AdditionalServiceData", ADDITIONAL_SERVICE_DATA);
- resourceCreatePage = addProperty(serviceComponentPage, propertyMap, vf.getName());
+ resourceCreatePage = addProperty(serviceComponentPage, propertyMap);
final var downloadCsarArtifactFlow = new DownloadCsarArtifactFlow(webDriver);
downloadCsarArtifactFlow.setWaitBeforeGetTheFile(5L);
assertTrue(csarFiles.values().stream().filter(bytes -> new String(bytes).contains(ADDITIONAL_SERVICE_DATA)).findAny().isPresent());
}
- private ComponentPage addProperty(ComponentPage serviceComponentPage, final Map<String, String> propertyMap, String name) {
+ private ComponentPage addProperty(ComponentPage serviceComponentPage, final Map<String, String> propertyMap) {
final AddComponentPropertyFlow addComponentPropertyFlow = new AddComponentPropertyFlow(webDriver, propertyMap);
serviceComponentPage.isLoaded();
final ComponentPage resourcePropertiesAssignmentPage = serviceComponentPage.goToPropertiesAssignment();
stringMap.put("PropMapKey2", "PropMapValue2");
stringMap.put("PropMapKey3", "PropMapValue3");
propertyMap.put("property5", stringMap);
- propertyMap.put("property6", 500);
+ propertyMap.put("property6", "500 GB");
return propertyMap;
}
package org.openecomp.sdc.heat.datatypes;
/**
- * This enum is responsible for defining properties that have scalar values measured in size units.
+ * This enum is responsible for defining properties that have scalar values measured in time units.
*/
public enum ToscaScalarUnitTime {D, H, M, S, MS, US, NS}
@Getter
@AllArgsConstructor
public enum ToscaScalarUnitTypes {
- SCALAR_UNIT_SIZE("scalar-unit.size"), SCALAR_UNIT_TIME("scalar-unit.time"), SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
- private String type;
+ SCALAR_UNIT_BITRATE("scalar-unit.bitrate"),
+ SCALAR_UNIT_SIZE("scalar-unit.size"),
+ SCALAR_UNIT_TIME("scalar-unit.time"),
+ SCALAR_UNIT_FREQUENCY("scalar-unit.frequency");
+ private final String type;
}
Code Review / sdc.git / commitdiff