Merge with 2.0.0-m3

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

@@ -8,34 +8,26 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import sonia.scm.repository.BrowserResult;
 import sonia.scm.repository.FileObject;
 import sonia.scm.repository.NamespaceAndName;
 
 import java.net.URI;
-import java.util.ArrayList;
-import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 import static org.mockito.MockitoAnnotations.initMocks;
 
-public class BrowserResultToBrowserResultDtoMapperTest {
+public class BrowserResultToFileObjectDtoMapperTest {
 
   private final URI baseUri = URI.create("http://example.com/base/");
   @SuppressWarnings("unused") // Is injected
   private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
 
-  @Mock
-  private FileObjectToFileObjectDtoMapper fileObjectToFileObjectDtoMapper;
-
   @InjectMocks
-  private BrowserResultToBrowserResultDtoMapper mapper;
+  private FileObjectToFileObjectDtoMapperImpl fileObjectToFileObjectDtoMapper;
+
+  private BrowserResultToFileObjectDtoMapper mapper;
 
   private final Subject subject = mock(Subject.class);
   private final ThreadState subjectThreadState = new SubjectThreadState(subject);
@@ -47,6 +39,7 @@ public class BrowserResultToBrowserResultDtoMapperTest {
   @Before
   public void init() {
     initMocks(this);
+    mapper = new BrowserResultToFileObjectDtoMapper(fileObjectToFileObjectDtoMapper);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
 
@@ -63,9 +56,6 @@ public class BrowserResultToBrowserResultDtoMapperTest {
     fileObject2.setPath("/path/object/2");
     fileObject2.setDescription("description of file object 2");
     fileObject2.setDirectory(true);
-
-    when(fileObjectToFileObjectDtoMapper.map(any(FileObject.class), any(NamespaceAndName.class), anyString()))
-      .thenReturn(new FileObjectDto());
   }
 
   @After
@@ -77,7 +67,7 @@ public class BrowserResultToBrowserResultDtoMapperTest {
   public void shouldMapAttributesCorrectly() {
     BrowserResult browserResult = createBrowserResult();
 
-    BrowserResultDto dto = mapper.map(browserResult, new NamespaceAndName("foo", "bar"), "path");
+    FileObjectDto dto = mapper.map(browserResult, new NamespaceAndName("foo", "bar"));
 
     assertEqualAttributes(browserResult, dto);
   }
@@ -87,10 +77,9 @@ public class BrowserResultToBrowserResultDtoMapperTest {
     BrowserResult browserResult = createBrowserResult();
     NamespaceAndName namespaceAndName = new NamespaceAndName("foo", "bar");
 
-    BrowserResultDto dto = mapper.map(browserResult, namespaceAndName, "path");
+    FileObjectDto dto = mapper.map(browserResult, namespaceAndName);
 
-    verify(fileObjectToFileObjectDtoMapper).map(fileObject1, namespaceAndName, "Revision");
-    verify(fileObjectToFileObjectDtoMapper).map(fileObject2, namespaceAndName, "Revision");
+    assertThat(dto.getEmbedded().getItemsBy("children")).hasSize(2);
   }
 
   @Test
@@ -98,28 +87,27 @@ public class BrowserResultToBrowserResultDtoMapperTest {
     BrowserResult browserResult = createBrowserResult();
     NamespaceAndName namespaceAndName = new NamespaceAndName("foo", "bar");
 
-    BrowserResultDto dto = mapper.map(browserResult, namespaceAndName, "path");
+    FileObjectDto dto = mapper.map(browserResult, namespaceAndName);
 
     assertThat(dto.getLinks().getLinkBy("self").get().getHref()).contains("path");
   }
 
   private BrowserResult createBrowserResult() {
-    BrowserResult browserResult = new BrowserResult();
-    browserResult.setRevision("Revision");
-    browserResult.setFiles(createFileObjects());
-
-    return browserResult;
+    return new BrowserResult("Revision", createFileObject());
   }
 
-  private List<FileObject> createFileObjects() {
-    List<FileObject> fileObjects = new ArrayList<>();
+  private FileObject createFileObject() {
+    FileObject file = new FileObject();
+    file.setName("");
+    file.setPath("/path");
+    file.setDirectory(true);
 
-    fileObjects.add(fileObject1);
-    fileObjects.add(fileObject2);
-    return fileObjects;
+    file.addChild(fileObject1);
+    file.addChild(fileObject2);
+    return file;
   }
 
-  private void assertEqualAttributes(BrowserResult browserResult, BrowserResultDto dto) {
+  private void assertEqualAttributes(BrowserResult browserResult, FileObjectDto dto) {
     assertThat(dto.getRevision()).isEqualTo(browserResult.getRevision());
   }
 

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

@@ -173,6 +173,30 @@ public class ResourceLinksTest {
     assertEquals(BASE_URL + ConfigResource.CONFIG_PATH_V2, url);
   }
 
+  @Test
+  public void shouldHandleSpacesInPaths() {
+    String url = resourceLinks.source().content("space", "name", "rev", "name with spaces");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/name/content/rev/name%20with%20spaces", url);
+  }
+
+  @Test
+  public void shouldHandleBackslashInPaths() {
+    String url = resourceLinks.source().content("space", "name", "rev", "name_with_\\");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/name/content/rev/name_with_%5C", url);
+  }
+
+  @Test
+  public void shouldHandleNewLineInPaths() {
+    String url = resourceLinks.source().content("space", "name", "rev", "name_with\nnew_line");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/name/content/rev/name_with%0Anew_line", url);
+  }
+
+  @Test
+  public void shouldKeepSlashesInInPaths() {
+    String url = resourceLinks.source().content("space", "name", "rev", "some/dir/somewhere");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/name/content/rev/some/dir/somewhere", url);
+  }
+
   @Before
   public void initUriInfo() {
     initMocks(this);

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

@@ -21,12 +21,8 @@ import sonia.scm.repository.api.RepositoryServiceFactory;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.Arrays;
-import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 import static sonia.scm.api.v2.resources.DispatcherMock.createDispatcher;
 
@@ -45,24 +41,19 @@ public class SourceRootResourceTest extends RepositoryTestBase {
   @Mock
   private BrowseCommandBuilder browseCommandBuilder;
 
-  @Mock
-  private FileObjectToFileObjectDtoMapper fileObjectToFileObjectDtoMapper;
-
   @InjectMocks
-  private BrowserResultToBrowserResultDtoMapper browserResultToBrowserResultDtoMapper;
+  private FileObjectToFileObjectDtoMapperImpl fileObjectToFileObjectDtoMapper;
+
+  private BrowserResultToFileObjectDtoMapper browserResultToFileObjectDtoMapper;
 
 
   @Before
   public void prepareEnvironment() throws Exception {
+    browserResultToFileObjectDtoMapper = new BrowserResultToFileObjectDtoMapper(fileObjectToFileObjectDtoMapper);
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(service);
     when(service.getBrowseCommand()).thenReturn(browseCommandBuilder);
 
-    FileObjectDto dto = new FileObjectDto();
-    dto.setName("name");
-    dto.setLength(1024);
-
-    when(fileObjectToFileObjectDtoMapper.map(any(FileObject.class), any(NamespaceAndName.class), anyString())).thenReturn(dto);
-    SourceRootResource sourceRootResource = new SourceRootResource(serviceFactory, browserResultToBrowserResultDtoMapper);
+    SourceRootResource sourceRootResource = new SourceRootResource(serviceFactory, browserResultToFileObjectDtoMapper);
     super.sourceRootResource = Providers.of(sourceRootResource);
     dispatcher = createDispatcher(getRepositoryRootResource());
   }
@@ -76,8 +67,9 @@ public class SourceRootResourceTest extends RepositoryTestBase {
 
     dispatcher.invoke(request, response);
     assertThat(response.getStatus()).isEqualTo(200);
+    System.out.println(response.getContentAsString());
     assertThat(response.getContentAsString()).contains("\"revision\":\"revision\"");
-    assertThat(response.getContentAsString()).contains("\"files\":");
+    assertThat(response.getContentAsString()).contains("\"children\":");
   }
 
   @Test
@@ -92,12 +84,10 @@ public class SourceRootResourceTest extends RepositoryTestBase {
 
   @Test
   public void shouldGetResultForSingleFile() throws URISyntaxException, IOException {
-    BrowserResult browserResult = new BrowserResult();
-    browserResult.setRevision("revision");
     FileObject fileObject = new FileObject();
     fileObject.setName("File Object!");
-
-    browserResult.setFiles(Arrays.asList(fileObject));
+    fileObject.setPath("/");
+    BrowserResult browserResult = new BrowserResult("revision", fileObject);
 
     when(browseCommandBuilder.getBrowserResult()).thenReturn(browserResult);
     MockHttpRequest request = MockHttpRequest.get("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/sources/revision/fileabc");
@@ -120,10 +110,15 @@ public class SourceRootResourceTest extends RepositoryTestBase {
   }
 
   private BrowserResult createBrowserResult() {
-    return new BrowserResult("revision", "tag", "branch", createFileObjects());
+    return new BrowserResult("revision", createFileObject());
   }
 
-  private List<FileObject> createFileObjects() {
+  private FileObject createFileObject() {
+    FileObject parent = new FileObject();
+    parent.setName("bar");
+    parent.setPath("/foo/bar");
+    parent.setDirectory(true);
+
     FileObject fileObject1 = new FileObject();
     fileObject1.setName("FO 1");
     fileObject1.setDirectory(false);
@@ -131,6 +126,7 @@ public class SourceRootResourceTest extends RepositoryTestBase {
     fileObject1.setPath("/foo/bar/fo1");
     fileObject1.setLength(1024L);
     fileObject1.setLastModified(0L);
+    parent.addChild(fileObject1);
 
     FileObject fileObject2 = new FileObject();
     fileObject2.setName("FO 2");
@@ -139,7 +135,8 @@ public class SourceRootResourceTest extends RepositoryTestBase {
     fileObject2.setPath("/foo/bar/fo2");
     fileObject2.setLength(4096L);
     fileObject2.setLastModified(1234L);
+    parent.addChild(fileObject2);
 
-    return Arrays.asList(fileObject1, fileObject2);
+    return parent;
   }
 }

scm-webapp/src/test/java/sonia/scm/web/i18n/I18nServletTest.java

@@ -0,0 +1,255 @@
+package sonia.scm.web.i18n;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+import com.google.common.base.Charsets;
+import com.google.common.io.Files;
+import org.apache.commons.lang3.StringUtils;
+import org.assertj.core.util.Lists;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockSettings;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnitRunner;
+import sonia.scm.boot.RestartEvent;
+import sonia.scm.cache.Cache;
+import sonia.scm.cache.CacheManager;
+import sonia.scm.event.ScmEventBus;
+import sonia.scm.plugin.PluginLoader;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.Silent.class)
+@SubjectAware(configuration = "classpath:sonia/scm/shiro-001.ini")
+public class I18nServletTest {
+
+  @Rule
+  public ShiroRule shiro = new ShiroRule();
+
+  private static final String GIT_PLUGIN_JSON = json(
+    "{",
+      "'scm-git-plugin': {",
+        "'information': {",
+          "'clone' : 'Clone',",
+          "'create' : 'Create',",
+          "'replace' : 'Push'",
+        "}",
+      "}",
+    "}"
+  );
+  private static final String HG_PLUGIN_JSON = json(
+    "{",
+      "'scm-hg-plugin': {",
+        "'information': {",
+          "'clone' : 'Clone',",
+          "'create' : 'Create',",
+          "'replace' : 'Push'",
+        "}",
+      "}",
+    "}"
+  );
+  private static String SVN_PLUGIN_JSON = json(
+    "{",
+      "'scm-svn-plugin': {",
+        "'information': {",
+          "'checkout' : 'Checkout'",
+        "}",
+      "}",
+    "}"
+  );
+
+  private static String json(String... parts) {
+    return String.join("\n", parts ).replaceAll("'", "\"");
+  }
+
+  @Rule
+  public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  @Mock
+  PluginLoader pluginLoader;
+
+  @Mock
+  CacheManager cacheManager;
+
+  @Mock
+  ClassLoader classLoader;
+
+  I18nServlet servlet;
+
+  @Mock
+  private Cache cache;
+  private Enumeration<URL> resources;
+
+  @Before
+  @SuppressWarnings("unchecked")
+  public void init() throws IOException {
+    resources = Collections.enumeration(Lists.newArrayList(
+      createFileFromString(SVN_PLUGIN_JSON).toURL(),
+      createFileFromString(GIT_PLUGIN_JSON).toURL(),
+      createFileFromString(HG_PLUGIN_JSON).toURL()
+    ));
+    when(pluginLoader.getUberClassLoader()).thenReturn(classLoader);
+    when(cacheManager.getCache(I18nServlet.CACHE_NAME)).thenReturn(cache);
+    MockSettings settings = new MockSettingsImpl<>();
+    settings.useConstructor(pluginLoader, cacheManager);
+    settings.defaultAnswer(InvocationOnMock::callRealMethod);
+    servlet = mock(I18nServlet.class, settings);
+  }
+
+  @Test
+  public void shouldCleanCacheOnRestartEvent() {
+    ScmEventBus.getInstance().register(servlet);
+
+    ScmEventBus.getInstance().post(new RestartEvent(I18nServlet.class, "Restart to reload the plugin resources"));
+
+    verify(cache).clear();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void shouldFailWith404OnMissingResources() throws IOException {
+    String path = "/locales/de/plugins.json";
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    PrintWriter writer = mock(PrintWriter.class);
+    when(response.getWriter()).thenReturn(writer);
+    when(request.getServletPath()).thenReturn(path);
+    when(classLoader.getResources("locales/de/plugins.json")).thenThrow(IOException.class);
+
+    servlet.doGet(request, response);
+
+    verify(response).setStatus(404);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void shouldFailWith500OnIOException() throws IOException {
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    doThrow(IOException.class).when(response).getWriter();
+
+    servlet.doGet(request, response);
+
+    verify(response).setStatus(500);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void inDevelopmentStageShouldNotUseCache() throws IOException {
+    String path = "/locales/de/plugins.json";
+    when(servlet.isProductionStage()).thenReturn(false);
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    File file = temporaryFolder.newFile();
+    PrintWriter writer = new PrintWriter(new FileOutputStream(file));
+    when(response.getWriter()).thenReturn(writer);
+    when(request.getServletPath()).thenReturn(path);
+    when(classLoader.getResources("locales/de/plugins.json")).thenReturn(resources);
+
+    servlet.doGet(request, response);
+
+    String json = Files.readLines(file, Charset.defaultCharset()).get(0);
+    assertJson(json);
+    verify(cache, never()).get(any());
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void inProductionStageShouldUseCache() throws IOException {
+    String path = "/locales/de/plugins.json";
+    when(servlet.isProductionStage()).thenReturn(true);
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    File file = temporaryFolder.newFile();
+    PrintWriter writer = new PrintWriter(new FileOutputStream(file));
+    when(response.getWriter()).thenReturn(writer);
+    when(request.getServletPath()).thenReturn(path);
+    when(classLoader.getResources("locales/de/plugins.json")).thenReturn(resources);
+
+    servlet.doGet(request, response);
+
+    String json = Files.readLines(file, Charset.defaultCharset()).get(0);
+    assertJson(json);
+    verify(cache).get(path);
+    verify(cache).put(eq(path), any());
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void inProductionStageShouldGetFromCache() throws IOException {
+    String path = "/locales/de/plugins.json";
+    when(servlet.isProductionStage()).thenReturn(true);
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    File file = temporaryFolder.newFile();
+    PrintWriter writer = new PrintWriter(new FileOutputStream(file));
+    when(response.getWriter()).thenReturn(writer);
+    when(request.getServletPath()).thenReturn(path);
+    when(classLoader.getResources("locales/de/plugins.json")).thenReturn(resources);
+    ObjectMapper objectMapper = new ObjectMapper();
+    JsonNode node = objectMapper.readTree(GIT_PLUGIN_JSON);
+    node = servlet.merge(node, objectMapper.readTree(HG_PLUGIN_JSON));
+    node = servlet.merge(node, objectMapper.readTree(SVN_PLUGIN_JSON));
+    when(cache.get(path)).thenReturn(node);
+
+    servlet.doGet(request, response);
+
+    String json = Files.readLines(file, Charset.defaultCharset()).get(0);
+    verify(servlet, never()).collectJsonFile(path);
+    verify(cache, never()).put(eq(path), any());
+    verify(cache).get(path);
+    assertJson(json);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void shouldCollectJsonFile() throws IOException {
+    String path = "locales/de/plugins.json";
+    when(classLoader.getResources(path)).thenReturn(resources);
+
+    Optional<JsonNode> jsonNodeOptional = servlet.collectJsonFile("/" + path);
+
+    assertJson(jsonNodeOptional.orElse(null));
+  }
+
+  public void assertJson(JsonNode actual) throws IOException {
+    assertJson(actual.toString());
+  }
+
+  public void assertJson(String actual) throws IOException {
+    assertThat(actual)
+      .isNotEmpty()
+      .contains(StringUtils.deleteWhitespace(GIT_PLUGIN_JSON.substring(1, GIT_PLUGIN_JSON.length() - 1)))
+      .contains(StringUtils.deleteWhitespace(HG_PLUGIN_JSON.substring(1, HG_PLUGIN_JSON.length() - 1)))
+      .contains(StringUtils.deleteWhitespace(SVN_PLUGIN_JSON.substring(1, SVN_PLUGIN_JSON.length() - 1)));
+  }
+
+  public File createFileFromString(String json) throws IOException {
+    File file = temporaryFolder.newFile();
+    Files.write(json.getBytes(Charsets.UTF_8), file);
+    return file;
+  }
+
+}