ConfigurePdsProjectTest.java

package com.proalpha.pds.projconf;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
 
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import com.atlassian.connector.eclipse.internal.jira.core.JiraCorePlugin;
import com.proalpha.pds.projconf.configure.ConfigurePdsProject;
import com.proalpha.pds.projconf.importwizards.ReadDemasFile;
 
public class ConfigurePdsProjectTest {
 
    private static final Logger logger = LoggerFactory.getLogger(ConfigurePdsProjectTest.class);
    
    private static final String RES_DIR = System.getProperty("user.dir") + "\\test\\resources";
    private ConfigurePdsProject testProject;
    private ReadDemasFile propertiesFile;
 
    @Before
    public void setUp() {
 
        propertiesFile = new ReadDemasFile(RES_DIR + "\\PDSconfig.properties");
        testProject = new ConfigurePdsProject(propertiesFile);
    }
 
    @After
    public void tearDown() {
        testProject = null;
    }
 
    @Test
    public void test() {
        try {
            testProject.installPaProject(new NullProgressMonitor());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            fail(e.toString());
        }
 
        List<IProject> projects = Arrays.asList(ResourcesPlugin.getWorkspace().getRoot().getProjects());
 
        for (IProject p : projects) {
            System.out.println(p.getName());
            if (p.getName().equals("proalpha-de-72b00-dev")) {
                assertEquals("proalpha-de-72b00-dev", p.getName());
                return;
            }
        }
    }
 
    @Test
    public void checkRepositoryUrlIsSet() throws CoreException, IOException {
        testProject.configureMylyn("https://jira.proalpha.com", "proAlpha", propertiesFile.getJiraProject(),
                "Mir zugewiesene Vorgänge");
 
        @SuppressWarnings("restriction")
        Set<TaskRepository> repositories = TasksUi.getRepositoryManager()
                .getRepositories(JiraCorePlugin.CONNECTOR_KIND);
 
        Set<String> repositoryUrlSet = new HashSet<String>();
 
        for (TaskRepository taskRepository : repositories) {
            repositoryUrlSet.add(taskRepository.getRepositoryUrl());
        }
 
        String expected = "https://jira.proalpha.com";
        assertTrue(repositoryUrlSet.contains(expected));
    }
 
    @Test
    public void checkRepositoryLabelIsSet() throws CoreException, IOException {
        testProject.configureMylyn(propertiesFile.getJiraUrl(), "proAlpha", "proALPHA JIRA",
                "Mir zugewiesene Vorgänge");
 
        @SuppressWarnings("restriction")
        Set<TaskRepository> repositories = TasksUi.getRepositoryManager()
                .getRepositories(JiraCorePlugin.CONNECTOR_KIND);
 
        Set<String> repositoryLabelSet = new HashSet<String>();
 
        for (TaskRepository taskRepository : repositories) {
            repositoryLabelSet.add(taskRepository.getRepositoryLabel());
        }
 
        String expected = "proALPHA JIRA";
        assertTrue(repositoryLabelSet.contains(expected));
    }
 
    @Test
    public void checkRepositoryCategoryIsSet() {
        testProject.configureMylyn(propertiesFile.getJiraUrl(), "proAlpha", propertiesFile.getJiraProject(),
                "Mir zugewiesene Vorgänge");
 
        @SuppressWarnings("restriction")
        Set<TaskRepository> repositories = TasksUi.getRepositoryManager()
                .getRepositories(JiraCorePlugin.CONNECTOR_KIND);
 
        Set<String> repositoryCategorySet = new HashSet<String>();
 
        for (TaskRepository taskRepository : repositories) {
            repositoryCategorySet.add(taskRepository.getCategory());
        }
 
        String expected = "proAlpha";
        assertTrue(repositoryCategorySet.contains(expected));
    }
 
    @Test
    public void checkRepositoryCredentialsAreSet() {
        testProject.configureMylyn(propertiesFile.getJiraUrl(), "proAlpha", propertiesFile.getJiraProject(),
                "Mir zugewiesene Vorgänge");
 
        @SuppressWarnings("restriction")
        Set<TaskRepository> repositories = TasksUi.getRepositoryManager()
                .getRepositories(JiraCorePlugin.CONNECTOR_KIND);
 
        Set<AuthenticationCredentials> credentialsSet = new HashSet<AuthenticationCredentials>();
 
        for (TaskRepository taskRepository : repositories) {
            credentialsSet.add(taskRepository.getCredentials(AuthenticationType.REPOSITORY));
        }
 
        String expectedUsername = "";
        String expectedPassword = "";
 
        if (credentialsSet.size() != 1) {
            fail("There must be only one authentication credentials set!");
        }
 
        for (AuthenticationCredentials authenticationCredentials : credentialsSet) {
            assertEquals(expectedUsername, authenticationCredentials.getUserName());
            assertEquals(expectedPassword, authenticationCredentials.getPassword());
        }
 
    }
 
