Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Overhaul repeatable @TestPropertySource support

Browse Source 
Prior to this commit, if multiple, directly present
`@TestPropertySource` annotations declared the same property, the
precedence ordering was top-down instead of bottom-up, in contrast to
the semantics for class hierarchies. In other words, a subsequent
`@TestPropertySource` annotation could not override a property in a
previous `@TestPropertySource` annotation.

This commit overhauls the internals of `TestPropertySourceUtils` in
order to provide proper support for property overrides within local,
directly present `@TestPropertySource` declarations.

Specifically, the `locations` and `properties` attributes from all
`@TestPropertySource` declarations that are directly present or
meta-present on a given class are now merged into a single instance of
`TestPropertySourceAttributes` internally, with assertions in place to
ensure that such "same level" `@TestPropertySource` declarations do not
configure different values for the `inheritLocations` and
`inheritProperties` flags. Effectively, all "same level"
`@TestPropertySource` declarations are treated internally as if there
were only one such annotation declared by the user.

See gh-23320
This commit is contained in:
Sam Brannen
2019-07-25 23:15:33 +02:00
parent 2e476ca14f
commit 136af0b164
36 changed files with 687 additions and 854 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
spring-test/src/test/java/org/springframework/test/context/env/TestPropertySourceTestSuite.java vendored Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.platform.suite.api.IncludeClassNamePatterns;
import org.junit.platform.suite.api.IncludeEngines;
import org.junit.platform.suite.api.SelectPackages;
import org.junit.platform.suite.api.UseTechnicalNames;
import org.junit.runner.RunWith;
import org.springframework.test.context.TestPropertySource;
/**
* Test suite for tests that involve {@link TestPropertySource @TestPropertySource}.
*
* <p>Note that tests included in this suite will be executed at least twice if
* run from an automated build process, test runner, etc. that is not configured
* to exclude tests based on a {@code "*TestSuite.class"} pattern match.
*
* @author Sam Brannen
* @since 5.2
*/
@RunWith(JUnitPlatform.class)
@IncludeEngines("junit-vintage")
@SelectPackages("org.springframework.test.context.env")
@IncludeClassNamePatterns(".*Tests$")
@UseTechnicalNames
public class TestPropertySourceTestSuite {
}

9
spring-test/src/test/java/org/springframework/test/context/env/repeatable/ParentClassWithMultipleTestProperties.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/AbstractClassWithTestProperty.java vendored
View File

