Java tutorial
package org.apache.archiva.webdav; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import com.gargoylesoftware.htmlunit.HttpMethod; import com.gargoylesoftware.htmlunit.NicelyResynchronizingAjaxController; import com.gargoylesoftware.htmlunit.WebClient; import com.gargoylesoftware.htmlunit.WebRequest; import com.gargoylesoftware.htmlunit.WebResponse; import junit.framework.TestCase; import net.sf.ehcache.CacheManager; import org.apache.archiva.admin.model.beans.ManagedRepository; import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin; import org.apache.archiva.configuration.ArchivaConfiguration; import org.apache.archiva.configuration.Configuration; import org.apache.archiva.configuration.ManagedRepositoryConfiguration; import org.apache.archiva.configuration.RemoteRepositoryConfiguration; import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner; import org.apache.archiva.webdav.httpunit.MkColMethodWebRequest; import org.apache.archiva.webdav.util.MavenIndexerCleaner; import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationEvent; import org.springframework.context.MessageSourceResolvable; import org.springframework.context.NoSuchMessageException; import org.springframework.core.ResolvableType; import org.springframework.core.env.Environment; import org.springframework.core.io.Resource; import org.springframework.mock.web.MockHttpServletRequest; import org.springframework.mock.web.MockHttpServletResponse; import org.springframework.mock.web.MockServletConfig; import org.springframework.mock.web.MockServletContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.web.context.WebApplicationContext; import javax.inject.Inject; import javax.servlet.Servlet; import javax.servlet.ServletContext; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.UnsupportedEncodingException; import java.lang.annotation.Annotation; import java.net.URL; import java.nio.charset.Charset; import java.util.Locale; import java.util.Map; import org.apache.commons.lang.StringUtils; /** * AbstractRepositoryServletTestCase */ @RunWith(ArchivaSpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath*:spring-context.xml", "classpath*:/repository-servlet-simple.xml" }) public abstract class AbstractRepositoryServletTestCase extends TestCase { protected static final String REPOID_INTERNAL = "internal"; protected File repoRootInternal; protected File repoRootLegacy; @Inject protected ArchivaConfiguration archivaConfiguration; @Inject protected ApplicationContext applicationContext; @Inject protected ManagedRepositoryAdmin managedRepositoryAdmin; protected Logger log = LoggerFactory.getLogger(getClass()); protected void saveConfiguration() throws Exception { saveConfiguration(archivaConfiguration); } @Before @Override public void setUp() throws Exception { super.setUp(); String appserverBase = new File("target/appserver-base").getAbsolutePath(); System.setProperty("appserver.base", appserverBase); File testConf = new File("src/test/resources/repository-archiva.xml"); File testConfDest = new File(appserverBase, "conf/archiva.xml"); if (testConfDest.exists()) { FileUtils.deleteQuietly(testConfDest); } FileUtils.copyFile(testConf, testConfDest); repoRootInternal = new File(appserverBase, "data/repositories/internal"); repoRootLegacy = new File(appserverBase, "data/repositories/legacy"); Configuration config = archivaConfiguration.getConfiguration(); config.getManagedRepositories().clear(); config.addManagedRepository( createManagedRepository(REPOID_INTERNAL, "Internal Test Repo", repoRootInternal, true)); managedRepositoryAdmin.createIndexContext(managedRepositoryAdmin.getManagedRepository(REPOID_INTERNAL)); config.getProxyConnectors().clear(); config.getRemoteRepositories().clear(); saveConfiguration(archivaConfiguration); CacheManager.getInstance().clearAll(); applicationContext.getBean(MavenIndexerCleaner.class).cleanupIndex(); } protected UnauthenticatedRepositoryServlet unauthenticatedRepositoryServlet = new UnauthenticatedRepositoryServlet(); protected void startRepository() throws Exception { final MockServletContext mockServletContext = new MockServletContext(); WebApplicationContext webApplicationContext = new TestWebapplicationContext(applicationContext, mockServletContext); mockServletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, webApplicationContext); MockServletConfig mockServletConfig = new MockServletConfig() { @Override public ServletContext getServletContext() { return mockServletContext; } }; unauthenticatedRepositoryServlet.init(mockServletConfig); } protected String createVersionMetadata(String groupId, String artifactId, String version) { return createVersionMetadata(groupId, artifactId, version, null, null, null); } protected String createVersionMetadata(String groupId, String artifactId, String version, String timestamp, String buildNumber, String lastUpdated) { StringBuilder buf = new StringBuilder(); buf.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n"); buf.append("<metadata>\n"); buf.append(" <groupId>").append(groupId).append("</groupId>\n"); buf.append(" <artifactId>").append(artifactId).append("</artifactId>\n"); buf.append(" <version>").append(version).append("</version>\n"); boolean hasSnapshot = StringUtils.isNotBlank(timestamp) || StringUtils.isNotBlank(buildNumber); boolean hasLastUpdated = StringUtils.isNotBlank(lastUpdated); if (hasSnapshot || hasLastUpdated) { buf.append(" <versioning>\n"); if (hasSnapshot) { buf.append(" <snapshot>\n"); buf.append(" <buildNumber>").append(buildNumber).append("</buildNumber>\n"); buf.append(" <timestamp>").append(timestamp).append("</timestamp>\n"); buf.append(" </snapshot>\n"); } if (hasLastUpdated) { buf.append(" <lastUpdated>").append(lastUpdated).append("</lastUpdated>\n"); } buf.append(" </versioning>\n"); } buf.append("</metadata>"); return buf.toString(); } public static class TestWebapplicationContext implements WebApplicationContext { private ApplicationContext applicationContext; private ServletContext servletContext; TestWebapplicationContext(ApplicationContext applicationContext, ServletContext servletContext) { this.applicationContext = applicationContext; } @Override public ServletContext getServletContext() { return servletContext; } @Override public String getId() { return applicationContext.getId(); } @Override public String getApplicationName() { return applicationContext.getApplicationName(); } @Override public String getDisplayName() { return applicationContext.getDisplayName(); } @Override public long getStartupDate() { return applicationContext.getStartupDate(); } @Override public ApplicationContext getParent() { return applicationContext.getParent(); } @Override public AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException { return applicationContext.getAutowireCapableBeanFactory(); } @Override public void publishEvent(ApplicationEvent applicationEvent) { applicationContext.publishEvent(applicationEvent); } @Override public Environment getEnvironment() { return applicationContext.getEnvironment(); } @Override public BeanFactory getParentBeanFactory() { return applicationContext.getParentBeanFactory(); } @Override public boolean containsLocalBean(String s) { return applicationContext.containsLocalBean(s); } @Override public boolean containsBeanDefinition(String s) { return applicationContext.containsBeanDefinition(s); } @Override public int getBeanDefinitionCount() { return applicationContext.getBeanDefinitionCount(); } @Override public String[] getBeanDefinitionNames() { return applicationContext.getBeanDefinitionNames(); } @Override public String[] getBeanNamesForType(Class<?> aClass) { return applicationContext.getBeanNamesForType(aClass); } @Override public String[] getBeanNamesForType(Class<?> aClass, boolean b, boolean b2) { return applicationContext.getBeanNamesForType(aClass, b, b2); } @Override public <T> Map<String, T> getBeansOfType(Class<T> tClass) throws BeansException { return applicationContext.getBeansOfType(tClass); } @Override public <T> Map<String, T> getBeansOfType(Class<T> tClass, boolean b, boolean b2) throws BeansException { return applicationContext.getBeansOfType(tClass, b, b2); } @Override public String[] getBeanNamesForAnnotation(Class<? extends Annotation> aClass) { return applicationContext.getBeanNamesForAnnotation(aClass); } @Override public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> aClass) throws BeansException { return applicationContext.getBeansWithAnnotation(aClass); } @Override public <A extends Annotation> A findAnnotationOnBean(String s, Class<A> aClass) throws NoSuchBeanDefinitionException { return applicationContext.findAnnotationOnBean(s, aClass); } @Override public <T> T getBean(Class<T> aClass, Object... objects) throws BeansException { return applicationContext.getBean(aClass, objects); } @Override public Object getBean(String s) throws BeansException { return applicationContext.getBean(s); } @Override public <T> T getBean(String s, Class<T> tClass) throws BeansException { return applicationContext.getBean(s, tClass); } @Override public <T> T getBean(Class<T> tClass) throws BeansException { return applicationContext.getBean(tClass); } @Override public Object getBean(String s, Object... objects) throws BeansException { return applicationContext.getBean(s, objects); } @Override public boolean containsBean(String s) { return applicationContext.containsBean(s); } @Override public boolean isSingleton(String s) throws NoSuchBeanDefinitionException { return applicationContext.isSingleton(s); } @Override public boolean isPrototype(String s) throws NoSuchBeanDefinitionException { return applicationContext.isPrototype(s); } @Override public boolean isTypeMatch(String s, Class<?> aClass) throws NoSuchBeanDefinitionException { return applicationContext.isTypeMatch(s, aClass); } @Override public Class<?> getType(String s) throws NoSuchBeanDefinitionException { return applicationContext.getType(s); } @Override public String[] getAliases(String s) { return applicationContext.getAliases(s); } @Override public String getMessage(String s, Object[] objects, String s2, Locale locale) { return applicationContext.getMessage(s, objects, s2, locale); } @Override public String getMessage(String s, Object[] objects, Locale locale) throws NoSuchMessageException { return applicationContext.getMessage(s, objects, locale); } @Override public String getMessage(MessageSourceResolvable messageSourceResolvable, Locale locale) throws NoSuchMessageException { return applicationContext.getMessage(messageSourceResolvable, locale); } @Override public Resource[] getResources(String s) throws IOException { return applicationContext.getResources(s); } @Override public void publishEvent(Object o) { // no op } @Override public String[] getBeanNamesForType(ResolvableType resolvableType) { return new String[0]; } @Override public boolean isTypeMatch(String s, ResolvableType resolvableType) throws NoSuchBeanDefinitionException { return false; } @Override public Resource getResource(String s) { return applicationContext.getResource(s); } @Override public ClassLoader getClassLoader() { return applicationContext.getClassLoader(); } } protected Servlet findServlet(String name) throws Exception { return unauthenticatedRepositoryServlet; } protected String getSpringConfigLocation() { return "classpath*:/META-INF/spring-context.xml,classpath*:spring-context.xml"; } protected static WebClient newClient() { final WebClient webClient = new WebClient(); webClient.getOptions().setJavaScriptEnabled(false); webClient.getOptions().setCssEnabled(false); webClient.getOptions().setAppletEnabled(false); webClient.getOptions().setThrowExceptionOnFailingStatusCode(false); webClient.setAjaxController(new NicelyResynchronizingAjaxController()); return webClient; } protected WebResponse getWebResponse(String path) throws Exception { return getWebResponse(new GetMethodWebRequest("http://localhost" + path));//, false ); } protected WebResponse getWebResponse(WebRequest webRequest) //, boolean followRedirect ) throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI(webRequest.getUrl().getPath()); request.addHeader("User-Agent", "Apache Archiva unit test"); request.setMethod(webRequest.getHttpMethod().name()); if (webRequest.getHttpMethod() == HttpMethod.PUT) { PutMethodWebRequest putRequest = PutMethodWebRequest.class.cast(webRequest); request.setContentType(putRequest.contentType); request.setContent(IOUtils.toByteArray(putRequest.inputStream)); } if (webRequest instanceof MkColMethodWebRequest) { request.setMethod("MKCOL"); } final MockHttpServletResponse response = execute(request); if (response.getStatus() == HttpServletResponse.SC_MOVED_PERMANENTLY || response.getStatus() == HttpServletResponse.SC_MOVED_TEMPORARILY) { String location = response.getHeader("Location"); log.debug("follow redirect to {}", location); return getWebResponse(new GetMethodWebRequest(location)); } return new WebResponse(null, null, 1) { @Override public String getContentAsString() { try { return response.getContentAsString(); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e.getMessage(), e); } } @Override public int getStatusCode() { return response.getStatus(); } @Override public String getResponseHeaderValue(String headerName) { return response.getHeader(headerName); } }; } protected MockHttpServletResponse execute(HttpServletRequest request) throws Exception { MockHttpServletResponse response = new MockHttpServletResponse() { @Override public String getContentAsString() throws UnsupportedEncodingException { String errorMessage = getErrorMessage(); return (errorMessage != null) ? errorMessage : super.getContentAsString(); } }; this.unauthenticatedRepositoryServlet.service(request, response); return response; } public static class GetMethodWebRequest extends WebRequest { String url; public GetMethodWebRequest(String url) throws Exception { super(new URL(url)); this.url = url; } } public static class PutMethodWebRequest extends WebRequest { String url; InputStream inputStream; String contentType; public PutMethodWebRequest(String url, InputStream inputStream, String contentType) throws Exception { super(new URL(url), HttpMethod.PUT); this.url = url; this.inputStream = inputStream; this.contentType = contentType; } } public static class ServletUnitClient { AbstractRepositoryServletTestCase abstractRepositoryServletTestCase; public ServletUnitClient(AbstractRepositoryServletTestCase abstractRepositoryServletTestCase) { this.abstractRepositoryServletTestCase = abstractRepositoryServletTestCase; } public WebResponse getResponse(WebRequest request) throws Exception { return getResponse(request, false); } public WebResponse getResponse(WebRequest request, boolean followRedirect) throws Exception { // alwasy following redirect as it's normal return abstractRepositoryServletTestCase.getWebResponse(request);//, followRedirect ); } public WebResponse getResource(WebRequest request) throws Exception { return getResponse(request); } } public ServletUnitClient getServletUnitClient() { return new ServletUnitClient(this); } @Override @After public void tearDown() throws Exception { if (repoRootInternal.exists()) { FileUtils.deleteDirectory(repoRootInternal); } if (repoRootLegacy.exists()) { FileUtils.deleteDirectory(repoRootLegacy); } } protected void assertFileContents(String expectedContents, File repoRoot, String path) throws IOException { File actualFile = new File(repoRoot, path); assertTrue("File <" + actualFile.getAbsolutePath() + "> should exist.", actualFile.exists()); assertTrue("File <" + actualFile.getAbsolutePath() + "> should be a file (not a dir/link/device/etc).", actualFile.isFile()); String actualContents = FileUtils.readFileToString(actualFile, Charset.defaultCharset()); assertEquals("File Contents of <" + actualFile.getAbsolutePath() + ">", expectedContents, actualContents); } protected void assertRepositoryValid(RepositoryServlet servlet, String repoId) throws Exception { ManagedRepository repository = servlet.getRepository(repoId); assertNotNull("Archiva Managed Repository id:<" + repoId + "> should exist.", repository); File repoRoot = new File(repository.getLocation()); assertTrue("Archiva Managed Repository id:<" + repoId + "> should have a valid location on disk.", repoRoot.exists() && repoRoot.isDirectory()); } protected void assertResponseOK(WebResponse response) { assertNotNull("Should have recieved a response", response); Assert.assertEquals("Should have been an OK response code", // HttpServletResponse.SC_OK, // response.getStatusCode()); } protected void assertResponseOK(WebResponse response, String path) { assertNotNull("Should have recieved a response", response); Assert.assertEquals("Should have been an OK response code for path: " + path, HttpServletResponse.SC_OK, response.getStatusCode()); } protected void assertResponseNotFound(WebResponse response) { assertNotNull("Should have recieved a response", response); Assert.assertEquals("Should have been an 404/Not Found response code.", HttpServletResponse.SC_NOT_FOUND, response.getStatusCode()); } protected void assertResponseInternalServerError(WebResponse response) { assertNotNull("Should have recieved a response", response); Assert.assertEquals("Should have been an 500/Internal Server Error response code.", HttpServletResponse.SC_INTERNAL_SERVER_ERROR, response.getStatusCode()); } protected void assertResponseConflictError(WebResponse response) { assertNotNull("Should have received a response", response); Assert.assertEquals("Should have been a 409/Conflict response code.", HttpServletResponse.SC_CONFLICT, response.getStatusCode()); } protected ManagedRepositoryConfiguration createManagedRepository(String id, String name, File location, boolean blockRedeployments) { ManagedRepositoryConfiguration repo = new ManagedRepositoryConfiguration(); repo.setId(id); repo.setName(name); repo.setLocation(location.getAbsolutePath()); repo.setBlockRedeployments(blockRedeployments); return repo; } protected ManagedRepositoryConfiguration createManagedRepository(String id, String name, File location, String layout, boolean blockRedeployments) { ManagedRepositoryConfiguration repo = createManagedRepository(id, name, location, blockRedeployments); repo.setLayout(layout); return repo; } protected RemoteRepositoryConfiguration createRemoteRepository(String id, String name, String url) { RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration(); repo.setId(id); repo.setName(name); repo.setUrl(url); return repo; } protected void saveConfiguration(ArchivaConfiguration archivaConfiguration) throws Exception { archivaConfiguration.save(archivaConfiguration.getConfiguration()); } protected void setupCleanRepo(File repoRootDir) throws IOException { FileUtils.deleteDirectory(repoRootDir); if (!repoRootDir.exists()) { repoRootDir.mkdirs(); } } protected void assertManagedFileNotExists(File repoRootInternal, String resourcePath) { File repoFile = new File(repoRootInternal, resourcePath); assertFalse("Managed Repository File <" + repoFile.getAbsolutePath() + "> should not exist.", repoFile.exists()); } protected void setupCleanInternalRepo() throws Exception { setupCleanRepo(repoRootInternal); } protected File populateRepo(File repoRootManaged, String path, String contents) throws Exception { File destFile = new File(repoRootManaged, path); destFile.getParentFile().mkdirs(); FileUtils.writeStringToFile(destFile, contents, Charset.defaultCharset()); return destFile; } }