Repository: incubator-tamaya-extensions Updated Branches: refs/heads/master ebc994124 -> a44a2ab61
[TAMAYA-244] Added more tests, mostly for CombinedConfiguration. Project: http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/commit/a44a2ab6 Tree: http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/tree/a44a2ab6 Diff: http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/diff/a44a2ab6 Branch: refs/heads/master Commit: a44a2ab6148bd7d2e82e0cb546eccfab14667497 Parents: ebc9941 Author: Oliver B. Fischer <[email protected]> Authored: Sun Mar 19 01:31:15 2017 +0100 Committer: Oliver B. Fischer <[email protected]> Committed: Sun Mar 19 01:31:15 2017 +0100 ---------------------------------------------------------------------- .../tamaya/functions/CombinedConfiguration.java | 33 +- .../functions/CombinedConfigurationTest.java | 337 ++++++++++++++++++- .../tamaya/functions/MethodNotMockedAnswer.java | 38 +++ 3 files changed, 390 insertions(+), 18 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/blob/a44a2ab6/modules/functions/src/main/java/org/apache/tamaya/functions/CombinedConfiguration.java ---------------------------------------------------------------------- diff --git a/modules/functions/src/main/java/org/apache/tamaya/functions/CombinedConfiguration.java b/modules/functions/src/main/java/org/apache/tamaya/functions/CombinedConfiguration.java index 02d88a1..2e3f0cc 100644 --- a/modules/functions/src/main/java/org/apache/tamaya/functions/CombinedConfiguration.java +++ b/modules/functions/src/main/java/org/apache/tamaya/functions/CombinedConfiguration.java @@ -54,15 +54,16 @@ class CombinedConfiguration implements Configuration{ continue; } - configurations.add(config); + addConfiguration(config); } } } + @Override public String get(String key) { String curValue = null; - for(Configuration config: configurations){ + for(Configuration config: getConfigurations()){ String value = config.get(key); if(value!=null){ curValue = value; @@ -87,6 +88,10 @@ class CombinedConfiguration implements Configuration{ @Override public <T> T getOrDefault(String key, Class<T> type, T defaultValue) { + Objects.requireNonNull(type, "Type must be given."); + Objects.requireNonNull(key, "Key must be given."); + Objects.requireNonNull(defaultValue, "Default value must be given."); + T val = get(key, type); if(val==null){ return defaultValue; @@ -97,7 +102,7 @@ class CombinedConfiguration implements Configuration{ @Override public <T> T get(String key, Class<T> type) { T curValue = null; - for(Configuration config: configurations){ + for(Configuration config: getConfigurations()){ T value = config.get(key, type); if(value!=null){ curValue = value; @@ -109,7 +114,7 @@ class CombinedConfiguration implements Configuration{ @Override public <T> T get(String key, TypeLiteral<T> type) { T curValue = null; - for(Configuration config: configurations){ + for(Configuration config: getConfigurations()){ T value = config.get(key, type); if(value!=null){ curValue = value; @@ -120,6 +125,10 @@ class CombinedConfiguration implements Configuration{ @Override public <T> T getOrDefault(String key, TypeLiteral<T> type, T defaultValue) { + Objects.requireNonNull(key, "Key must be given."); + Objects.requireNonNull(type, "Type must be given."); + Objects.requireNonNull(defaultValue, "Default value must be given."); + T val = get(key, type); if(val==null){ return defaultValue; @@ -130,7 +139,7 @@ class CombinedConfiguration implements Configuration{ @Override public Map<String, String> getProperties() { Map<String, String> result = new HashMap<>(); - for(Configuration ps:configurations){ + for(Configuration ps : getConfigurations()){ result.putAll(ps.getProperties()); } return result; @@ -138,11 +147,15 @@ class CombinedConfiguration implements Configuration{ @Override public Configuration with(ConfigOperator operator) { + Objects.requireNonNull(operator, "Operator must be given."); + return operator.operate(this); } @Override public <T> T query(ConfigQuery<T> query) { + Objects.requireNonNull(query, "Query must be given."); + return query.query(this); } @@ -159,4 +172,14 @@ class CombinedConfiguration implements Configuration{ ", configurations=" + configurations + '}'; } + + protected void addConfiguration(Configuration config) { + configurations.add(config); + } + + protected List<Configuration> getConfigurations() { + return configurations; + } + + } http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/blob/a44a2ab6/modules/functions/src/test/java/org/apache/tamaya/functions/CombinedConfigurationTest.java ---------------------------------------------------------------------- diff --git a/modules/functions/src/test/java/org/apache/tamaya/functions/CombinedConfigurationTest.java b/modules/functions/src/test/java/org/apache/tamaya/functions/CombinedConfigurationTest.java index 2275f7a..04c6573 100644 --- a/modules/functions/src/test/java/org/apache/tamaya/functions/CombinedConfigurationTest.java +++ b/modules/functions/src/test/java/org/apache/tamaya/functions/CombinedConfigurationTest.java @@ -30,16 +30,24 @@ import org.apache.tamaya.spisupport.DefaultConfigurationContextBuilder; import org.apache.tamaya.spisupport.SimplePropertySource; import org.assertj.core.api.ThrowableAssert; import org.junit.Test; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import java.lang.reflect.Method; +import java.lang.reflect.Type; import java.util.Collections; +import java.util.HashMap; import java.util.Map; import java.util.TreeMap; +import static java.util.Arrays.asList; import static java.util.Collections.singletonMap; +import static org.apache.tamaya.functions.MethodNotMockedAnswer.NOT_MOCKED_ANSWER; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.mockito.Mockito.CALLS_REAL_METHODS; -import static org.mockito.Mockito.mock; +import static org.assertj.core.api.Assertions.within; +import static org.mockito.Mockito.*; public class CombinedConfigurationTest { @@ -140,26 +148,329 @@ public class CombinedConfigurationTest { .hasMessage("Value must be given."); } + @Test + public void getOrDefaultWithSignatureStringStringReturnsDefaultIfKeyIsUnknown() { + CombinedConfiguration cc = mock(CombinedConfiguration.class); + doReturn(null).when(cc).get("a"); + doCallRealMethod().when(cc).getOrDefault(anyString(), anyString()); + + String result = cc.getOrDefault("a", "tzui"); + + assertThat(result).isEqualTo("tzui"); + } + + @Test + public void getOrDefaultWithSignatureStringStringReturnsFoundValueIfKeyIsKnown() { + CombinedConfiguration cc = mock(CombinedConfiguration.class); + doReturn("b").when(cc).get(Mockito.eq("a")); + doCallRealMethod().when(cc).getOrDefault(anyString(), anyString()); + + String result = cc.getOrDefault("a", "z"); + + assertThat(result).isEqualTo("b"); + } + + /* + * Tests for getOrDefault(String, TypeLiteral<T>, T> + */ + + @Test + public void getOrDefaultStringTypeLiteralTThrowsNPEIfKeyIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class); + doCallRealMethod().when(cc).getOrDefault(anyString(), eq(TypeLiteral.of(Integer.class)), + Mockito.any(Integer.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.getOrDefault(null, TypeLiteral.of(Integer.class), 1); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Key must be given."); + + } + + @Test + public void getOrDefaultStringTypeLiteralTThrowsNPEIfTypeIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).getOrDefault(anyString(), eq((TypeLiteral<Integer>)null), + Mockito.any(Integer.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.<Integer>getOrDefault("a", (TypeLiteral<Integer>)null, 1); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Type must be given."); + } + + @Test + public void getOrDefaultStringTypeLiteralTThrowsNPEIfDefaultValueIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).getOrDefault(anyString(), eq(TypeLiteral.of(Integer.class)), + Mockito.any(Integer.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.getOrDefault("a", TypeLiteral.of(Integer.class), null); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Default value must be given."); + } + + @Test + public void getOrDefaultStringTypeLiteralTReturnsDefaultValueIfKeyIsUnknown() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doReturn(null).when(cc).get(eq("a"), eq(TypeLiteral.<Integer>of(Integer.class))); + doCallRealMethod().when(cc).getOrDefault(anyString(), eq(TypeLiteral.of(Integer.class)), + Mockito.any(Integer.class)); + + TypeLiteral<Integer> typeLiteral = TypeLiteral.of(Integer.class); + Integer result = cc.<Integer>getOrDefault("a", typeLiteral, 789); + + assertThat(result).isEqualTo(789); + } - // a, b - // a, null - // getOrDefault none one three - // String getOrDefault(String var1, String var2); none one three + @Test + public void getOrDefaultStringTypeLiteralTReturnsFoundValueIfKeyIsKnown() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doReturn(999).when(cc).get(eq("a"), eq(TypeLiteral.<Integer>of(Integer.class))); + doCallRealMethod().when(cc).getOrDefault(anyString(), eq(TypeLiteral.of(Integer.class)), + Mockito.anyInt()); - // <T> T getOrDefault(String var1, Class<T> var2, T var3); none one three + Integer result = cc.<Integer>getOrDefault("a", TypeLiteral.<Integer>of(Integer.class), 789); + + assertThat(result).isEqualTo(999); + } - // <T> T get(String var1, Class<T> var2); none one three + /* + * Tests for getOrDefault(String, Class<T>, T> + */ - // <T> T get(String var1, TypeLiteral<T> var2); none one three + @Test + public void getOrDefaultStringClassTThrowsNPEIfKeyIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class); + doCallRealMethod().when(cc).getOrDefault(anyString(), Mockito.any(Class.class), + Mockito.any(Integer.class)); - // <T> T getOrDefault(String var1, TypeLiteral<T> var2, T var3); none one three + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.getOrDefault(null, Integer.class, 1); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Key must be given."); + } - // Map<String, String> getProperties(); none one three + @Test + public void getOrDefaultStringClassTThrowsNPEIfTypeIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class); + doCallRealMethod().when(cc).getOrDefault(anyString(), Mockito.any(Class.class), Mockito.anyInt()); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.getOrDefault("a", (Class<Integer>) null, 1); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Type must be given."); + } + + @Test + public void getOrDefaultStringClassTThrowsNPEIfDefaultValueIsNull() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).getOrDefault(anyString(), any(Class.class), + Mockito.any(Integer.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.getOrDefault("a", Integer.class, null); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Default value must be given."); + } + + @Test + public void getOrDefaultStringClassTReturnsDefaultValueIfKeyIsUnknown() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doReturn(null).when(cc).get(eq("a"), any(Class.class)); + doCallRealMethod().when(cc).getOrDefault(anyString(), any(Class.class), + Mockito.any(Integer.class)); - // Configuration with(ConfigOperator var1); none one three + TypeLiteral<Integer> typeLiteral = TypeLiteral.of(Integer.class); + Integer result = cc.<Integer>getOrDefault("a", Integer.class, 789); - // <T> T query(ConfigQuery<T> var1); none one three + assertThat(result).isEqualTo(789); + } + + + @Test + public void getOrDefaultStringClassTReturnsFoundValueIfKeyIsKnown() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doReturn(999).when(cc).get(eq("a"), any(Class.class)); + doCallRealMethod().when(cc).getOrDefault(anyString(), any(Class.class), + Mockito.anyInt()); + + Integer result = cc.<Integer>getOrDefault("a", Integer.class, 789); + + assertThat(result).isEqualTo(999); + } + + /* + * Tests for getProperties(); + */ + + @Test + public void getPropertiesReturnsEmptyMapIfAllConfigurationsAreEmpty() throws Exception { + Map<String, String> propsOfA = new HashMap<>(); + Map<String, String> propsOfB = new HashMap<>(); + Map<String, String> propsOfC = new HashMap<>(); + + Configuration configA = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configB = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configC = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + + doReturn(propsOfA).when(configA).getProperties(); + doReturn(propsOfB).when(configB).getProperties(); + doReturn(propsOfC).when(configC).getProperties(); + + CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + + doReturn(asList(configA, configB, configC)).when(cc).getConfigurations(); + doCallRealMethod().when(cc).getProperties(); + + Map<String, String> result = cc.getProperties(); + + assertThat(result).isEmpty(); + } + + @Test + public void getPropertiesReturnsLastValueOfManyForAGivenKey() throws Exception { + Map<String, String> propsOfA = new HashMap<String, String>() {{ put("a", "A"); }}; + Map<String, String> propsOfB = new HashMap<String, String>() {{ put("b", "B"); }}; + Map<String, String> propsOfC = new HashMap<String, String>() {{ put("a", "Z"); }}; + + Configuration configA = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configB = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configC = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + + doReturn(propsOfA).when(configA).getProperties(); + doReturn(propsOfB).when(configB).getProperties(); + doReturn(propsOfC).when(configC).getProperties(); + + CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + + doReturn(asList(configA, configB, configC)).when(cc).getConfigurations(); + doCallRealMethod().when(cc).getProperties(); + + Map<String, String> result = cc.getProperties(); + + assertThat(result).containsEntry("a", "Z") + .doesNotContainEntry("a", "A"); + } + + @Test + public void getPropertiesReturnsAllProperties() throws Exception { + Map<String, String> propsOfA = new HashMap<String, String>() {{ put("a", "A"); }}; + Map<String, String> propsOfB = new HashMap<String, String>() {{ put("b", "B"); }}; + Map<String, String> propsOfC = new HashMap<String, String>() {{ put("c", "C"); }}; + + Configuration configA = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configB = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + Configuration configC = Mockito.mock(Configuration.class, NOT_MOCKED_ANSWER); + + doReturn(propsOfA).when(configA).getProperties(); + doReturn(propsOfB).when(configB).getProperties(); + doReturn(propsOfC).when(configC).getProperties(); + + CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + + doReturn(asList(configA, configB, configC)).when(cc).getConfigurations(); + doCallRealMethod().when(cc).getProperties(); + + Map<String, String> result = cc.getProperties(); + + assertThat(result).hasSize(3) + .containsEntry("a", "A") + .containsEntry("b", "B") + .containsEntry("c", "C"); + } + + /* + * Tests for with(ConfigOperator) + */ + + @Test + public void withWithIndentityOperatorReturnsEqualConfiguration() throws Exception { + class IdentityOpr implements ConfigOperator { + @Override + public Configuration operate(Configuration config) { + return config; + } + } + + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).with(Mockito.any(ConfigOperator.class)); + + Configuration result = cc.with(new IdentityOpr()); + + assertThat(result).isNotNull() + .isEqualTo(result); + } + + @Test + public void withWithNullAsOperatorParmeterThrowsNPE() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).with(Mockito.any(ConfigOperator.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.with(null); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Operator must be given."); + } + + /* + * Tests for query(ConfigQuery) + */ + + @Test + public void queryWithNullAsQueryParameterThrowsNPE() throws Exception { + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).query(Mockito.any(ConfigQuery.class)); + + assertThatThrownBy(new ThrowableAssert.ThrowingCallable() { + @Override + public void call() throws Throwable { + cc.query(null); + } + }).isInstanceOf(NullPointerException.class) + .hasMessage("Query must be given."); + } + + @Test + public void queryWithRealQueryReturnsCorrectResult() throws Exception { + class GetZahl implements ConfigQuery<Integer> { + @Override + public Integer query(Configuration config) { + return config.get("zahl", Integer.class); + } + } + + final CombinedConfiguration cc = mock(CombinedConfiguration.class, NOT_MOCKED_ANSWER); + doCallRealMethod().when(cc).query(Mockito.any(ConfigQuery.class)); + doReturn(1).when(cc).<Integer>get(eq("zahl"), eq(Integer.class)); + + Integer result = cc.query(new GetZahl()); + + assertThat(result).isEqualTo(1); + } // ConfigurationContext getContext(); none one three http://git-wip-us.apache.org/repos/asf/incubator-tamaya-extensions/blob/a44a2ab6/modules/functions/src/test/java/org/apache/tamaya/functions/MethodNotMockedAnswer.java ---------------------------------------------------------------------- diff --git a/modules/functions/src/test/java/org/apache/tamaya/functions/MethodNotMockedAnswer.java b/modules/functions/src/test/java/org/apache/tamaya/functions/MethodNotMockedAnswer.java new file mode 100644 index 0000000..3727c5f --- /dev/null +++ b/modules/functions/src/test/java/org/apache/tamaya/functions/MethodNotMockedAnswer.java @@ -0,0 +1,38 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tamaya.functions; + +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import java.lang.reflect.Method; + +public class MethodNotMockedAnswer implements Answer +{ + public final static Answer NOT_MOCKED_ANSWER = new MethodNotMockedAnswer(); + + @Override + public Object answer(InvocationOnMock invocation) throws Throwable + { + Method calledMethod = invocation.getMethod(); + String signature = calledMethod.toGenericString(); + + throw new RuntimeException(signature + " is not mocked!"); + } +}
