Relocate projects to spring-boot-project

Move projects to better reflect the way that Spring Boot is released.

The following projects are under `spring-boot-project`:

  - `spring-boot`
  - `spring-boot-autoconfigure`
  - `spring-boot-tools`
  - `spring-boot-starters`
  - `spring-boot-actuator`
  - `spring-boot-actuator-autoconfigure`
  - `spring-boot-test`
  - `spring-boot-test-autoconfigure`
  - `spring-boot-devtools`
  - `spring-boot-cli`
  - `spring-boot-docs`

See gh-9316

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/java/org/springframework/boot/configurationmetadata/AbstractConfigurationMetadataTests.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2012-2016 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
+ *
+ *      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.springframework.boot.configurationmetadata;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Base for configuration meta-data tests.
+ *
+ * @author Stephane Nicoll
+ */
+public abstract class AbstractConfigurationMetadataTests {
+
+	@Rule
+	public final ExpectedException thrown = ExpectedException.none();
+
+	protected void assertSource(ConfigurationMetadataSource actual, String groupId,
+			String type, String sourceType) {
+		assertThat(actual).isNotNull();
+		assertThat(actual.getGroupId()).isEqualTo(groupId);
+		assertThat(actual.getType()).isEqualTo(type);
+		assertThat(actual.getSourceType()).isEqualTo(sourceType);
+	}
+
+	protected void assertProperty(ConfigurationMetadataProperty actual, String id,
+			String name, Class<?> type, Object defaultValue) {
+		assertThat(actual).isNotNull();
+		assertThat(actual.getId()).isEqualTo(id);
+		assertThat(actual.getName()).isEqualTo(name);
+		String typeName = type != null ? type.getName() : null;
+		assertThat(actual.getType()).isEqualTo(typeName);
+		assertThat(actual.getDefaultValue()).isEqualTo(defaultValue);
+	}
+
+	protected void assertItem(ConfigurationMetadataItem actual, String sourceType) {
+		assertThat(actual).isNotNull();
+		assertThat(actual.getSourceType()).isEqualTo(sourceType);
+	}
+
+	protected InputStream getInputStreamFor(String name) throws IOException {
+		Resource r = new ClassPathResource(
+				"metadata/configuration-metadata-" + name + ".json");
+		return r.getInputStream();
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/java/org/springframework/boot/configurationmetadata/ConfigurationMetadataRepositoryJsonBuilderTests.java

@@ -0,0 +1,254 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      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.springframework.boot.configurationmetadata;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link ConfigurationMetadataRepository}.
+ *
+ * @author Stephane Nicoll
+ */
+public class ConfigurationMetadataRepositoryJsonBuilderTests
+		extends AbstractConfigurationMetadataTests {
+
+	@Test
+	public void nullResource() throws IOException {
+		this.thrown.expect(IllegalArgumentException.class);
+		ConfigurationMetadataRepositoryJsonBuilder.create().withJsonResource(null);
+	}
+
+	@Test
+	public void simpleRepository() throws IOException {
+		try (InputStream foo = getInputStreamFor("foo")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(foo).build();
+			validateFoo(repo);
+			assertThat(repo.getAllGroups()).hasSize(1);
+			contains(repo.getAllProperties(), "spring.foo.name", "spring.foo.description",
+					"spring.foo.counter");
+			assertThat(repo.getAllProperties()).hasSize(3);
+		}
+	}
+
+	@Test
+	public void hintsOnMaps() throws IOException {
+		try (InputStream map = getInputStreamFor("map")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(map).build();
+			validateMap(repo);
+			assertThat(repo.getAllGroups()).hasSize(1);
+			contains(repo.getAllProperties(), "spring.map.first", "spring.map.second",
+					"spring.map.keys", "spring.map.values");
+			assertThat(repo.getAllProperties()).hasSize(4);
+		}
+	}
+
+	@Test
+	public void severalRepositoriesNoConflict() throws IOException {
+		try (InputStream foo = getInputStreamFor("foo");
+				InputStream bar = getInputStreamFor("bar")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(foo, bar).build();
+			validateFoo(repo);
+			validateBar(repo);
+			assertThat(repo.getAllGroups()).hasSize(2);
+			contains(repo.getAllProperties(), "spring.foo.name", "spring.foo.description",
+					"spring.foo.counter", "spring.bar.name", "spring.bar.description",
+					"spring.bar.counter");
+			assertThat(repo.getAllProperties()).hasSize(6);
+		}
+	}
+
+	@Test
+	public void repositoryWithRoot() throws IOException {
+		try (InputStream foo = getInputStreamFor("foo");
+				InputStream root = getInputStreamFor("root")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(foo, root).build();
+			validateFoo(repo);
+			assertThat(repo.getAllGroups()).hasSize(2);
+
+			contains(repo.getAllProperties(), "spring.foo.name", "spring.foo.description",
+					"spring.foo.counter", "spring.root.name", "spring.root2.name");
+			assertThat(repo.getAllProperties()).hasSize(5);
+		}
+	}
+
+	@Test
+	public void severalRepositoriesIdenticalGroups() throws IOException {
+		try (InputStream foo = getInputStreamFor("foo");
+				InputStream foo2 = getInputStreamFor("foo2")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(foo, foo2).build();
+			assertThat(repo.getAllGroups()).hasSize(1);
+			ConfigurationMetadataGroup group = repo.getAllGroups().get("spring.foo");
+			contains(group.getSources(), "org.acme.Foo", "org.acme.Foo2",
+					"org.springframework.boot.FooProperties");
+			assertThat(group.getSources()).hasSize(3);
+			contains(group.getProperties(), "spring.foo.name", "spring.foo.description",
+					"spring.foo.counter", "spring.foo.enabled", "spring.foo.type");
+			assertThat(group.getProperties()).hasSize(5);
+			contains(repo.getAllProperties(), "spring.foo.name", "spring.foo.description",
+					"spring.foo.counter", "spring.foo.enabled", "spring.foo.type");
+			assertThat(repo.getAllProperties()).hasSize(5);
+		}
+	}
+
+	@Test
+	public void emptyGroups() throws IOException {
+		try (InputStream in = getInputStreamFor("empty-groups")) {
+			ConfigurationMetadataRepository repo = ConfigurationMetadataRepositoryJsonBuilder
+					.create(in).build();
+			validateEmptyGroup(repo);
+			assertThat(repo.getAllGroups()).hasSize(1);
+			contains(repo.getAllProperties(), "name", "title");
+			assertThat(repo.getAllProperties()).hasSize(2);
+		}
+	}
+
+	@Test
+	public void builderInstancesAreIsolated() throws IOException {
+		try (InputStream foo = getInputStreamFor("foo");
+				InputStream bar = getInputStreamFor("bar")) {
+			ConfigurationMetadataRepositoryJsonBuilder builder = ConfigurationMetadataRepositoryJsonBuilder
+					.create();
+			ConfigurationMetadataRepository firstRepo = builder.withJsonResource(foo)
+					.build();
+			validateFoo(firstRepo);
+			ConfigurationMetadataRepository secondRepo = builder.withJsonResource(bar)
+					.build();
+			validateFoo(secondRepo);
+			validateBar(secondRepo);
+			// first repo not impacted by second build
+			assertThat(secondRepo).isNotEqualTo(firstRepo);
+			assertThat(firstRepo.getAllGroups()).hasSize(1);
+			assertThat(firstRepo.getAllProperties()).hasSize(3);
+			assertThat(secondRepo.getAllGroups()).hasSize(2);
+			assertThat(secondRepo.getAllProperties()).hasSize(6);
+		}
+	}
+
+	private void validateFoo(ConfigurationMetadataRepository repo) {
+		ConfigurationMetadataGroup group = repo.getAllGroups().get("spring.foo");
+		contains(group.getSources(), "org.acme.Foo",
+				"org.springframework.boot.FooProperties");
+		ConfigurationMetadataSource source = group.getSources().get("org.acme.Foo");
+		contains(source.getProperties(), "spring.foo.name", "spring.foo.description");
+		assertThat(source.getProperties()).hasSize(2);
+		ConfigurationMetadataSource source2 = group.getSources()
+				.get("org.springframework.boot.FooProperties");
+		contains(source2.getProperties(), "spring.foo.name", "spring.foo.counter");
+		assertThat(source2.getProperties()).hasSize(2);
+		validatePropertyHints(repo.getAllProperties().get("spring.foo.name"), 0, 0);
+		validatePropertyHints(repo.getAllProperties().get("spring.foo.description"), 0,
+				0);
+		validatePropertyHints(repo.getAllProperties().get("spring.foo.counter"), 1, 1);
+	}
+
+	private void validateBar(ConfigurationMetadataRepository repo) {
+		ConfigurationMetadataGroup group = repo.getAllGroups().get("spring.bar");
+		contains(group.getSources(), "org.acme.Bar",
+				"org.springframework.boot.BarProperties");
+		ConfigurationMetadataSource source = group.getSources().get("org.acme.Bar");
+		contains(source.getProperties(), "spring.bar.name", "spring.bar.description");
+		assertThat(source.getProperties()).hasSize(2);
+		ConfigurationMetadataSource source2 = group.getSources()
+				.get("org.springframework.boot.BarProperties");
+		contains(source2.getProperties(), "spring.bar.name", "spring.bar.counter");
+		assertThat(source2.getProperties()).hasSize(2);
+		validatePropertyHints(repo.getAllProperties().get("spring.bar.name"), 0, 0);
+		validatePropertyHints(repo.getAllProperties().get("spring.bar.description"), 2,
+				2);
+		validatePropertyHints(repo.getAllProperties().get("spring.bar.counter"), 0, 0);
+	}
+
+	private void validateMap(ConfigurationMetadataRepository repo) {
+		ConfigurationMetadataGroup group = repo.getAllGroups().get("spring.map");
+		ConfigurationMetadataSource source = group.getSources().get("org.acme.Map");
+		contains(source.getProperties(), "spring.map.first", "spring.map.second",
+				"spring.map.keys", "spring.map.values");
+		assertThat(source.getProperties()).hasSize(4);
+		ConfigurationMetadataProperty first = repo.getAllProperties()
+				.get("spring.map.first");
+		assertThat(first.getHints().getKeyHints()).hasSize(2);
+		assertThat(first.getHints().getValueProviders()).hasSize(0);
+		assertThat(first.getHints().getKeyHints().get(0).getValue()).isEqualTo("one");
+		assertThat(first.getHints().getKeyHints().get(0).getDescription())
+				.isEqualTo("First.");
+		assertThat(first.getHints().getKeyHints().get(1).getValue()).isEqualTo("two");
+		assertThat(first.getHints().getKeyHints().get(1).getDescription())
+				.isEqualTo("Second.");
+		ConfigurationMetadataProperty second = repo.getAllProperties()
+				.get("spring.map.second");
+		assertThat(second.getHints().getValueHints()).hasSize(2);
+		assertThat(second.getHints().getValueProviders()).hasSize(0);
+		assertThat(second.getHints().getValueHints().get(0).getValue()).isEqualTo("42");
+		assertThat(second.getHints().getValueHints().get(0).getDescription())
+				.isEqualTo("Choose me.");
+		assertThat(second.getHints().getValueHints().get(1).getValue()).isEqualTo("24");
+		assertThat(second.getHints().getValueHints().get(1).getDescription()).isNull();
+		ConfigurationMetadataProperty keys = repo.getAllProperties()
+				.get("spring.map.keys");
+		assertThat(keys.getHints().getValueHints()).hasSize(0);
+		assertThat(keys.getHints().getValueProviders()).hasSize(1);
+		assertThat(keys.getHints().getValueProviders().get(0).getName()).isEqualTo("any");
+		ConfigurationMetadataProperty values = repo.getAllProperties()
+				.get("spring.map.values");
+		assertThat(values.getHints().getValueHints()).hasSize(0);
+		assertThat(values.getHints().getValueProviders()).hasSize(1);
+		assertThat(values.getHints().getValueProviders().get(0).getName())
+				.isEqualTo("handle-as");
+		assertThat(values.getHints().getValueProviders().get(0).getParameters())
+				.hasSize(1);
+		assertThat(values.getHints().getValueProviders().get(0).getParameters()
+				.get("target")).isEqualTo("java.lang.Integer");
+	}
+
+	private void validateEmptyGroup(ConfigurationMetadataRepository repo) {
+		ConfigurationMetadataGroup group = repo.getAllGroups().get("");
+		contains(group.getSources(), "org.acme.Foo", "org.acme.Bar");
+		ConfigurationMetadataSource source = group.getSources().get("org.acme.Foo");
+		contains(source.getProperties(), "name");
+		assertThat(source.getProperties()).hasSize(1);
+		ConfigurationMetadataSource source2 = group.getSources().get("org.acme.Bar");
+		contains(source2.getProperties(), "title");
+		assertThat(source2.getProperties()).hasSize(1);
+		validatePropertyHints(repo.getAllProperties().get("name"), 0, 0);
+		validatePropertyHints(repo.getAllProperties().get("title"), 0, 0);
+	}
+
+	private void validatePropertyHints(ConfigurationMetadataProperty property,
+			int valueHints, int valueProviders) {
+		assertThat(property.getHints().getValueHints().size()).isEqualTo(valueHints);
+		assertThat(property.getHints().getValueProviders().size())
+				.isEqualTo(valueProviders);
+	}
+
+	private void contains(Map<String, ?> source, String... keys) {
+		for (String key : keys) {
+			assertThat(source).containsKey(key);
+		}
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/java/org/springframework/boot/configurationmetadata/DescriptionExtractorTests.java

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2012-2016 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
+ *
+ *      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.springframework.boot.configurationmetadata;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link DescriptionExtractor}.
+ *
+ * @author Stephane Nicoll
+ */
+public class DescriptionExtractorTests {
+
+	private static final String NEW_LINE = System.getProperty("line.separator");
+
+	private DescriptionExtractor extractor = new DescriptionExtractor();
+
+	@Test
+	public void extractShortDescription() {
+		String description = this.extractor
+				.getShortDescription("My short " + "description. More stuff.");
+		assertThat(description).isEqualTo("My short description.");
+	}
+
+	@Test
+	public void extractShortDescriptionNewLineBeforeDot() {
+		String description = this.extractor.getShortDescription(
+				"My short" + NEW_LINE + "description." + NEW_LINE + "More stuff.");
+		assertThat(description).isEqualTo("My short description.");
+	}
+
+	@Test
+	public void extractShortDescriptionNewLineBeforeDotWithSpaces() {
+		String description = this.extractor.getShortDescription(
+				"My short  " + NEW_LINE + " description.  " + NEW_LINE + "More stuff.");
+		assertThat(description).isEqualTo("My short description.");
+	}
+
+	@Test
+	public void extractShortDescriptionNoDot() {
+		String description = this.extractor.getShortDescription("My short description");
+		assertThat(description).isEqualTo("My short description");
+	}
+
+	@Test
+	public void extractShortDescriptionNoDotMultipleLines() {
+		String description = this.extractor
+				.getShortDescription("My short description " + NEW_LINE + " More stuff");
+		assertThat(description).isEqualTo("My short description");
+	}
+
+	@Test
+	public void extractShortDescriptionNull() {
+		assertThat(this.extractor.getShortDescription(null)).isEqualTo(null);
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/java/org/springframework/boot/configurationmetadata/JsonReaderTests.java

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2012-2017 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
+ *
+ *      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.springframework.boot.configurationmetadata;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.List;
+
+import org.hamcrest.CoreMatchers;
+import org.json.JSONException;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link JsonReader}
+ *
+ * @author Stephane Nicoll
+ */
+public class JsonReaderTests extends AbstractConfigurationMetadataTests {
+
+	private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
+
+	private final JsonReader reader = new JsonReader();
+
+	@Test
+	public void emptyMetadata() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("empty");
+		assertThat(rawMetadata.getSources()).isEmpty();
+		assertThat(rawMetadata.getItems()).isEmpty();
+	}
+
+	@Test
+	public void invalidMetadata() throws IOException {
+		this.thrown.expectCause(CoreMatchers.<Throwable>instanceOf(JSONException.class));
+		readFor("invalid");
+	}
+
+	@Test
+	public void emptyGroupName() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("empty-groups");
+		List<ConfigurationMetadataItem> items = rawMetadata.getItems();
+		assertThat(items).hasSize(2);
+
+		ConfigurationMetadataItem name = items.get(0);
+		assertProperty(name, "name", "name", String.class, null);
+		ConfigurationMetadataItem dotTitle = items.get(1);
+		assertProperty(dotTitle, "title", "title", String.class, null);
+	}
+
+	@Test
+	public void simpleMetadata() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("foo");
+		List<ConfigurationMetadataSource> sources = rawMetadata.getSources();
+		assertThat(sources).hasSize(2);
+		List<ConfigurationMetadataItem> items = rawMetadata.getItems();
+		assertThat(items).hasSize(4);
+		List<ConfigurationMetadataHint> hints = rawMetadata.getHints();
+		assertThat(hints).hasSize(1);
+
+		ConfigurationMetadataSource source = sources.get(0);
+		assertSource(source, "spring.foo", "org.acme.Foo", "org.acme.config.FooApp");
+		assertThat(source.getSourceMethod()).isEqualTo("foo()");
+		assertThat(source.getDescription()).isEqualTo("This is Foo.");
+		assertThat(source.getShortDescription()).isEqualTo("This is Foo.");
+
+		ConfigurationMetadataItem item = items.get(0);
+		assertProperty(item, "spring.foo.name", "name", String.class, null);
+		assertItem(item, "org.acme.Foo");
+		ConfigurationMetadataItem item2 = items.get(1);
+		assertProperty(item2, "spring.foo.description", "description", String.class,
+				"FooBar");
+		assertThat(item2.getDescription()).isEqualTo("Foo description.");
+		assertThat(item2.getShortDescription()).isEqualTo("Foo description.");
+		assertThat(item2.getSourceMethod()).isNull();
+		assertItem(item2, "org.acme.Foo");
+
+		ConfigurationMetadataHint hint = hints.get(0);
+		assertThat(hint.getId()).isEqualTo("spring.foo.counter");
+		assertThat(hint.getValueHints()).hasSize(1);
+		ValueHint valueHint = hint.getValueHints().get(0);
+		assertThat(valueHint.getValue()).isEqualTo(42);
+		assertThat(valueHint.getDescription()).isEqualTo(
+				"Because that's the answer to any question, choose it. \nReally.");
+		assertThat(valueHint.getShortDescription())
+				.isEqualTo("Because that's the answer to any question, choose it.");
+		assertThat(hint.getValueProviders()).hasSize(1);
+		ValueProvider valueProvider = hint.getValueProviders().get(0);
+		assertThat(valueProvider.getName()).isEqualTo("handle-as");
+		assertThat(valueProvider.getParameters()).hasSize(1);
+		assertThat(valueProvider.getParameters().get("target"))
+				.isEqualTo(Integer.class.getName());
+	}
+
+	@Test
+	public void metadataHints() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("bar");
+		List<ConfigurationMetadataHint> hints = rawMetadata.getHints();
+		assertThat(hints).hasSize(1);
+
+		ConfigurationMetadataHint hint = hints.get(0);
+		assertThat(hint.getId()).isEqualTo("spring.bar.description");
+		assertThat(hint.getValueHints()).hasSize(2);
+		ValueHint valueHint = hint.getValueHints().get(0);
+		assertThat(valueHint.getValue()).isEqualTo("one");
+		assertThat(valueHint.getDescription()).isEqualTo("One.");
+		ValueHint valueHint2 = hint.getValueHints().get(1);
+		assertThat(valueHint2.getValue()).isEqualTo("two");
+		assertThat(valueHint2.getDescription()).isEqualTo(null);
+
+		assertThat(hint.getValueProviders()).hasSize(2);
+		ValueProvider valueProvider = hint.getValueProviders().get(0);
+		assertThat(valueProvider.getName()).isEqualTo("handle-as");
+		assertThat(valueProvider.getParameters()).hasSize(1);
+		assertThat(valueProvider.getParameters().get("target"))
+				.isEqualTo(String.class.getName());
+		ValueProvider valueProvider2 = hint.getValueProviders().get(1);
+		assertThat(valueProvider2.getName()).isEqualTo("any");
+		assertThat(valueProvider2.getParameters()).isEmpty();
+	}
+
+	@Test
+	public void rootMetadata() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("root");
+		List<ConfigurationMetadataSource> sources = rawMetadata.getSources();
+		assertThat(sources).isEmpty();
+		List<ConfigurationMetadataItem> items = rawMetadata.getItems();
+		assertThat(items).hasSize(2);
+		ConfigurationMetadataItem item = items.get(0);
+		assertProperty(item, "spring.root.name", "spring.root.name", String.class, null);
+	}
+
+	@Test
+	public void deprecatedMetadata() throws IOException {
+		RawConfigurationMetadata rawMetadata = readFor("deprecated");
+		List<ConfigurationMetadataItem> items = rawMetadata.getItems();
+		assertThat(items).hasSize(5);
+
+		ConfigurationMetadataItem item = items.get(0);
+		assertProperty(item, "server.port", "server.port", Integer.class, null);
+		assertThat(item.isDeprecated()).isTrue();
+		assertThat(item.getDeprecation().getReason())
+				.isEqualTo("Server namespace has moved to spring.server");
+		assertThat(item.getDeprecation().getReplacement())
+				.isEqualTo("server.spring.port");
+		assertThat(item.getDeprecation().getLevel()).isEqualTo(Deprecation.Level.WARNING);
+
+		ConfigurationMetadataItem item2 = items.get(1);
+		assertProperty(item2, "server.cluster-name", "server.cluster-name", String.class,
+				null);
+		assertThat(item2.isDeprecated()).isTrue();
+		assertThat(item2.getDeprecation().getReason()).isNull();
+		assertThat(item2.getDeprecation().getReplacement()).isNull();
+		assertThat(item.getDeprecation().getLevel()).isEqualTo(Deprecation.Level.WARNING);
+
+		ConfigurationMetadataItem item3 = items.get(2);
+		assertProperty(item3, "spring.server.name", "spring.server.name", String.class,
+				null);
+		assertThat(item3.isDeprecated()).isFalse();
+		assertThat(item3.getDeprecation()).isEqualTo(null);
+
+		ConfigurationMetadataItem item4 = items.get(3);
+		assertProperty(item4, "spring.server-name", "spring.server-name", String.class,
+				null);
+		assertThat(item4.isDeprecated()).isTrue();
+		assertThat(item4.getDeprecation().getReason()).isNull();
+		assertThat(item4.getDeprecation().getReplacement())
+				.isEqualTo("spring.server.name");
+		assertThat(item4.getDeprecation().getLevel()).isEqualTo(Deprecation.Level.ERROR);
+
+		ConfigurationMetadataItem item5 = items.get(4);
+		assertProperty(item5, "spring.server-name2", "spring.server-name2", String.class,
+				null);
+		assertThat(item5.isDeprecated()).isTrue();
+		assertThat(item5.getDeprecation().getReason()).isNull();
+		assertThat(item5.getDeprecation().getReplacement())
+				.isEqualTo("spring.server.name");
+		assertThat(item5.getDeprecation().getLevel())
+				.isEqualTo(Deprecation.Level.WARNING);
+	}
+
+	RawConfigurationMetadata readFor(String path) throws IOException {
+		return this.reader.read(getInputStreamFor(path), DEFAULT_CHARSET);
+	}
+
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-bar.json