@@ -19,12 +19,13 @@ package org.springframework.test.context.env.repeatable;
import org.springframework.test.context.TestPropertySource;
/**
* Abstract parent class with multiple properties definition for tests.
* Abstract base class which declares an inlined property via
* {@link TestPropertySource @TestPropertySource}.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource(properties = "first = value from parent class")
@TestPropertySource(properties = "second = value from parent class")
public abstract class ParentClassWithMultipleTestProperties {
@TestPropertySource(properties = "key1 = parent")
abstract class AbstractClassWithTestProperty extends AbstractRepeatableTestPropertySourceTests {
}

28
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceOverridesInheritedPropertyTests.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/AbstractRepeatableTestPropertySourceTests.java vendored
View File

@@ -16,49 +16,39 @@
package org.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.junit4.SpringRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
* Abstract base class for integration tests involving
* {@link TestPropertySource @TestPropertySource} as a repeatable annotation.
*
* Verify the overriding of property which defined both in the parent class and locally in
* the {@link TestPropertySource} annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@RunWith(SpringRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "inherited = local value")
public class TestPropertySourceOverridesInheritedPropertyTests extends ParentClassWithTestProperties {
abstract class AbstractRepeatableTestPropertySourceTests {
@Autowired
Environment env;
@Value("${inherited}")
String inherited;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertThat(env.getProperty("inherited")).isEqualTo("local value");
assertThat(inherited).isEqualTo("local value");
protected void assertEnvironmentValue(String key, String expected) {
assertThat(env.getProperty(key)).as("Value of key [" + key + "].").isEqualTo(expected);
}
@Configuration
static class Config {
}
}

42
spring-test/src/test/java/org/springframework/test/context/env/repeatable/DefaultPropertiesFileDetectionRepeatedTestPropertySourceTests.java vendored Normal file
View File

@@ -0,0 +1,42 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource
@TestPropertySource("local.properties")
public class DefaultPropertiesFileDetectionRepeatedTestPropertySourceTests
extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("default.value", "default file");
assertEnvironmentValue("key1", "local file");
}
}

45
spring-test/src/test/java/org/springframework/test/context/env/repeatable/ExplicitPropertiesFilesRepeatedTestPropertySourceTests.java vendored Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* <p>Same as {@link ReversedExplicitPropertiesFilesRepeatedTestPropertySourceTests},
* but with the order of the properties files reversed.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource("first.properties")
@TestPropertySource("second.properties")
public class ExplicitPropertiesFilesRepeatedTestPropertySourceTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("alpha", "omega");
assertEnvironmentValue("first", "1111");
assertEnvironmentValue("second", "2222");
}
}

23
spring-test/src/test/java/org/springframework/test/context/env/repeatable/AnnotationWithTestPropertyInPropertiesFile.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalInlinedPropertyAndInheritedInlinedPropertyTests.java vendored
View File

@@ -16,22 +16,25 @@
package org.springframework.test.context.env.repeatable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* A custom annotation which defined properties file in the {@link TestPropertySource}.
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@TestPropertySource("meta.properties")
public @interface AnnotationWithTestPropertyInPropertiesFile {
@TestPropertySource(properties = "key2 = local")
public class LocalInlinedPropertyAndInheritedInlinedPropertyTests extends AbstractClassWithTestProperty {
@Test
public void test() {
assertEnvironmentValue("key1", "parent");
assertEnvironmentValue("key2", "local");
}
}

18
spring-test/src/test/java/org/springframework/test/context/env/repeatable/FooTestPropertyDeclaration.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalInlinedPropertyAndMetaInlinedPropertyTests.java vendored
View File

@@ -16,14 +16,26 @@
package org.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Abstract parent class with foo property definition for tests.
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource(properties = "foo = value from parent class")
public abstract class FooTestPropertyDeclaration {
@TestPropertySource(properties = "key1 = local")
@MetaInlinedTestProperty
public class LocalInlinedPropertyAndMetaInlinedPropertyTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("key1", "local");
assertEnvironmentValue("meta", "inlined");
}
}

52
spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalInlinedPropertyOverridesInheritedAndMetaInlinedPropertiesTests.java vendored Normal file
View File

@@ -0,0 +1,52 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.env.repeatable.LocalInlinedPropertyOverridesInheritedAndMetaInlinedPropertiesTests.Key1InlinedTestProperty;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource(properties = "key1 = local")
@Key1InlinedTestProperty
public class LocalInlinedPropertyOverridesInheritedAndMetaInlinedPropertiesTests extends AbstractClassWithTestProperty {
@Test
public void test() {
assertEnvironmentValue("key1", "local");
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@TestPropertySource(properties = "key1 = meta")
@interface Key1InlinedTestProperty {
}
}

43
spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalInlinedPropertyOverridesInheritedInlinedPropertyTests.java vendored Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource(properties = "key1 = local value")
@TestPropertySource(properties = "second = local override")
public class LocalInlinedPropertyOverridesInheritedInlinedPropertyTests extends RepeatedTestPropertySourceTests {
@Test
@Override
public void test() {
assertEnvironmentValue("key1", "local value");
assertEnvironmentValue("second", "local override");
assertEnvironmentValue("first", "repeated override");
}
}

23
spring-test/src/test/java/org/springframework/test/context/env/repeatable/FooTestProperty.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalInlinedPropertyOverridesMetaInlinedPropertyTests.java vendored
View File

@@ -16,22 +16,25 @@
package org.springframework.test.context.env.repeatable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* A custom annotation with foo property defined by the {@link TestPropertySource}.
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@TestPropertySource(properties = "foo = value from meta-annotation")
public @interface FooTestProperty {
@TestPropertySource(properties = "meta = local override")
@MetaInlinedTestProperty
public class LocalInlinedPropertyOverridesMetaInlinedPropertyTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("meta", "local override");
}
}

62
spring-test/src/test/java/org/springframework/test/context/env/repeatable/LocalPropertiesFileAndMetaPropertiesFileTests.java vendored Normal file
View File

@@ -0,0 +1,62 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.env.repeatable.LocalPropertiesFileAndMetaPropertiesFileTests.MetaFileTestProperty;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* <p>Verify a property value is defined both in the properties file which is declared
* via {@link MetaFileTestProperty @MetaFileTestProperty} and in the properties file
* which is declared locally via {@code @TestPropertySource}.
*
* @author Anatoliy Korovin
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource("local.properties")
@MetaFileTestProperty
public class LocalPropertiesFileAndMetaPropertiesFileTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("key1", "local file");
assertEnvironmentValue("key2", "meta file");
}
/**
* Composed annotation that declares a properties file via
* {@link TestPropertySource @TestPropertySource}.
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@TestPropertySource("meta.properties")
@interface MetaFileTestProperty {
}
}

8
spring-test/src/test/java/org/springframework/test/context/env/repeatable/AnnotationWithTestProperty.java → spring-test/src/test/java/org/springframework/test/context/env/repeatable/MetaInlinedTestProperty.java vendored
View File

@@ -16,7 +16,6 @@
package org.springframework.test.context.env.repeatable;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@@ -25,13 +24,14 @@ import java.lang.annotation.Target;
import org.springframework.test.context.TestPropertySource;
/**
* A custom annotation with properties defined by the {@link TestPropertySource}.
* Composed annotation that declares a {@code meta} inlined property via
* {@link TestPropertySource @TestPropertySource}.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@TestPropertySource(properties = "meta = value from meta-annotation")
public @interface AnnotationWithTestProperty {
@TestPropertySource(properties = "meta = inlined")
@interface MetaInlinedTestProperty {
}

30
spring-test/src/test/java/org/springframework/test/context/env/repeatable/ParentClassWithTestProperties.java vendored
View File

@@ -1,30 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.springframework.test.context.TestPropertySource;
/**
* Base class which declare a property by the {@link TestPropertySource} annotation.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@TestPropertySource(properties = "inherited = 12345")
public abstract class ParentClassWithTestProperties {
}

43
spring-test/src/test/java/org/springframework/test/context/env/repeatable/RepeatedTestPropertySourceTests.java vendored Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Integration tests for {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* <p>Tests multiple local {@link TestPropertySource} declarations.
*
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource(properties = "first = repeated")
@TestPropertySource(properties = "second = repeated")
@TestPropertySource(properties = "first = repeated override")
public class RepeatedTestPropertySourceTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("first", "repeated override");
assertEnvironmentValue("second", "repeated");
}
}

41
spring-test/src/test/java/org/springframework/test/context/env/repeatable/ReversedExplicitPropertiesFilesRepeatedTestPropertySourceTests.java vendored Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.springframework.test.context.TestPropertySource;
/**
* Same as {@link ExplicitPropertiesFilesRepeatedTestPropertySourceTests}, but
* with the order of the properties files reversed.
*
* @author Sam Brannen
* @since 5.2
*/
@TestPropertySource("second.properties")
@TestPropertySource("first.properties")
public class ReversedExplicitPropertiesFilesRepeatedTestPropertySourceTests extends AbstractRepeatableTestPropertySourceTests {
@Test
public void test() {
assertEnvironmentValue("alpha", "beta");
assertEnvironmentValue("first", "1111");
assertEnvironmentValue("second", "1111");
}
}

