merge

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

@@ -19,8 +19,15 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.Silent.class)
 public class WebResourceServletTest {

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

@@ -44,7 +44,7 @@ import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.Silent.class)
 @Slf4j
-public class BranchRootResourceTest {
+public class BranchRootResourceTest extends RepositoryTestBase {
 
   public static final String BRANCH_PATH = "space/repo/branches/master";
   public static final String BRANCH_URL = "/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + BRANCH_PATH;
@@ -92,9 +92,8 @@ public class BranchRootResourceTest {
     changesetCollectionToDtoMapper = new ChangesetCollectionToDtoMapper(changesetToChangesetDtoMapper, resourceLinks);
     BranchCollectionToDtoMapper branchCollectionToDtoMapper = new BranchCollectionToDtoMapper(branchToDtoMapper, resourceLinks);
     branchRootResource = new BranchRootResource(serviceFactory, branchToDtoMapper, branchCollectionToDtoMapper, changesetCollectionToDtoMapper);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider.of(new RepositoryResource(null, null, null, null, MockProvider.of(branchRootResource), null, null, null, null, null, null)), null);
-    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
-
+    super.branchRootResource = MockProvider.of(branchRootResource);
+    dispatcher.getRegistry().addSingletonResource(getRepositoryRootResource());
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(service);
     when(serviceFactory.create(any(Repository.class))).thenReturn(service);
     when(service.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));

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

@@ -44,7 +44,7 @@ import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.Silent.class)
 @Slf4j
