Merged heads

scm-webapp/src/test/java/sonia/scm/api/rest/resources/AbstractManagerResourceTest.java

@@ -0,0 +1,137 @@
+package sonia.scm.api.rest.resources;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import sonia.scm.Manager;
+import sonia.scm.ModelObject;
+
+import javax.ws.rs.core.GenericEntity;
+import javax.ws.rs.core.Request;
+import java.util.Collection;
+import java.util.Comparator;
+
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AbstractManagerResourceTest {
+
+  @Mock
+  private Manager<Simple, Exception> manager;
+  @Mock
+  private Request request;
+  @Captor
+  private ArgumentCaptor<Comparator<Simple>> comparatorCaptor;
+
+  private AbstractManagerResource<Simple, Exception> abstractManagerResource;
+
+  @Before
+  public void captureComparator() {
+    when(manager.getAll(comparatorCaptor.capture(), eq(0), eq(1))).thenReturn(emptyList());
+    abstractManagerResource = new SimpleManagerResource();
+  }
+
+  @Test
+  public void shouldAcceptDefaultSortByParameter() {
+    abstractManagerResource.getAll(request, 0, 1, null, true);
+
+    Comparator<Simple> comparator = comparatorCaptor.getValue();
+    assertTrue(comparator.compare(new Simple("1", null), new Simple("2", null)) > 0);
+  }
+
+  @Test
+  public void shouldAcceptValidSortByParameter() {
+    abstractManagerResource.getAll(request, 0, 1, "data", true);
+
+    Comparator<Simple> comparator = comparatorCaptor.getValue();
+    assertTrue(comparator.compare(new Simple("", "1"), new Simple("", "2")) > 0);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void shouldFailForIllegalSortByParameter() {
+    abstractManagerResource.getAll(request, 0, 1, "x", true);
+  }
+
+
+  private class SimpleManagerResource extends AbstractManagerResource<Simple, Exception> {
+
+    {
+      disableCache = true;
+    }
+
+    private SimpleManagerResource() {
+      super(AbstractManagerResourceTest.this.manager, Simple.class);
+    }
+
+    @Override
+    protected GenericEntity<Collection<Simple>> createGenericEntity(Collection<Simple> items) {
+      return null;
+    }
+
+    @Override
+    protected String getId(Simple item) {
+      return null;
+    }
+
+    @Override
+    protected String getPathPart() {
+      return null;
+    }
+  }
+
+  public static class Simple implements ModelObject {
+
+    private String id;
+    private String data;
+
+    Simple(String id, String data) {
+      this.id = id;
+      this.data = data;
+    }
+
+    public String getData() {
+      return data;
+    }
+
+    @Override
+    public String getId() {
+      return id;
+    }
+
+    @Override
+    public void setLastModified(Long timestamp) {
+
+    }
+
+    @Override
+    public Long getCreationDate() {
+      return null;
+    }
+
+    @Override
+    public void setCreationDate(Long timestamp) {
+
+    }
+
+    @Override
+    public Long getLastModified() {
+      return null;
+    }
+
+    @Override
+    public String getType() {
+      return null;
+    }
+    @Override
+    public boolean isValid() {
+      return false;
+    }
+  }
+}

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

@@ -30,11 +30,12 @@ public class GroupCollectionToDtoMapperTest {
 
   private final UriInfo uriInfo = mock(UriInfo.class);
   private final UriInfoStore uriInfoStore = new UriInfoStore();
+  private final ResourceLinks resourceLinks = new ResourceLinks(uriInfoStore);
   private final GroupToGroupDtoMapper groupToDtoMapper = mock(GroupToGroupDtoMapper.class);
   private final Subject subject = mock(Subject.class);
   private final ThreadState subjectThreadState = new SubjectThreadState(subject);
 
-  private final GroupCollectionToDtoMapper mapper = new GroupCollectionToDtoMapper(groupToDtoMapper, uriInfoStore);
+  private final GroupCollectionToDtoMapper mapper = new GroupCollectionToDtoMapper(groupToDtoMapper, resourceLinks);
 
   private URI expectedBaseUri;
 

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

@@ -20,7 +20,6 @@ import sonia.scm.group.GroupManager;
 import sonia.scm.web.VndMediaType;
 
 import javax.servlet.http.HttpServletResponse;
-import javax.ws.rs.core.UriInfo;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -28,7 +27,9 @@ import java.net.URL;
 import java.util.Collections;
 
 import static java.util.Collections.singletonList;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doNothing;
@@ -47,10 +48,7 @@ public class GroupRootResourceTest {
 
   private Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
 
-  @Mock
-  private UriInfo uriInfo;
-  @Mock
-  private UriInfoStore uriInfoStore;
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(URI.create("/"));
 
   @Mock
   private GroupManager groupManager;
@@ -64,21 +62,19 @@ public class GroupRootResourceTest {
   @Before
   public void prepareEnvironment() throws IOException, GroupException {
     initMocks(this);
-    doNothing().when(groupManager).create(groupCaptor.capture());
+    when(groupManager.create(groupCaptor.capture())).thenAnswer(invocation -> invocation.getArguments()[0]);
+    doNothing().when(groupManager).modify(groupCaptor.capture());
 
     Group group = createDummyGroup();
     when(groupManager.getPage(any(), eq(0), eq(10))).thenReturn(new PageResult<>(singletonList(group), 1));
     when(groupManager.get("admin")).thenReturn(group);
 
-    GroupCollectionToDtoMapper groupCollectionToDtoMapper = new GroupCollectionToDtoMapper(groupToDtoMapper, uriInfoStore);
-    GroupCollectionResource groupCollectionResource = new GroupCollectionResource(groupManager, dtoToGroupMapper, groupCollectionToDtoMapper);
+    GroupCollectionToDtoMapper groupCollectionToDtoMapper = new GroupCollectionToDtoMapper(groupToDtoMapper, resourceLinks);
+    GroupCollectionResource groupCollectionResource = new GroupCollectionResource(groupManager, dtoToGroupMapper, groupCollectionToDtoMapper, resourceLinks);
     GroupResource groupResource = new GroupResource(groupManager, groupToDtoMapper, dtoToGroupMapper);
     GroupRootResource groupRootResource = new GroupRootResource(MockProvider.of(groupCollectionResource), MockProvider.of(groupResource));
 
     dispatcher.getRegistry().addSingletonResource(groupRootResource);
-
-    when(uriInfo.getBaseUri()).thenReturn(URI.create("/"));
-    when(uriInfoStore.get()).thenReturn(uriInfo);
   }
 
   @Test
@@ -108,6 +104,74 @@ public class GroupRootResourceTest {
     assertTrue(response.getContentAsString().contains("\"name\":\"user\""));
   }
 
+  @Test
+  public void shouldUpdateGroup() throws URISyntaxException, IOException {
+    URL url = Resources.getResource("sonia/scm/api/v2/group-test-update.json");
+    byte[] groupJson = Resources.toByteArray(url);
+
+    Group group = createDummyGroup();
+    when(groupManager.get("admin")).thenReturn(group);
+    Group updatedGroup = createDummyGroup();
+    updatedGroup.setDescription("Updated description");
+
+    MockHttpRequest request = MockHttpRequest
+      .put("/" + GroupRootResource.GROUPS_PATH_V2 + "admin")
+      .contentType(VndMediaType.GROUP)
+      .content(groupJson);
+
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+    Group capturedGroup = groupCaptor.getValue();
+
+    assertEquals(HttpServletResponse.SC_NO_CONTENT, response.getStatus());
+
+    assertEquals("Updated description", capturedGroup.getDescription());
+  }
+
+  @Test
+  public void updateShouldFailOnNonexistentGroup() throws URISyntaxException, IOException {
+    URL url = Resources.getResource("sonia/scm/api/v2/group-test-update.json");
+    byte[] groupJson = Resources.toByteArray(url);
+
+    Group updatedGroup = createDummyGroup();
+    updatedGroup.setDescription("Updated description");
+
+    MockHttpRequest request = MockHttpRequest
+      .put("/" + GroupRootResource.GROUPS_PATH_V2 + "idontexist")
+      .contentType(VndMediaType.GROUP)
+      .content(groupJson);
+
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(HttpServletResponse.SC_NOT_FOUND, response.getStatus());
+  }
+
+  @Test
+  public void shouldDeleteGroup() throws URISyntaxException {
+    Group group = createDummyGroup();
+    when(groupManager.get("admin")).thenReturn(group);
+
+    MockHttpRequest request = MockHttpRequest.delete("/" + GroupRootResource.GROUPS_PATH_V2 + "admin");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(HttpServletResponse.SC_NO_CONTENT, response.getStatus());
+  }
+
+  @Test
+  public void shouldNotFailOnDeletingNonexistentGroup() throws URISyntaxException {
+    MockHttpRequest request = MockHttpRequest.delete("/" + GroupRootResource.GROUPS_PATH_V2 + "idontexist");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(HttpServletResponse.SC_NO_CONTENT, response.getStatus());
+  }
+
   @Test
   public void shouldCreateNewGroupWithMembers() throws URISyntaxException, IOException {
     URL url = Resources.getResource("sonia/scm/api/v2/group-test-create.json");

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

@@ -8,10 +8,8 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import sonia.scm.group.Group;
 
-import javax.ws.rs.core.UriInfo;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.stream.IntStream;
@@ -24,10 +22,9 @@ import static org.mockito.MockitoAnnotations.initMocks;
 
 public class GroupToGroupDtoMapperTest {
 
-  @Mock
-  private UriInfo uriInfo;
-  @Mock
-  private UriInfoStore uriInfoStore;
+  private final URI baseUri = URI.create("http://example.com/base/");
+  @SuppressWarnings("unused") // Is injected
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
 
   @InjectMocks
   private GroupToGroupDtoMapperImpl mapper;
@@ -40,10 +37,7 @@ public class GroupToGroupDtoMapperTest {
   @Before
   public void init() throws URISyntaxException {
     initMocks(this);
-    URI baseUri = new URI("http://example.com/base/");
     expectedBaseUri = baseUri.resolve(GroupRootResource.GROUPS_PATH_V2 + "/");
-    when(uriInfo.getBaseUri()).thenReturn(baseUri);
-    when(uriInfoStore.get()).thenReturn(uriInfo);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
   }

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

@@ -0,0 +1,33 @@
+package sonia.scm.api.v2.resources;
+
+import com.google.inject.binder.AnnotatedBindingBuilder;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class MapperModuleTest {
+
+  @Test
+  public void shouldBindToClassesWithDefaultConstructorOnly() {
+    AnnotatedBindingBuilder binding = mock(AnnotatedBindingBuilder.class);
+    ArgumentCaptor<Class> captor = ArgumentCaptor.forClass(Class.class);
+    when(binding.to(captor.capture())).thenReturn(null);
+    new MapperModule() {
+      @Override
+      protected <T> AnnotatedBindingBuilder<T> bind(Class<T> clazz) {
+        return binding;
+      }
+    }.configure();
+    captor.getAllValues().forEach(this::verifyClassCanBeInstantiated);
+  }
+
+  private <T> T verifyClassCanBeInstantiated(Class<T> c) {
+    try {
+      return c.getConstructor().newInstance();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+}

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

@@ -0,0 +1,237 @@
+package sonia.scm.api.v2.resources;
+
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+import com.google.common.io.Resources;
+import org.jboss.resteasy.core.Dispatcher;
+import org.jboss.resteasy.mock.MockDispatcherFactory;
+import org.jboss.resteasy.mock.MockHttpRequest;
+import org.jboss.resteasy.mock.MockHttpResponse;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import sonia.scm.PageResult;
+import sonia.scm.repository.Repository;
+import sonia.scm.repository.RepositoryException;
+import sonia.scm.repository.RepositoryManager;
+import sonia.scm.web.VndMediaType;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import static java.util.Collections.singletonList;
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
+import static javax.servlet.http.HttpServletResponse.SC_BAD_REQUEST;
+import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
+import static javax.servlet.http.HttpServletResponse.SC_NO_CONTENT;
+import static javax.servlet.http.HttpServletResponse.SC_OK;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+@SubjectAware(
+  username = "trillian",
+  password = "secret",
+  configuration = "classpath:sonia/scm/repository/shiro.ini"
+)
+public class RepositoryRootResourceTest {
+
+  private final Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
+
+  @Rule
+  public ShiroRule shiro = new ShiroRule();
+
+  @Mock
+  private RepositoryManager repositoryManager;
+
+  private final URI baseUri = URI.create("/");
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
+
+  @InjectMocks
+  private RepositoryToRepositoryDtoMapperImpl repositoryToDtoMapper;
+  @InjectMocks
+  private RepositoryDtoToRepositoryMapperImpl dtoToRepositoryMapper;
+
+  @Before
+  public void prepareEnvironment() {
+    initMocks(this);
+    RepositoryResource repositoryResource = new RepositoryResource(repositoryToDtoMapper, dtoToRepositoryMapper, repositoryManager, null, null, null, null, null);
+    RepositoryCollectionToDtoMapper repositoryCollectionToDtoMapper = new RepositoryCollectionToDtoMapper(repositoryToDtoMapper, resourceLinks);
+    RepositoryCollectionResource repositoryCollectionResource = new RepositoryCollectionResource(repositoryManager, repositoryCollectionToDtoMapper, dtoToRepositoryMapper, resourceLinks);
+    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider.of(repositoryResource), MockProvider.of(repositoryCollectionResource));
+    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+  }
+
+  @Test
+  public void shouldFailForNotExistingRepository() throws URISyntaxException {
+    when(repositoryManager.getByNamespace(anyString(), anyString())).thenReturn(empty());
+    mockRepository("space", "repo");
+
+    MockHttpRequest request = MockHttpRequest.get("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/other");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_NOT_FOUND, response.getStatus());
+  }
+
+  @Test
+  public void shouldFindExistingRepository() throws URISyntaxException {
+    mockRepository("space", "repo");
+
+    MockHttpRequest request = MockHttpRequest.get("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_OK, response.getStatus());
+    assertTrue(response.getContentAsString().contains("\"name\":\"repo\""));
+  }
+
+  @Test
+  public void shouldMapProperties() throws URISyntaxException {
+    Repository repository = mockRepository("space", "repo");
+    repository.setProperty("testKey", "testValue");
+
+    MockHttpRequest request = MockHttpRequest.get("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertTrue(response.getContentAsString().contains("\"testKey\":\"testValue\""));
+  }
+
+  @Test
+  public void shouldGetAll() throws URISyntaxException {
+    PageResult<Repository> singletonPageResult = createSingletonPageResult(mockRepository("space", "repo"));
+    when(repositoryManager.getPage(any(), eq(0), eq(10))).thenReturn(singletonPageResult);
+
+    MockHttpRequest request = MockHttpRequest.get("/" + RepositoryRootResource.REPOSITORIES_PATH_V2);
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_OK, response.getStatus());
+    assertTrue(response.getContentAsString().contains("\"name\":\"repo\""));
+  }
+
+  @Test
+  public void shouldHandleUpdateForNotExistingRepository() throws URISyntaxException, IOException {
+    URL url = Resources.getResource("sonia/scm/api/v2/repository-test-update.json");
+    byte[] repository = Resources.toByteArray(url);
+    when(repositoryManager.getByNamespace(anyString(), anyString())).thenReturn(empty());
+
+    MockHttpRequest request = MockHttpRequest
+      .put("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo")
+      .contentType(VndMediaType.REPOSITORY)
+      .content(repository);
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_NOT_FOUND, response.getStatus());
+  }
+
+  @Test
+  public void shouldHandleUpdateForExistingRepository() throws Exception {
+    mockRepository("space", "repo");
+
+    URL url = Resources.getResource("sonia/scm/api/v2/repository-test-update.json");
+    byte[] repository = Resources.toByteArray(url);
+
+    MockHttpRequest request = MockHttpRequest
+      .put("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo")
+      .contentType(VndMediaType.REPOSITORY)
+      .content(repository);
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_NO_CONTENT, response.getStatus());
+    verify(repositoryManager).modify(anyObject());
+  }
+
+  @Test
+  public void shouldHandleUpdateForExistingRepositoryForChangedNamespace() throws Exception {
+    mockRepository("wrong", "repo");
+
+    URL url = Resources.getResource("sonia/scm/api/v2/repository-test-update.json");
+    byte[] repository = Resources.toByteArray(url);
+
+    MockHttpRequest request = MockHttpRequest
+      .put("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "wrong/repo")
+      .contentType(VndMediaType.REPOSITORY)
+      .content(repository);
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_BAD_REQUEST, response.getStatus());
+    verify(repositoryManager, never()).modify(anyObject());
+  }
+
+  @Test
+  public void shouldHandleDeleteForExistingRepository() throws Exception {
+    mockRepository("space", "repo");
+
+    MockHttpRequest request = MockHttpRequest.delete("/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo");
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(SC_NO_CONTENT, response.getStatus());
+    verify(repositoryManager).delete(anyObject());
+  }
+
+  @Test
+  public void shouldCreateNewRepositoryInCorrectNamespace() throws URISyntaxException, IOException, RepositoryException {
+    when(repositoryManager.create(any())).thenAnswer(invocation -> {
+      Repository repository = (Repository) invocation.getArguments()[0];
+      repository.setNamespace("otherspace");
+      return repository;
+    });
+
+    URL url = Resources.getResource("sonia/scm/api/v2/repository-test-update.json");
+    byte[] repositoryJson = Resources.toByteArray(url);
+
+    MockHttpRequest request = MockHttpRequest
+      .post("/" + RepositoryRootResource.REPOSITORIES_PATH_V2)
+      .contentType(VndMediaType.REPOSITORY)
+      .content(repositoryJson);
+    MockHttpResponse response = new MockHttpResponse();
+
+    dispatcher.invoke(request, response);
+
+    assertEquals(HttpServletResponse.SC_CREATED, response.getStatus());
+    assertEquals("/v2/repositories/otherspace/repo", response.getOutputHeaders().get("Location").get(0).toString());
+    verify(repositoryManager).create(any(Repository.class));
+  }
+
+  private PageResult<Repository> createSingletonPageResult(Repository repository) {
+    return new PageResult<>(singletonList(repository), 0);
+  }
+
+  private Repository mockRepository(String namespace, String name) {
+    Repository repository = new Repository();
+    repository.setNamespace(namespace);
+    repository.setName(name);
+    String id = namespace + "-" + name;
+    repository.setId(id);
+    when(repositoryManager.getByNamespace(namespace, name)).thenReturn(of(repository));
+    when(repositoryManager.get(id)).thenReturn(repository);
+    return repository;
+  }
+}

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

@@ -0,0 +1,159 @@
+package sonia.scm.api.v2.resources;
+
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+import org.apache.shiro.util.ThreadContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import sonia.scm.repository.HealthCheckFailure;
+import sonia.scm.repository.Permission;
+import sonia.scm.repository.PermissionType;
+import sonia.scm.repository.Repository;
+
+import java.net.URI;
+
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+@SubjectAware(
+  username = "trillian",
+  password = "secret",
+  configuration = "classpath:sonia/scm/repository/shiro.ini"
+)
+public class RepositoryToRepositoryDtoMapperTest {
+
+  @Rule
+  public final ShiroRule rule = new ShiroRule();
+
+  private final URI baseUri = URI.create("http://example.com/base/");
+  @SuppressWarnings("unused") // Is injected
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
+
+  @InjectMocks
+  private RepositoryToRepositoryDtoMapperImpl mapper;
+
+  @Before
+  public void init() {
+    initMocks(this);
+  }
+
+  @After
+  public void cleanup() {
+    ThreadContext.unbindSubject();
+  }
+
+  @Test
+  public void shouldMapSimpleProperties() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals("testspace", dto.getNamespace());
+    assertEquals("test", dto.getName());
+    assertEquals("description", dto.getDescription());
+    assertEquals("git", dto.getType());
+    assertEquals("none@example.com", dto.getContact());
+  }
+
+  @Test
+  public void shouldMapPropertiesProperty() {
+    Repository repository = createTestRepository();
+    repository.setProperty("testKey", "testValue");
+
+    RepositoryDto dto = mapper.map(repository);
+
+    assertEquals("testValue", dto.getProperties().get("testKey"));
+  }
+
+  @Test
+  @SubjectAware(username = "unpriv")
+  public void shouldCreateLinksForUnprivilegedUser() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test",
+      dto.getLinks().getLinkBy("self").get().getHref());
+    assertFalse(dto.getLinks().getLinkBy("update").isPresent());
+    assertFalse(dto.getLinks().getLinkBy("delete").isPresent());
+    assertFalse(dto.getLinks().getLinkBy("permissions").isPresent());
+  }
+
+  @Test
+  public void shouldCreateDeleteLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test",
+      dto.getLinks().getLinkBy("delete").get().getHref());
+  }
+
+  @Test
+  public void shouldCreateUpdateLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test",
+      dto.getLinks().getLinkBy("update").get().getHref());
+  }
+
+  @Test
+  public void shouldMapHealthCheck() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(1, dto.getHealthCheckFailures().size());
+    assertEquals("summary", dto.getHealthCheckFailures().get(0).getSummary());
+  }
+
+  @Test
+  public void shouldCreateTagsLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test/tags/",
+      dto.getLinks().getLinkBy("tags").get().getHref());
+  }
+
+  @Test
+  public void shouldCreateBranchesLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test/branches/",
+      dto.getLinks().getLinkBy("branches").get().getHref());
+  }
+
+  @Test
+  public void shouldCreateChangesetsLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test/changesets/",
+      dto.getLinks().getLinkBy("changesets").get().getHref());
+  }
+
+  @Test
+  public void shouldCreateSourcesLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test/sources/",
+      dto.getLinks().getLinkBy("sources").get().getHref());
+  }
+
+  @Test
+  public void shouldCreatePermissionsLink() {
+    RepositoryDto dto = mapper.map(createTestRepository());
+    assertEquals(
+      "http://example.com/base/v2/repositories/testspace/test/permissions/",
+      dto.getLinks().getLinkBy("permissions").get().getHref());
+  }
+
+  private Repository createTestRepository() {
+    Repository repository = new Repository();
+    repository.setNamespace("testspace");
+    repository.setName("test");
+    repository.setDescription("description");
+    repository.setType("git");
+    repository.setContact("none@example.com");
+    repository.setId("1");
+    repository.setCreationDate(System.currentTimeMillis());
+    repository.setHealthCheckFailures(singletonList(new HealthCheckFailure("1", "summary", "url", "failure")));
+    repository.setPermissions(singletonList(new Permission("permission", PermissionType.READ)));
+
+    return repository;
+  }
+}

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