71
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritTests.java vendored
View File

@@ -1,71 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Test a property definition by the using of {@link TestPropertySource} both in the
* parent class and locally.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "key = 051187")
public class TestPropertySourceInheritTests extends ParentClassWithTestProperties {
@Autowired
Environment env;
@Value("${key}")
String key;
@Value("${inherited}")
String inherited;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertThat(env.getProperty("key")).isEqualTo("051187");
assertThat(this.key).isEqualTo("051187");
assertThat(env.getProperty("inherited")).isEqualTo("12345");
assertThat(inherited).isEqualTo("12345");
}
@Configuration
static class Config {
}
}

67
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationOverridesLocallyTests.java vendored
View File

@@ -1,67 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* This test verifies an overriding of the property value which declared in the
* meta-annotation by the {@link TestPropertySource} when this property is also defined
* locally in {@link TestPropertySource}.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "meta = local value")
@AnnotationWithTestProperty
public class TestPropertySourceInheritedFromMetaAnnotationOverridesLocallyTests {
@Autowired
Environment env;
@Value("${meta}")
String meta;
@Test
public void inlineLocalPropertyAndPropertyFromMetaAnnotation() {
assertThat(env.getProperty("meta")).isEqualTo("local value");
assertThat(meta).isEqualTo("local value");
}
@Configuration
static class Config {
}
}