-public class ChangesetRootResourceTest {
+public class ChangesetRootResourceTest extends RepositoryTestBase {
 
 
   public static final String CHANGESET_PATH = "space/repo/changesets/";
@@ -79,10 +79,8 @@ public class ChangesetRootResourceTest {
   public void prepareEnvironment() throws Exception {
     changesetCollectionToDtoMapper = new ChangesetCollectionToDtoMapper(changesetToChangesetDtoMapper, resourceLinks);
     changesetRootResource = new ChangesetRootResource(serviceFactory, changesetCollectionToDtoMapper, changesetToChangesetDtoMapper);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
-      .of(new RepositoryResource(null, null, null, null, null,
-        MockProvider.of(changesetRootResource), null, null, null, null, null)), null);
-    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+    super.changesetRootResource = MockProvider.of(changesetRootResource);
+    dispatcher.getRegistry().addSingletonResource(getRepositoryRootResource());
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(repositoryService);
     when(serviceFactory.create(any(Repository.class))).thenReturn(repositoryService);
     when(repositoryService.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));

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

@@ -37,7 +37,7 @@ import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.Silent.class)
 @Slf4j
-public class DiffResourceTest {
+public class DiffResourceTest extends RepositoryTestBase {
 
 
   public static final String DIFF_PATH = "space/repo/diff/";
@@ -63,10 +63,8 @@ public class DiffResourceTest {
   @Before
   public void prepareEnvironment() throws Exception {
     diffRootResource = new DiffRootResource(serviceFactory);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
-      .of(new RepositoryResource(null, null, null, null, null,
-        null, null, null, null, MockProvider.of(diffRootResource),null)), null);
-    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+    super.diffRootResource = MockProvider.of(diffRootResource);
+    dispatcher.getRegistry().addSingletonResource(getRepositoryRootResource());
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(service);
     when(serviceFactory.create(any(Repository.class))).thenReturn(service);
     when(service.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));

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

@@ -14,6 +14,7 @@ public class DispatcherMock {
     dispatcher.getProviderFactory().registerProvider(AlreadyExistsExceptionMapper.class);
     dispatcher.getProviderFactory().registerProvider(AuthorizationExceptionMapper.class);
     dispatcher.getProviderFactory().registerProvider(ConcurrentModificationExceptionMapper.class);
+    dispatcher.getProviderFactory().registerProvider(InternalRepositoryExceptionMapper.class);
     dispatcher.getProviderFactory().registerProvider(ChangePasswordNotAllowedExceptionMapper.class);
     return dispatcher;
   }

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

@@ -47,7 +47,7 @@ import static org.mockito.Mockito.when;
 
 @RunWith(MockitoJUnitRunner.Silent.class)
 @Slf4j
-public class FileHistoryResourceTest {
+public class FileHistoryResourceTest extends RepositoryTestBase {
 
   public static final String FILE_HISTORY_PATH = "space/repo/history/";
   public static final String FILE_HISTORY_URL = "/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + FILE_HISTORY_PATH;
@@ -81,10 +81,8 @@ public class FileHistoryResourceTest {
   public void prepareEnvironment() throws Exception {
     fileHistoryCollectionToDtoMapper = new FileHistoryCollectionToDtoMapper(changesetToChangesetDtoMapper, resourceLinks);
     fileHistoryRootResource = new FileHistoryRootResource(serviceFactory, fileHistoryCollectionToDtoMapper);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
-      .of(new RepositoryResource(null, null, null, null, null,
-        null, null, null, null, null, MockProvider.of(fileHistoryRootResource))), null);
-    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+    super.fileHistoryRootResource = MockProvider.of(fileHistoryRootResource);
+    dispatcher.getRegistry().addSingletonResource(getRepositoryRootResource());
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(service);
     when(serviceFactory.create(any(Repository.class))).thenReturn(service);
     when(service.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));

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

@@ -0,0 +1,149 @@
+package sonia.scm.api.v2.resources;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.shiro.subject.Subject;
+import org.apache.shiro.subject.support.SubjectThreadState;
+import org.apache.shiro.util.ThreadContext;
+import org.apache.shiro.util.ThreadState;
+import org.assertj.core.util.Lists;
+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.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+import sonia.scm.api.rest.AuthorizationExceptionMapper;
+import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.Modifications;
+import sonia.scm.repository.NamespaceAndName;
+import sonia.scm.repository.Repository;
+import sonia.scm.repository.api.ModificationsCommandBuilder;
+import sonia.scm.repository.api.RepositoryService;
+import sonia.scm.repository.api.RepositoryServiceFactory;
+import sonia.scm.web.VndMediaType;
+
+import java.net.URI;
+import java.text.MessageFormat;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@Slf4j
+@RunWith(MockitoJUnitRunner.Silent.class)
+public class ModificationsResourceTest extends RepositoryTestBase {
+
+
+  public static final String MODIFICATIONS_PATH = "space/repo/modifications/";
+  public static final String MODIFICATIONS_URL = "/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + MODIFICATIONS_PATH;
+  private final Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
+
+  private final URI baseUri = URI.create("/");
+  private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
+
+  @Mock
+  private RepositoryServiceFactory serviceFactory;
+
+  @Mock
+  private RepositoryService repositoryService;
+
+  @Mock
+  private ModificationsCommandBuilder modificationsCommandBuilder;
+
+  @InjectMocks
+  private ModificationsToDtoMapperImpl modificationsToDtoMapper;
+
+  private ModificationsRootResource modificationsRootResource;
+
+
+  private final Subject subject = mock(Subject.class);
+  private final ThreadState subjectThreadState = new SubjectThreadState(subject);
+
+
+  @Before
+  public void prepareEnvironment() throws Exception {
+    modificationsRootResource = new ModificationsRootResource(serviceFactory, modificationsToDtoMapper);
+    super.modificationsRootResource = MockProvider.of(modificationsRootResource);
+    dispatcher.getRegistry().addSingletonResource(getRepositoryRootResource());
+    when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(repositoryService);
+    when(serviceFactory.create(any(Repository.class))).thenReturn(repositoryService);
+    when(repositoryService.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));
+    dispatcher.getProviderFactory().registerProvider(NotFoundExceptionMapper.class);
+    dispatcher.getProviderFactory().registerProvider(AuthorizationExceptionMapper.class);
+    dispatcher.getProviderFactory().registerProvider(InternalRepositoryExceptionMapper.class);
+    when(repositoryService.getModificationsCommand()).thenReturn(modificationsCommandBuilder);
+    subjectThreadState.bind();
+    ThreadContext.bind(subject);
+    when(subject.isPermitted(any(String.class))).thenReturn(true);
+  }
+
+  @After
+  public void cleanupContext() {
+    ThreadContext.unbindSubject();
+  }
+
+  @Test
+  public void shouldGet404OnMissingModifications() throws Exception {
+    when(modificationsCommandBuilder.revision(any())).thenReturn(modificationsCommandBuilder);
+    when(modificationsCommandBuilder.getModifications()).thenReturn(null);
+
+    MockHttpRequest request = MockHttpRequest
+      .get(MODIFICATIONS_URL + "not_existing_revision")
+      .accept(VndMediaType.MODIFICATIONS);
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    assertEquals(404, response.getStatus());
+  }
+
+  @Test
+  public void shouldGet500OnModificationsCommandError() throws Exception {
+    when(modificationsCommandBuilder.revision(any())).thenReturn(modificationsCommandBuilder);
+    when(modificationsCommandBuilder.getModifications()).thenThrow(InternalRepositoryException.class);
+
+    MockHttpRequest request = MockHttpRequest
+      .get(MODIFICATIONS_URL + "revision")
+      .accept(VndMediaType.MODIFICATIONS);
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    assertEquals(500, response.getStatus());
+  }
+
+
+  @Test
+  public void shouldGetModifications() throws Exception {
+    Modifications modifications = new Modifications();
+    String revision = "revision";
+    String addedFile_1 = "a.txt";
+    String addedFile_2 = "b.txt";
+    String modifiedFile_1 = "d.txt";
+    String modifiedFile_2 = "c.txt";
+    String removedFile_1 = "e.txt";
+    String removedFile_2 = "f.txt";
+    modifications.setRevision(revision);
+    modifications.setAdded(Lists.newArrayList(addedFile_1, addedFile_2));
+    modifications.setModified(Lists.newArrayList(modifiedFile_1, modifiedFile_2));
+    modifications.setRemoved(Lists.newArrayList(removedFile_1, removedFile_2));
+    when(modificationsCommandBuilder.getModifications()).thenReturn(modifications);
+    when(modificationsCommandBuilder.revision(eq(revision))).thenReturn(modificationsCommandBuilder);
+
+    MockHttpRequest request = MockHttpRequest
+      .get(MODIFICATIONS_URL + revision)
+      .accept(VndMediaType.MODIFICATIONS);
+    MockHttpResponse response = new MockHttpResponse();
+    dispatcher.invoke(request, response);
+    assertEquals(200, response.getStatus());
+    log.info("the content: ", response.getContentAsString());
+    assertTrue(response.getContentAsString().contains(String.format("\"revision\":\"%s\"", revision)));
+    assertTrue(response.getContentAsString().contains(MessageFormat.format("\"added\":[\"{0}\",\"{1}\"]", addedFile_1, addedFile_2)));
+    assertTrue(response.getContentAsString().contains(MessageFormat.format("\"modified\":[\"{0}\",\"{1}\"]", modifiedFile_1, modifiedFile_2)));
+    assertTrue(response.getContentAsString().contains(MessageFormat.format("\"removed\":[\"{0}\",\"{1}\"]", removedFile_1, removedFile_2)));
+  }
+}

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

@@ -64,7 +64,7 @@ import static sonia.scm.api.v2.resources.PermissionDto.GROUP_PREFIX;
   password = "secret",
   configuration = "classpath:sonia/scm/repository/shiro.ini"
 )
-public class PermissionRootResourceTest {
+public class PermissionRootResourceTest extends RepositoryTestBase {
   private static final String REPOSITORY_NAMESPACE = "repo_namespace";
   private static final String REPOSITORY_NAME = "repo";
   private static final String PERMISSION_WRITE = "repository:permissionWrite:" + REPOSITORY_NAME;
@@ -137,9 +137,8 @@ public class PermissionRootResourceTest {
     initMocks(this);
     permissionCollectionToDtoMapper = new PermissionCollectionToDtoMapper(permissionToPermissionDtoMapper, resourceLinks);
     permissionRootResource = new PermissionRootResource(permissionDtoToPermissionMapper, permissionToPermissionDtoMapper, permissionCollectionToDtoMapper, resourceLinks, repositoryManager);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
-      .of(new RepositoryResource(null, null, null, null, null, null, null, null, MockProvider.of(permissionRootResource), null, null)), null);
-    dispatcher = createDispatcher(repositoryRootResource);
+    super.permissionRootResource = MockProvider.of(permissionRootResource);
+    dispatcher = createDispatcher(getRepositoryRootResource());
     subjectThreadState.bind();
     ThreadContext.bind(subject);
   }

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

@@ -55,7 +55,7 @@ import static sonia.scm.api.v2.resources.DispatcherMock.createDispatcher;
   password = "secret",
   configuration = "classpath:sonia/scm/repository/shiro.ini"
 )
-public class RepositoryRootResourceTest {
+public class RepositoryRootResourceTest extends RepositoryTestBase {
 
   private Dispatcher dispatcher;
 
@@ -79,11 +79,12 @@ public class RepositoryRootResourceTest {
   @Before
   public void prepareEnvironment() {
     initMocks(this);
-    RepositoryResource repositoryResource = new RepositoryResource(repositoryToDtoMapper, dtoToRepositoryMapper, repositoryManager, null, null, null, null, null, null, null, null);
+    super.repositoryToDtoMapper = repositoryToDtoMapper;
+    super.dtoToRepositoryMapper = dtoToRepositoryMapper;
+    super.manager = repositoryManager;
     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 = createDispatcher(repositoryRootResource);
+    super.repositoryCollectionResource = MockProvider.of(new RepositoryCollectionResource(repositoryManager, repositoryCollectionToDtoMapper, dtoToRepositoryMapper, resourceLinks));
+    dispatcher = createDispatcher(getRepositoryRootResource());
   }
 
   @Test

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

@@ -0,0 +1,42 @@
+package sonia.scm.api.v2.resources;
+
+import sonia.scm.repository.RepositoryManager;
+
+import javax.inject.Provider;
+
+public abstract class RepositoryTestBase {
+
+
+  protected RepositoryToRepositoryDtoMapper repositoryToDtoMapper;
+  protected RepositoryDtoToRepositoryMapper dtoToRepositoryMapper;
+  protected RepositoryManager manager;
+  protected Provider<TagRootResource> tagRootResource;
+  protected Provider<BranchRootResource> branchRootResource;
+  protected Provider<ChangesetRootResource> changesetRootResource;
+  protected Provider<SourceRootResource> sourceRootResource;
+  protected Provider<ContentResource> contentResource;
+  protected Provider<PermissionRootResource> permissionRootResource;
+  protected Provider<DiffRootResource> diffRootResource;
+  protected Provider<ModificationsRootResource> modificationsRootResource;
+  protected Provider<FileHistoryRootResource> fileHistoryRootResource;
+  protected Provider<RepositoryCollectionResource> repositoryCollectionResource;
+
+
+  RepositoryRootResource getRepositoryRootResource() {
+    return new RepositoryRootResource(MockProvider.of(new RepositoryResource(
+      repositoryToDtoMapper,
+      dtoToRepositoryMapper,
+      manager,
+      tagRootResource,
+      branchRootResource,
+      changesetRootResource,
+      sourceRootResource,
+      contentResource,
+      permissionRootResource,
+      diffRootResource,
+      modificationsRootResource,
+      fileHistoryRootResource)), repositoryCollectionResource);
+  }
+
+
+}

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

@@ -28,6 +28,7 @@ public class ResourceLinksMock {
     when(resourceLinks.config()).thenReturn(new ResourceLinks.ConfigLinks(uriInfo));
     when(resourceLinks.branch()).thenReturn(new ResourceLinks.BranchLinks(uriInfo));
     when(resourceLinks.diff()).thenReturn(new ResourceLinks.DiffLinks(uriInfo));
+    when(resourceLinks.modifications()).thenReturn(new ResourceLinks.ModificationsLinks(uriInfo));
     when(resourceLinks.repositoryType()).thenReturn(new ResourceLinks.RepositoryTypeLinks(uriInfo));
     when(resourceLinks.repositoryTypeCollection()).thenReturn(new ResourceLinks.RepositoryTypeCollectionLinks(uriInfo));
     when(resourceLinks.uiPluginCollection()).thenReturn(new ResourceLinks.UIPluginCollectionLinks(uriInfo));

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

@@ -32,7 +32,7 @@ import static sonia.scm.api.v2.resources.DispatcherMock.createDispatcher;
 
 
 @RunWith(MockitoJUnitRunner.Silent.class)
-public class SourceRootResourceTest {
+public class SourceRootResourceTest extends RepositoryTestBase {
 
   private Dispatcher dispatcher;
   private final URI baseUri = URI.create("/");
@@ -63,20 +63,8 @@ public class SourceRootResourceTest {
 
     when(fileObjectToFileObjectDtoMapper.map(any(FileObject.class), any(NamespaceAndName.class), anyString())).thenReturn(dto);
     SourceRootResource sourceRootResource = new SourceRootResource(serviceFactory, browserResultToBrowserResultDtoMapper);
-    RepositoryRootResource repositoryRootResource =
-      new RepositoryRootResource(MockProvider.of(new RepositoryResource(null,
-        null,
-        null,
-        null,
-        null,
-        null,
-        MockProvider.of(sourceRootResource),
-        null,
-        null,
-        null,
-        null)),
-        null);
-    dispatcher = createDispatcher(repositoryRootResource);
+    super.sourceRootResource = MockProvider.of(sourceRootResource);
+    dispatcher = createDispatcher(getRepositoryRootResource());
   }
 
   @Test

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

@@ -7,7 +7,6 @@ import org.apache.shiro.util.ThreadContext;
 import org.apache.shiro.util.ThreadState;
 import org.assertj.core.util.Lists;
 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.After;
@@ -35,14 +34,15 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import static sonia.scm.api.v2.resources.DispatcherMock.createDispatcher;
 
 @Slf4j
 @RunWith(MockitoJUnitRunner.Silent.class)
-public class TagRootResourceTest {
+public class TagRootResourceTest extends RepositoryTestBase {
 
   public static final String TAG_PATH = "space/repo/tags/";
   public static final String TAG_URL = "/" + RepositoryRootResource.REPOSITORIES_PATH_V2 + TAG_PATH;
-  private final Dispatcher dispatcher = MockDispatcherFactory.createDispatcher();
+  private Dispatcher dispatcher ;
 
   private final URI baseUri = URI.create("/");
   private final ResourceLinks resourceLinks = ResourceLinksMock.createMock(baseUri);
@@ -55,7 +55,6 @@ public class TagRootResourceTest {
 
   @Mock
   private TagsCommandBuilder tagsCommandBuilder;
-
   private TagCollectionToDtoMapper tagCollectionToDtoMapper;
 
   @InjectMocks
@@ -72,10 +71,8 @@ public class TagRootResourceTest {
   public void prepareEnvironment() throws Exception {
     tagCollectionToDtoMapper = new TagCollectionToDtoMapper(resourceLinks, tagToTagDtoMapper);
     tagRootResource = new TagRootResource(serviceFactory, tagCollectionToDtoMapper, tagToTagDtoMapper);
-    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
-      .of(new RepositoryResource(null, null, null, MockProvider.of(tagRootResource), null,
-        null, null, null, null, null, null)), null);
-    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+    super.tagRootResource = MockProvider.of(tagRootResource);
+    dispatcher = createDispatcher(getRepositoryRootResource());
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(repositoryService);
     when(serviceFactory.create(any(Repository.class))).thenReturn(repositoryService);
     when(repositoryService.getRepository()).thenReturn(new Repository("repoId", "git", "space", "repo"));