org.eclipse.egit.core.test/src/org/eclipse/egit/core/internal/util/ProjectUtilTest.java

   1 /*******************************************************************************
   2  * Copyright (C) 2012, Matthias Sohn <matthias.sohn@sap.com> and others.
   3  *
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *******************************************************************************/
   9 package org.eclipse.egit.core.internal.util;
  10
  11 import static org.hamcrest.MatcherAssert.assertThat;
  12 import static org.hamcrest.Matchers.hasItem;
  13 import static org.junit.Assert.assertEquals;
  14 import static org.junit.Assert.assertFalse;
  15 import static org.junit.Assert.assertNull;
  16 import static org.junit.Assert.assertTrue;
  17 import static org.mockito.Matchers.any;
  18 import static org.mockito.Matchers.eq;
  19 import static org.mockito.Mockito.mock;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.when;
  22
  23 import java.io.File;
  24 import java.util.ArrayList;
  25 import java.util.Collection;
  26 import java.util.Collections;
  27 import java.util.Set;
  28 import java.util.TreeSet;
  29
  30 import org.eclipse.core.resources.IProject;
  31 import org.eclipse.core.resources.IResource;
  32 import org.eclipse.core.resources.ResourcesPlugin;
  33 import org.eclipse.core.runtime.IProgressMonitor;
  34 import org.eclipse.core.runtime.NullProgressMonitor;
  35 import org.eclipse.egit.core.op.ConnectProviderOperation;
  36 import org.eclipse.egit.core.test.GitTestCase;
  37 import org.eclipse.egit.core.test.TestProject;
  38 import org.eclipse.egit.core.test.TestRepository;
  39 import org.eclipse.jgit.util.FileUtils;
  40 import org.junit.After;
  41 import org.junit.Before;
  42 import org.junit.Test;
  43
  44 public class ProjectUtilTest extends GitTestCase {
  45
  46         private TestRepository repository;
  47
  48         private TestProject project2;
  49
  50         @Before
  51         public void setUp() throws Exception {
  52                 super.setUp();
  53                 repository = new TestRepository(gitDir);
  54         }
  55
  56         @After
  57         public void tearDown() throws Exception {
  58                 super.tearDown();
  59                 if (project2 != null)
  60                         project2.dispose();
  61         }
  62
  63         @Test
  64         public void testGetValidOpenProjects() throws Exception {
  65                 IProject[] projects = ProjectUtil.getValidOpenProjects(repository
  66                                 .getRepository());
  67                 assertEquals(1, projects.length);
  68                 IProject p = projects[0];
  69                 assertEquals("Project-1", p.getDescription().getName());
  70         }
  71
  72         @Test
  73         public void testGetProjectsContains() throws Exception {
  74                 TestProject prj2 = new TestProject(true, "Project-1-sub");
  75
  76                 try {
  77                         repository.createFile(project.getProject(), "xxx");
  78                         repository.createFile(project.getProject(), "zzz");
  79                         repository.createFile(prj2.getProject(), "zzz");
  80
  81                         project.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
  82                         prj2.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
  83
  84                         IProject[] projectsContaining = ProjectUtil.getProjectsContaining(
  85                                         repository.getRepository(),
  86                                         Collections.singleton("Project-1/xxx"));
  87                         IProject[] projectsEmpty = ProjectUtil.getProjectsContaining(
  88                                         repository.getRepository(), Collections.singleton("yyy"));
  89                         IProject[] projectSelf = ProjectUtil.getProjectsContaining(
  90                                         repository.getRepository(),
  91                                         Collections.singleton("Project-1"));
  92                         Set<String> files = new TreeSet<String>();
  93                         files.add("Project-1/xxx");
  94                         files.add("Project-1/zzz");
  95                         IProject[] multiFile = ProjectUtil.getProjectsContaining(
  96                                         repository.getRepository(), files);
  97
  98                         files.clear();
  99                         files.add("Project-1/xxx");
 100                         files.add("Project-1-sub/zzz");
 101                         IProject[] multiProject = ProjectUtil.getProjectsContaining(
 102                                         repository.getRepository(), files);
 103                         IProject[] nonExistProject = ProjectUtil.getProjectsContaining(
 104                                         repository.getRepository(),
 105                                         Collections.singleton("Project-2"));
 106
 107                         assertEquals(1, projectsContaining.length);
 108                         assertEquals(0, projectsEmpty.length);
 109                         assertEquals(1, projectSelf.length);
 110                         assertEquals(1, multiFile.length);
 111                         assertEquals(2, multiProject.length);
 112                         assertEquals(0, nonExistProject.length);
 113
 114                         IProject p = projectsContaining[0];
 115                         assertEquals("Project-1", p.getDescription().getName());
 116                 } finally {
 117                         prj2.dispose();
 118                 }
 119         }
 120
 121         @Test
 122         public void testGetNestedProjectsContains() throws Exception {
 123                 TestProject prj2 = new TestProject(true, "Project-1/dir/Project-1-sub");
 124
 125                 try {
 126                         repository.createFile(project.getProject(), "xxx");
 127                         repository.createFile(project.getProject(), "zzz");
 128                         repository.createFile(prj2.getProject(), "zzz");
 129
 130                         project.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
 131                         prj2.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
 132
 133                         IProject[] projectsContaining = ProjectUtil.getProjectsContaining(
 134                                         repository.getRepository(),
 135                                         Collections.singleton("Project-1/xxx"));
 136                         IProject[] projectsEmpty = ProjectUtil.getProjectsContaining(
 137                                         repository.getRepository(), Collections.singleton("yyy"));
 138                         IProject[] projectSelf = ProjectUtil.getProjectsContaining(
 139                                         repository.getRepository(),
 140                                         Collections.singleton("Project-1"));
 141                         Set<String> files = new TreeSet<String>();
 142                         files.add("Project-1/xxx");
 143                         files.add("Project-1/zzz");
 144                         IProject[] multiFile = ProjectUtil.getProjectsContaining(
 145                                         repository.getRepository(), files);
 146
 147                         files.clear();
 148                         files.add("Project-1/dir/Project-1-sub/zzz");
 149                         files.add("Project-1/xxx");
 150                         IProject[] multiProject = ProjectUtil.getProjectsContaining(
 151                                         repository.getRepository(), files);
 152                         IProject[] nonExistProject = ProjectUtil.getProjectsContaining(
 153                                         repository.getRepository(),
 154                                         Collections.singleton("Project-2"));
 155
 156                         assertEquals(1, projectsContaining.length);
 157                         assertEquals(0, projectsEmpty.length);
 158                         assertEquals(1, projectSelf.length);
 159                         assertEquals(1, multiFile.length);
 160                         assertEquals(2, multiProject.length);
 161                         assertEquals(0, nonExistProject.length);
 162
 163                         IProject p = projectsContaining[0];
 164                         assertEquals("Project-1", p.getDescription().getName());
 165                 } finally {
 166                         prj2.dispose();
 167                 }
 168         }
 169
 170         @Test
 171         public void testFindContainer() throws Exception {
 172                 File tmp = new File("/tmp/file");
 173                 File test1 = new File(project.getProject().getLocation().toFile(), "xxx");
 174                 File test2 = new File(repository.getRepository().getWorkTree(), "xxx");
 175
 176                 assertNull(ProjectUtil.findContainer(tmp));
 177                 assertEquals(project.getProject(), ProjectUtil.findContainer(test1));
 178                 assertEquals(ResourcesPlugin.getWorkspace().getRoot(), ProjectUtil.findContainer(test2));
 179         }
 180
 181         @Test
 182         public void testGetValidOpenProjectsClosedProject() throws Exception {
 183                 project.getProject().close(new NullProgressMonitor());
 184                 IProject[] projects = ProjectUtil.getValidOpenProjects(repository
 185                                 .getRepository());
 186                 assertEquals(0, projects.length);
 187         }
 188
 189         @Test
 190         public void testRefreshValidProjects() throws Exception {
 191                 IProject p = mock(IProject.class);
 192                 when(p.getLocation()).thenReturn(project.getProject().getLocation());
 193                 IProject[] projects = new IProject[1];
 194                 projects[0] = p;
 195                 ProjectUtil.refreshValidProjects(projects, new NullProgressMonitor());
 196                 verify(p).refreshLocal(eq(IResource.DEPTH_INFINITE),
 197                                 any(IProgressMonitor.class));
 198         }
 199
 200         @Test
 201         public void testCloseMissingProject() throws Exception {
 202                 IProject p = mock(IProject.class);
 203                 File projectFile = project.getProject().getLocation()
 204                                 .append(".project").toFile();
 205                 FileUtils.delete(projectFile);
 206                 ProjectUtil.closeMissingProject(p, projectFile,
 207                                 new NullProgressMonitor());
 208                 verify(p).close(any(IProgressMonitor.class));
 209         }
 210
 211         @Test
 212         public void testRefreshResource() throws Exception {
 213                 IResource r = mock(IResource.class);
 214                 IResource[] resources = new IResource[1];
 215                 resources[0] = r;
 216                 ProjectUtil.refreshResources(resources, new NullProgressMonitor());
 217                 verify(r).refreshLocal(eq(IResource.DEPTH_INFINITE),
 218                                 any(IProgressMonitor.class));
 219         }
 220
 221         @Test
 222         public void testGetProjectsUnconnected() throws Exception {
 223                 IProject[] projects = ProjectUtil.getProjects(repository
 224                                 .getRepository());
 225                 assertEquals(0, projects.length);
 226         }
 227
 228         @Test
 229         public void testGetProjects() throws Exception {
 230                 ConnectProviderOperation operation = new ConnectProviderOperation(
 231                                 project.getProject(), gitDir);
 232                 operation.execute(null);
 233                 IProject[] projects = ProjectUtil.getProjects(repository
 234                                 .getRepository());
 235                 assertEquals(1, projects.length);
 236                 IProject p = projects[0];
 237                 assertEquals("Project-1", p.getDescription().getName());
 238         }
 239
 240         @Test
 241         public void testFindProjectFiles() {
 242                 Collection<File> files = new ArrayList<File>();
 243                 assertTrue(ProjectUtil.findProjectFiles(files, gitDir.getParentFile(),
 244                                 null, new NullProgressMonitor()));
 245         }
 246
 247         @Test
 248         public void testFindProjectFilesNullDir() {
 249                 Collection<File> files = new ArrayList<File>();
 250                 assertFalse(ProjectUtil.findProjectFiles(files, null, null,
 251                                 new NullProgressMonitor()));
 252         }
 253
 254         @Test
 255         public void testFindProjectFilesEmptyDir() throws Exception {
 256                 Collection<File> files = new ArrayList<File>();
 257                 File dir = new File(gitDir.getParentFile().getPath() + File.separator
 258                                 + "xxx");
 259                 FileUtils.mkdir(dir);
 260                 assertFalse(ProjectUtil.findProjectFiles(files, dir, null,
 261                                 new NullProgressMonitor()));
 262         }
 263
 264         @Test
 265         public void testFindProjectFilesNested() throws Exception {
 266                 project2 = new TestProject(true, "Project-1/Project-Nested");
 267                 File workingDir = gitDir.getParentFile();
 268
 269                 Collection<File> foundFiles = new ArrayList<File>();
 270                 boolean found = ProjectUtil.findProjectFiles(foundFiles, workingDir,
 271                                 null, new NullProgressMonitor());
 272
 273                 assertTrue("Expected to find projects", found);
 274                 assertThat(foundFiles, hasItem(new File(workingDir, "Project-1/.project")));
 275                 assertThat(foundFiles, hasItem(new File(workingDir, "Project-1/Project-Nested/.project")));
 276         }
 277 }