73
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationTests.java vendored
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* This test verifies a declaration of properties by the {@link TestPropertySource} both
* locally and in the custom meta-annotation.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "key = 051187")
@AnnotationWithTestProperty
public class TestPropertySourceInheritedFromMetaAnnotationTests {
@Autowired
Environment env;
@Value("${key}")
String key;
@Value("${meta}")
String meta;
@Test
public void inlineLocalPropertyAndPropertyFromMetaAnnotation() {
// local inlined:
assertThat(env.getProperty("key")).isEqualTo("051187");
assertThat(this.key).isEqualTo("051187");
// inlined from meta-annotation:
assertThat(env.getProperty("meta")).isEqualTo("value from meta-annotation");
assertThat(meta).isEqualTo("value from meta-annotation");
}
@Configuration
static class Config {
}
}

76
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceInheritedFromMetaAnnotationWithPropertiesFileTests.java vendored
View File

@@ -1,76 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Verify a property value defined both in the properties file which declared in the
* custom annotation {@link AnnotationWithTestPropertyInPropertiesFile} and a definition
* of property by the local usage of {@link TestPropertySource} with a properties file
* name.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource("local.properties")
@AnnotationWithTestPropertyInPropertiesFile
public class TestPropertySourceInheritedFromMetaAnnotationWithPropertiesFileTests {
@Autowired
Environment env;
@Value("${key}")
String key;
@Value("${meta}")
String meta;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertPropertyValue("key", key, "local value");
assertPropertyValue("meta", meta, "a value from file in the meta-annotation");
}
private void assertPropertyValue(String name, String value, String expectedValue) {
assertThat(env.getProperty(name)).isEqualTo(expectedValue);
assertThat(value).isEqualTo(expectedValue);
}
@Configuration
static class Config {
}
}

63
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourcePartialOverridesInheritedPropertyTests.java vendored
View File

@@ -1,63 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Verify the overriding of property which defined both in the parent class and locally in
* the {@link TestPropertySource} annotation. Also, verify that the value of not
* conflicted properties is applied from the parent class.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "second = local value")
public class TestPropertySourcePartialOverridesInheritedPropertyTests extends ParentClassWithMultipleTestProperties {
@Value("${first}")
String first;
@Value("${second}")
String second;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertThat(first).isEqualTo("value from parent class");
assertThat(second).isEqualTo("local value");
}
@Configuration
static class Config {
}
}

58
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableOverridesTests.java vendored
View File

@@ -1,58 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Verify an overriding of a property value which defined both in custom annotation
* and in the parent class, when this property declares locally by the
* {@link TestPropertySource}.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@FooTestProperty
@TestPropertySource(properties = "foo = local value")
public class TestPropertySourceRepeatableOverridesTests extends FooTestPropertyDeclaration {
@Value("${foo}")
String foo;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertThat(foo).isEqualTo("local value");
}
@Configuration
static class Config {
}
}

