ClasspathBuilderTest.java

/*******************************************************************************
 * Copyright (c) 2012-2017 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.plugin.java.plain.server.projecttype;

import org.eclipse.che.jdt.core.launching.JREContainerInitializer;
import org.eclipse.che.plugin.java.plain.server.BaseTest;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.testng.MockitoTestNGListener;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import static java.util.Arrays.asList;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.testng.Assert.assertEquals;

/**
 * @author Valeriy Svydenko
 */
@Listeners(value = {MockitoTestNGListener.class})
public class ClasspathBuilderTest extends BaseTest {
    private final static String SOURCE_FOLDER1 = "/src1";
    private final static String SOURCE_FOLDER2 = "/src/src2";
    private final static String LIBRARY        = "/projects/lib/lib1";

    @InjectMocks
    private ClasspathBuilder classpathBuilder;

    @Mock
    private IJavaProject iJavaProject;
    @Mock
    private IProject     iProject;

    private List<String> sourceFolders;
    private List<String> library;

    @BeforeMethod
    public void setUp() throws Exception {
        sourceFolders = new ArrayList<>();
        library = new ArrayList<>();

        when(iJavaProject.getProject()).thenReturn(iProject);
    }

    @Test
    public void classpathShouldBeUpdatedOnlyWithJREContainer() throws Exception {
        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        ArgumentCaptor<IClasspathEntry[]> classpathEntries = ArgumentCaptor.forClass(IClasspathEntry[].class);
        verify(iJavaProject).setRawClasspath(classpathEntries.capture(), eq(null));

        assertEquals(1, classpathEntries.getValue().length);
        assertEquals(new Path(JREContainerInitializer.JRE_CONTAINER), classpathEntries.getValue()[0].getPath());
    }

    @Test
    public void sourceFoldersShouldBeAddedToClasspath() throws Exception {
        IFolder sourceFolder1 = mock(IFolder.class);
        IFolder sourceFolder2 = mock(IFolder.class);

        when(iProject.getFolder(SOURCE_FOLDER1)).thenReturn(sourceFolder1);
        when(iProject.getFolder(SOURCE_FOLDER2)).thenReturn(sourceFolder2);
        when(sourceFolder1.exists()).thenReturn(true);
        when(sourceFolder1.getFullPath()).thenReturn(new Path(SOURCE_FOLDER1));
        when(sourceFolder2.exists()).thenReturn(true);
        when(sourceFolder2.getFullPath()).thenReturn(new Path(SOURCE_FOLDER2));

        sourceFolders.add(SOURCE_FOLDER1);
        sourceFolders.add(SOURCE_FOLDER2);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        verify(iProject, times(2)).getFolder(anyString());

        ArgumentCaptor<IClasspathEntry[]> classpathEntriesCapture = ArgumentCaptor.forClass(IClasspathEntry[].class);
        verify(iJavaProject).setRawClasspath(classpathEntriesCapture.capture(), eq(null));

        List<IClasspathEntry> classpathEntries = asList(classpathEntriesCapture.getValue());
        assertEquals(3, classpathEntries.size());
        assertThat(classpathEntries).onProperty("path").containsOnly(new Path(JREContainerInitializer.JRE_CONTAINER),
                                                                     new Path(SOURCE_FOLDER1),
                                                                     new Path(SOURCE_FOLDER2));
    }

