Rename embedded servlet tests

Rename `spring-boot-integration-tests-embedded-servlet-container` to
`spring-boot-server-tests`.

See gh-9316

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/com/example/ResourceHandlingApplication.java

@@ -0,0 +1,72 @@
+/*
+ * 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 com.example;
+
+import java.io.IOException;
+import java.net.URL;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.system.EmbeddedServerPortFileWriter;
+import org.springframework.boot.web.servlet.ServletRegistrationBean;
+import org.springframework.context.annotation.Bean;
+
+/**
+ * Test application for verifying an embedded container's static resource handling.
+ *
+ * @author Andy Wilkinson
+ */
+@SpringBootApplication
+public class ResourceHandlingApplication {
+
+	public static void main(String[] args) {
+		new SpringApplicationBuilder(ResourceHandlingApplication.class)
+				.properties("server.port:0")
+				.listeners(new EmbeddedServerPortFileWriter("target/server.port"))
+				.run(args);
+	}
+
+	@Bean
+	public ServletRegistrationBean<?> resourceServletRegistration() {
+		ServletRegistrationBean<?> registration = new ServletRegistrationBean<HttpServlet>(
+				new HttpServlet() {
+
+					@Override
+					protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+							throws ServletException, IOException {
+						URL resource = getServletContext()
+								.getResource(req.getQueryString());
+						if (resource == null) {
+							resp.sendError(404);
+						}
+						else {
+							resp.getWriter().println(resource);
+							resp.getWriter().flush();
+						}
+					}
+
+				});
+		registration.addUrlMappings("/servletContext");
+		return registration;
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/AbstractApplicationLauncher.java

@@ -0,0 +1,104 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileReader;
+import java.lang.ProcessBuilder.Redirect;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.rules.ExternalResource;
+
+import org.springframework.util.FileCopyUtils;
+
+/**
+ * Base {@link ExternalResource} for launching a Spring Boot application as part of a
+ * JUnit test.
+ *
+ * @author Andy Wilkinson
+ */
+abstract class AbstractApplicationLauncher extends ExternalResource {
+
+	private final ApplicationBuilder applicationBuilder;
+
+	private Process process;
+
+	private int httpPort;
+
+	protected AbstractApplicationLauncher(ApplicationBuilder applicationBuilder) {
+		this.applicationBuilder = applicationBuilder;
+	}
+
+	@Override
+	protected final void before() throws Throwable {
+		this.process = startApplication();
+	}
+
+	@Override
+	protected final void after() {
+		this.process.destroy();
+	}
+
+	public final int getHttpPort() {
+		return this.httpPort;
+	}
+
+	protected abstract List<String> getArguments(File archive);
+
+	protected abstract File getWorkingDirectory();
+
+	protected abstract String getDescription(String packaging);
+
+	private Process startApplication() throws Exception {
+		File workingDirectory = getWorkingDirectory();
+		File serverPortFile = workingDirectory == null ? new File("target/server.port")
+				: new File(workingDirectory, "target/server.port");
+		serverPortFile.delete();
+		File archive = this.applicationBuilder.buildApplication();
+		List<String> arguments = new ArrayList<>();
+		arguments.add(System.getProperty("java.home") + "/bin/java");
+		arguments.addAll(getArguments(archive));
+		ProcessBuilder processBuilder = new ProcessBuilder(
+				arguments.toArray(new String[arguments.size()]));
+		processBuilder.redirectOutput(Redirect.INHERIT);
+		processBuilder.redirectError(Redirect.INHERIT);
+		if (workingDirectory != null) {
+			processBuilder.directory(workingDirectory);
+		}
+		Process process = processBuilder.start();
+		this.httpPort = awaitServerPort(process, serverPortFile);
+		return process;
+	}
+
+	private int awaitServerPort(Process process, File serverPortFile) throws Exception {
+		long end = System.currentTimeMillis() + 30000;
+		while (serverPortFile.length() == 0) {
+			if (System.currentTimeMillis() > end) {
+				throw new IllegalStateException(
+						"server.port file was not written within 30 seconds");
+			}
+			if (!process.isAlive()) {
+				throw new IllegalStateException("Application failed to launch");
+			}
+			Thread.sleep(100);
+		}
+		return Integer
+				.parseInt(FileCopyUtils.copyToString(new FileReader(serverPortFile)));
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/AbstractEmbeddedServletContainerIntegrationTests.java

@@ -0,0 +1,113 @@
+/*
+ * 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.context.embedded;
+
+import java.io.IOException;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.codehaus.plexus.util.StringUtils;
+import org.junit.ClassRule;
+import org.junit.Rule;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.http.client.ClientHttpResponse;
+import org.springframework.web.client.ResponseErrorHandler;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.UriTemplateHandler;
+
+/**
+ * Base class for embedded servlet container integration tests.
+ *
+ * @author Andy Wilkinson
+ */
+public abstract class AbstractEmbeddedServletContainerIntegrationTests {
+
+	@ClassRule
+	public static final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+	@Rule
+	public final AbstractApplicationLauncher launcher;
+
+	protected final RestTemplate rest = new RestTemplate();
+
+	public static Object[] parameters(String packaging,
+			List<Class<? extends AbstractApplicationLauncher>> applicationLaunchers) {
+		List<Object> parameters = new ArrayList<>();
+		parameters.addAll(createParameters(packaging, "jetty", applicationLaunchers));
+		parameters.addAll(createParameters(packaging, "tomcat", applicationLaunchers));
+		parameters.addAll(createParameters(packaging, "undertow", applicationLaunchers));
+		return parameters.toArray(new Object[parameters.size()]);
+	}
+
+	private static List<Object> createParameters(String packaging, String container,
+			List<Class<? extends AbstractApplicationLauncher>> applicationLaunchers) {
+		List<Object> parameters = new ArrayList<>();
+		ApplicationBuilder applicationBuilder = new ApplicationBuilder(temporaryFolder,
+				packaging, container);
+		for (Class<? extends AbstractApplicationLauncher> launcherClass : applicationLaunchers) {
+			try {
+				AbstractApplicationLauncher launcher = launcherClass
+						.getDeclaredConstructor(ApplicationBuilder.class)
+						.newInstance(applicationBuilder);
+				String name = StringUtils.capitalise(container) + ": "
+						+ launcher.getDescription(packaging);
+				parameters.add(new Object[] { name, launcher });
+			}
+			catch (Exception ex) {
+				throw new RuntimeException(ex);
+			}
+		}
+		return parameters;
+	}
+
+	protected AbstractEmbeddedServletContainerIntegrationTests(String name,
+			AbstractApplicationLauncher launcher) {
+		this.launcher = launcher;
+		this.rest.setErrorHandler(new ResponseErrorHandler() {
+
+			@Override
+			public boolean hasError(ClientHttpResponse response) throws IOException {
+				return false;
+			}
+
+			@Override
+			public void handleError(ClientHttpResponse response) throws IOException {
+
+			}
+
+		});
+		this.rest.setUriTemplateHandler(new UriTemplateHandler() {
+
+			@Override
+			public URI expand(String uriTemplate, Object... uriVariables) {
+				return URI.create(
+						"http://localhost:" + launcher.getHttpPort() + uriTemplate);
+			}
+
+			@Override
+			public URI expand(String uriTemplate, Map<String, ?> uriVariables) {
+				return URI.create(
+						"http://localhost:" + launcher.getHttpPort() + uriTemplate);
+			}
+
+		});
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/ApplicationBuilder.java

@@ -0,0 +1,143 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.jar.JarOutputStream;
+import java.util.zip.ZipEntry;
+
+import com.samskivert.mustache.Mustache;
+import org.apache.maven.shared.invoker.DefaultInvocationRequest;
+import org.apache.maven.shared.invoker.DefaultInvoker;
+import org.apache.maven.shared.invoker.InvocationRequest;
+import org.apache.maven.shared.invoker.InvocationResult;
+import org.apache.maven.shared.invoker.MavenInvocationException;
+import org.junit.rules.TemporaryFolder;
+
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.StringUtils;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Builds a Spring Boot application using Maven. To use this class, the {@code maven.home}
+ * system property must be set.
+ *
+ * @author Andy Wilkinson
+ */
+class ApplicationBuilder {
+
+	private final TemporaryFolder temp;
+
+	private final String packaging;
+
+	private final String container;
+
+	ApplicationBuilder(TemporaryFolder temp, String packaging, String container) {
+		this.temp = temp;
+		this.packaging = packaging;
+		this.container = container;
+	}
+
+	File buildApplication() throws Exception {
+		File containerFolder = new File(this.temp.getRoot(), this.container);
+		if (containerFolder.exists()) {
+			return new File(containerFolder, "app/target/app-0.0.1." + this.packaging);
+		}
+		return doBuildApplication(containerFolder);
+	}
+
+	private File doBuildApplication(File containerFolder)
+			throws IOException, FileNotFoundException, MavenInvocationException {
+		File resourcesJar = createResourcesJar();
+		File appFolder = new File(containerFolder, "app");
+		appFolder.mkdirs();
+		writePom(appFolder, resourcesJar);
+		copyApplicationSource(appFolder);
+		packageApplication(appFolder);
+		return new File(appFolder, "target/app-0.0.1." + this.packaging);
+	}
+
+	private File createResourcesJar() throws IOException, FileNotFoundException {
+		File resourcesJar = new File(this.temp.getRoot(), "resources.jar");
+		if (resourcesJar.exists()) {
+			return resourcesJar;
+		}
+		JarOutputStream resourcesJarStream = new JarOutputStream(
+				new FileOutputStream(resourcesJar));
+		resourcesJarStream.putNextEntry(new ZipEntry("META-INF/resources/"));
+		resourcesJarStream.closeEntry();
+		resourcesJarStream.putNextEntry(
+				new ZipEntry("META-INF/resources/nested-meta-inf-resource.txt"));
+		resourcesJarStream.write("nested".getBytes());
+		resourcesJarStream.closeEntry();
+		resourcesJarStream.close();
+		return resourcesJar;
+	}
+
+	private void writePom(File appFolder, File resourcesJar)
+			throws FileNotFoundException, IOException {
+		Map<String, Object> context = new HashMap<>();
+		context.put("packaging", this.packaging);
+		context.put("container", this.container);
+		context.put("bootVersion", Versions.getBootVersion());
+		context.put("resourcesJarPath", resourcesJar.getAbsolutePath());
+		FileWriter out = new FileWriter(new File(appFolder, "pom.xml"));
+		Mustache.compiler().escapeHTML(false)
+				.compile(new FileReader("src/test/resources/pom-template.xml"))
+				.execute(context, out);
+		out.close();
+	}
+
+	private void copyApplicationSource(File appFolder) throws IOException {
+		File examplePackage = new File(appFolder, "src/main/java/com/example");
+		examplePackage.mkdirs();
+		FileCopyUtils.copy(
+				new File("src/test/java/com/example/ResourceHandlingApplication.java"),
+				new File(examplePackage, "ResourceHandlingApplication.java"));
+		if ("war".equals(this.packaging)) {
+			File srcMainWebapp = new File(appFolder, "src/main/webapp");
+			srcMainWebapp.mkdirs();
+			FileCopyUtils.copy("webapp resource",
+					new FileWriter(new File(srcMainWebapp, "webapp-resource.txt")));
+		}
+	}
+
+	private void packageApplication(File appFolder) throws MavenInvocationException {
+		InvocationRequest invocation = new DefaultInvocationRequest();
+		invocation.setBaseDirectory(appFolder);
+		invocation.setGoals(Collections.singletonList("package"));
+		String repository = System.getProperty("repository");
+		if (StringUtils.hasText(repository) && !repository.equals("${repository}")) {
+			Properties properties = new Properties();
+			properties.put("repository", repository);
+			invocation.setProperties(properties);
+		}
+		InvocationResult execute = new DefaultInvoker().execute(invocation);
+		assertThat(execute.getExitCode()).isEqualTo(0);
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/BootRunApplicationLauncher.java

@@ -0,0 +1,149 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.FileSystemUtils;
+import org.springframework.util.StreamUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * {@link AbstractApplicationLauncher} that launches a Spring Boot application with a
+ * classpath similar to that used when run with Maven or Gradle.
+ *
+ * @author Andy Wilkinson
+ */
+class BootRunApplicationLauncher extends AbstractApplicationLauncher {
+
+	private final File exploded = new File("target/run");
+
+	BootRunApplicationLauncher(ApplicationBuilder applicationBuilder) {
+		super(applicationBuilder);
+	}
+
+	@Override
+	protected List<String> getArguments(File archive) {
+		try {
+			explodeArchive(archive);
+			deleteLauncherClasses();
+			File targetClasses = populateTargetClasses(archive);
+			File dependencies = populateDependencies(archive);
+			if (archive.getName().endsWith(".war")) {
+				populateSrcMainWebapp();
+			}
+			List<String> classpath = new ArrayList<>();
+			classpath.add(targetClasses.getAbsolutePath());
+			for (File dependency : dependencies.listFiles()) {
+				classpath.add(dependency.getAbsolutePath());
+			}
+			return Arrays.asList("-cp",
+					StringUtils.collectionToDelimitedString(classpath,
+							File.pathSeparator),
+					"com.example.ResourceHandlingApplication");
+		}
+		catch (IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private void deleteLauncherClasses() {
+		FileSystemUtils.deleteRecursively(new File(this.exploded, "org"));
+	}
+
+	private File populateTargetClasses(File archive) throws IOException {
+		File targetClasses = new File(this.exploded, "target/classes");
+		targetClasses.mkdirs();
+		File source = new File(this.exploded, getClassesPath(archive));
+		FileSystemUtils.copyRecursively(source, targetClasses);
+		FileSystemUtils.deleteRecursively(source);
+		return targetClasses;
+	}
+
+	private File populateDependencies(File archive) throws IOException {
+		File dependencies = new File(this.exploded, "dependencies");
+		dependencies.mkdirs();
+		List<String> libPaths = getLibPaths(archive);
+		for (String libPath : libPaths) {
+			File libDirectory = new File(this.exploded, libPath);
+			for (File jar : libDirectory.listFiles()) {
+				FileCopyUtils.copy(jar, new File(dependencies, jar.getName()));
+			}
+			FileSystemUtils.deleteRecursively(libDirectory);
+		}
+		return dependencies;
+	}
+
+	private void populateSrcMainWebapp() throws IOException {
+		File srcMainWebapp = new File(this.exploded, "src/main/webapp");
+		srcMainWebapp.mkdirs();
+		File source = new File(this.exploded, "webapp-resource.txt");
+		FileCopyUtils.copy(source, new File(srcMainWebapp, "webapp-resource.txt"));
+		source.delete();
+	}
+
+	private String getClassesPath(File archive) {
+		return archive.getName().endsWith(".jar") ? "BOOT-INF/classes"
+				: "WEB-INF/classes";
+	}
+
+	private List<String> getLibPaths(File archive) {
+		return archive.getName().endsWith(".jar")
+				? Collections.singletonList("BOOT-INF/lib")
+				: Arrays.asList("WEB-INF/lib", "WEB-INF/lib-provided");
+	}
+
+	private void explodeArchive(File archive) throws IOException {
+		FileSystemUtils.deleteRecursively(this.exploded);
+		JarFile jarFile = new JarFile(archive);
+		Enumeration<JarEntry> entries = jarFile.entries();
+		while (entries.hasMoreElements()) {
+			JarEntry jarEntry = entries.nextElement();
+			File extracted = new File(this.exploded, jarEntry.getName());
+			if (jarEntry.isDirectory()) {
+				extracted.mkdirs();
+			}
+			else {
+				FileOutputStream extractedOutputStream = new FileOutputStream(extracted);
+				StreamUtils.copy(jarFile.getInputStream(jarEntry), extractedOutputStream);
+				extractedOutputStream.close();
+			}
+		}
+		jarFile.close();
+	}
+
+	@Override
+	protected File getWorkingDirectory() {
+		return this.exploded;
+	}
+
+	@Override
+	protected String getDescription(String packaging) {
+		return "build system run " + packaging + " project";
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/EmbeddedServletContainerJarDevelopmentIntegrationTests.java

@@ -0,0 +1,67 @@
+/*
+ * 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.context.embedded;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for Spring Boot's embedded servlet container support when developing
+ * a jar application.
+ *
+ * @author Andy Wilkinson
+ */
+@RunWith(Parameterized.class)
+public class EmbeddedServletContainerJarDevelopmentIntegrationTests
+		extends AbstractEmbeddedServletContainerIntegrationTests {
+
+	@Parameters(name = "{0}")
+	public static Object[] parameters() {
+		return AbstractEmbeddedServletContainerIntegrationTests.parameters("jar", Arrays
+				.asList(BootRunApplicationLauncher.class, IdeApplicationLauncher.class));
+	}
+
+	public EmbeddedServletContainerJarDevelopmentIntegrationTests(String name,
+			AbstractApplicationLauncher launcher) {
+		super(name, launcher);
+	}
+
+	@Test
+	public void metaInfResourceFromDependencyIsAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void metaInfResourceFromDependencyIsAvailableViaServletContext()
+			throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/servletContext?/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/EmbeddedServletContainerJarPackagingIntegrationTests.java

@@ -0,0 +1,89 @@
+/*
+ * 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.context.embedded;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for Spring Boot's embedded servlet container support using jar
+ * packaging.
+ *
+ * @author Andy Wilkinson
+ */
+@RunWith(Parameterized.class)
+public class EmbeddedServletContainerJarPackagingIntegrationTests
+		extends AbstractEmbeddedServletContainerIntegrationTests {
+
+	@Parameters(name = "{0}")
+	public static Object[] parameters() {
+		return AbstractEmbeddedServletContainerIntegrationTests.parameters("jar",
+				Arrays.asList(PackagedApplicationLauncher.class,
+						ExplodedApplicationLauncher.class));
+	}
+
+	public EmbeddedServletContainerJarPackagingIntegrationTests(String name,
+			AbstractApplicationLauncher launcher) {
+		super(name, launcher);
+	}
+
+	@Test
+	public void nestedMetaInfResourceIsAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void nestedMetaInfResourceIsAvailableViaServletContext() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/servletContext?/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void nestedJarIsNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/BOOT-INF/lib/resources-1.0.jar", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+	@Test
+	public void applicationClassesAreNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/BOOT-INF/classes/com/example/ResourceHandlingApplication.class",
+				String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+	@Test
+	public void launcherIsNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/org/springframework/boot/loader/Launcher.class", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/EmbeddedServletContainerWarDevelopmentIntegrationTests.java

@@ -0,0 +1,74 @@
+/*
+ * 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.context.embedded;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for Spring Boot's embedded servlet container support when developing
+ * a war application.
+ *
+ * @author Andy Wilkinson
+ */
+@RunWith(Parameterized.class)
+public class EmbeddedServletContainerWarDevelopmentIntegrationTests
+		extends AbstractEmbeddedServletContainerIntegrationTests {
+
+	@Parameters(name = "{0}")
+	public static Object[] parameters() {
+		return AbstractEmbeddedServletContainerIntegrationTests.parameters("war", Arrays
+				.asList(BootRunApplicationLauncher.class, IdeApplicationLauncher.class));
+	}
+
+	public EmbeddedServletContainerWarDevelopmentIntegrationTests(String name,
+			AbstractApplicationLauncher launcher) {
+		super(name, launcher);
+	}
+
+	@Test
+	public void metaInfResourceFromDependencyIsAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void metaInfResourceFromDependencyIsAvailableViaServletContext()
+			throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/servletContext?/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void webappResourcesAreAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity("/webapp-resource.txt",
+				String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/EmbeddedServletContainerWarPackagingIntegrationTests.java

@@ -0,0 +1,100 @@
+/*
+ * 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.context.embedded;
+
+import java.util.Arrays;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Integration tests for Spring Boot's embedded servlet container support using war
+ * packaging.
+ *
+ * @author Andy Wilkinson
+ */
+@RunWith(Parameterized.class)
+public class EmbeddedServletContainerWarPackagingIntegrationTests
+		extends AbstractEmbeddedServletContainerIntegrationTests {
+
+	@Parameters(name = "{0}")
+	public static Object[] parameters() {
+		return AbstractEmbeddedServletContainerIntegrationTests.parameters("war",
+				Arrays.asList(PackagedApplicationLauncher.class,
+						ExplodedApplicationLauncher.class));
+	}
+
+	public EmbeddedServletContainerWarPackagingIntegrationTests(String name,
+			AbstractApplicationLauncher launcher) {
+		super(name, launcher);
+	}
+
+	@Test
+	public void nestedMetaInfResourceIsAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void nestedMetaInfResourceIsAvailableViaServletContext() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/servletContext?/nested-meta-inf-resource.txt", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void nestedJarIsNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest
+				.getForEntity("/WEB-INF/lib/resources-1.0.jar", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+	@Test
+	public void applicationClassesAreNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/WEB-INF/classes/com/example/ResourceHandlingApplication.class",
+				String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+	@Test
+	public void webappResourcesAreAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity("/webapp-resource.txt",
+				String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.OK);
+	}
+
+	@Test
+	public void loaderClassesAreNotAvailableViaHttp() throws Exception {
+		ResponseEntity<String> entity = this.rest.getForEntity(
+				"/org/springframework/boot/loader/Launcher.class", String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+		entity = this.rest.getForEntity(
+				"/org/springframework/../springframework/boot/loader/Launcher.class",
+				String.class);
+		assertThat(entity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/ExplodedApplicationLauncher.java

@@ -0,0 +1,88 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import org.springframework.util.FileSystemUtils;
+import org.springframework.util.StreamUtils;
+
+/**
+ * {@link AbstractApplicationLauncher} that launches a Spring Boot application using
+ * {@code JarLauncher} or {@code WarLauncher} and an exploded archive.
+ *
+ * @author Andy Wilkinson
+ */
+class ExplodedApplicationLauncher extends AbstractApplicationLauncher {
+
+	private final File exploded = new File("target/exploded");
+
+	ExplodedApplicationLauncher(ApplicationBuilder applicationBuilder) {
+		super(applicationBuilder);
+	}
+
+	@Override
+	protected File getWorkingDirectory() {
+		return this.exploded;
+	}
+
+	@Override
+	protected String getDescription(String packaging) {
+		return "exploded " + packaging;
+	}
+
+	@Override
+	protected List<String> getArguments(File archive) {
+		String mainClass = archive.getName().endsWith(".war")
+				? "org.springframework.boot.loader.WarLauncher"
+				: "org.springframework.boot.loader.JarLauncher";
+		try {
+			explodeArchive(archive);
+			return Arrays.asList("-cp", this.exploded.getAbsolutePath(), mainClass);
+		}
+		catch (IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private void explodeArchive(File archive) throws IOException {
+		FileSystemUtils.deleteRecursively(this.exploded);
+		JarFile jarFile = new JarFile(archive);
+		Enumeration<JarEntry> entries = jarFile.entries();
+		while (entries.hasMoreElements()) {
+			JarEntry jarEntry = entries.nextElement();
+			File extracted = new File(this.exploded, jarEntry.getName());
+			if (jarEntry.isDirectory()) {
+				extracted.mkdirs();
+			}
+			else {
+				FileOutputStream extractedOutputStream = new FileOutputStream(extracted);
+				StreamUtils.copy(jarFile.getInputStream(jarEntry), extractedOutputStream);
+				extractedOutputStream.close();
+			}
+		}
+		jarFile.close();
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/IdeApplicationLauncher.java

@@ -0,0 +1,160 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+import org.springframework.util.FileCopyUtils;
+import org.springframework.util.FileSystemUtils;
+import org.springframework.util.StreamUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * {@link AbstractApplicationLauncher} that launches a Spring Boot application with a
+ * classpath similar to that used when run in an IDE.
+ *
+ * @author Andy Wilkinson
+ */
+class IdeApplicationLauncher extends AbstractApplicationLauncher {
+
+	private final File exploded = new File("target/ide");
+
+	IdeApplicationLauncher(ApplicationBuilder applicationBuilder) {
+		super(applicationBuilder);
+	}
+
+	@Override
+	protected File getWorkingDirectory() {
+		return this.exploded;
+	}
+
+	@Override
+	protected String getDescription(String packaging) {
+		return "IDE run " + packaging + " project";
+	}
+
+	@Override
+	protected List<String> getArguments(File archive) {
+		try {
+			explodeArchive(archive, this.exploded);
+			deleteLauncherClasses();
+			File targetClasses = populateTargetClasses(archive);
+			File dependencies = populateDependencies(archive);
+			File resourcesProject = explodedResourcesProject(dependencies);
+			if (archive.getName().endsWith(".war")) {
+				populateSrcMainWebapp();
+			}
+			List<String> classpath = new ArrayList<>();
+			classpath.add(targetClasses.getAbsolutePath());
+			for (File dependency : dependencies.listFiles()) {
+				classpath.add(dependency.getAbsolutePath());
+			}
+			classpath.add(resourcesProject.getAbsolutePath());
+			return Arrays.asList("-cp",
+					StringUtils.collectionToDelimitedString(classpath,
+							File.pathSeparator),
+					"com.example.ResourceHandlingApplication");
+		}
+		catch (IOException ex) {
+			throw new RuntimeException(ex);
+		}
+	}
+
+	private File populateTargetClasses(File archive) throws IOException {
+		File targetClasses = new File(this.exploded, "target/classes");
+		targetClasses.mkdirs();
+		File source = new File(this.exploded, getClassesPath(archive));
+		FileSystemUtils.copyRecursively(source, targetClasses);
+		FileSystemUtils.deleteRecursively(source);
+		return targetClasses;
+	}
+
+	private File populateDependencies(File archive) throws IOException {
+		File dependencies = new File(this.exploded, "dependencies");
+		dependencies.mkdirs();
+		List<String> libPaths = getLibPaths(archive);
+		for (String libPath : libPaths) {
+			File libDirectory = new File(this.exploded, libPath);
+			for (File jar : libDirectory.listFiles()) {
+				FileCopyUtils.copy(jar, new File(dependencies, jar.getName()));
+			}
+			FileSystemUtils.deleteRecursively(libDirectory);
+		}
+		return dependencies;
+	}
+
+	private File explodedResourcesProject(File dependencies) throws IOException {
+		File resourcesProject = new File(this.exploded,
+				"resources-project/target/classes");
+		File resourcesJar = new File(dependencies, "resources-1.0.jar");
+		explodeArchive(resourcesJar, resourcesProject);
+		resourcesJar.delete();
+		return resourcesProject;
+	}
+
+	private void populateSrcMainWebapp() throws IOException {
+		File srcMainWebapp = new File(this.exploded, "src/main/webapp");
+		srcMainWebapp.mkdirs();
+		File source = new File(this.exploded, "webapp-resource.txt");
+		FileCopyUtils.copy(source, new File(srcMainWebapp, "webapp-resource.txt"));
+		source.delete();
+	}
+
+	private void deleteLauncherClasses() {
+		FileSystemUtils.deleteRecursively(new File(this.exploded, "org"));
+	}
+
+	private String getClassesPath(File archive) {
+		return archive.getName().endsWith(".jar") ? "BOOT-INF/classes"
+				: "WEB-INF/classes";
+	}
+
+	private List<String> getLibPaths(File archive) {
+		return archive.getName().endsWith(".jar")
+				? Collections.singletonList("BOOT-INF/lib")
+				: Arrays.asList("WEB-INF/lib", "WEB-INF/lib-provided");
+	}
+
+	private void explodeArchive(File archive, File destination) throws IOException {
+		FileSystemUtils.deleteRecursively(destination);
+		JarFile jarFile = new JarFile(archive);
+		Enumeration<JarEntry> entries = jarFile.entries();
+		while (entries.hasMoreElements()) {
+			JarEntry jarEntry = entries.nextElement();
+			File extracted = new File(destination, jarEntry.getName());
+			if (jarEntry.isDirectory()) {
+				extracted.mkdirs();
+			}
+			else {
+				FileOutputStream extractedOutputStream = new FileOutputStream(extracted);
+				StreamUtils.copy(jarFile.getInputStream(jarEntry), extractedOutputStream);
+				extractedOutputStream.close();
+			}
+		}
+		jarFile.close();
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/PackagedApplicationLauncher.java

@@ -0,0 +1,50 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * {@link AbstractApplicationLauncher} that launches a packaged Spring Boot application
+ * using {@code java -jar}.
+ *
+ * @author Andy Wilkinson
+ */
+class PackagedApplicationLauncher extends AbstractApplicationLauncher {
+
+	PackagedApplicationLauncher(ApplicationBuilder applicationBuilder) {
+		super(applicationBuilder);
+	}
+
+	@Override
+	protected File getWorkingDirectory() {
+		return null;
+	}
+
+	@Override
+	protected String getDescription(String packaging) {
+		return "packaged " + packaging;
+	}
+
+	@Override
+	protected List<String> getArguments(File archive) {
+		return Arrays.asList("-jar", archive.getAbsolutePath());
+	}
+
+}

spring-boot-tests/spring-boot-integration-tests/spring-boot-server-tests/src/test/java/org/springframework/boot/context/embedded/Versions.java

@@ -0,0 +1,61 @@
+/*
+ * 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.context.embedded;
+
+import java.io.File;
+import java.io.FileReader;
+
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathFactory;
+
+import org.xml.sax.InputSource;
+
+import org.springframework.util.StringUtils;
+
+/**
+ * Provides access to dependency versions by querying the project's pom.
+ *
+ * @author Andy Wilkinson
+ */
+final class Versions {
+
+	private static final String PROPERTIES = "/*[local-name()='project']/*[local-name()='properties']";
+
+	private Versions() {
+	}
+
+	public static String getBootVersion() {
+		String baseDir = StringUtils.cleanPath(new File(".").getAbsolutePath());
+		String mainBaseDir = evaluateExpression("pom.xml",
+				PROPERTIES + "/*[local-name()='main.basedir']/text()");
+		mainBaseDir = mainBaseDir.replace("${basedir}", baseDir);
+		return evaluateExpression(mainBaseDir + "/pom.xml",
+				PROPERTIES + "/*[local-name()='revision']/text()");
+	}
+
+	private static String evaluateExpression(String file, String expression) {
+		try {
+			InputSource source = new InputSource(new FileReader(file));
+			XPath xpath = XPathFactory.newInstance().newXPath();
+			return xpath.compile(expression).evaluate(source);
+		}
+		catch (Exception ex) {
+			throw new IllegalStateException("Failed to evaluate expression", ex);
+		}
+	}
+
+}