aboutsummaryrefslogtreecommitdiffstats
path: root/utils/src/test/java/org/onap
diff options
context:
space:
mode:
Diffstat (limited to 'utils/src/test/java/org/onap')
-rw-r--r--utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java1424
1 files changed, 1424 insertions, 0 deletions
diff --git a/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java b/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java
new file mode 100644
index 00000000..beca88f0
--- /dev/null
+++ b/utils/src/test/java/org/onap/policy/common/utils/properties/BeanConfiguratorTest.java
@@ -0,0 +1,1424 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP - Common Modules
+ * ================================================================================
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.common.utils.properties;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Properties;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.common.utils.properties.exception.PropertyAccessException;
+import org.onap.policy.common.utils.properties.exception.PropertyException;
+import org.onap.policy.common.utils.properties.exception.PropertyInvalidException;
+import org.onap.policy.common.utils.properties.exception.PropertyMissingException;
+
+/**
+ * Test class for PropertyConfiguration.
+ */
+public class BeanConfiguratorTest {
+
+ /**
+ * Property used for most of the simple configuration subclasses.
+ */
+ private static final String THE_VALUE = "the.value";
+
+ /**
+ * String property value.
+ */
+ private static final String STRING_VALUE = "a string";
+
+ /**
+ * Default value for string property.
+ */
+ private static final String STRING_VALUE_DEFAULT = "another string";
+
+ /**
+ * Value that cannot be coerced into any other type.
+ */
+ private static final String INVALID_VALUE = "invalid";
+
+ /**
+ * Properties used when invoking constructors.
+ */
+ private Properties props;
+
+ private BeanConfigurator beancfg;
+
+ @Before
+ public void setUp() {
+ props = new Properties();
+ beancfg = new BeanConfigurator();
+ }
+
+ @Test
+ public void testConfigureFromProperties() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ PlainStringConfig cfg = new PlainStringConfig();
+
+ assertSame(cfg, beancfg.configureFromProperties(cfg, props));
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testSetAllFields() throws Exception {
+
+ /*
+ * Implements an extra interface, just to see that it doesn't cause issues.
+ */
+ class GrandParentConfig implements DoesNothing {
+
+ @Property(name = "grandparent.value")
+ protected boolean grandparentValue;
+
+ @SuppressWarnings("unused")
+ public void setGrandparentValue(boolean grandparentValue) {
+ this.grandparentValue = grandparentValue;
+ }
+ }
+
+ /*
+ * Implements the extra interface, too.
+ */
+ class ParentConfig extends GrandParentConfig implements DoesNothing {
+
+ @Property(name = "parent.value")
+ protected long parentValue;
+
+ @SuppressWarnings("unused")
+ public void setParentValue(long parentValue) {
+ this.parentValue = parentValue;
+ }
+ }
+
+ class Config extends ParentConfig {
+
+ @Property(name = THE_VALUE)
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+
+ final Config cfg = new Config();
+
+ // try one set of values
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ props.setProperty("parent.value", "50000");
+ props.setProperty("grandparent.value", "true");
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ assertEquals(50000L, cfg.parentValue);
+ assertEquals(true, cfg.grandparentValue);
+
+ // now a different set of values
+ props.setProperty(THE_VALUE, STRING_VALUE + "x");
+ props.setProperty("parent.value", "50001");
+ props.setProperty("grandparent.value", "false");
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE + "x", cfg.value);
+ assertEquals(50001L, cfg.parentValue);
+ assertEquals(false, cfg.grandparentValue);
+ }
+
+ @Test
+ public void testSetAllFields_NoProperties() throws Exception {
+
+ class Config {
+
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(null, cfg.value);
+ }
+
+ @Test
+ public void testSetValueObjectFieldProperties_FieldSet() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ PlainStringConfig cfg = new PlainStringConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testSetValueObjectFieldProperties_NoAnnotation() throws PropertyException {
+ class Config {
+
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertNull(cfg.value);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testSetValueObjectFieldProperties_WrongFieldType() throws PropertyException {
+ class Config {
+
+ // Cannot set a property into an "Exception" field
+ @Property(name = THE_VALUE)
+ private Exception value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Exception value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetSetter_NoSetter() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE)
+ private String value;
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test(expected = PropertyMissingException.class)
+ public void testSetValueObjectMethodFieldPropertiesProperty_NoProperty_NoDefault() throws PropertyException {
+ beancfg.configureFromProperties(new PlainStringConfig(), props);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testSetValueObjectMethodFieldPropertiesProperty_IllegalArgEx() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+
+ beancfg = new BeanConfigurator() {
+ @Override
+ protected Object getValue(Field field, Properties props, Property prop) {
+ throw new IllegalArgumentException("expected exception");
+ }
+ };
+
+ beancfg.configureFromProperties(new PlainStringConfig(), props);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testSetValueObjectMethodFieldPropertiesProperty_MethodEx() throws PropertyException {
+ class Config extends PlainStringConfig {
+
+ @Override
+ public void setValue(String value) {
+ throw new IllegalArgumentException("expected exception");
+ }
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testGetValue() throws PropertyException {
+ // this class contains all of the supported field types
+ class Config {
+
+ @Property(name = "string")
+ private String stringValue;
+
+ @Property(name = "boolean.true")
+ private Boolean boolTrueValue;
+
+ @Property(name = "boolean.false")
+ private Boolean boolFalseValue;
+
+ @Property(name = "primitive.boolean.true")
+ private boolean primBoolTrueValue;
+
+ @Property(name = "primitive.boolean.false")
+ private boolean primBoolFalseValue;
+
+ @Property(name = "integer")
+ private Integer intValue;
+
+ @Property(name = "primitive.integer")
+ private int primIntValue;
+
+ @Property(name = "long")
+ private Long longValue;
+
+ @Property(name = "primitive.long")
+ private long primLongValue;
+
+ @SuppressWarnings("unused")
+ public String getStringValue() {
+ return stringValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setStringValue(String stringValue) {
+ this.stringValue = stringValue;
+ }
+
+ @SuppressWarnings("unused")
+ public Boolean getBoolTrueValue() {
+ return boolTrueValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setBoolTrueValue(Boolean boolTrueValue) {
+ this.boolTrueValue = boolTrueValue;
+ }
+
+ @SuppressWarnings("unused")
+ public Boolean getBoolFalseValue() {
+ return boolFalseValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setBoolFalseValue(Boolean boolFalseValue) {
+ this.boolFalseValue = boolFalseValue;
+ }
+
+ @SuppressWarnings("unused")
+ public boolean isPrimBoolTrueValue() {
+ return primBoolTrueValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setPrimBoolTrueValue(boolean primBoolTrueValue) {
+ this.primBoolTrueValue = primBoolTrueValue;
+ }
+
+ @SuppressWarnings("unused")
+ public boolean isPrimBoolFalseValue() {
+ return primBoolFalseValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setPrimBoolFalseValue(boolean primBoolFalseValue) {
+ this.primBoolFalseValue = primBoolFalseValue;
+ }
+
+ @SuppressWarnings("unused")
+ public Integer getIntValue() {
+ return intValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setIntValue(Integer intValue) {
+ this.intValue = intValue;
+ }
+
+ @SuppressWarnings("unused")
+ public int getPrimIntValue() {
+ return primIntValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setPrimIntValue(int primIntValue) {
+ this.primIntValue = primIntValue;
+ }
+
+ @SuppressWarnings("unused")
+ public Long getLongValue() {
+ return longValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setLongValue(Long longValue) {
+ this.longValue = longValue;
+ }
+
+ @SuppressWarnings("unused")
+ public long getPrimLongValue() {
+ return primLongValue;
+ }
+
+ @SuppressWarnings("unused")
+ public void setPrimLongValue(long primLongValue) {
+ this.primLongValue = primLongValue;
+ }
+ }
+
+ props.setProperty("string", "a string");
+ props.setProperty("boolean.true", "true");
+ props.setProperty("boolean.false", "false");
+ props.setProperty("primitive.boolean.true", "true");
+ props.setProperty("primitive.boolean.false", "false");
+ props.setProperty("integer", "100");
+ props.setProperty("primitive.integer", "101");
+ props.setProperty("long", "10000");
+ props.setProperty("primitive.long", "10001");
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("a string", cfg.stringValue);
+ assertEquals(true, cfg.boolTrueValue);
+ assertEquals(false, cfg.boolFalseValue);
+ assertEquals(true, cfg.primBoolTrueValue);
+ assertEquals(false, cfg.primBoolFalseValue);
+ assertEquals(100, cfg.intValue.intValue());
+ assertEquals(101, cfg.primIntValue);
+ assertEquals(10000, cfg.longValue.longValue());
+ assertEquals(10001, cfg.primLongValue);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetValue_UnsupportedType() throws PropertyException {
+ class Config {
+
+ // Cannot set a property into an "Exception" field
+ @Property(name = THE_VALUE)
+ private Exception value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Exception value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testCheckModifiable_OtherModifiers() throws PropertyException {
+ // this class contains all of the supported field types
+ class Config {
+
+ @Property(name = "public")
+ public String publicString;
+
+ @Property(name = "private")
+ private String privateString;
+
+ @Property(name = "protected")
+ protected String protectedString;
+
+ @SuppressWarnings("unused")
+ public void setPublicString(String publicString) {
+ this.publicString = publicString;
+ }
+
+ @SuppressWarnings("unused")
+ public void setPrivateString(String privateString) {
+ this.privateString = privateString;
+ }
+
+ @SuppressWarnings("unused")
+ public void setProtectedString(String protectedString) {
+ this.protectedString = protectedString;
+ }
+ }
+
+ props.setProperty("public", "a public string");
+ props.setProperty("private", "a private string");
+ props.setProperty("protected", "a protected string");
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("a public string", cfg.publicString);
+ assertEquals("a private string", cfg.privateString);
+ assertEquals("a protected string", cfg.protectedString);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testCheckModifiable_Static() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new StaticPropConfig(), props);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testCheckModifiable_Final() throws PropertyException {
+ class Config {
+
+ // Cannot set a property into an "final" field
+ @Property(name = THE_VALUE)
+ private final String value = "";
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testCheckMethod_Static() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(new StaticMethodConfig(), props);
+ }
+
+ @Test
+ public void testGetStringValue() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ PlainStringConfig cfg = new PlainStringConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testGetBooleanValue_NoDefault() throws PropertyException {
+ props.setProperty(THE_VALUE, "true");
+ PlainBooleanConfig cfg = new PlainBooleanConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(true, cfg.value);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testGetBooleanValue_InvalidDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+ private Boolean value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Boolean value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "true");
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testGetBooleanValue_ValidDefault_True() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "true")
+ private Boolean value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Boolean value) {
+ this.value = value;
+ }
+ }
+
+ // property not defined
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(true, cfg.value);
+
+ // try again, with the property defined as true
+ props.setProperty(THE_VALUE, "true");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(true, cfg.value);
+
+ // try again, with the property defined as false
+ props.setProperty(THE_VALUE, "false");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(false, cfg.value);
+ }
+
+ @Test
+ public void testGetBooleanValue_ValidDefault_False() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "false")
+ private Boolean value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Boolean value) {
+ this.value = value;
+ }
+ }
+
+ // property not defined
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(false, cfg.value);
+
+ // try again, with the property defined as true
+ props.setProperty(THE_VALUE, "true");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(true, cfg.value);
+
+ // try again, with the property defined as false
+ props.setProperty(THE_VALUE, "false");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(false, cfg.value);
+ }
+
+ @Test
+ public void testGetIntegerValue_NoDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE)
+ private Integer value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Integer value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "200");
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(200, cfg.value.intValue());
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testGetIntegerValue_InvalidDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+ private Integer value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Integer value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "200");
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testGetIntegerValue_ValidDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "201")
+ private Integer value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Integer value) {
+ this.value = value;
+ }
+ }
+
+ // property not defined
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(201, cfg.value.intValue());
+
+ // try again, with the property defined
+ props.setProperty(THE_VALUE, "200");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(200, cfg.value.intValue());
+ }
+
+ @Test
+ public void testGetLongValue_NoDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE)
+ private Long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Long value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "20000");
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(20000L, cfg.value.longValue());
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testGetLongValue_InvalidDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+ private Long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Long value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "20000");
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testGetLongValue_ValidDefault() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "20001")
+ private Long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(Long value) {
+ this.value = value;
+ }
+ }
+
+ // property not defined
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(20001L, cfg.value.longValue());
+
+ // try again, with the property defined
+ props.setProperty(THE_VALUE, "20000");
+ cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(20000L, cfg.value.longValue());
+ }
+
+ @Test
+ public void testGetPropValue_Prop_NoDefault() throws PropertyException {
+ props.setProperty(THE_VALUE, STRING_VALUE);
+
+ PlainStringConfig cfg = new PlainStringConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testGetPropValue_Prop_Default() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = STRING_VALUE_DEFAULT)
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, STRING_VALUE);
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testGetPropValue_EmptyProp_EmptyOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ props.setProperty(THE_VALUE, "");
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("", cfg.value);
+ }
+
+ @Test
+ public void testGetPropValue_NullProp_EmptyOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("", cfg.value);
+ }
+
+ @Test
+ public void testGetPropValue_EmptyDefault_EmptyOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("", cfg.value);
+ }
+
+ @Test
+ public void testGetPropValue_Default_EmptyOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = STRING_VALUE, accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test(expected = PropertyMissingException.class)
+ public void testGetPropValue_EmptyDefault_EmptyNotOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testGetPropValue_Default_EmptyNotOk() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = STRING_VALUE, accept = "")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test
+ public void testMakeBoolean_True() throws PropertyException {
+ props.setProperty(THE_VALUE, "true");
+ PlainBooleanConfig cfg = new PlainBooleanConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(true, cfg.value);
+ }
+
+ @Test
+ public void testMakeBoolean_False() throws PropertyException {
+ props.setProperty(THE_VALUE, "false");
+ PlainBooleanConfig cfg = new PlainBooleanConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(false, cfg.value);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testMakeBoolean_Invalid() throws PropertyException {
+ props.setProperty(THE_VALUE, INVALID_VALUE);
+ beancfg.configureFromProperties(new PlainBooleanConfig(), props);
+ }
+
+ @Test
+ public void testMakeInteger_Valid() throws PropertyException {
+ props.setProperty(THE_VALUE, "300");
+ PlainPrimIntConfig cfg = new PlainPrimIntConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(300, cfg.value);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testMakeInteger_Invalid() throws PropertyException {
+ props.setProperty(THE_VALUE, INVALID_VALUE);
+ beancfg.configureFromProperties(new PlainPrimIntConfig(), props);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testMakeInteger_TooBig() throws PropertyException {
+ props.setProperty(THE_VALUE, String.valueOf(Integer.MAX_VALUE + 10L));
+ beancfg.configureFromProperties(new PlainPrimIntConfig(), props);
+ }
+
+ @Test
+ public void testMakeLong_Valid() throws PropertyException {
+ props.setProperty(THE_VALUE, "30000");
+ PlainPrimLongConfig cfg = new PlainPrimLongConfig();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(30000L, cfg.value);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testMakeLong_Invalid() throws PropertyException {
+ props.setProperty(THE_VALUE, INVALID_VALUE);
+ beancfg.configureFromProperties(new PlainPrimLongConfig(), props);
+ }
+
+ @Test
+ public void testCheckDefaultValue_NotEmpty_Valid() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "700")
+ private long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals(700L, cfg.value);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testCheckDefaultValue_NotEmpty_Invalid() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = INVALID_VALUE)
+ private long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test(expected = PropertyInvalidException.class)
+ public void testCheckDefaultValue_Empty_EmptyOk_Invalid() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+ private long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testIsEmptyOkPropertyString_True() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ // missing property - should default to ""
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals("", cfg.value);
+
+ // add an empty property - should take the property's value
+ props.setProperty(THE_VALUE, "");
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals("", cfg.value);
+
+ // add the property - should take the property's value
+ props.setProperty(THE_VALUE, STRING_VALUE);
+ beancfg.configureFromProperties(cfg, props);
+ assertEquals(STRING_VALUE, cfg.value);
+ }
+
+ @Test(expected = PropertyMissingException.class)
+ public void testIsEmptyOkPropertyString_False() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "")
+ private long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testIsEmptyOkProperty_True() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "empty")
+ private String value;
+
+ @SuppressWarnings("unused")
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ Config cfg = new Config();
+ beancfg.configureFromProperties(cfg, props);
+
+ assertEquals("", cfg.value);
+ }
+
+ @Test(expected = PropertyMissingException.class)
+ public void testIsEmptyOkProperty_False() throws PropertyException {
+ class Config {
+
+ @Property(name = THE_VALUE, defaultValue = "", accept = "")
+ private long value;
+
+ @SuppressWarnings("unused")
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ beancfg.configureFromProperties(new Config(), props);
+ }
+
+ @Test
+ public void testPutToProperties() throws Exception {
+
+ /*
+ * Implements the extra interface, too.
+ */
+ class ParentConfig implements DoesNothing {
+
+ @Property(name = "the.parent.value")
+ protected long parentValue;
+
+ @SuppressWarnings("unused")
+ public long getParentValue() {
+ return parentValue;
+ }
+ }
+
+ class Config extends ParentConfig {
+
+ @Property(name = THE_VALUE)
+ private String value;
+
+ @Property(name = "the.other.value")
+ private String other;
+
+ @SuppressWarnings("unused")
+ public String getValue() {
+ return value;
+ }
+
+ @SuppressWarnings("unused")
+ public String getOther() {
+ return other;
+ }
+ }
+
+
+ final Config cfg = new Config();
+
+ cfg.parentValue = 1010;
+ cfg.value = STRING_VALUE;
+ cfg.other = "other";
+
+ beancfg.addToProperties(cfg, props, "the", "a");
+
+ assertEquals("1010", props.getProperty("a.parent.value"));
+ assertEquals(STRING_VALUE, props.getProperty("a.value"));
+ assertEquals("other", props.getProperty("a.other.value"));
+
+ // original prefix is empty
+ beancfg.addToProperties(cfg, props, "", "not");
+ assertEquals(STRING_VALUE, props.getProperty("not.the.value"));
+
+ // original prefix is ends with "."
+ beancfg.addToProperties(cfg, props, "the.", "a");
+ assertEquals(STRING_VALUE, props.getProperty("a.value"));
+
+ // new prefix is empty
+ beancfg.addToProperties(cfg, props, "", "");
+ assertEquals(STRING_VALUE, props.getProperty(THE_VALUE));
+
+ // new prefix is ends with "."
+ beancfg.addToProperties(cfg, props, "the", "xxx.");
+ assertEquals(STRING_VALUE, props.getProperty("xxx.value"));
+ }
+
+ @Test
+ public void testPutProperty() throws Exception {
+
+ class Config {
+ // no annotation - should not be copied
+ private String noAnnotation;
+
+ @Property(name = THE_VALUE)
+ private String value;
+
+ // null value - should not be copied
+ @Property(name = "the.null.value")
+ private String nullValue;
+
+ // should be copied, but retain its prefix
+ @Property(name = "some.other.prefix")
+ private String other;
+
+ @SuppressWarnings("unused")
+ public String getNoAnnotation() {
+ return noAnnotation;
+ }
+
+ @SuppressWarnings("unused")
+ public String getValue() {
+ return value;
+ }
+
+ @SuppressWarnings("unused")
+ public String getNullValue() {
+ return nullValue;
+ }
+
+ @SuppressWarnings("unused")
+ public String getOther() {
+ return other;
+ }
+ }
+
+ Config cfg = new Config();
+ cfg.noAnnotation = "no annotation";
+ cfg.value = STRING_VALUE;
+ cfg.nullValue = null;
+ cfg.other = "some other value";
+ beancfg.addToProperties(cfg, props, "the", "a");
+
+ assertFalse(props.contains("noAnnotation"));
+ assertEquals(STRING_VALUE, props.getProperty("a.value"));
+ assertFalse(props.contains("a.null.value"));
+ assertEquals("some other value", props.getProperty("some.other.prefix"));
+ }
+
+ @Test
+ public void testGetGetter() throws Exception {
+
+ class Config {
+ // getter method starts with "is" for these
+ @Property(name = "plain.bool")
+ private Boolean plainBool;
+
+ @Property(name = "prim.bool")
+ private boolean primBool;
+
+ // getter method starts with "get" for these
+ @Property(name = "plain.bool.get")
+ private Boolean plainBoolGet;
+
+ @Property(name = "prim.bool.get")
+ private boolean primBoolGet;
+
+ @Property(name = "int")
+ private int intValue;
+
+ @Property(name = "string")
+ private String stringValue;
+
+ @SuppressWarnings("unused")
+ public Boolean isPlainBool() {
+ return plainBool;
+ }
+
+ @SuppressWarnings("unused")
+ public boolean isPrimBool() {
+ return primBool;
+ }
+
+ @SuppressWarnings("unused")
+ public Boolean getPlainBoolGet() {
+ return plainBoolGet;
+ }
+
+ @SuppressWarnings("unused")
+ public boolean getPrimBoolGet() {
+ return primBoolGet;
+ }
+
+ @SuppressWarnings("unused")
+ public int getIntValue() {
+ return intValue;
+ }
+
+ @SuppressWarnings("unused")
+ public String getStringValue() {
+ return stringValue;
+ }
+ }
+
+ Config cfg = new Config();
+ cfg.plainBool = true;
+ cfg.primBool = false;
+ cfg.plainBoolGet = false;
+ cfg.primBoolGet = true;
+ cfg.intValue = 1100;
+ cfg.stringValue = STRING_VALUE;
+ beancfg.addToProperties(cfg, props, "", "");
+
+ assertEquals("true", props.getProperty("plain.bool"));
+ assertEquals("false", props.getProperty("prim.bool"));
+ assertEquals("false", props.getProperty("plain.bool.get"));
+ assertEquals("true", props.getProperty("prim.bool.get"));
+ assertEquals("1100", props.getProperty("int"));
+ assertEquals(STRING_VALUE, props.getProperty("string"));
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetGetter_NoGetter() throws Exception {
+
+ class Config {
+ @Property(name = THE_VALUE)
+ private String value;
+ }
+
+ Config cfg = new Config();
+ cfg.value = STRING_VALUE;
+ beancfg.addToProperties(cfg, props, "", "");
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetGetter_NoGetterForBoolean() throws Exception {
+
+ class Config {
+ @Property(name = THE_VALUE)
+ private boolean value;
+ }
+
+ Config cfg = new Config();
+ cfg.value = true;
+ beancfg.addToProperties(cfg, props, "", "");
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetGetter_PrivateGetter() throws Exception {
+
+ class Config {
+ @Property(name = THE_VALUE)
+ private String value;
+
+ @SuppressWarnings("unused")
+ private String getValue() {
+ return value;
+ }
+ }
+
+ Config cfg = new Config();
+ cfg.value = STRING_VALUE;
+ beancfg.addToProperties(cfg, props, "", "");
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetGetter_SecurityEx() throws Exception {
+
+ class Config {
+ @Property(name = THE_VALUE)
+ private String value;
+
+ @SuppressWarnings("unused")
+ private String getValue() {
+ return value;
+ }
+ }
+
+ Config cfg = new Config();
+ cfg.value = STRING_VALUE;
+
+ beancfg = new BeanConfigurator() {
+ @Override
+ protected Method getGetter(Field field, String methodName) throws SecurityException {
+ throw new SecurityException("expected exception");
+ }
+ };
+
+ beancfg.addToProperties(cfg, props, "", "");
+ }
+
+ @Test(expected = PropertyAccessException.class)
+ public void testGetBeanValue_Ex() throws Exception {
+
+ class Config {
+
+ @Property(name = THE_VALUE)
+ private String value;
+
+ @SuppressWarnings("unused")
+ public String getValue() {
+ throw new RuntimeException("expected exception");
+ }
+ }
+
+
+ final Config cfg = new Config();
+ cfg.value = STRING_VALUE;
+
+ beancfg.addToProperties(cfg, props, "the", "a");
+
+ }
+
+ /**
+ * Config with a String value having no qualifiers.
+ */
+ public class PlainStringConfig {
+
+ @Property(name = THE_VALUE)
+ private String value;
+
+ public String getValue() {
+ return value;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * Config with a Boolean value having no qualifiers.
+ */
+ public class PlainBooleanConfig {
+
+ @Property(name = THE_VALUE)
+ private Boolean value;
+
+ public void setValue(Boolean value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * Config with an int value having no qualifiers.
+ */
+ public class PlainPrimIntConfig {
+
+ @Property(name = THE_VALUE)
+ private int value;
+
+ public void setValue(int value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * Config with a long value having no qualifiers.
+ */
+ public class PlainPrimLongConfig {
+
+ @Property(name = THE_VALUE)
+ private long value;
+
+ public void setValue(long value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * A config whose field is "static".
+ */
+ public static class StaticPropConfig {
+
+ // "static" field cannot be set
+ @Property(name = THE_VALUE)
+ private static String value;
+
+ public static void setValue(String value) {
+ StaticPropConfig.value = value;
+ }
+ }
+
+ /**
+ * A config whose method is "static".
+ */
+ public static class StaticMethodConfig {
+
+ // "static" field cannot be set
+ @Property(name = THE_VALUE)
+ private String value;
+
+ public static void setValue(String value) {
+
+ }
+ }
+
+ /**
+ * This is just used as a mix-in to ensure that the configuration ignores interfaces.
+ */
+ public static interface DoesNothing {
+
+ }
+}