    @Test
    public void folderShouldNotBeAddedToClasspathIfItNotExist() throws Exception {
        IFolder sourceFolder1 = mock(IFolder.class);

        when(iProject.getFolder(SOURCE_FOLDER1)).thenReturn(sourceFolder1);
        when(sourceFolder1.exists()).thenReturn(false);

        sourceFolders.add(SOURCE_FOLDER1);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        verify(iProject).getFolder(anyString());

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void libraryFolderShouldNotBeAddedIfListOfLibrariesIsNull() throws Exception {
        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, null);

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void libraryFolderShouldNotBeAddedIfItIsEmpty() throws Exception {
        library.add("");

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void libraryFolderShouldNotBeAddedIfItIsNotExist() throws Exception {
        library.add(LIBRARY);
        IFolder libraryFolder1 = mock(IFolder.class);

        when(iProject.getFolder(LIBRARY)).thenReturn(libraryFolder1);
        when(libraryFolder1.exists()).thenReturn(false);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void elementShouldNotBeAddedAsLibToClasspathIfItIsFolder() throws Exception {
        library.add(LIBRARY);
        IFolder libraryFolder1 = mock(IFolder.class);
        IResourceProxy iResourceProxy = mock(IResourceProxy.class);

        when(iProject.getFolder(LIBRARY)).thenReturn(libraryFolder1);
        when(libraryFolder1.exists()).thenReturn(true);
        when(iResourceProxy.getType()).thenReturn(IResource.FOLDER);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        ArgumentCaptor<IResourceProxyVisitor> resourceProxyVisitorArgumentCaptor = ArgumentCaptor.forClass(IResourceProxyVisitor.class);
        verify(libraryFolder1).accept(resourceProxyVisitorArgumentCaptor.capture(), eq(IContainer.INCLUDE_PHANTOMS));

        resourceProxyVisitorArgumentCaptor.getValue().visit(iResourceProxy);
        verify(iResourceProxy).getType();

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void elementShouldNotBeAddedAsLibToClasspathIfItIsNotJar() throws Exception {
        library.add(LIBRARY);
        IFolder libraryFolder1 = mock(IFolder.class);
        IResourceProxy iResourceProxy = mock(IResourceProxy.class);

        when(iProject.getFolder(LIBRARY)).thenReturn(libraryFolder1);
        when(libraryFolder1.exists()).thenReturn(true);
        when(iResourceProxy.getType()).thenReturn(IResource.FILE);
        when(iResourceProxy.requestFullPath()).thenReturn(new Path(LIBRARY));

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        ArgumentCaptor<IResourceProxyVisitor> resourceProxyVisitorArgumentCaptor = ArgumentCaptor.forClass(IResourceProxyVisitor.class);
        verify(libraryFolder1).accept(resourceProxyVisitorArgumentCaptor.capture(), eq(IContainer.INCLUDE_PHANTOMS));

        resourceProxyVisitorArgumentCaptor.getValue().visit(iResourceProxy);
        verify(iResourceProxy).getType();

        verifyIfOnlyJREContainerInClasspath();
    }

    @Test
    public void elementShouldBeAddedAsLibToClasspathFromLibFolder() throws Exception {
        Path jarPath = new Path(LIBRARY + "/a.jar");

        library.add(LIBRARY);
        IFolder libraryFolder1 = mock(IFolder.class);
        IResourceProxy iResourceProxy = mock(IResourceProxy.class);
        IResource iResource = mock(IResource.class);

        when(iProject.getFolder(LIBRARY)).thenReturn(libraryFolder1);
        when(libraryFolder1.exists()).thenReturn(true);
        when(iResourceProxy.getType()).thenReturn(IResource.FILE);
        when(iResourceProxy.requestFullPath()).thenReturn(jarPath);
        when(iResourceProxy.requestResource()).thenReturn(iResource);
        when(iResource.getLocation()).thenReturn(jarPath);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        ArgumentCaptor<IResourceProxyVisitor> resourceProxyVisitorArgumentCaptor = ArgumentCaptor.forClass(IResourceProxyVisitor.class);
        verify(libraryFolder1).accept(resourceProxyVisitorArgumentCaptor.capture(), eq(IContainer.INCLUDE_PHANTOMS));

        resourceProxyVisitorArgumentCaptor.getValue().visit(iResourceProxy);
        verify(iResourceProxy).getType();

        assertEquals(jarPath, iResource.getLocation());
    }

    @Test
    public void rawClasspathShouldBeContained3Arguments() throws Exception {
        createTestProject();

        library.add("/lib");
        sourceFolders.add("/src");

        IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject("/project");
        IJavaProject iJavaProject = JavaCore.create(project);

        classpathBuilder.generateClasspath(iJavaProject, sourceFolders, library);

        List<IClasspathEntry> classpathEntries = Arrays.asList(iJavaProject.getRawClasspath());
        assertThat(classpathEntries).onProperty("path").containsOnly(new Path(JREContainerInitializer.JRE_CONTAINER),
                                                                     new Path("/project/src"),
                                                                     new Path(root + "/project/lib/a.jar"));
    }

    private void verifyIfOnlyJREContainerInClasspath() throws JavaModelException {
        ArgumentCaptor<IClasspathEntry[]> classpathEntriesCapture = ArgumentCaptor.forClass(IClasspathEntry[].class);
        verify(iJavaProject).setRawClasspath(classpathEntriesCapture.capture(), eq(null));

        List<IClasspathEntry> classpathEntries = asList(classpathEntriesCapture.getValue());

        assertEquals(1, classpathEntries.size());
        assertThat(classpathEntries).onProperty("path").containsOnly(new Path(JREContainerInitializer.JRE_CONTAINER));
    }

}