Merging base branch back into feature

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

@@ -10,7 +10,6 @@ import org.jboss.resteasy.mock.MockHttpResponse;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.mockito.Answers;
 import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
@@ -49,8 +48,7 @@ public class GroupRootResourceTest {
 
   private Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
 
-  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-  private ResourceLinks resourceLinks;
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(URI.create("/"));
 
   @Mock
   private GroupManager groupManager;
@@ -64,15 +62,13 @@ 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);
 
-    ResourceLinksMock.initMock(resourceLinks, URI.create("/"));
-
     GroupCollectionToDtoMapper groupCollectionToDtoMapper = new GroupCollectionToDtoMapper(groupToDtoMapper, resourceLinks);
     GroupCollectionResource groupCollectionResource = new GroupCollectionResource(groupManager, dtoToGroupMapper, groupCollectionToDtoMapper, resourceLinks);
     GroupResource groupResource = new GroupResource(groupManager, groupToDtoMapper, dtoToGroupMapper);

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

@@ -7,9 +7,7 @@ import org.apache.shiro.util.ThreadState;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.Answers;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import sonia.scm.group.Group;
 
 import java.net.URI;
@@ -24,8 +22,9 @@ import static org.mockito.MockitoAnnotations.initMocks;
 
 public class GroupToGroupDtoMapperTest {
 
-  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-  private ResourceLinks resourceLinks;
+  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;
@@ -38,12 +37,8 @@ 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 + "/");
     subjectThreadState.bind();
-
-    ResourceLinksMock.initMock(resourceLinks, baseUri);
-
     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

@@ -1,26 +1,29 @@
 package sonia.scm.api.v2.resources;
 
+import javax.ws.rs.core.UriInfo;
 import java.net.URI;
 
-import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
-import static sonia.scm.api.v2.resources.GroupRootResource.GROUPS_PATH_V2;
-import static sonia.scm.api.v2.resources.UserRootResource.USERS_PATH_V2;
 
 public class ResourceLinksMock {
-  public static void initMock(ResourceLinks resourceLinks, URI baseUri) {
-    when(resourceLinks.user().self(anyString())).thenAnswer(invocation -> baseUri + USERS_PATH_V2 + invocation.getArguments()[0]);
-    when(resourceLinks.user().update(anyString())).thenAnswer(invocation -> baseUri + USERS_PATH_V2 + invocation.getArguments()[0]);
-    when(resourceLinks.user().delete(anyString())).thenAnswer(invocation -> baseUri + USERS_PATH_V2 + invocation.getArguments()[0]);
+  public static ResourceLinks createMock(URI baseUri) {
+    ResourceLinks resourceLinks = mock(ResourceLinks.class);
 
-    when(resourceLinks.userCollection().self()).thenAnswer(invocation -> baseUri + USERS_PATH_V2);
-    when(resourceLinks.userCollection().create()).thenAnswer(invocation -> baseUri + USERS_PATH_V2);
+    UriInfo uriInfo = mock(UriInfo.class);
+    when(uriInfo.getBaseUri()).thenReturn(baseUri);
 
-    when(resourceLinks.group().self(anyString())).thenAnswer(invocation -> baseUri + GROUPS_PATH_V2 + invocation.getArguments()[0]);
-    when(resourceLinks.group().update(anyString())).thenAnswer(invocation -> baseUri + GROUPS_PATH_V2 + invocation.getArguments()[0]);
-    when(resourceLinks.group().delete(anyString())).thenAnswer(invocation -> baseUri + GROUPS_PATH_V2 + invocation.getArguments()[0]);
-
-    when(resourceLinks.groupCollection().self()).thenAnswer(invocation -> baseUri + GROUPS_PATH_V2);
-    when(resourceLinks.groupCollection().create()).thenAnswer(invocation -> baseUri + GROUPS_PATH_V2);
+    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

@@ -84,6 +84,54 @@ public class ResourceLinksTest {
     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);

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

@@ -7,7 +7,6 @@ import org.apache.shiro.util.ThreadContext;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.Answers;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import sonia.scm.PageResult;
@@ -28,8 +27,8 @@ import static sonia.scm.PageResult.createPage;
 
 public class UserCollectionToDtoMapperTest {
 
-  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-  private ResourceLinks resourceLinks;
+  private final URI baseUri = URI.create("http://example.com/base/");
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
   @Mock
   private UserToUserDtoMapper userToDtoMapper;
   @Mock
@@ -45,9 +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 + "/");
-    ResourceLinksMock.initMock(resourceLinks, baseUri);
     subjectThreadState.bind();
     ThreadContext.bind(subject);
   }

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

@@ -11,7 +11,6 @@ import org.jboss.resteasy.mock.MockHttpResponse;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.mockito.Answers;
 import org.mockito.ArgumentCaptor;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
@@ -51,8 +50,7 @@ public class UserRootResourceTest {
 
   private Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
 
-  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-  private ResourceLinks resourceLinks;
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(URI.create("/"));
 
   @Mock
   private PasswordService passwordService;
@@ -66,15 +64,13 @@ 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());
 
-    ResourceLinksMock.initMock(resourceLinks, URI.create("/"));
-
     UserCollectionToDtoMapper userCollectionToDtoMapper = new UserCollectionToDtoMapper(userToDtoMapper, resourceLinks);
     UserCollectionResource userCollectionResource = new UserCollectionResource(userManager, dtoToUserMapper,
        userCollectionToDtoMapper, resourceLinks);

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

@@ -7,14 +7,11 @@ import org.apache.shiro.util.ThreadState;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
-import org.mockito.Answers;
 import org.mockito.InjectMocks;
-import org.mockito.Mock;
 import sonia.scm.api.rest.resources.UserResource;
 import sonia.scm.user.User;
 
 import java.net.URI;
-import java.net.URISyntaxException;
 import java.time.Instant;
 
 import static org.junit.Assert.assertEquals;
@@ -25,8 +22,9 @@ import static org.mockito.MockitoAnnotations.initMocks;
 
 public class UserToUserDtoMapperTest {
 
-  @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-  private ResourceLinks resourceLinks;
+  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;
@@ -37,12 +35,10 @@ 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 + "/");
     subjectThreadState.bind();
-    ResourceLinksMock.initMock(resourceLinks, baseUri);
     ThreadContext.bind(subject);
   }
 

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

@@ -37,6 +37,7 @@ 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.apache.shiro.util.ThreadContext;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;