Merge

scm-webapp/src/test/java/sonia/scm/TemplatingPushStateDispatcherTest.java

@@ -17,6 +17,7 @@ import java.io.StringWriter;
 import java.io.Writer;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -45,6 +46,23 @@ public class TemplatingPushStateDispatcherTest {
 
   @Test
   public void testDispatch() throws IOException {
+    TemplatingPushStateDispatcher.IndexHtmlModel model = dispatch();
+    assertEquals("/scm", model.getContextPath());
+    assertNull(model.getLiveReloadURL());
+  }
+
+  @Test
+  public void testDispatchWithLiveReloadURL() throws IOException {
+    System.setProperty("livereload.url", "/livereload.js");
+    try {
+      TemplatingPushStateDispatcher.IndexHtmlModel model = dispatch();
+      assertEquals("/livereload.js", model.getLiveReloadURL());
+    } finally {
+      System.clearProperty("livereload.url");
+    }
+  }
+
+  private TemplatingPushStateDispatcher.IndexHtmlModel dispatch() throws IOException {
     when(request.getContextPath()).thenReturn("/scm");
     when(templateEngine.getTemplate(TemplatingPushStateDispatcher.TEMPLATE)).thenReturn(template);
 
@@ -59,8 +77,7 @@ public class TemplatingPushStateDispatcherTest {
 
     verify(template).execute(any(Writer.class), captor.capture());
 
-    TemplatingPushStateDispatcher.IndexHtmlModel model = (TemplatingPushStateDispatcher.IndexHtmlModel) captor.getValue();
-    assertEquals("/scm", model.getContextPath());
+    return (TemplatingPushStateDispatcher.IndexHtmlModel) captor.getValue();
   }
 
 }

scm-webapp/src/test/java/sonia/scm/api/v2/resources/ChangesetRootResourceTest.java

@@ -169,7 +169,7 @@ public class ChangesetRootResourceTest extends RepositoryTestBase {
     when(logCommandBuilder.setStartChangeset(anyString())).thenReturn(logCommandBuilder);
     when(logCommandBuilder.getChangesets()).thenReturn(changesetPagingResult);
     MockHttpRequest request = MockHttpRequest
-      .get(CHANGESET_URL + "id")
+      .get(CHANGESET_URL + id)
       .accept(VndMediaType.CHANGESET);
     MockHttpResponse response = new MockHttpResponse();
     dispatcher.invoke(request, response);

scm-webapp/src/test/java/sonia/scm/api/v2/resources/ContentResourceTest.java

@@ -92,7 +92,7 @@ public class ContentResourceTest {
     Response response = contentResource.get(NAMESPACE, REPO_NAME, REV, "SomeGoCode.go");
     assertEquals(200, response.getStatus());
 
-    assertEquals("GO", response.getHeaderString("Language"));
+    assertEquals("GO", response.getHeaderString("X-Programming-Language"));
     assertEquals("text/x-go", response.getHeaderString("Content-Type"));
   }
 
@@ -103,7 +103,7 @@ public class ContentResourceTest {
     Response response = contentResource.get(NAMESPACE, REPO_NAME, REV, "Dockerfile");
     assertEquals(200, response.getStatus());
 
-    assertEquals("DOCKERFILE", response.getHeaderString("Language"));
+    assertEquals("DOCKERFILE", response.getHeaderString("X-Programming-Language"));
     assertEquals("text/plain", response.getHeaderString("Content-Type"));
   }
 

scm-webapp/src/test/java/sonia/scm/api/v2/resources/DiffResourceTest.java

@@ -20,18 +20,22 @@ import org.mockito.junit.MockitoJUnitRunner;
 import sonia.scm.NotFoundException;
 import sonia.scm.api.rest.AuthorizationExceptionMapper;
 import sonia.scm.api.rest.ContextualExceptionMapper;
+import sonia.scm.api.rest.IllegalArgumentExceptionMapper;
 import sonia.scm.api.v2.NotFoundExceptionMapper;
 import sonia.scm.repository.NamespaceAndName;
 import sonia.scm.repository.Repository;
 import sonia.scm.repository.api.DiffCommandBuilder;
+import sonia.scm.repository.api.DiffFormat;
 import sonia.scm.repository.api.RepositoryService;
 import sonia.scm.repository.api.RepositoryServiceFactory;
 import sonia.scm.web.VndMediaType;
 
 import java.net.URISyntaxException;
+import java.util.Arrays;
 
 import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
@@ -74,6 +78,7 @@ public class DiffResourceTest extends RepositoryTestBase {
     dispatcher.getProviderFactory().register(new NotFoundExceptionMapper(mapper));
     dispatcher.getProviderFactory().registerProvider(AuthorizationExceptionMapper.class);
     dispatcher.getProviderFactory().registerProvider(CRLFInjectionExceptionMapper.class);
+    dispatcher.getProviderFactory().registerProvider(IllegalArgumentExceptionMapper.class);
     when(service.getDiffCommand()).thenReturn(diffCommandBuilder);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
@@ -88,19 +93,17 @@ public class DiffResourceTest extends RepositoryTestBase {
   @Test
   public void shouldGetDiffs() throws Exception {
     when(diffCommandBuilder.setRevision(anyString())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.setFormat(any())).thenReturn(diffCommandBuilder);
     when(diffCommandBuilder.retriveContent(any())).thenReturn(diffCommandBuilder);
-
     MockHttpRequest request = MockHttpRequest
       .get(DIFF_URL + "revision")
       .accept(VndMediaType.DIFF);
     MockHttpResponse response = new MockHttpResponse();
+
     dispatcher.invoke(request, response);
-    assertEquals(200, response.getStatus());
-    log.info("Response :{}", response.getContentAsString());
+
     assertThat(response.getStatus())
       .isEqualTo(200);
-    assertThat(response.getContentAsString())
-      .isNotNull();
     String expectedHeader = "Content-Disposition";
     String expectedValue = "attachment; filename=\"repo-revision.diff\"; filename*=utf-8''repo-revision.diff";
     assertThat(response.getOutputHeaders().containsKey(expectedHeader)).isTrue();
@@ -122,6 +125,7 @@ public class DiffResourceTest extends RepositoryTestBase {
   @Test
   public void shouldGet404OnMissingRevision() throws Exception {
     when(diffCommandBuilder.setRevision(anyString())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.setFormat(any())).thenReturn(diffCommandBuilder);
     when(diffCommandBuilder.retriveContent(any())).thenThrow(new NotFoundException("Text", "x"));
 
     MockHttpRequest request = MockHttpRequest
@@ -137,6 +141,7 @@ public class DiffResourceTest extends RepositoryTestBase {
   @Test
   public void shouldGet400OnCrlfInjection() throws Exception {
     when(diffCommandBuilder.setRevision(anyString())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.setFormat(any())).thenReturn(diffCommandBuilder);
     when(diffCommandBuilder.retriveContent(any())).thenThrow(new NotFoundException("Text", "x"));
 
     MockHttpRequest request = MockHttpRequest
@@ -147,6 +152,47 @@ public class DiffResourceTest extends RepositoryTestBase {
     assertEquals(400, response.getStatus());
   }
 
+  @Test
+  public void shouldGet400OnUnknownFormat() throws Exception {
+    when(diffCommandBuilder.setRevision(anyString())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.setFormat(any())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.retriveContent(any())).thenThrow(new NotFoundException("Test", "test"));
 
+    MockHttpRequest request = MockHttpRequest
+      .get(DIFF_URL + "revision?format=Unknown")
+      .accept(VndMediaType.DIFF);
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    assertEquals(400, response.getStatus());
+  }
 
+  @Test
+  public void shouldAcceptDiffFormats() throws Exception {
+    when(diffCommandBuilder.setRevision(anyString())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.setFormat(any())).thenReturn(diffCommandBuilder);
+    when(diffCommandBuilder.retriveContent(any())).thenReturn(diffCommandBuilder);
+
+    Arrays.stream(DiffFormat.values()).map(DiffFormat::name).forEach(
+      this::assertRequestOk
+    );
+  }
+
+  private void assertRequestOk(String format) {
+    MockHttpRequest request = null;
+    try {
+      request = MockHttpRequest
+        .get(DIFF_URL + "revision?format=" + format)
+        .accept(VndMediaType.DIFF);
+    } catch (URISyntaxException e) {
+      e.printStackTrace();
+      fail("got exception: " + e);
+    }
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertThat(response.getStatus())
+      .withFailMessage("diff format from DiffFormat enum must be accepted: " + format)
+      .isEqualTo(200);
+  }
 }

scm-webapp/src/test/java/sonia/scm/api/v2/resources/DispatcherMock.java

@@ -7,6 +7,7 @@ import sonia.scm.api.rest.AuthorizationExceptionMapper;
 import sonia.scm.api.rest.ConcurrentModificationExceptionMapper;
 import sonia.scm.api.rest.IllegalArgumentExceptionMapper;
 import sonia.scm.api.v2.NotFoundExceptionMapper;
+import sonia.scm.api.v2.NotSupportedFeatureExceptionMapper;
 
 public class DispatcherMock {
   public static Dispatcher createDispatcher(Object resource) {
@@ -21,6 +22,7 @@ public class DispatcherMock {
     dispatcher.getProviderFactory().register(new ChangePasswordNotAllowedExceptionMapper(mapper));
     dispatcher.getProviderFactory().register(new InvalidPasswordExceptionMapper(mapper));
     dispatcher.getProviderFactory().registerProvider(IllegalArgumentExceptionMapper.class);
+    dispatcher.getProviderFactory().register(new NotSupportedFeatureExceptionMapper(mapper));
     return dispatcher;
   }
 }

scm-webapp/src/test/java/sonia/scm/boot/RestartServletTest.java

@@ -0,0 +1,133 @@
+package sonia.scm.boot;
+
+import com.github.legman.Subscribe;
+import com.google.common.base.Charsets;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import sonia.scm.Stage;
+import sonia.scm.event.ScmEventBus;
+import sonia.scm.event.ScmTestEventBus;
+
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class RestartServletTest {
+
+  @Mock
+  private HttpServletRequest request;
+
+  @Mock
+  private HttpServletResponse response;
+
+  private RestartServlet restartServlet;
+
+  private EventListener listener;
+
+  private void setUpObjectUnderTest(Stage stage) {
+    listener = new EventListener();
+    ScmEventBus eventBus = ScmTestEventBus.getInstance();
+    eventBus.register(listener);
+
+    restartServlet = new RestartServlet(eventBus, stage);
+  }
+
+  @Test
+  public void testRestart() throws IOException {
+    setUpObjectUnderTest(Stage.DEVELOPMENT);
+    setRequestInputReason("something changed");
+
+    restartServlet.doPost(request, response);
+
+    verify(response).setStatus(HttpServletResponse.SC_ACCEPTED);
+
+    RestartEvent restartEvent = listener.restartEvent;
+    assertThat(restartEvent).isNotNull();
+    assertThat(restartEvent.getCause()).isEqualTo(RestartServlet.class);
+    assertThat(restartEvent.getReason()).isEqualTo("something changed");
+  }
+
+  @Test
+  public void testRestartCalledTwice() throws IOException {
+    setUpObjectUnderTest(Stage.DEVELOPMENT);
+
+    setRequestInputReason("initial change");
+    restartServlet.doPost(request, response);
+    verify(response).setStatus(HttpServletResponse.SC_ACCEPTED);
+
+    setRequestInputReason("changed again");
+    restartServlet.doPost(request, response);
+    verify(response).setStatus(HttpServletResponse.SC_CONFLICT);
+  }
+
+  @Test
+  public void testRestartWithInvalidContent() throws IOException {
+    setUpObjectUnderTest(Stage.DEVELOPMENT);
+
+    setRequestInputContent("invalid json");
+
+    restartServlet.doPost(request, response);
+
+    verify(response).setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+  }
+
+  @Test
+  public void testRestartInProductionStage() throws IOException {
+    setUpObjectUnderTest(Stage.PRODUCTION);
+
+    setRequestInputReason("initial change");
+
+    restartServlet.doPost(request, response);
+
+    verify(response).setStatus(HttpServletResponse.SC_NOT_ACCEPTABLE);
+  }
+
+  private void setRequestInputReason(String message) throws IOException {
+    String content = createReason(message);
+    setRequestInputContent(content);
+  }
+
+  private void setRequestInputContent(String content) throws IOException {
+    InputStream input = createReasonAsInputStream(content);
+    when(request.getInputStream()).thenReturn(createServletInputStream(input));
+  }
+
+  private ServletInputStream createServletInputStream(final InputStream inputStream) {
+    return new ServletInputStream() {
+      @Override
+      public int read() throws IOException {
+        return inputStream.read();
+      }
+    };
+  }
+
+  private InputStream createReasonAsInputStream(String content) {
+    return new ByteArrayInputStream(content.getBytes(Charsets.UTF_8));
+  }
+
+  private String createReason(String message) {
+    return String.format("{\"message\": \"%s\"}", message);
+  }
+
+  public static class EventListener {
+
+    private RestartEvent restartEvent;
+
+    @Subscribe(async = false)
+    public void store(RestartEvent restartEvent) {
+      this.restartEvent = restartEvent;
+    }
+
+  }
+}

scm-webapp/src/test/java/sonia/scm/boot/ServletContextCleanerTest.java

@@ -0,0 +1,53 @@
+package sonia.scm.boot;
+
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import javax.servlet.ServletContext;
+
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.Set;
+import java.util.Vector;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ServletContextCleanerTest {
+
+  @Mock
+  private ServletContext servletContext;
+
+  @Test
+  public void testCleanup() {
+    Set<String> names = ImmutableSet.of(
+      "org.jboss.resteasy.Dispatcher",
+      "resteasy.Deployment",
+      "sonia.scm.Context",
+      "org.eclipse.jetty.HttpServer",
+      "javax.servlet.Context",
+      "org.apache.shiro.SecurityManager"
+    );
+
+    when(servletContext.getAttributeNames()).thenReturn(toEnumeration(names));
+
+    ServletContextCleaner.cleanup(servletContext);
+
+    verify(servletContext).removeAttribute("org.jboss.resteasy.Dispatcher");
+    verify(servletContext).removeAttribute("resteasy.Deployment");
+    verify(servletContext).removeAttribute("sonia.scm.Context");
+    verify(servletContext, never()).removeAttribute("org.eclipse.jetty.HttpServer");
+    verify(servletContext, never()).removeAttribute("javax.servlet.Context");
+    verify(servletContext).removeAttribute("org.apache.shiro.SecurityManager");
+  }
+
+  private <T> Enumeration<T> toEnumeration(Collection<T> collection) {
+    return new Vector<>(collection).elements();
+  }
+}

scm-webapp/src/test/java/sonia/scm/plugin/DefaultUberWebResourceLoaderTest.java

@@ -42,6 +42,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
+import sonia.scm.Stage;
 
 import javax.servlet.ServletContext;
 import java.io.File;
@@ -96,14 +97,12 @@ public class DefaultUberWebResourceLoaderTest extends WebResourceLoaderTestBase
    * Method description
    *
    *
-   * @throws MalformedURLException
    */
   @Test
-  public void testGetResourceFromCache() throws MalformedURLException
-  {
+  public void testGetResourceFromCache() {
     DefaultUberWebResourceLoader resourceLoader =
       new DefaultUberWebResourceLoader(servletContext,
-        new ArrayList<PluginWrapper>());
+        new ArrayList<PluginWrapper>(), Stage.PRODUCTION);
 
     resourceLoader.getCache().put("/myresource", GITHUB);
 
@@ -112,6 +111,15 @@ public class DefaultUberWebResourceLoaderTest extends WebResourceLoaderTestBase
     assertSame(GITHUB, resource);
   }
 
+  @Test
+  public void testGetResourceCacheIsDisableInStageDevelopment() throws MalformedURLException {
+    DefaultUberWebResourceLoader resourceLoader = new DefaultUberWebResourceLoader(servletContext, new ArrayList<>(), Stage.DEVELOPMENT);
+    when(servletContext.getResource("/scm")).thenAnswer(invocation -> new URL("https://scm-manager.org"));
+    URL url = resourceLoader.getResource("/scm");
+    URL secondUrl = resourceLoader.getResource("/scm");
+    assertNotSame(url, secondUrl);
+  }
+
   /**
    * Method description
    *