org.eclipse.egit.core.test.MergeWithPreferredStrategyTest.java Source code

Introduction

Here is the source code for org.eclipse.egit.core.test.MergeWithPreferredStrategyTest.java

Source

/*******************************************************************************
 * Copyright (C) 2015 Obeo and others.
 *
 * 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
 *******************************************************************************/
package org.eclipse.egit.core.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.util.Iterator;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.egit.core.Activator;
import org.eclipse.egit.core.GitCorePreferences;
import org.eclipse.egit.core.op.MergeOperation;
import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.LogCommand;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.merge.MergeStrategy;
import org.eclipse.jgit.revwalk.RevCommit;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * This makes sure that the preferred merge strategy chosen bu the user ni the
 * preferences is actually used by MergeOperations to do its job.
 */
public class MergeWithPreferredStrategyTest extends GitTestCase {

    private static final String MASTER = Constants.R_HEADS + Constants.MASTER;

    private static final String SIDE = Constants.R_HEADS + "side";

    private TestRepository testRepository;

    private File file2;

    private File file3;

    /**
     * Sets the preference "preferred merge strategy" to "ours", so that the
     * MergeStrategy that will be used by any operation that needs a merge will
     * be the {@link MergeStrategy#OURS}.
     */
    @Override
    @Before
    public void setUp() throws Exception {
        super.setUp();
        InstanceScope.INSTANCE.getNode(Activator.getPluginId()).put(GitCorePreferences.core_preferredMergeStrategy,
                "ours");
        gitDir = new File(project.getProject().getLocationURI().getPath(), Constants.DOT_GIT);
        testRepository = new TestRepository(gitDir);
        testRepository.connect(project.getProject());

        File file1 = testRepository.createFile(project.getProject(), "file1-1");
        testRepository.addAndCommit(project.getProject(), file1, "master commit 1");
        testRepository.createBranch(MASTER, SIDE);
        file2 = testRepository.createFile(project.getProject(), "file2");
        testRepository.appendFileContent(file2, "Content 2");
        testRepository.addAndCommit(project.getProject(), file2, "master commit 2");
        testRepository.checkoutBranch(SIDE);
        file3 = testRepository.createFile(project.getProject(), "file3");
        testRepository.appendFileContent(file3, "Content 3");
        testRepository.addAndCommit(project.getProject(), file3, "side commit 3");
        testRepository.checkoutBranch(MASTER);
    }

    /**
     * Removes any preference about preferred merge strategy after any test.
     */
    @Override
    @After
    public void tearDown() throws Exception {
        super.tearDown();
        InstanceScope.INSTANCE.getNode(Activator.getPluginId())
                .remove(GitCorePreferences.core_preferredMergeStrategy);
    }

    @Test
    public void testMergeUsesPreferredStrategy() throws Exception {
        MergeOperation operation = new MergeOperation(testRepository.getRepository(), SIDE);
        operation.execute(new NullProgressMonitor());

        // With the MergeStrategy OURS, new files from branch 'side' should be
        // ignored and new files from branch 'master' should be present
        assertEquals(4, countCommitsInHead());
        assertTrue(testRepository.getIFile(project.getProject(), file2).exists());
        assertFalse(testRepository.getIFile(project.getProject(), file3).exists());
    }

    @Test
    public void testMergeUsesPreferredStrategyRegisteredWithExplicitName() throws Exception {
        InstanceScope.INSTANCE.getNode(Activator.getPluginId()).put(GitCorePreferences.core_preferredMergeStrategy,
                "org.eclipse.egit.core.test.theirs");
        MergeOperation operation = new MergeOperation(testRepository.getRepository(), SIDE);
        operation.execute(new NullProgressMonitor());

        // With the MergeStrategy THEIRS, new files from branch 'master' should
        // be ignored and new files from branch 'side' should be present
        assertEquals(4, countCommitsInHead());
        assertFalse(testRepository.getIFile(project.getProject(), file2).exists());
        assertTrue(testRepository.getIFile(project.getProject(), file3).exists());
    }

    @Test
    public void testStrategyCanBeOverridden() throws Exception {
        MergeOperation operation = new MergeOperation(testRepository.getRepository(), SIDE, "recursive");
        operation.execute(new NullProgressMonitor());

        // With the MergeStrategy RECURSIVE, new files from branch 'master' and
        // 'side' should be present
        assertEquals(4, countCommitsInHead());
        assertTrue(testRepository.getIFile(project.getProject(), file2).exists());
        assertTrue(testRepository.getIFile(project.getProject(), file3).exists());
    }

    private int countCommitsInHead() throws GitAPIException {
        try (Git git = new Git(testRepository.getRepository())) {
            LogCommand log = git.log();
            Iterable<RevCommit> commits = log.call();
            int result = 0;
            for (Iterator i = commits.iterator(); i.hasNext();) {
                i.next();
                result++;
            }
            return result;
        }
    }
}