73
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableTests.java vendored
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Test multiple test property declarations by the using of {@link TestPropertySource} as
* a repeatable annotation.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource(properties = "first = 1111")
@TestPropertySource(properties = "second = 2222")
public class TestPropertySourceRepeatableTests {
@Autowired
Environment env;
@Value("${first}")
String first;
@Value("${second}")
String second;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertPropertyValue("first", first, "1111");
assertPropertyValue("second", second, "2222");
}
private void assertPropertyValue(String name, String value, String expectedValue) {
assertThat(env.getProperty(name)).isEqualTo(expectedValue);
assertThat(value).isEqualTo(expectedValue);
}
@Configuration
static class Config {
}
}

73
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableWithDefaultPropertiesFileTests.java vendored
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Verify a repeatable usage of {@link TestPropertySource} both with a default value of
* properties file and with a specified properties file name in the
* {@link TestPropertySource} annotation.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource
@TestPropertySource("local.properties")
public class TestPropertySourceRepeatableWithDefaultPropertiesFileTests {
@Autowired
Environment env;
@Value("${key}")
String key;
@Value("${default.value}")
String defaultValue;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertPropertyValue("key", key, "local value");
assertPropertyValue("default.value", defaultValue, "a value from default properties file");
}
private void assertPropertyValue(String name, String value, String expectedValue) {
assertThat(env.getProperty(name)).isEqualTo(expectedValue);
assertThat(value).isEqualTo(expectedValue);
}
@Configuration
static class Config {
}
}

73
spring-test/src/test/java/org/springframework/test/context/env/repeatable/TestPropertySourceRepeatableWithPropertiesFileTests.java vendored
View File

