implement modification api in git, svn and hg. implement the endpoint

scm-webapp/src/main/java/sonia/scm/api/rest/IllegalArgumentExceptionMapper.java

@@ -45,7 +45,8 @@ import javax.ws.rs.ext.Provider;
  * @author Sebastian Sdorra
  * @since 1.36
  */
-@Provider @Slf4j
+@Provider
+@Slf4j
 public class IllegalArgumentExceptionMapper
   implements ExceptionMapper<IllegalArgumentException>
 {

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ChangesetToChangesetDtoMapper.java

@@ -65,7 +65,8 @@ public abstract class ChangesetToChangesetDtoMapper extends BaseMapper<Changeset
 
     Links.Builder linksBuilder = linkingTo()
       .self(resourceLinks.changeset().self(repository.getNamespace(), repository.getName(), target.getId()))
-      .single(link("diff", resourceLinks.diff().self(namespace, name, target.getId())));
+      .single(link("diff", resourceLinks.diff().self(namespace, name, target.getId())))
+      .single(link("modifications", resourceLinks.modifications().self(namespace, name, target.getId())));
     target.add(linksBuilder.build());
   }
 

scm-webapp/src/main/java/sonia/scm/api/v2/resources/InternalRepositoryExceptionMapper.java

@@ -0,0 +1,15 @@
+package sonia.scm.api.v2.resources;
+
+import sonia.scm.api.rest.StatusExceptionMapper;
+import sonia.scm.repository.InternalRepositoryException;
+
+import javax.ws.rs.core.Response;
+import javax.ws.rs.ext.Provider;
+
+@Provider
+public class InternalRepositoryExceptionMapper extends StatusExceptionMapper<InternalRepositoryException> {
+
+  public InternalRepositoryExceptionMapper() {
+    super(InternalRepositoryException.class, Response.Status.INTERNAL_SERVER_ERROR);
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/MapperModule.java

@@ -34,6 +34,7 @@ public class MapperModule extends AbstractModule {
     bind(TagToTagDtoMapper.class).to(Mappers.getMapper(TagToTagDtoMapper.class).getClass());
 
     bind(FileObjectToFileObjectDtoMapper.class).to(Mappers.getMapper(FileObjectToFileObjectDtoMapper.class).getClass());
+    bind(ModificationsToDtoMapper.class).to(Mappers.getMapper(ModificationsToDtoMapper.class).getClass());
 
     // no mapstruct required
     bind(UIPluginDtoMapper.class);

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ModificationsDto.java

@@ -0,0 +1,45 @@
+package sonia.scm.api.v2.resources;
+
+import de.otto.edison.hal.HalRepresentation;
+import de.otto.edison.hal.Links;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+@NoArgsConstructor
+public class ModificationsDto extends HalRepresentation {
+
+
+  private String revision;
+  /**
+   * list of added files
+   */
+  private List<String> added;
+
+  /**
+   * list of modified files
+   */
+  private List<String> modified;
+
+  /**
+   * list of removed files
+   */
+  private List<String> removed;
+
+  @Override
+  @SuppressWarnings("squid:S1185") // We want to have this method available in this package
+  protected HalRepresentation add(Links links) {
+    return super.add(links);
+  }
+
+  @SuppressWarnings("squid:S1185") // We want to have this method available in this package
+  protected HalRepresentation withEmbedded(String rel, List<? extends HalRepresentation> halRepresentations) {
+    return super.withEmbedded(rel, halRepresentations);
+  }
+
+
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ModificationsRootResource.java

@@ -0,0 +1,70 @@
+package sonia.scm.api.v2.resources;
+
+import com.webcohesion.enunciate.metadata.rs.ResponseCode;
+import com.webcohesion.enunciate.metadata.rs.StatusCodes;
+import com.webcohesion.enunciate.metadata.rs.TypeHint;
+import sonia.scm.repository.InternalRepositoryException;
+import sonia.scm.repository.Modifications;
+import sonia.scm.repository.NamespaceAndName;
+import sonia.scm.repository.RepositoryNotFoundException;
+import sonia.scm.repository.RevisionNotFoundException;
+import sonia.scm.repository.api.RepositoryService;
+import sonia.scm.repository.api.RepositoryServiceFactory;
+import sonia.scm.web.VndMediaType;
+
+import javax.inject.Inject;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+
+public class ModificationsRootResource {
+
+  private final RepositoryServiceFactory serviceFactory;
+  private final ModificationsToDtoMapper modificationsToDtoMapper;
+
+  @Inject
+  public ModificationsRootResource(RepositoryServiceFactory serviceFactory, ModificationsToDtoMapper modificationsToDtoMapper) {
+    this.serviceFactory = serviceFactory;
+    this.modificationsToDtoMapper = modificationsToDtoMapper;
+  }
+
+  /**
+   * Get the file modifications related to a revision.
+   * file modifications are for example: Modified, Added or Removed.
+   *
+   * @param namespace
+   * @param name
+   * @param revision
+   * @return
+   * @throws IOException
+   * @throws RevisionNotFoundException
+   * @throws RepositoryNotFoundException
+   */
+  @GET
+  @StatusCodes({
+    @ResponseCode(code = 200, condition = "success"),
+    @ResponseCode(code = 401, condition = "not authenticated / invalid credentials"),
+    @ResponseCode(code = 403, condition = "not authorized, the current user has no privileges to read the changeset"),
+    @ResponseCode(code = 404, condition = "not found, no changeset with the specified id is available in the repository"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  @Produces(VndMediaType.MODIFICATIONS)
+  @TypeHint(ModificationsDto.class)
+  @Path("{revision}")
+  public Response get(@PathParam("namespace") String namespace, @PathParam("name") String name, @PathParam("revision") String revision) throws IOException, RevisionNotFoundException, RepositoryNotFoundException , InternalRepositoryException {
+    try (RepositoryService repositoryService = serviceFactory.create(new NamespaceAndName(namespace, name))) {
+      Modifications modifications = repositoryService.getModificationsCommand()
+        .revision(revision)
+        .getModifications();
+      ModificationsDto output = modificationsToDtoMapper.map(modifications, repositoryService.getRepository());
+      if (modifications != null ) {
+        return Response.ok(output).build();
+      } else {
+        return Response.status(Response.Status.NOT_FOUND).build();
+      }
+    }
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ModificationsToDtoMapper.java

@@ -0,0 +1,31 @@
+package sonia.scm.api.v2.resources;
+
+import de.otto.edison.hal.Links;
+import org.mapstruct.AfterMapping;
+import org.mapstruct.Context;
+import org.mapstruct.Mapper;
+import org.mapstruct.Mapping;
+import org.mapstruct.MappingTarget;
+import sonia.scm.repository.Modifications;
+import sonia.scm.repository.Repository;
+
+import javax.inject.Inject;
+
+import static de.otto.edison.hal.Links.linkingTo;
+
+@Mapper
+public abstract class ModificationsToDtoMapper extends BaseMapper<Modifications, ModificationsDto> {
+
+  @Inject
+  private ResourceLinks resourceLinks;
+
+  @Mapping(target = "attributes", ignore = true) // We do not map HAL attributes
+  public abstract ModificationsDto map(Modifications modifications, @Context Repository repository);
+
+  @AfterMapping
+  void appendLinks(@MappingTarget ModificationsDto target, @Context Repository repository) {
+    Links.Builder linksBuilder = linkingTo()
+      .self(resourceLinks.modifications().self(repository.getNamespace(), repository.getName(), target.getRevision()));
+    target.add(linksBuilder.build());
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/RepositoryResource.java

@@ -40,6 +40,7 @@ public class RepositoryResource {
   private final Provider<ContentResource> contentResource;
   private final Provider<PermissionRootResource> permissionRootResource;
   private final Provider<DiffRootResource> diffRootResource;
+  private final Provider<ModificationsRootResource> modificationsRootResource;
 
   @Inject
   public RepositoryResource(
@@ -50,7 +51,7 @@ public class RepositoryResource {
     Provider<ChangesetRootResource> changesetRootResource,
     Provider<SourceRootResource> sourceRootResource, Provider<ContentResource> contentResource,
     Provider<PermissionRootResource> permissionRootResource,
-    Provider<DiffRootResource> diffRootResource) {
+    Provider<DiffRootResource> diffRootResource, Provider<ModificationsRootResource> modificationsRootResource) {
     this.dtoToRepositoryMapper = dtoToRepositoryMapper;
     this.manager = manager;
     this.repositoryToDtoMapper = repositoryToDtoMapper;
@@ -62,6 +63,7 @@ public class RepositoryResource {
     this.contentResource = contentResource;
     this.permissionRootResource = permissionRootResource;
     this.diffRootResource = diffRootResource;
+    this.modificationsRootResource = modificationsRootResource;
   }
 
   /**
@@ -180,6 +182,9 @@ public class RepositoryResource {
     return permissionRootResource.get();
   }
 
+ @Path("modifications/")
+  public ModificationsRootResource modifications() {return modificationsRootResource.get(); }
+
   private Optional<Response> handleNotArchived(Throwable throwable) {
     if (throwable instanceof RepositoryIsNotArchivedException) {
       return Optional.of(Response.status(Response.Status.PRECONDITION_FAILED).build());

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ResourceLinks.java

@@ -307,6 +307,21 @@ class ResourceLinks {
     }
   }
 
+  public ModificationsLinks modifications() {
+    return new ModificationsLinks(uriInfoStore.get());
+  }
+
+  static class ModificationsLinks {
+    private final LinkBuilder modificationsLinkBuilder;
+
+    ModificationsLinks(UriInfo uriInfo) {
+      modificationsLinkBuilder = new LinkBuilder(uriInfo, RepositoryRootResource.class, RepositoryResource.class, ModificationsRootResource.class);
+    }
+    String self(String namespace, String name, String revision) {
+      return modificationsLinkBuilder.method("getRepositoryResource").parameters(namespace, name).method("modifications").parameters().method("get").parameters(revision).href();
+    }
+  }
+
   public SourceLinks source() {
     return new SourceLinks(uriInfoStore.get());
   }

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

@@ -92,7 +92,7 @@ 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);
+    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);
 
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(service);

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

@@ -81,7 +81,7 @@ public class ChangesetRootResourceTest {
     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);
+        MockProvider.of(changesetRootResource), null, null, null, null, null)), null);
     dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(repositoryService);
     when(serviceFactory.create(any(Repository.class))).thenReturn(repositoryService);

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

@@ -0,0 +1,151 @@
+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 {
+
+
+  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);
+    RepositoryRootResource repositoryRootResource = new RepositoryRootResource(MockProvider
+      .of(new RepositoryResource(null, null, null, null, null,
+        null, null, null, null, null, MockProvider.of(modificationsRootResource))), null);
+    dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
+    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

@@ -138,7 +138,7 @@ public class PermissionRootResourceTest {
     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);
+      .of(new RepositoryResource(null, null, null, null, null, null, null, null, MockProvider.of(permissionRootResource), null, null)), null);
     dispatcher = createDispatcher(repositoryRootResource);
     subjectThreadState.bind();
     ThreadContext.bind(subject);

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

@@ -79,7 +79,7 @@ public class RepositoryRootResourceTest {
   @Before
   public void prepareEnvironment() {
     initMocks(this);
-    RepositoryResource repositoryResource = new RepositoryResource(repositoryToDtoMapper, dtoToRepositoryMapper, repositoryManager, null, null, null, null, null, null, null);
+    RepositoryResource repositoryResource = new RepositoryResource(repositoryToDtoMapper, dtoToRepositoryMapper, repositoryManager, null, null, null, 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));

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

@@ -27,6 +27,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

@@ -1,7 +1,6 @@
 package sonia.scm.api.v2.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;
@@ -74,6 +73,7 @@ public class SourceRootResourceTest {
         MockProvider.of(sourceRootResource),
         null,
         null,
+        null,
         null)),
         null);
     dispatcher = createDispatcher(repositoryRootResource);

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

@@ -74,7 +74,7 @@ public class TagRootResourceTest {
     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, null, null, null, null, null)), null);
     dispatcher.getRegistry().addSingletonResource(repositoryRootResource);
     when(serviceFactory.create(new NamespaceAndName("space", "repo"))).thenReturn(repositoryService);
     when(serviceFactory.create(any(Repository.class))).thenReturn(repositoryService);