@@ -0,0 +1,29 @@
+package sonia.scm.api.v2.resources;
+
+import javax.ws.rs.core.UriInfo;
+import java.net.URI;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ResourceLinksMock {
+  public static ResourceLinks createMock(URI baseUri) {
+    ResourceLinks resourceLinks = mock(ResourceLinks.class);
+
+    UriInfo uriInfo = mock(UriInfo.class);
+    when(uriInfo.getBaseUri()).thenReturn(baseUri);
+
+    when(resourceLinks.user()).thenReturn(new ResourceLinks.UserLinks(uriInfo));
+    when(resourceLinks.userCollection()).thenReturn(new ResourceLinks.UserCollectionLinks(uriInfo));
+    when(resourceLinks.group()).thenReturn(new ResourceLinks.GroupLinks(uriInfo));
+    when(resourceLinks.groupCollection()).thenReturn(new ResourceLinks.GroupCollectionLinks(uriInfo));
+    when(resourceLinks.repository()).thenReturn(new ResourceLinks.RepositoryLinks(uriInfo));
+    when(resourceLinks.repositoryCollection()).thenReturn(new ResourceLinks.RepositoryCollectionLinks(uriInfo));
+    when(resourceLinks.tagCollection()).thenReturn(new ResourceLinks.TagCollectionLinks(uriInfo));
+    when(resourceLinks.branchCollection()).thenReturn(new ResourceLinks.BranchCollectionLinks(uriInfo));
+    when(resourceLinks.changesetCollection()).thenReturn(new ResourceLinks.ChangesetCollectionLinks(uriInfo));
+    when(resourceLinks.sourceCollection()).thenReturn(new ResourceLinks.SourceCollectionLinks(uriInfo));
+    when(resourceLinks.permissionCollection()).thenReturn(new ResourceLinks.PermissionCollectionLinks(uriInfo));
+    return resourceLinks;
+  }
+}

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