@@ -0,0 +1,65 @@
+{
+  "groups": [
+    {
+      "name": "spring.bar",
+      "type": "org.acme.Bar",
+      "sourceType": "org.acme.config.BarApp",
+      "sourceMethod": "bar()",
+      "description": "This is Bar."
+    },
+    {
+      "name": "spring.bar",
+      "type": "org.springframework.boot.BarProperties"
+    }
+  ],
+  "properties": [
+    {
+      "name": "spring.bar.name",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Bar"
+    },
+    {
+      "name": "spring.bar.description",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Bar",
+      "description": "Bar description.",
+      "defaultValue": "BarFoo"
+    },
+    {
+      "name": "spring.bar.name",
+      "type": "java.lang.String",
+      "sourceType": "org.springframework.boot.BarProperties"
+    },
+    {
+      "name": "spring.bar.counter",
+      "type": "java.lang.Integer",
+      "sourceType": "org.springframework.boot.BarProperties",
+      "defaultValue": 0
+    }
+  ],
+  "hints": [
+    {
+      "name": "spring.bar.description",
+      "values": [
+        {
+          "value": "one",
+          "description": "One."
+        },
+        {
+          "value": "two"
+        }
+      ],
+      "providers": [
+        {
+          "name": "handle-as",
+          "parameters": {
+            "target": "java.lang.String"
+          }
+        },
+        {
+          "name": "any"
+        }
+      ]
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-deprecated.json

@@ -0,0 +1,38 @@
+{
+	"properties": [
+		{
+			"name": "server.port",
+			"type": "java.lang.Integer",
+			"deprecation": {
+				"reason": "Server namespace has moved to spring.server",
+				"replacement": "server.spring.port"
+			}
+		},
+		{
+			"name": "server.cluster-name",
+			"type": "java.lang.String",
+			"deprecated": true
+		},
+		{
+			"name": "spring.server.name",
+			"type": "java.lang.String",
+			"deprecated": false
+		},
+    {
+      "name": "spring.server-name",
+      "type": "java.lang.String",
+      "deprecation": {
+        "level": "error",
+        "replacement": "spring.server.name"
+      }
+    },
+    {
+      "name": "spring.server-name2",
+      "type": "java.lang.String",
+      "deprecation": {
+        "level": "INVALID",
+        "replacement": "spring.server.name"
+      }
+    }
+	]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-empty-groups.json

@@ -0,0 +1,30 @@
+{
+  "groups": [
+    {
+      "name": "",
+      "type": "org.acme.Foo",
+      "sourceType": "org.acme.config.FooApp",
+      "sourceMethod": "foo()",
+      "description": "This is Foo."
+    },
+    {
+      "name": "",
+      "type": "org.acme.Bar",
+      "sourceType": "org.acme.config.FooApp",
+      "sourceMethod": "bar()",
+      "description": "This is Bar."
+    }
+  ],
+  "properties": [
+    {
+      "name": "name",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Foo"
+    },
+    {
+      "name": "title",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Bar"
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-empty.json

@@ -0,0 +1,3 @@
+{
+  "foo": "bar"
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-foo.json

@@ -0,0 +1,59 @@
+{
+  "groups": [
+    {
+      "name": "spring.foo",
+      "type": "org.acme.Foo",
+      "sourceType": "org.acme.config.FooApp",
+      "sourceMethod": "foo()",
+      "description": "This is Foo."
+    },
+    {
+      "name": "spring.foo",
+      "type": "org.springframework.boot.FooProperties"
+    }
+  ],
+  "properties": [
+    {
+      "name": "spring.foo.name",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Foo"
+    },
+    {
+      "name": "spring.foo.description",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Foo",
+      "description": "Foo description.",
+      "defaultValue": "FooBar"
+    },
+    {
+      "name": "spring.foo.name",
+      "type": "java.lang.String",
+      "sourceType": "org.springframework.boot.FooProperties"
+    },
+    {
+      "name": "spring.foo.counter",
+      "type": "java.lang.Integer",
+      "sourceType": "org.springframework.boot.FooProperties",
+      "defaultValue": 0
+    }
+  ],
+  "hints": [
+    {
+      "name": "spring.foo.counter",
+      "values": [
+        {
+          "value": 42,
+          "description": "Because that's the answer to any question, choose it. \nReally."
+        }
+      ],
+      "providers": [
+        {
+          "name": "handle-as",
+          "parameters": {
+            "target": "java.lang.Integer"
+          }
+        }
+      ]
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-foo2.json

@@ -0,0 +1,23 @@
+{
+  "groups": [
+    {
+      "name": "spring.foo",
+      "type": "org.acme.Foo2",
+      "sourceType": "org.acme.config.FooApp",
+      "sourceMethod": "foo2()",
+      "description": "This is Foo2."
+    }
+  ],
+  "properties": [
+    {
+      "name": "spring.foo.enabled",
+      "type": "java.lang.Boolean",
+      "sourceType": "org.acme.Foo2"
+    },
+    {
+      "name": "spring.foo.type",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Foo2"
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-invalid.json

@@ -0,0 +1,8 @@
+{
+  "properties": [
+    {
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Invalid"
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-map.json

@@ -0,0 +1,79 @@
+{
+  "groups": [
+    {
+      "name": "spring.map",
+      "type": "org.acme.Map",
+      "sourceType": "org.acme.config.MapApp",
+      "sourceMethod": "map()",
+      "description": "This is Map."
+    }
+  ],
+  "properties": [
+    {
+      "name": "spring.map.first",
+      "type": "java.util.Map<String,String>",
+      "sourceType": "org.acme.Map"
+    },
+    {
+      "name": "spring.map.second",
+      "type": "java.util.Map<String,String>",
+      "sourceType": "org.acme.Map"
+    },
+    {
+      "name": "spring.map.keys",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Map"
+    },
+    {
+      "name": "spring.map.values",
+      "type": "java.lang.String",
+      "sourceType": "org.acme.Map"
+    }
+  ],
+  "hints": [
+    {
+      "name": "spring.map.first.keys",
+      "values": [
+        {
+          "value": "one",
+          "description": "First."
+        },
+        {
+          "value": "two",
+          "description": "Second."
+        }
+      ]
+    },
+    {
+      "name": "spring.map.second.values",
+      "values": [
+        {
+          "value": "42",
+          "description": "Choose me."
+        },
+        {
+          "value": "24"
+        }
+      ]
+    },
+    {
+      "name": "spring.map.keys",
+      "providers": [
+        {
+          "name": "any"
+        }
+      ]
+    },
+    {
+      "name": "spring.map.values",
+      "providers": [
+        {
+          "name": "handle-as",
+          "parameters": {
+            "target": "java.lang.Integer"
+          }
+        }
+      ]
+    }
+  ]
+}

spring-boot-project/spring-boot-tools/spring-boot-configuration-metadata/src/test/resources/metadata/configuration-metadata-root.json

@@ -0,0 +1,11 @@
+{
+  "properties": [
+    {
+      "name": "spring.root.name",
+      "type": "java.lang.String"
+    },
+    {
+      "name": "spring.root2.name"
+    }
+  ]
+}