    @SuppressWarnings("restriction")
    @Test
    public void checkRepositoryIsAdded() {
        String repositoryUrl = "https://jira.proalpha.com";
        String category = "proAlpha";
        String repositorySummary = "Mir zugewiesene Vorgänge";
        testProject.configureMylyn(repositoryUrl, category, propertiesFile.getJiraProject(),
                repositorySummary);
 
        TaskRepository expected = new TaskRepository(JiraCorePlugin.CONNECTOR_KIND, repositoryUrl);
        expected.setCategory(category);
        expected.setRepositoryLabel(propertiesFile.getJiraProject());
        expected.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("", ""), true);
 
        TasksUi.getRepositoryManager().addRepository(expected);
 
        Set<TaskRepository> repositories = TasksUi.getRepositoryManager()
                .getRepositories(JiraCorePlugin.CONNECTOR_KIND);
 
        for (TaskRepository actual : repositories) {
            assertEquals(expected, actual);
        }
    }
 
    @Test
    public void checkRepositoryIsAddedOnlyOnce() {
        String category = "proAlpha";
        String repositorySummary = "Mir zugewiesene Vorgänge";
        testProject.configureMylyn(propertiesFile.getJiraUrl(), category, propertiesFile.getJiraProject(),
                repositorySummary);
 
        @SuppressWarnings("restriction")
        TaskRepository expected = new TaskRepository(JiraCorePlugin.CONNECTOR_KIND, propertiesFile.getJiraUrl());
        expected.setCategory(category);
        expected.setRepositoryLabel(propertiesFile.getJiraProject());
        expected.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("", ""), true);
 
        TasksUi.getRepositoryManager().addRepository(expected);
        TasksUi.getRepositoryManager().addRepository(expected);
 
        List<TaskRepository> repositories = TasksUi.getRepositoryManager().getAllRepositories();
 
        int repositoryCounter = 0;
 
        for (TaskRepository actual : repositories) {
            if (actual.getUrl() == propertiesFile.getJiraUrl()) {
                repositoryCounter++;
            }
        }
 
        int expectedRepositoryCounter = 1;
 
        assertEquals(expectedRepositoryCounter, repositoryCounter);
    }
 
    @SuppressWarnings("restriction")
    @Test
    public void checkRepositoryQueryAddedMoreThenOnceThrowsException() {
        String category = "proAlpha";
        String repositorySummary = "Mir zugewiesene Vorgänge";
        testProject.configureMylyn(propertiesFile.getJiraUrl(), category, propertiesFile.getJiraProject(),
                repositorySummary);
 
        TaskRepository repository = new TaskRepository(JiraCorePlugin.CONNECTOR_KIND, propertiesFile.getJiraUrl());
        repository.setCategory(category);
        repository.setRepositoryLabel(propertiesFile.getJiraProject());
        repository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("", ""), true);
        TasksUi.getRepositoryManager().addRepository(repository);
 
        RepositoryQuery repQuery = (RepositoryQuery) TasksUi.getRepositoryModel().createRepositoryQuery(repository);
        repQuery.setSummary(repositorySummary);
        TasksUiPlugin.getTaskList().addQuery(repQuery);
 
        try {
            TasksUiPlugin.getTaskList().addQuery(repQuery);
        } catch (Exception actual) {
            assertTrue(actual instanceof IllegalArgumentException);
        }
    }
 
    @SuppressWarnings("restriction")
    @Test
    public void checkRepositoryQuerySummaryIsSet() {
        String category = "proAlpha";
        String expected = "Mir zugewiesene Vorgänge";
        testProject.configureMylyn(propertiesFile.getJiraUrl(), category, propertiesFile.getJiraProject(),
                expected);
 
        TaskRepository repository = new TaskRepository(JiraCorePlugin.CONNECTOR_KIND, propertiesFile.getJiraUrl());
        repository.setCategory(category);
        repository.setRepositoryLabel(propertiesFile.getJiraProject());
        repository.setCredentials(AuthenticationType.REPOSITORY, new AuthenticationCredentials("", ""), true);
        TasksUi.getRepositoryManager().addRepository(repository);
 
        RepositoryQuery repQuery = (RepositoryQuery) TasksUi.getRepositoryModel().createRepositoryQuery(repository);
        repQuery.setSummary(expected);
        TasksUiPlugin.getTaskList().addQuery(repQuery);
 
        Set<RepositoryQuery> repQueries = TasksUiPlugin.getTaskList().getRepositoryQueries(propertiesFile.getJiraUrl());
 
        for (RepositoryQuery repositoryQuery : repQueries) {
            assertEquals(expected, repositoryQuery.getSummary());
        }
    }
 
}