@@ -2,85 +2,140 @@ package sonia.scm.api.v2.resources;
 
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
 
 import javax.ws.rs.core.UriInfo;
 import java.net.URI;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
-import static sonia.scm.api.v2.resources.ResourceLinks.group;
-import static sonia.scm.api.v2.resources.ResourceLinks.user;
-import static sonia.scm.api.v2.resources.ResourceLinks.userCollection;
+import static org.mockito.MockitoAnnotations.initMocks;
 
 public class ResourceLinksTest {
 
   private static final String BASE_URL = "http://example.com/";
 
-  private UriInfo uriInfo = mock(UriInfo.class);
+  @Mock
+  private UriInfoStore uriInfoStore;
+  @Mock
+  private UriInfo uriInfo;
+
+  @InjectMocks
+  private ResourceLinks resourceLinks;
 
   @Test
   public void shouldCreateCorrectUserSelfUrl() {
-    String url = user(uriInfo).self("ich");
+    String url = resourceLinks.user().self("ich");
     assertEquals(BASE_URL + UserRootResource.USERS_PATH_V2 + "ich", url);
   }
 
   @Test
   public void shouldCreateCorrectUserDeleteUrl() {
-    String url = user(uriInfo).delete("ich");
+    String url = resourceLinks.user().delete("ich");
     assertEquals(BASE_URL + UserRootResource.USERS_PATH_V2 + "ich", url);
   }
 
   @Test
   public void shouldCreateCorrectUserUpdateUrl() {
-    String url = user(uriInfo).update("ich");
+    String url = resourceLinks.user().update("ich");
     assertEquals(BASE_URL + UserRootResource.USERS_PATH_V2 + "ich", url);
   }
 
   @Test
   public void shouldCreateCorrectUserCreateUrl() {
-    String url = userCollection(uriInfo).create();
+    String url = resourceLinks.userCollection().create();
     assertEquals(BASE_URL + UserRootResource.USERS_PATH_V2, url);
   }
 
   @Test
   public void shouldCreateCorrectUserCollectionUrl() {
-    String url = userCollection(uriInfo).self();
+    String url = resourceLinks.userCollection().self();
     assertEquals(BASE_URL + UserRootResource.USERS_PATH_V2, url);
   }
 
   @Test
   public void shouldCreateCorrectGroupSelfUrl() {
-    String url = group(uriInfo).self("nobodies");
+    String url = resourceLinks.group().self("nobodies");
     assertEquals(BASE_URL + GroupRootResource.GROUPS_PATH_V2 + "nobodies", url);
   }
 
   @Test
   public void shouldCreateCorrectGroupDeleteUrl() {
-    String url = group(uriInfo).delete("nobodies");
+    String url = resourceLinks.group().delete("nobodies");
     assertEquals(BASE_URL + GroupRootResource.GROUPS_PATH_V2 + "nobodies", url);
   }
 
   @Test
   public void shouldCreateCorrectGroupUpdateUrl() {
-    String url = group(uriInfo).update("nobodies");
+    String url = resourceLinks.group().update("nobodies");
     assertEquals(BASE_URL + GroupRootResource.GROUPS_PATH_V2 + "nobodies", url);
   }
 
   @Test
   public void shouldCreateCorrectGroupCreateUrl() {
-    String url = ResourceLinks.groupCollection(uriInfo).create();
+    String url = resourceLinks.groupCollection().create();
     assertEquals(BASE_URL + GroupRootResource.GROUPS_PATH_V2, url);
   }
 
   @Test
   public void shouldCreateCorrectGroupCollectionUrl() {
-    String url = ResourceLinks.groupCollection(uriInfo).self();
+    String url = resourceLinks.groupCollection().self();
     assertEquals(BASE_URL + GroupRootResource.GROUPS_PATH_V2, url);
   }
 
+  @Test
+  public void shouldCreateCorrectRepositorySelfUrl() {
+    String url = resourceLinks.repository().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectRepositoryDeleteUrl() {
+    String url = resourceLinks.repository().delete("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectRepositoryUpdateUrl() {
+    String url = resourceLinks.repository().update("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectTagCollectionUrl() {
+    String url = resourceLinks.tagCollection().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/tags/", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectBranchCollectionUrl() {
+    String url = resourceLinks.branchCollection().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/branches/", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectChangesetCollectionUrl() {
+    String url = resourceLinks.changesetCollection().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/changesets/", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectSourceCollectionUrl() {
+    String url = resourceLinks.sourceCollection().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/sources/", url);
+  }
+
+  @Test
+  public void shouldCreateCorrectPermissionCollectionUrl() {
+    String url = resourceLinks.sourceCollection().self("space", "repo");
+    assertEquals(BASE_URL + RepositoryRootResource.REPOSITORIES_PATH_V2 + "space/repo/sources/", url);
+  }
+
   @Before
   public void initUriInfo() {
+    initMocks(this);
+    when(uriInfoStore.get()).thenReturn(uriInfo);
     when(uriInfo.getBaseUri()).thenReturn(URI.create(BASE_URL));
   }
 }

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

@@ -12,7 +12,6 @@ import org.mockito.Mock;
 import sonia.scm.PageResult;
 import sonia.scm.user.User;
 
-import javax.ws.rs.core.UriInfo;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Arrays;
@@ -28,14 +27,12 @@ import static sonia.scm.PageResult.createPage;
 
 public class UserCollectionToDtoMapperTest {
 
+  private final URI baseUri = URI.create("http://example.com/base/");
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
   @Mock
-  private  UriInfo uriInfo;
+  private UserToUserDtoMapper userToDtoMapper;
   @Mock
-  private  UriInfoStore uriInfoStore;
-  @Mock
-  private  UserToUserDtoMapper userToDtoMapper;
-  @Mock
-  private  Subject subject;
+  private Subject subject;
 
   @InjectMocks
   private SubjectThreadState subjectThreadState;
@@ -47,10 +44,7 @@ public class UserCollectionToDtoMapperTest {
   @Before
   public void init() throws URISyntaxException {
     initMocks(this);
-    URI baseUri = new URI("http://example.com/base/");
     expectedBaseUri = baseUri.resolve(UserRootResource.USERS_PATH_V2 + "/");
-    when(uriInfo.getBaseUri()).thenReturn(baseUri);
-    when(uriInfoStore.get()).thenReturn(uriInfo);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
   }

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

@@ -8,7 +8,6 @@ import org.mockito.Mock;
 import sonia.scm.user.User;
 
 import java.time.Instant;
-import java.util.Optional;
 
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.when;
@@ -47,7 +46,7 @@ public class UserDtoToUserMapperTest {
     UserDto dto = new UserDto();
     dto.setName("abc");
     dto.setCreationDate(Instant.now());
-    dto.setLastModified(Optional.empty());
+    dto.setLastModified(null);
     return dto;
   }
 }

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

@@ -21,7 +21,6 @@ import sonia.scm.user.UserManager;
 import sonia.scm.web.VndMediaType;
 
 import javax.servlet.http.HttpServletResponse;
-import javax.ws.rs.core.UriInfo;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -51,10 +50,7 @@ public class UserRootResourceTest {
 
   private Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
 
-  @Mock
-  private UriInfo uriInfo;
-  @Mock
-  private UriInfoStore uriInfoStore;
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(URI.create("/"));
 
   @Mock
   private PasswordService passwordService;
@@ -68,23 +64,21 @@ public class UserRootResourceTest {
   private ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);
 
   @Before
-  public void prepareEnvironment() throws IOException, UserException {
+  public void prepareEnvironment() throws UserException {
     initMocks(this);
     User dummyUser = createDummyUser("Neo");
-    doNothing().when(userManager).create(userCaptor.capture());
+    when(userManager.create(userCaptor.capture())).thenAnswer(invocation -> invocation.getArguments()[0]);
     doNothing().when(userManager).modify(userCaptor.capture());
     doNothing().when(userManager).delete(userCaptor.capture());
 
-    UserCollectionToDtoMapper userCollectionToDtoMapper = new UserCollectionToDtoMapper(userToDtoMapper, uriInfoStore);
+    UserCollectionToDtoMapper userCollectionToDtoMapper = new UserCollectionToDtoMapper(userToDtoMapper, resourceLinks);
     UserCollectionResource userCollectionResource = new UserCollectionResource(userManager, dtoToUserMapper,
-      userCollectionToDtoMapper);
+       userCollectionToDtoMapper, resourceLinks);
     UserResource userResource = new UserResource(dtoToUserMapper, userToDtoMapper, userManager);
     UserRootResource userRootResource = new UserRootResource(MockProvider.of(userCollectionResource),
                                                              MockProvider.of(userResource));
 
     dispatcher.getRegistry().addSingletonResource(userRootResource);
-    when(uriInfo.getBaseUri()).thenReturn(URI.create("/"));
-    when(uriInfoStore.get()).thenReturn(uriInfo);
   }
 
   @Test

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

@@ -8,13 +8,10 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import sonia.scm.api.rest.resources.UserResource;
 import sonia.scm.user.User;
 
-import javax.ws.rs.core.UriInfo;
 import java.net.URI;
-import java.net.URISyntaxException;
 import java.time.Instant;
 
 import static org.junit.Assert.assertEquals;
@@ -25,10 +22,9 @@ import static org.mockito.MockitoAnnotations.initMocks;
 
 public class UserToUserDtoMapperTest {
 
-  @Mock
-  private UriInfo uriInfo;
-  @Mock
-  private UriInfoStore uriInfoStore;
+  private final URI baseUri = URI.create("http://example.com/base/");
+  @SuppressWarnings("unused") // Is injected
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
 
   @InjectMocks
   private UserToUserDtoMapperImpl mapper;
@@ -39,12 +35,9 @@ public class UserToUserDtoMapperTest {
   private URI expectedBaseUri;
 
   @Before
-  public void init() throws URISyntaxException {
+  public void init() {
     initMocks(this);
-    URI baseUri = new URI("http://example.com/base/");
     expectedBaseUri = baseUri.resolve(UserRootResource.USERS_PATH_V2 + "/");
-    when(uriInfo.getBaseUri()).thenReturn(baseUri);
-    when(uriInfoStore.get()).thenReturn(uriInfo);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
   }
@@ -125,6 +118,6 @@ public class UserToUserDtoMapperTest {
     UserDto userDto = mapper.map(user);
 
     assertEquals(expectedCreationDate, userDto.getCreationDate());
-    assertEquals(expectedModificationDate, userDto.getLastModified().get());
+    assertEquals(expectedModificationDate, userDto.getLastModified());
   }
 }

scm-webapp/src/test/java/sonia/scm/repository/DefaultNamespaceStrategyTest.java

@@ -0,0 +1,24 @@
+package sonia.scm.repository;
+
+import com.github.sdorra.shiro.ShiroRule;
+import com.github.sdorra.shiro.SubjectAware;
+import org.junit.Rule;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+@SubjectAware(configuration = "classpath:sonia/scm/shiro-001.ini")
+public class DefaultNamespaceStrategyTest {
+
+  @Rule
+  public ShiroRule shiroRule = new ShiroRule();
+
+  private DefaultNamespaceStrategy namespaceStrategy = new DefaultNamespaceStrategy();
+
+  @Test
+  @SubjectAware(username = "trillian", password = "secret")
+  public void testNamespaceStrategy() {
+    assertEquals("trillian", namespaceStrategy.getNamespace());
+  }
+
+}

scm-webapp/src/test/java/sonia/scm/repository/DefaultRepositoryManagerPerfTest.java

@@ -33,13 +33,6 @@ package sonia.scm.repository;
 import com.google.common.base.Stopwatch;
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.Provider;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.authc.AuthenticationException;
 import org.apache.shiro.authc.AuthenticationInfo;
@@ -58,7 +51,6 @@ import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import static org.mockito.Mockito.*;
 import org.mockito.runners.MockitoJUnitRunner;
 import sonia.scm.SCMContextProvider;
 import sonia.scm.Type;
@@ -67,9 +59,19 @@ import sonia.scm.config.ScmConfiguration;
 import sonia.scm.security.AuthorizationCollector;
 import sonia.scm.security.DefaultKeyGenerator;
 import sonia.scm.security.KeyGenerator;
-import sonia.scm.security.SecuritySystem;
 import sonia.scm.user.UserTestData;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
 /**
  * Performance test for {@link RepositoryManager#getAll()}.
  * 
@@ -93,7 +95,7 @@ public class DefaultRepositoryManagerPerfTest {
   private final ScmConfiguration configuration = new ScmConfiguration();
   
   private final KeyGenerator keyGenerator = new DefaultKeyGenerator();
-  
+
   @Mock
   private RepositoryHandler repositoryHandler;
   
@@ -110,14 +112,15 @@ public class DefaultRepositoryManagerPerfTest {
     when(repositoryHandler.getType()).thenReturn(new Type(REPOSITORY_TYPE, REPOSITORY_TYPE));
     Set<RepositoryHandler> handlerSet = ImmutableSet.of(repositoryHandler);
     RepositoryMatcher repositoryMatcher = new RepositoryMatcher(Collections.<RepositoryPathMatcher>emptySet());
-    
+    NamespaceStrategy namespaceStrategy = mock(NamespaceStrategy.class);
     repositoryManager = new DefaultRepositoryManager(
       configuration, 
       contextProvider, 
       keyGenerator, 
       repositoryDAO,
       handlerSet, 
-      repositoryMatcher
+      repositoryMatcher,
+      namespaceStrategy
     );
     
     setUpTestRepositories();
@@ -127,10 +130,7 @@ public class DefaultRepositoryManagerPerfTest {
     
     ThreadContext.bind(securityManager);
   }
-  
-  /**
-   * Tear down test objects.
-   */
+
   @After
   public void tearDown(){
     ThreadContext.unbindSecurityManager();
@@ -183,8 +183,8 @@ private long calculateAverage(List<Long> times) {
     when(repositoryDAO.getAll()).thenReturn(repositories.values());
   }
   
-  private Repository createTestRepository(int number){
-    Repository repository = new Repository(keyGenerator.createKey(), REPOSITORY_TYPE, "repo-" + number);
+  private Repository createTestRepository(int number) {
+    Repository repository = new Repository(keyGenerator.createKey(), REPOSITORY_TYPE, "namespace", "repo-" + number);
     repository.getPermissions().add(new Permission("trillian", PermissionType.READ));
     return repository;
   }

scm-webapp/src/test/java/sonia/scm/repository/DefaultRepositoryManagerTest.java

@@ -31,45 +31,56 @@
 package sonia.scm.repository;
 
 //~--- non-JDK imports --------------------------------------------------------
+
 import com.github.legman.Subscribe;
 import com.github.sdorra.shiro.ShiroRule;
 import com.github.sdorra.shiro.SubjectAware;
 import com.google.common.collect.ImmutableSet;
-
+import org.apache.shiro.authz.UnauthorizedException;
+import org.junit.Rule;
 import org.junit.Test;
-
+import org.junit.rules.ExpectedException;
+import org.mockito.invocation.InvocationOnMock;
+import sonia.scm.HandlerEventType;
+import sonia.scm.Manager;
+import sonia.scm.ManagerTestBase;
+import sonia.scm.ModelObject;
 import sonia.scm.Type;
+import sonia.scm.TypedObject;
 import sonia.scm.config.ScmConfiguration;
+import sonia.scm.event.ScmEventBus;
 import sonia.scm.repository.api.HookContext;
 import sonia.scm.repository.api.HookContextFactory;
 import sonia.scm.repository.api.HookFeature;
 import sonia.scm.repository.spi.HookContextProvider;
 import sonia.scm.repository.xml.XmlRepositoryDAO;
 import sonia.scm.security.DefaultKeyGenerator;
+import sonia.scm.security.KeyGenerator;
+import sonia.scm.store.ConfigurationStoreFactory;
 import sonia.scm.store.JAXBConfigurationStoreFactory;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-import static org.hamcrest.Matchers.*;
-
-//~--- JDK imports ------------------------------------------------------------
-import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
-
 import java.util.HashSet;
 import java.util.Set;
 import java.util.Stack;
-import org.apache.shiro.authz.UnauthorizedException;
-import org.junit.Rule;
-import org.junit.rules.ExpectedException;
-import org.mockito.invocation.InvocationOnMock;
-import sonia.scm.HandlerEventType;
-import sonia.scm.Manager;
-import sonia.scm.ManagerTestBase;
-import sonia.scm.event.ScmEventBus;
-import sonia.scm.security.KeyGenerator;
-import sonia.scm.store.ConfigurationStoreFactory;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasProperty;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+//~--- JDK imports ------------------------------------------------------------
 
 /**
  * Unit tests for {@link DefaultRepositoryManager}.
@@ -89,14 +100,12 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
   @Rule
   public ExpectedException thrown = ExpectedException.none();
 
-  /**
-   * Tests {@link RepositoryManager#create(sonia.scm.repository.Repository)}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
+  private ScmConfiguration configuration;
+
+  private String mockedNamespace = "default_namespace";
+
   @Test
-  public void testCreate() throws RepositoryException, IOException {
+  public void testCreate() throws RepositoryException {
     Repository heartOfGold = createTestRepository();
     Repository dbRepo = manager.get(heartOfGold.getId());
 
@@ -104,89 +113,47 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertRepositoriesEquals(dbRepo, heartOfGold);
   }
 
-  /**
-   * Tests {@link RepositoryManager#create(sonia.scm.repository.Repository)} without the required permissions.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @SubjectAware(
     username = "unpriv"
   )
   @Test(expected = UnauthorizedException.class)
-  public void testCreateWithoutPrivileges() throws RepositoryException, IOException {
+  public void testCreateWithoutPrivileges() throws RepositoryException {
     createTestRepository();
   }
 
-  /**
-   * Tests {@link RepositoryManager#create(sonia.scm.repository.Repository)} with a already existing repository.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test(expected = RepositoryAlreadyExistsException.class)
-  public void testCreateExisting() throws RepositoryException, IOException {
+  public void testCreateExisting() throws RepositoryException {
     createTestRepository();
     createTestRepository();
   }
 
-  /**
-   * Tests {@link RepositoryManager#delete(sonia.scm.repository.Repository)}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testDelete() throws RepositoryException, IOException {
+  public void testDelete() throws RepositoryException {
     delete(manager, createTestRepository());
   }
 
-  /**
-   * Tests {@link RepositoryManager#delete(sonia.scm.repository.Repository)} without the required permissions.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @SubjectAware(
     username = "unpriv"
   )
   @Test(expected = UnauthorizedException.class)
-  public void testDeleteWithoutPrivileges() throws RepositoryException, IOException {
+  public void testDeleteWithoutPrivileges() throws RepositoryException {
     delete(manager, createTestRepository());
   }
 
-  /**
-   * Tests {@link RepositoryManager#delete(sonia.scm.repository.Repository)} with a non archived repository and with
-   * enabled archive mode.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test(expected = RepositoryIsNotArchivedException.class)
-  public void testDeleteNonArchived() throws RepositoryException, IOException {
-    delete(createRepositoryManager(true), createTestRepository());
+  public void testDeleteNonArchived() throws RepositoryException {
+    configuration.setEnableRepositoryArchive(true);
+    delete(manager, createTestRepository());
   }
 
-  /**
-   * Tests {@link RepositoryManager#delete(sonia.scm.repository.Repository)} with a non existing repository.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test(expected = RepositoryNotFoundException.class)
-  public void testDeleteNotFound() throws RepositoryException, IOException {
+  public void testDeleteNotFound() throws RepositoryException {
     manager.delete(createRepositoryWithId());
   }
 
-  /**
-   * Tests {@link RepositoryManager#delete(sonia.scm.repository.Repository)} with enabled archive mode.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
   public void testDeleteWithEnabledArchive()
-    throws RepositoryException, IOException {
+    throws RepositoryException {
     Repository repository = createTestRepository();
 
     repository.setArchived(true);
@@ -195,14 +162,8 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     delete(drm, repository);
   }
 
-  /**
-   * Tests {@link RepositoryManager#get(java.lang.String)} .
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testGet() throws RepositoryException, IOException {
+  public void testGet() throws RepositoryException {
     Repository heartOfGold = createTestRepository();
     String id = heartOfGold.getId();
     String description = heartOfGold.getDescription();
@@ -216,17 +177,11 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertEquals(description, heartOfGold.getDescription());
   }
 
-  /**
-   * Tests {@link RepositoryManager#get(java.lang.String)} without required privileges.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
   @SubjectAware(
     username = "crato"
   )
-  public void testGetWithoutRequiredPrivileges() throws RepositoryException, IOException {
+  public void testGetWithoutRequiredPrivileges() throws RepositoryException {
     Repository heartOfGold = RepositoryTestData.createHeartOfGold();
     manager.create(heartOfGold);
 
@@ -234,14 +189,8 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     manager.get(heartOfGold.getId());
   }
 
-  /**
-   * Tests {@link RepositoryManager#getAll()}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testGetAll() throws RepositoryException, IOException {
+  public void testGetAll() throws RepositoryException {
     Repository heartOfGold = createTestRepository();
     Repository happyVerticalPeopleTransporter = createSecondTestRepository();
     boolean foundHeart = false;
@@ -276,16 +225,10 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
       heartOfGold.getDescription().equals(heartReference.getDescription()));
   }
 
-  /**
-   * Tests {@link RepositoryManager#getAll()} with permission for 2 of 3 repositories.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
   @SuppressWarnings("unchecked")
   @SubjectAware(username = "dent")
-  public void testGetAllWithPermissions() throws RepositoryException, IOException {
+  public void testGetAllWithPermissionsForTwoOrThreeRepos() throws RepositoryException {
     // mock key generator
     KeyGenerator keyGenerator = mock(KeyGenerator.class);
     Stack<String> keys = new Stack<>();
@@ -325,14 +268,8 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     );
   }
 
-  /**
-   * Tests repository manager events.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testEvents() throws RepositoryException, IOException {
+  public void testEvents() throws RepositoryException {
     RepositoryManager repoManager = createRepositoryManager(false);
     repoManager.init(contextProvider);
     TestListener listener = new TestListener();
@@ -362,14 +299,8 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertSame(HandlerEventType.DELETE, listener.postEvent);
   }
 
-  /**
-   * Tests {@link RepositoryManager#modify(sonia.scm.repository.Repository)}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testModify() throws RepositoryException, IOException {
+  public void testModify() throws RepositoryException {
     Repository heartOfGold = createTestRepository();
 
     heartOfGold.setDescription("prototype ship");
@@ -380,17 +311,10 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertNotNull(hearReference);
     assertEquals(hearReference.getDescription(), "prototype ship");
   }
-  
-  /**
-   * Tests {@link RepositoryManager#modify(sonia.scm.repository.Repository)} without
-   * the required permissions.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
+
   @Test
   @SubjectAware(username = "crato")
-  public void testModifyWithoutRequiredPermissions() throws RepositoryException, IOException {
+  public void testModifyWithoutRequiredPermissions() throws RepositoryException {
     Repository heartOfGold = RepositoryTestData.createHeartOfGold();
     manager.create(heartOfGold);
     heartOfGold.setDescription("prototype ship");
@@ -399,26 +323,13 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     manager.modify(heartOfGold);
   }
 
-  /**
-   * Tests {@link RepositoryManager#modify(sonia.scm.repository.Repository)} with a non
-   * existing repository.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test(expected = RepositoryNotFoundException.class)
-  public void testModifyNotFound() throws RepositoryException, IOException {
+  public void testModifyNotFound() throws RepositoryException {
     manager.modify(createRepositoryWithId());
   }
 
-  /**
-   * Tests {@link RepositoryManager#refresh(sonia.scm.repository.Repository)}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testRefresh() throws RepositoryException, IOException {
+  public void testRefresh() throws RepositoryException {
     Repository heartOfGold = createTestRepository();
     String description = heartOfGold.getDescription();
 
@@ -427,16 +338,9 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertEquals(description, heartOfGold.getDescription());
   }
 
-  /**
-   * Tests {@link RepositoryManager#refresh(sonia.scm.repository.Repository)} without
-   * required permissions.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
   @SubjectAware(username = "crato")
-  public void testRefreshWithoutRequiredPermissions() throws RepositoryException, IOException {
+  public void testRefreshWithoutRequiredPermissions() throws RepositoryException {
     Repository heartOfGold = RepositoryTestData.createHeartOfGold();
     manager.create(heartOfGold);
     heartOfGold.setDescription("prototype ship");
@@ -445,26 +349,13 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     manager.refresh(heartOfGold);
   }
 
-  /**
-   * Tests {@link RepositoryManager#refresh(sonia.scm.repository.Repository)} with a non existing
-   * repository.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test(expected = RepositoryNotFoundException.class)
-  public void testRefreshNotFound() throws RepositoryException, IOException {
+  public void testRefreshNotFound() throws RepositoryException {
     manager.refresh(createRepositoryWithId());
   }
 
-  /**
-   * Tests repository hooks.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void testRepositoryHook() throws RepositoryException, IOException {
+  public void testRepositoryHook() throws RepositoryException {
     CountingReceiveHook hook = new CountingReceiveHook();
     RepositoryManager repoManager = createRepositoryManager(false);
 
@@ -483,28 +374,96 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     assertEquals(2, hook.eventsReceived);
   }
 
-  /**
-   * Tests {@link RepositoryManager#getFromTypeAndUri(String, String)}.
-   *
-   * @throws IOException
-   * @throws RepositoryException
-   */
   @Test
-  public void getRepositoryFromRequestUriTest() throws RepositoryException, IOException {
+  public void testNamespaceSet() throws Exception {
+    RepositoryManager repoManager = createRepositoryManager(false);
+    Repository repository = spy(createTestRepository());
+    repository.setName("Testrepo");
+    ((DefaultRepositoryManager) repoManager).create(repository);
+    assertEquals("default_namespace", repository.getNamespace());
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_withoutLeadingSlash() throws RepositoryException {
     RepositoryManager m = createManager();
     m.init(contextProvider);
-    
-    createRepository(m, new Repository("1", "hg", "scm"));
-    createRepository(m, new Repository("2", "hg", "scm-test"));
-    createRepository(m, new Repository("3", "git", "project1/test-1"));
-    createRepository(m, new Repository("4", "git", "project1/test-2"));
-    
-    assertEquals("scm", m.getFromUri("hg/scm").getName());
-    assertEquals("scm-test", m.getFromUri("hg/scm-test").getName());
-    assertEquals("scm-test", m.getFromUri("/hg/scm-test").getName());
-    assertEquals("project1/test-1", m.getFromUri("/git/project1/test-1").getName());
-    assertEquals("project1/test-1", m.getFromUri("/git/project1/test-1/ka/some/path").getName());
-    assertNull(m.getFromUri("/git/project1/test-3/ka/some/path"));
+
+    createUriTestRepositories(m);
+
+    assertEquals("scm-test", m.getFromUri("hg/namespace/scm-test").getName());
+    assertEquals("namespace", m.getFromUri("hg/namespace/scm-test").getNamespace());
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_withLeadingSlash() throws RepositoryException {
+    RepositoryManager m = createManager();
+    m.init(contextProvider);
+
+    createUriTestRepositories(m);
+
+    assertEquals("scm-test", m.getFromUri("/hg/namespace/scm-test").getName());
+    assertEquals("namespace", m.getFromUri("/hg/namespace/scm-test").getNamespace());
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_withPartialName() throws RepositoryException {
+    RepositoryManager m = createManager();
+    m.init(contextProvider);
+
+    createUriTestRepositories(m);
+
+    assertEquals("scm", m.getFromUri("hg/namespace/scm").getName());
+    assertEquals("namespace", m.getFromUri("hg/namespace/scm").getNamespace());
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_withTrailingFilePath() throws RepositoryException {
+    RepositoryManager m = createManager();
+    m.init(contextProvider);
+
+    createUriTestRepositories(m);
+
+    assertEquals("test-1", m.getFromUri("/git/namespace/test-1/ka/some/path").getName());
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_forNotExistingRepositoryName() throws RepositoryException {
+    RepositoryManager m = createManager();
+    m.init(contextProvider);
+
+    createUriTestRepositories(m);
+
+    assertNull(m.getFromUri("/git/namespace/test-3/ka/some/path"));
+  }
+
+  @Test
+  public void getRepositoryFromRequestUri_forWrongNamespace() throws RepositoryException {
+    RepositoryManager m = createManager();
+    m.init(contextProvider);
+
+    createUriTestRepositories(m);
+
+    assertNull(m.getFromUri("/git/other/other/test-2"));
+  }
+
+  @Test
+  public void shouldSetNamespace() throws RepositoryException {
+    Repository repository = new Repository(null, "hg", null, "scm");
+    manager.create(repository);
+    assertNotNull(repository.getId());
+    assertNotNull(repository.getNamespace());
+  }
+
+  private void createUriTestRepositories(RepositoryManager m) throws RepositoryException {
+    mockedNamespace = "namespace";
+    createRepository(m, new Repository("1", "hg", "namespace", "scm"));
+    createRepository(m, new Repository("2", "hg", "namespace", "scm-test"));
+    createRepository(m, new Repository("3", "git", "namespace", "test-1"));
+    createRepository(m, new Repository("4", "git", "namespace", "test-2"));
+
+    mockedNamespace = "other";
+    createRepository(m, new Repository("1", "hg", "other", "scm"));
+    createRepository(m, new Repository("2", "hg", "other", "scm-test"));
   }
 
   //~--- methods --------------------------------------------------------------
@@ -537,16 +496,19 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
 
     XmlRepositoryDAO repositoryDAO = new XmlRepositoryDAO(factory);
 
-    ScmConfiguration configuration = new ScmConfiguration();
+    this.configuration = new ScmConfiguration();
 
     configuration.setEnableRepositoryArchive(archiveEnabled);
 
+    NamespaceStrategy namespaceStrategy = mock(NamespaceStrategy.class);
+    when(namespaceStrategy.getNamespace()).thenAnswer(invocation -> mockedNamespace);
+
     return new DefaultRepositoryManager(configuration, contextProvider,
-      keyGenerator, repositoryDAO, handlerSet, createRepositoryMatcher());
+      keyGenerator, repositoryDAO, handlerSet, createRepositoryMatcher(), namespaceStrategy);
   }
   
   private void createRepository(RepositoryManager m, Repository repository)
-    throws RepositoryException, IOException {
+    throws RepositoryException {
     m.create(repository);
   }
 
@@ -573,7 +535,7 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     return new RepositoryMatcher(Collections.<RepositoryPathMatcher>emptySet());
   }       
 
-  private Repository createRepository(Repository repository) throws RepositoryException, IOException {
+  private Repository createRepository(Repository repository) throws RepositoryException {
     manager.create(repository);
     assertNotNull(repository.getId());
     assertNotNull(manager.get(repository.getId()));
@@ -588,17 +550,17 @@ public class DefaultRepositoryManagerTest extends ManagerTestBase<Repository, Re
     return repository;
   }
 
-  private Repository createSecondTestRepository() throws RepositoryException, IOException {
+  private Repository createSecondTestRepository() throws RepositoryException {
     return createRepository(
       RepositoryTestData.createHappyVerticalPeopleTransporter());
   }
 
-  private Repository createTestRepository() throws RepositoryException, IOException {
+  private Repository createTestRepository() throws RepositoryException {
     return createRepository(RepositoryTestData.createHeartOfGold());
   }
 
   private void delete(Manager<Repository, RepositoryException> manager, Repository repository)
-    throws RepositoryException, IOException {
+    throws RepositoryException {
 
     String id = repository.getId();
 

scm-webapp/src/test/java/sonia/scm/repository/RepositoryMatcherTest.java

@@ -31,10 +31,13 @@
 package sonia.scm.repository;
 
 import com.google.common.collect.Sets;
-import java.util.Set;
-import org.junit.Test;
-import static org.junit.Assert.*;
 import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Set;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 /**
  * Unit tests for {@link RepositoryMatcher}.
@@ -54,11 +57,11 @@ public class RepositoryMatcherTest {
 
   @Test
   public void testMatches() {
-    assertFalse(matcher.matches(repository("hg", "scm"), "hg", "scm-test/ka"));
-    assertFalse(matcher.matches(repository("git", "scm-test"), "hg", "scm-test"));
+    assertFalse(matcher.matches(repository("hg", "scm"), "hg", "namespace/scm-test/ka"));
+    assertFalse(matcher.matches(repository("git", "scm-test"), "hg", "namespace/scm-test"));
     
-    assertTrue(matcher.matches(repository("hg", "scm-test"), "hg", "scm-test/ka"));
-    assertTrue(matcher.matches(repository("hg", "scm-test"), "hg", "scm-test"));
+    assertTrue(matcher.matches(repository("hg", "scm-test"), "hg", "namespace/scm-test/ka"));
+    assertTrue(matcher.matches(repository("hg", "scm-test"), "hg", "namespace/scm-test"));
   }
   
   @Test
@@ -68,7 +71,7 @@ public class RepositoryMatcherTest {
   }
   
   private Repository repository(String type, String name) {
-    return new Repository(type + "-" + name, type, name);
+    return new Repository(type + "-" + name, type, "namespace", name);
   }
   
   private static class AbcRepositoryPathMatcher implements RepositoryPathMatcher {