@@ -1,73 +0,0 @@
/*
* Copyright 2002-2019 the original author or authors.
*
* 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
*
* https://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.springframework.test.context.env.repeatable;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for support {@link TestPropertySource @TestPropertySource} as a
* repeatable annotation.
*
* Test multiple test properties file declarations by the using of {@link TestPropertySource} as
* a repeatable annotation.
*
* @author Anatoliy Korovin
* @since 5.2
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
@TestPropertySource("first.properties")
@TestPropertySource("second.properties")
public class TestPropertySourceRepeatableWithPropertiesFileTests {
@Autowired
Environment env;
@Value("${first}")
String first;
@Value("${second}")
String second;
@Test
public void inlinePropertyFromParentClassAndFromLocalTestPropertySourceAnnotation() {
assertPropertyValue("first", first, "1111");
assertPropertyValue("second", second, "2222");
}
private void assertPropertyValue(String name, String value, String expectedValue) {
assertThat(env.getProperty(name)).isEqualTo(expectedValue);
assertThat(value).isEqualTo(expectedValue);
}
@Configuration
static class Config {
}
}

112
spring-test/src/test/java/org/springframework/test/context/support/TestPropertySourceUtilsTests.java
View File

@@ -57,23 +57,40 @@ public class TestPropertySourceUtilsTests {
private static final String[] FOO_LOCATIONS = new String[] {"classpath:/foo.properties"};
@Test
public void emptyAnnotation() {
assertThatIllegalStateException().isThrownBy(() ->
buildMergedTestPropertySources(EmptyPropertySources.class))
.withMessageStartingWith("Could not detect default properties file for test")
assertThatIllegalStateException()
.isThrownBy(() -> buildMergedTestPropertySources(EmptyPropertySources.class))
.withMessageStartingWith("Could not detect default properties file for test class")
.withMessageContaining("class path resource")
.withMessageContaining("does not exist")
.withMessageContaining("EmptyPropertySources.properties");
}
@Test
public void extendedEmptyAnnotation() {
assertThatIllegalStateException().isThrownBy(() ->
buildMergedTestPropertySources(ExtendedEmptyPropertySources.class))
assertThatIllegalStateException()
.isThrownBy(() -> buildMergedTestPropertySources(ExtendedEmptyPropertySources.class))
.withMessageStartingWith("Could not detect default properties file for test")
.withMessageContaining("class path resource")
.withMessageContaining("does not exist")
.withMessageContaining("ExtendedEmptyPropertySources.properties");
}
@Test
public void repeatedTestPropertySourcesWithConflictingInheritLocationsFlags() {
assertThatIllegalArgumentException()
.isThrownBy(() -> buildMergedTestPropertySources(RepeatedPropertySourcesWithConflictingInheritLocationsFlags.class))
.withMessageContaining("must declare the same value for 'inheritLocations' as other directly present or meta-present @TestPropertySource annotations");
}
@Test
public void repeatedTestPropertySourcesWithConflictingInheritPropertiesFlags() {
assertThatIllegalArgumentException()
.isThrownBy(() -> buildMergedTestPropertySources(RepeatedPropertySourcesWithConflictingInheritPropertiesFlags.class))
.withMessageContaining("must declare the same value for 'inheritProperties' as other directly present or meta-present @TestPropertySource annotations");
}
@Test
public void value() {
assertMergedTestPropertySources(ValuePropertySources.class, asArray("classpath:/value.xml"),
@@ -82,8 +99,8 @@ public class TestPropertySourceUtilsTests {
@Test
public void locationsAndValueAttributes() {
assertThatExceptionOfType(AnnotationConfigurationException.class).isThrownBy(() ->
buildMergedTestPropertySources(LocationsAndValuePropertySources.class));
assertThatExceptionOfType(AnnotationConfigurationException.class)
.isThrownBy(() -> buildMergedTestPropertySources(LocationsAndValuePropertySources.class));
}
@Test
@@ -126,30 +143,37 @@ public class TestPropertySourceUtilsTests {
@Test
public void addPropertiesFilesToEnvironmentWithNullContext() {
assertThatIllegalArgumentException().isThrownBy(() ->
addPropertiesFilesToEnvironment((ConfigurableApplicationContext) null, FOO_LOCATIONS))
.withMessageContaining("must not be null");
assertThatIllegalArgumentException()
.isThrownBy(() -> addPropertiesFilesToEnvironment((ConfigurableApplicationContext) null, FOO_LOCATIONS))
.withMessageContaining("'context' must not be null");
}
@Test
public void addPropertiesFilesToEnvironmentWithContextAndNullLocations() {
assertThatIllegalArgumentException().isThrownBy(() ->
addPropertiesFilesToEnvironment(mock(ConfigurableApplicationContext.class), (String[]) null))
.withMessageContaining("must not be null");
assertThatIllegalArgumentException()
.isThrownBy(() -> addPropertiesFilesToEnvironment(mock(ConfigurableApplicationContext.class), (String[]) null))
.withMessageContaining("'locations' must not be null");
}
@Test
public void addPropertiesFilesToEnvironmentWithNullEnvironment() {
assertThatIllegalArgumentException().isThrownBy(() ->
addPropertiesFilesToEnvironment((ConfigurableEnvironment) null, mock(ResourceLoader.class), FOO_LOCATIONS))
.withMessageContaining("must not be null");
assertThatIllegalArgumentException()
.isThrownBy(() -> addPropertiesFilesToEnvironment((ConfigurableEnvironment) null, mock(ResourceLoader.class), FOO_LOCATIONS))
.withMessageContaining("'environment' must not be null");
}
@Test
public void addPropertiesFilesToEnvironmentWithEnvironmentLocationsAndNullResourceLoader() {
assertThatIllegalArgumentException()
.isThrownBy(() -> addPropertiesFilesToEnvironment(new MockEnvironment(), null, FOO_LOCATIONS))
.withMessageContaining("'resourceLoader' must not be null");
}
@Test
public void addPropertiesFilesToEnvironmentWithEnvironmentAndNullLocations() {
assertThatIllegalArgumentException().isThrownBy(() ->
addPropertiesFilesToEnvironment(new MockEnvironment(), mock(ResourceLoader.class), (String[]) null))
.withMessageContaining("must not be null");
assertThatIllegalArgumentException()
.isThrownBy(() -> addPropertiesFilesToEnvironment(new MockEnvironment(), mock(ResourceLoader.class), (String[]) null))
.withMessageContaining("'locations' must not be null");
}
@Test
@@ -172,43 +196,43 @@ public class TestPropertySourceUtilsTests {
@Test
public void addInlinedPropertiesToEnvironmentWithNullContext() {
assertThatIllegalArgumentException().isThrownBy(() ->
addInlinedPropertiesToEnvironment((ConfigurableApplicationContext) null, KEY_VALUE_PAIR))
.withMessageContaining("context");
assertThatIllegalArgumentException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment((ConfigurableApplicationContext) null, KEY_VALUE_PAIR))
.withMessageContaining("'context' must not be null");
}
@Test
public void addInlinedPropertiesToEnvironmentWithContextAndNullInlinedProperties() {
assertThatIllegalArgumentException().isThrownBy(() ->
addInlinedPropertiesToEnvironment(mock(ConfigurableApplicationContext.class), (String[]) null))
.withMessageContaining("inlined");
assertThatIllegalArgumentException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment(mock(ConfigurableApplicationContext.class), (String[]) null))
.withMessageContaining("'inlinedProperties' must not be null");
}
@Test
public void addInlinedPropertiesToEnvironmentWithNullEnvironment() {
assertThatIllegalArgumentException().isThrownBy(() ->
addInlinedPropertiesToEnvironment((ConfigurableEnvironment) null, KEY_VALUE_PAIR))
.withMessageContaining("environment");
assertThatIllegalArgumentException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment((ConfigurableEnvironment) null, KEY_VALUE_PAIR))
.withMessageContaining("'environment' must not be null");
}
@Test
public void addInlinedPropertiesToEnvironmentWithEnvironmentAndNullInlinedProperties() {
assertThatIllegalArgumentException().isThrownBy(() ->
addInlinedPropertiesToEnvironment(new MockEnvironment(), (String[]) null))
.withMessageContaining("inlined");
assertThatIllegalArgumentException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment(new MockEnvironment(), (String[]) null))
.withMessageContaining("'inlinedProperties' must not be null");
}
@Test
public void addInlinedPropertiesToEnvironmentWithMalformedUnicodeInValue() {
assertThatIllegalStateException().isThrownBy(() ->
addInlinedPropertiesToEnvironment(new MockEnvironment(), asArray("key = \\uZZZZ")))
assertThatIllegalStateException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment(new MockEnvironment(), asArray("key = \\uZZZZ")))
.withMessageContaining("Failed to load test environment property");
}
@Test
public void addInlinedPropertiesToEnvironmentWithMultipleKeyValuePairsInSingleInlinedProperty() {
assertThatIllegalStateException().isThrownBy(() ->
addInlinedPropertiesToEnvironment(new MockEnvironment(), asArray("a=b\nx=y")))
assertThatIllegalStateException()
.isThrownBy(() -> addInlinedPropertiesToEnvironment(new MockEnvironment(), asArray("a=b\nx=y")))
.withMessageContaining("Failed to load exactly one test environment property");
}
@@ -226,9 +250,9 @@ public class TestPropertySourceUtilsTests {
@Test
public void convertInlinedPropertiesToMapWithNullInlinedProperties() {
assertThatIllegalArgumentException().isThrownBy(() ->
convertInlinedPropertiesToMap((String[]) null))
.withMessageContaining("inlined");
assertThatIllegalArgumentException()
.isThrownBy(() -> convertInlinedPropertiesToMap((String[]) null))
.withMessageContaining("'inlinedProperties' must not be null");
}
@@ -256,6 +280,16 @@ public class TestPropertySourceUtilsTests {
static class ExtendedEmptyPropertySources extends EmptyPropertySources {
}
@TestPropertySource(locations = "foo.properties", inheritLocations = false)
@TestPropertySource(locations = "bar.properties", inheritLocations = true)
static class RepeatedPropertySourcesWithConflictingInheritLocationsFlags {
}
@TestPropertySource(properties = "a = b", inheritProperties = false)
@TestPropertySource(properties = "x = y", inheritProperties = true)
static class RepeatedPropertySourcesWithConflictingInheritPropertiesFlags {
}
@TestPropertySource(locations = "/foo", value = "/bar")
static class LocationsAndValuePropertySources {
}