How to use

getRepositoryByRepositoryAlias

method

in

org.guvnor.structure.backend.repositories.ConfiguredRepositories

@Override
public Repository getRepositoryFromSpace(final Space space,
                     final String alias) {
  return configuredRepositories.getRepositoryByRepositoryAlias(space,
                                 alias);
}

@Override
public Repository getRepository(final String alias) {
  return configuredRepositories.getRepositoryByRepositoryAlias(alias);
}

public void onNewBranch(final @Observes NewBranchEvent changedEvent) {
  if (repositoriesByAlias.containsKey(changedEvent.getRepositoryAlias())) {
    final Repository repository = getRepositoryByRepositoryAlias(changedEvent.getRepositoryAlias());
    if (repository instanceof GitRepository) {
      ((GitRepository) repository).addBranch(changedEvent.getBranchName(),
                          changedEvent.getBranchPath());
      repositoriesByBranchRoot.put(changedEvent.getBranchPath(),
                     repository);
    }
  }
}

@Test
public void testCreateSecondNewAliasIfNecessary() {
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("alias"))).thenReturn(repository);
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("alias-1"))).thenReturn(repository);
  doReturn(Optional.of(mock(Branch.class))).when(repository).getDefaultBranch();
  doReturn("alias").when(repository).getAlias();
  String newAlias = repositoryService.createFreshRepositoryAlias("alias",
                                  new Space("alias"));
  assertEquals("alias-2",
         newAlias);
}

@Test
public void testCreateNewAliasIfNecessary() {
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("alias"))).thenReturn(repository);
  doReturn(Optional.of(mock(Branch.class))).when(repository).getDefaultBranch();
  doReturn("alias").when(repository).getAlias();
  String newAlias = repositoryService.createFreshRepositoryAlias("alias",
                                  new Space("alias"));
  assertEquals("alias-1",
         newAlias);
}

@Test
public void testNotCreateNewAliasIfNecessary() {
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("other-name"))).thenReturn(repository);
  doReturn(Optional.of(mock(Branch.class))).when(repository).getDefaultBranch();
  doReturn("alias").when(repository).getAlias();
  String newAlias = repositoryService.createFreshRepositoryAlias("alias",
                                  new Space("alias"));
  assertEquals("alias",
         newAlias);
}

@Test
public void testNotCreateNewAliasIfNecessary() {
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("other-name"))).thenReturn(repository);
  doReturn(Optional.of(mock(Branch.class))).when(repository).getDefaultBranch();
  doReturn("alias").when(repository).getAlias();
  String newAlias = repositoryService.createFreshRepositoryAlias("alias",
                                  new Space("alias"));
  assertEquals("alias",
         newAlias);
}

@Test
public void testCreateNewAliasIfNecessary() {
  when(configuredRepositories.getRepositoryByRepositoryAlias(any(),
                                eq("alias"))).thenReturn(repository);
  doReturn(Optional.of(mock(Branch.class))).when(repository).getDefaultBranch();
  doReturn("alias").when(repository).getAlias();
  String newAlias = repositoryService.createFreshRepositoryAlias("alias",
                                  new Space("alias"));
  assertEquals("alias-1",
         newAlias);
}

@Override
public List<FileDiff> diff(final PullRequest pullRequest) {
  final Repository repository = configuredRepositories.getRepositoryByRepositoryAlias(pullRequest.getTargetRepository());
  this.createHiddenBranch(pullRequest);
  String diff = String.format("diff:%s,%s",
                pullRequest.getTargetBranch(),
                this.buildHiddenBranchName(pullRequest));
  final List<FileDiff> diffs = (List<FileDiff>) this.ioService.readAttributes(convert(repository.getRoot()),
                                        diff);
  this.deleteHiddenBranch(pullRequest);
  return diffs;
}

@Test
public void testLoadSingle() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias("single");
  assertEquals(1,
         single.getBranches().size());
  assertNotNull(single.getBranchRoot("master"));
}

@Test
public void testLoadSingle() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO1S1);
  assertEquals(1,
         single.getBranches().size());
  assertNotNull(single.getBranch("master"));
}

@Test
public void testLoadSingle() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO1S1);
  assertEquals(1,
         single.getBranches().size());
  assertNotNull(single.getBranch("master"));
}

@Test
public void testLoadMultiBranch() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias("multibranch");
  assertEquals(3,
         single.getBranches().size());
  assertNotNull(single.getBranchRoot("master"));
  assertNotNull(single.getBranchRoot("dev"));
  assertNotNull(single.getBranchRoot("release"));
}

@Test
public void testLoadMultiBranch() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO2S1);
  assertEquals(3,
         single.getBranches().size());
  assertNotNull(single.getBranch("master"));
  assertNotNull(single.getBranch("dev"));
  assertNotNull(single.getBranch("release"));
}

@Test
public void testLoadMultiBranch() throws Exception {
  final Repository single = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO2S1);
  assertEquals(3,
         single.getBranches().size());
  assertNotNull(single.getBranch("master"));
  assertNotNull(single.getBranch("dev"));
  assertNotNull(single.getBranch("release"));
}

@Test
public void testRemoveSingle() throws Exception {
  final Path root = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                      REPO1S1).getDefaultBranch().get().getPath();
  assertNotNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                                 root));
  assertNotNull(configuredRepositories.remove(SPACE1,
                        REPO1S1));
  assertFalse(configuredRepositories.containsAlias(SPACE1,
                           REPO1S1));
  assertNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                               root));
}

@Test
public void testRemoveMultiBranch() throws Exception {
  final Branch devBranch = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO2S1).getBranch("dev").get();
  assertNotNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                                 devBranch.getPath()));
  assertNotNull(configuredRepositories.remove(SPACE1,
                        REPO2S1));
  assertFalse(configuredRepositories.containsAlias(SPACE1,
                           REPO2S1));
  assertNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                               devBranch.getPath()));
}

@Test
public void testRemoveMultiBranch() throws Exception {
  final Branch devBranch = configuredRepositories.getRepositoryByRepositoryAlias(SPACE1,
                                          REPO2S1).getBranch("dev").get();
  assertNotNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                                 devBranch.getPath()));
  assertNotNull(configuredRepositories.remove(SPACE1,
                        REPO2S1));
  assertFalse(configuredRepositories.containsAlias(SPACE1,
                           REPO2S1));
  assertNull(configuredRepositories.getRepositoryByRootPath(SPACE1,
                               devBranch.getPath()));
}

@Test
public void testRemoveSingle() throws Exception {
  final Path root = configuredRepositories.getRepositoryByRepositoryAlias("single").getRoot();
  assertNotNull(configuredRepositories.getRepositoryByRootPath(root));
  assertNotNull(configuredRepositories.remove("single"));
  assertFalse(configuredRepositories.containsAlias("single"));
  assertNull(configuredRepositories.getRepositoryByRootPath(root));
}

@Test
public void testRemoveMultiBranch() throws Exception {
  final Path devRoot = configuredRepositories.getRepositoryByRepositoryAlias("multibranch").getBranchRoot("dev");
  assertNotNull(configuredRepositories.getRepositoryByRootPath(devRoot));
  assertNotNull(configuredRepositories.remove("multibranch"));
  assertFalse(configuredRepositories.containsAlias("multibranch"));
  assertNull(configuredRepositories.getRepositoryByRootPath(devRoot));
}