Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorTim Neumann2019-09-18 09:14:54 +0000
committerThomas Wolf2019-11-11 22:28:59 +0000
commit16f145f4a8b8a76331e8d2c94fce4bdf01e777a5 (patch)
treeb79846c0d0095f68cee6648bba5d475f68dc12eb /org.eclipse.egit.ui.test/src
parent558a1bc2de76751caef2aec724fc6f5aeade51f6 (diff)
downloadegit-16f145f4a8b8a76331e8d2c94fce4bdf01e777a5.tar.gz
egit-16f145f4a8b8a76331e8d2c94fce4bdf01e777a5.tar.xz
egit-16f145f4a8b8a76331e8d2c94fce4bdf01e777a5.zip
GitHistoryView: Add ability to select refs to show
This commit adds: * Helper class to manage ref filter preferences (repo specific) * Changes to MenuBar * New Dialog to configure Ref filters * Fixes for existing tests, which were broken by this change * New tests for the new features CQ: 21056 Bug: 381520 Change-Id: I5e2eb4daa843e91ca120da45c09482e5ba82a6af Signed-off-by: Tim Neumann <Tim.Neumann@advantest.com>
Diffstat (limited to 'org.eclipse.egit.ui.test/src')
-rw-r--r--org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/LocalRepositoryTestCase.java25
-rw-r--r--org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/GitHistoryRefFilterConfigurationDialogTest.java755
-rw-r--r--org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/HistoryViewTest.java390
-rw-r--r--org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterHelperTest.java697
-rw-r--r--org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterUtil.java74
5 files changed, 1908 insertions, 33 deletions
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/LocalRepositoryTestCase.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/LocalRepositoryTestCase.java
index e3a6abfe61..acdafde08c 100644
--- a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/LocalRepositoryTestCase.java
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/LocalRepositoryTestCase.java
@@ -142,6 +142,8 @@ public abstract class LocalRepositoryTestCase extends EGitTestCase {
protected static final String REPO2 = "RemoteRepository";
+ protected static final String REMOTE_REPO_SIMPLE = "SimpleRemoteRepository";
+
protected static final String CHILDREPO = "ChildRepository";
/** A general project containing FOLDER containing FILE1 and FILE2 */
@@ -485,6 +487,29 @@ public abstract class LocalRepositoryTestCase extends EGitTestCase {
return mapping;
}
+ protected File createSimpleRemoteRepository(File repositoryDir)
+ throws Exception {
+ Repository myRepository = lookupRepository(repositoryDir);
+ File gitDir = new File(testDirectory, REMOTE_REPO_SIMPLE);
+ Repository myRemoteRepository = FileRepositoryBuilder.create(gitDir);
+ myRemoteRepository.create(true);
+ // double-check that this is bare
+ assertTrue(myRemoteRepository.isBare());
+
+ // now we configure the remote
+ myRepository.getConfig().setString("remote", "origin", "url",
+ "file:///" + myRemoteRepository.getDirectory().getPath());
+ myRepository.getConfig().setString("remote", "origin", "fetch",
+ "+refs/heads/*:refs/remotes/origin/*");
+ myRepository.getConfig().save();
+
+ // and push
+ PushOperationUI pa = new PushOperationUI(myRepository, "origin", false);
+ pa.execute(null);
+
+ return myRemoteRepository.getDirectory();
+ }
+
protected File createRemoteRepository(File repositoryDir)
throws Exception {
Repository myRepository = lookupRepository(repositoryDir);
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/GitHistoryRefFilterConfigurationDialogTest.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/GitHistoryRefFilterConfigurationDialogTest.java
new file mode 100644
index 0000000000..954013d12d
--- /dev/null
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/GitHistoryRefFilterConfigurationDialogTest.java
@@ -0,0 +1,755 @@
+/*******************************************************************************
+ * Copyright (C) 2019, Tim Neumann <Tim.Neumann@advantest.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.egit.ui.test.history;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.Mockito.doAnswer;
+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 java.io.File;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.eclipse.egit.core.RepositoryUtil;
+import org.eclipse.egit.ui.Activator;
+import org.eclipse.egit.ui.common.LocalRepositoryTestCase;
+import org.eclipse.egit.ui.internal.UIText;
+import org.eclipse.egit.ui.internal.history.GitHistoryRefFilterConfigurationDialog;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper.RefFilter;
+import org.eclipse.egit.ui.view.repositories.GitRepositoriesViewTestUtils;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.resource.JFaceResources;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotButton;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTableItem;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
+import org.eclipse.ui.PlatformUI;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+@RunWith(SWTBotJunit4ClassRunner.class)
+public class GitHistoryRefFilterConfigurationDialogTest
+ extends LocalRepositoryTestCase {
+ private Display display;
+
+ private Repository repo;
+
+ private SWTBotShell dialogBot;
+
+ private GitHistoryRefFilterConfigurationDialog dialog;
+
+ private RefFilterHelper refFilterHelper;
+
+ private GitRepositoriesViewTestUtils myRepoViewUtil;
+
+ private RefFilter newRefFilter(String filterString, boolean preConfigured,
+ boolean selected) {
+ return RefFilterUtil.newRefFilter(refFilterHelper, filterString,
+ preConfigured, selected);
+ }
+
+ @Before
+ public void setupTests() throws Exception {
+ display = PlatformUI.getWorkbench().getDisplay();
+
+ myRepoViewUtil = new GitRepositoriesViewTestUtils();
+ File repoFile = createProjectAndCommitToRepository();
+
+ RepositoryUtil repositoryUtil = Activator.getDefault()
+ .getRepositoryUtil();
+ repositoryUtil.addConfiguredRepository(repoFile);
+
+ repo = myRepoViewUtil.lookupRepository(repoFile);
+
+ refFilterHelper = mock(RefFilterHelper.class);
+
+ List<RefFilter> testFilters = new ArrayList<>();
+ testFilters.add(newRefFilter("HEAD", true, false));
+ testFilters.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true, false));
+ testFilters.add(newRefFilter("refs/heads/**", true, true));
+ testFilters.add(newRefFilter("refs/remotes/**", true, false));
+ testFilters.add(newRefFilter("refs/tags/**", true, false));
+ testFilters.add(newRefFilter("Mock", false, false));
+ testFilters.add(newRefFilter("test", false, false));
+ testFilters.add(newRefFilter("filter", false, true));
+
+ when(refFilterHelper.getRefFilters())
+ .thenReturn(new HashSet<>(testFilters));
+
+ doAnswer(new Answer<Void>() {
+ @Override
+ public Void answer(InvocationOnMock invocation) throws Throwable {
+ Set<RefFilter> filters = invocation.getArgument(0);
+ for (RefFilter filter : filters) {
+ filter.setSelected(filter.equals(testFilters.get(0)));
+ }
+ return null;
+ }
+ }).when(refFilterHelper).selectOnlyHEAD(anySet());
+
+ doAnswer(new Answer<Void>() {
+ @Override
+ public Void answer(InvocationOnMock invocation) throws Throwable {
+ Set<RefFilter> filters = invocation.getArgument(0);
+ for (RefFilter filter : filters) {
+ filter.setSelected(filter.equals(testFilters.get(1)));
+ }
+ return null;
+ }
+ }).when(refFilterHelper).selectOnlyCurrentBranch(anySet());
+
+ doAnswer(new Answer<Void>() {
+ @Override
+ public Void answer(InvocationOnMock invocation) throws Throwable {
+ Set<RefFilter> filters = invocation.getArgument(0);
+ for (RefFilter filter : filters) {
+ filter.setSelected(filter.equals(testFilters.get(0))
+ || filter.equals(testFilters.get(2))
+ || filter.equals(testFilters.get(3))
+ || filter.equals(testFilters.get(4)));
+ }
+ return null;
+ }
+ }).when(refFilterHelper).selectExactlyAllBranchesAndTags(anySet());
+
+ List<RefFilter> defaults = new ArrayList<>();
+ defaults.add(newRefFilter("HEAD", true, true));
+ defaults.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true, false));
+ defaults.add(newRefFilter("refs/heads/**", true, false));
+ defaults.add(newRefFilter("refs/remotes/**", true, false));
+ defaults.add(newRefFilter("refs/tags/**", true, false));
+
+ when(refFilterHelper.getDefaults())
+ .thenReturn(new HashSet<>(defaults));
+
+ display.asyncExec(() -> {
+ dialog = new GitHistoryRefFilterConfigurationDialog(
+ display.getActiveShell(), repo, refFilterHelper);
+ dialog.open();
+ });
+ dialogBot = bot
+ .shell(UIText.GitHistoryPage_filterRefDialog_dialogTitle);
+ }
+
+ @After
+ public void teardown() {
+ myRepoViewUtil.dispose();
+ display.asyncExec(dialog::close);
+ }
+
+ private static class RefFilterInfo {
+ private final String filterString;
+
+ private final boolean preConfigured;
+
+ private final boolean checked;
+
+ public RefFilterInfo(String filterString, boolean preConfigured,
+ boolean checked) {
+ this.filterString = filterString;
+ this.preConfigured = preConfigured;
+ this.checked = checked;
+ }
+
+ public String getFilterString() {
+ return filterString;
+ }
+
+ public boolean isPreConfigured() {
+ return preConfigured;
+ }
+
+ public boolean isChecked() {
+ return checked;
+ }
+ }
+
+ private List<Matcher<? super RefFilter>> getRefFilterMatchersFromInfos(
+ List<RefFilterInfo> infos) {
+ return infos.stream().map(info -> newRefFilterMatcher(info))
+ .collect(Collectors.toList());
+ }
+
+ private Matcher<RefFilter> newRefFilterMatcher(RefFilterInfo info) {
+ return RefFilterUtil.newRefFilterMatcher(info.getFilterString(),
+ info.isPreConfigured(), info.isChecked());
+ }
+
+ private List<Matcher<? super SWTBotTableItem>> getTableRowMatchersFromInfos(
+ List<RefFilterInfo> infos) {
+ return infos.stream().map(info -> newTableRowMatcher(info))
+ .collect(Collectors.toList());
+ }
+
+ private Matcher<SWTBotTableItem> newTableRowMatcher(RefFilterInfo info) {
+ return newTableRowMatcher(info.getFilterString(),
+ info.isPreConfigured(), info.isChecked());
+ }
+
+ private Matcher<SWTBotTableItem> newTableRowMatcher(String text,
+ boolean preConfigured, boolean checked) {
+ return new TypeSafeMatcher<SWTBotTableItem>() {
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("A table row with ");
+ description.appendValue(text);
+ description.appendText(" which is ");
+ if (!checked) {
+ description.appendText("_not_ ");
+ }
+ description.appendText("checked");
+
+ }
+
+ private boolean matchText(String itemText) {
+ if (preConfigured) {
+ return Objects.equals(itemText,
+ text + " - (preconfigured)");
+ } else {
+ return Objects.equals(itemText, text);
+ }
+ }
+
+ @Override
+ protected boolean matchesSafely(SWTBotTableItem item) {
+ return matchText(item.getText()) && item.isChecked() == checked;
+ }
+ };
+ }
+
+ private List<SWTBotTableItem> listOfRows(SWTBotTable table) {
+ int rows = table.rowCount();
+ List<SWTBotTableItem> result = new ArrayList<>(rows);
+ for (int i = 0; i < rows; i++) {
+ result.add(table.getTableItem(i));
+ }
+ return result;
+ }
+
+ private void click(String button) {
+ SWTBotButton btn = dialogBot.bot().button(button);
+ btn.click();
+ }
+
+ private void clickOk() {
+ click(IDialogConstants.OK_LABEL);
+ }
+
+ private void clickCancel() {
+ click(IDialogConstants.CANCEL_LABEL);
+ }
+
+ @SuppressWarnings("unchecked")
+ private ArgumentCaptor<Set<RefFilter>> newRefFilterSetArgCaptor() {
+ return ArgumentCaptor.forClass(Set.class);
+ }
+
+ private void verifyTableContents(List<RefFilterInfo> expected) {
+ SWTBotTable table = dialogBot.bot().table();
+
+ assertThat("Expeceted different rows", listOfRows(table),
+ contains(getTableRowMatchersFromInfos(expected)));
+ }
+
+ private void verifyResult(List<RefFilterInfo> expected) {
+ ArgumentCaptor<Set<RefFilter>> argument = newRefFilterSetArgCaptor();
+ verify(refFilterHelper, times(1)).setRefFilters(argument.capture());
+
+ assertThat("Expected different set to be saved", argument.getValue(),
+ containsInAnyOrder(getRefFilterMatchersFromInfos(expected)));
+ }
+
+ private void verifyTableContentsClickOkAndVerifyResult(
+ List<RefFilterInfo> expected) {
+ verifyTableContents(expected);
+ clickOk();
+ verifyResult(expected);
+ }
+
+ @Test
+ public void testInitialTableContent() throws Exception {
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testCheckOne() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(0).check();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, true));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testCheckTwo() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(3).check();
+ table.getTableItem(6).check();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, true));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, true));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testUncheckOne() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(2).uncheck();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testUncheckTwo() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(2).uncheck();
+ table.getTableItem(5).uncheck();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, false));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testUncheckAndCheck() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(2).uncheck();
+ table.getTableItem(7).check();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, true));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ private Event createEvent(Control control) {
+ Event event = new Event();
+ event.keyCode = SWT.NONE;
+ event.stateMask = SWT.NONE;
+ event.doit = true;
+ event.widget = control;
+ event.button = 1;
+ return event;
+ }
+
+ private void keyEvent(Control control, int keyCode) {
+ Event event = createEvent(control);
+ event.button = 0;
+ event.type = SWT.KeyDown;
+ event.keyCode = keyCode;
+ event.character = (char) keyCode;
+
+ Display.getDefault().post(event);
+
+ event.type = SWT.KeyUp;
+
+ Display.getDefault().post(event);
+ }
+
+ private void typeTextAndEnter(String text) {
+ Control c = dialog.getShell();
+ for (int i = 0; i < text.length(); i++) {
+ keyEvent(c, text.charAt(i));
+ }
+ keyEvent(c, 13);
+ }
+
+ @Test
+ public void testAdd() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_add);
+
+ typeTextAndEnter("added");
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("added", false, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ private SWTBotTreeItem findMaster(SWTBotTreeItem[] items) {
+ for (SWTBotTreeItem item : items) {
+ if (item.getText().startsWith("master")) {
+ return item;
+ }
+ }
+
+ SWTBotTreeItem found = null;
+
+ for (SWTBotTreeItem item : items) {
+ found = findMaster(item.getItems());
+ if (found != null) {
+ return found;
+ }
+ }
+
+ return null;
+ }
+
+ @Test
+ public void testAddRef() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_addRef);
+ SWTBotShell refSelectDialogBot = bot.shell(
+ UIText.GitHistoryPage_filterRefDialog_selectRefDialog_dialogTitle);
+
+ SWTBotTree treeBot = refSelectDialogBot.bot().tree();
+ SWTBotTreeItem[] items = treeBot.getAllItems();
+
+ SWTBotTreeItem masterItem = findMaster(items);
+
+ if (masterItem == null) {
+ fail("No master branch in select ref dialog.");
+ } else {
+ masterItem.select();
+ }
+
+ refSelectDialogBot.bot().button(IDialogConstants.OK_LABEL).click();
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("refs/heads/master", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testRemove() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+ table.getTableItem(5).select();
+ click(UIText.GitHistoryPage_filterRefDialog_button_remove);
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testEdit() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+ table.getTableItem(5).select();
+ click(UIText.GitHistoryPage_filterRefDialog_button_edit);
+
+ typeTextAndEnter("edited");
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("edited", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testDoubleClick() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+ SWTBotTableItem item = table.getTableItem(5);
+ item.doubleClick();
+
+ typeTextAndEnter("edited");
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("edited", false, true));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testButtonHead() throws Exception {
+
+ click(UIText.GitHistoryPage_filterRefDialog_button_headOnly);
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, true));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, false));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testButtonCurrentBranch() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_currentBranchOnly);
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, false));
+ expected.add(new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, true));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+ expected.add(new RefFilterInfo("filter", false, false));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testButtonAllBranches() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_allBranchesAndTags);
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, true));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, true));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, true));
+ expected.add(new RefFilterInfo("refs/tags/**", true, true));
+ expected.add(new RefFilterInfo("filter", false, false));
+ expected.add(new RefFilterInfo("Mock", false, false));
+ expected.add(new RefFilterInfo("test", false, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ }
+
+ @Test
+ public void testButtonRestoreDefaults() throws Exception {
+ click(JFaceResources.getString("defaults"));
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, true));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+
+ verifyTableContents(expected);
+ verify(refFilterHelper, Mockito.never())
+ .resetLastSelectionStateToDefault();
+ }
+
+ @Test
+ public void testButtonRestoreDefaultsAndOk() throws Exception {
+ click(JFaceResources.getString("defaults"));
+
+ List<RefFilterInfo> expected = new ArrayList<>();
+ expected.add(new RefFilterInfo("HEAD", true, true));
+ expected.add(
+ new RefFilterInfo("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(new RefFilterInfo("refs/heads/**", true, false));
+ expected.add(new RefFilterInfo("refs/remotes/**", true, false));
+ expected.add(new RefFilterInfo("refs/tags/**", true, false));
+
+ verifyTableContentsClickOkAndVerifyResult(expected);
+ verify(refFilterHelper).resetLastSelectionStateToDefault();
+ }
+
+ @Test
+ public void testButtonRestoreDefaultsAndCancel() throws Exception {
+ click(JFaceResources.getString("defaults"));
+ click(IDialogConstants.CANCEL_LABEL);
+
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ verify(refFilterHelper, Mockito.never())
+ .resetLastSelectionStateToDefault();
+ }
+
+ @Test
+ public void testCancel() throws Exception {
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testCancelAfterCheck() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(0).check();
+
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testCancelAfterUncheck() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+
+ table.getTableItem(2).uncheck();
+
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testCancelAfterAdd() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_add);
+
+ typeTextAndEnter("added");
+
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testCancelAfterEdit() throws Exception {
+ SWTBotTable table = dialogBot.bot().table();
+ table.getTableItem(5).select();
+ click(UIText.GitHistoryPage_filterRefDialog_button_edit);
+
+ typeTextAndEnter("edited");
+
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+
+ @Test
+ public void testCancelAfterButtonHead() throws Exception {
+ click(UIText.GitHistoryPage_filterRefDialog_button_headOnly);
+
+ clickCancel();
+ verify(refFilterHelper, Mockito.never())
+ .setRefFilters(ArgumentMatchers.any());
+ }
+}
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/HistoryViewTest.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/HistoryViewTest.java
index 58db11f588..158862725e 100644
--- a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/HistoryViewTest.java
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/HistoryViewTest.java
@@ -13,6 +13,11 @@
package org.eclipse.egit.ui.test.history;
import static org.eclipse.swtbot.swt.finder.matchers.WidgetMatcherFactory.withRegex;
+import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
+import static org.hamcrest.Matchers.emptyArray;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
@@ -22,6 +27,9 @@ import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
@@ -34,14 +42,24 @@ import org.eclipse.egit.gitflow.op.InitOperation;
import org.eclipse.egit.ui.Activator;
import org.eclipse.egit.ui.JobFamilies;
import org.eclipse.egit.ui.internal.UIText;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper.RefFilter;
import org.eclipse.egit.ui.internal.repository.RepositoriesView;
import org.eclipse.egit.ui.test.ContextMenuHelper;
import org.eclipse.egit.ui.test.TestUtil;
import org.eclipse.egit.ui.view.repositories.GitRepositoriesViewTestBase;
import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jgit.api.CheckoutCommand;
+import org.eclipse.jgit.api.CreateBranchCommand.SetupUpstreamMode;
+import org.eclipse.jgit.api.FetchCommand;
import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.PushCommand;
+import org.eclipse.jgit.api.ResetCommand;
+import org.eclipse.jgit.api.ResetCommand.ResetType;
+import org.eclipse.jgit.api.TagCommand;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
+import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
@@ -52,17 +70,21 @@ import org.eclipse.swt.widgets.TableItem;
import org.eclipse.swtbot.eclipse.finder.widgets.SWTBotView;
import org.eclipse.swtbot.swt.finder.SWTBot;
import org.eclipse.swtbot.swt.finder.junit.SWTBotJunit4ClassRunner;
+import org.eclipse.swtbot.swt.finder.waits.DefaultCondition;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotMenu;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotShell;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTable;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTableItem;
-import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarToggleButton;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotToolbarDropDownButton;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
import org.eclipse.swtbot.swt.finder.widgets.SWTBotTreeItem;
import org.eclipse.team.ui.history.IHistoryView;
import org.eclipse.ui.PlatformUI;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
@@ -80,6 +102,8 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
private File repoFile;
+ private RefFilterHelper refFilterHelper;
+
@Before
public void setupTests() throws Exception {
repoFile = createProjectAndCommitToRepository();
@@ -89,14 +113,117 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
folder2.create(false, true, null);
IFile addedFile = folder2.getFile(ADDEDFILE);
addedFile.create(
- new ByteArrayInputStream("More content".getBytes(prj
- .getDefaultCharset())), false, null);
+ new ByteArrayInputStream(
+ "More content".getBytes(prj.getDefaultCharset())),
+ false, null);
addAndCommit(addedFile, ADDEDMESSAGE);
+
// TODO count the commits
commitCount = 3;
+
+ setupAdditionalCommits();
+
RepositoryUtil repositoryUtil = Activator.getDefault()
.getRepositoryUtil();
repositoryUtil.addConfiguredRepository(repoFile);
+
+ Repository repo = myRepoViewUtil.lookupRepository(repoFile);
+
+ refFilterHelper = new RefFilterHelper(repo);
+ refFilterHelper.setRefFilters(refFilterHelper.getDefaults());
+ refFilterHelper.resetLastSelectionStateToDefault();
+ }
+
+ private void checkout(Git git, String ref, boolean create)
+ throws Exception {
+ CheckoutCommand checkout = git.checkout();
+ checkout.setName(ref);
+ checkout.setCreateBranch(create);
+ checkout.setUpstreamMode(SetupUpstreamMode.SET_UPSTREAM);
+ checkout.call();
+ }
+
+ private void commitNewFile(String fileName, String commitMsg)
+ throws Exception {
+ IProject prj = ResourcesPlugin.getWorkspace().getRoot()
+ .getProject(PROJ1);
+ IFile toCreate = prj.getFile(fileName);
+ toCreate.create(
+ new ByteArrayInputStream(
+ "Content".getBytes(prj.getDefaultCharset())),
+ false, null);
+ addAndCommit(toCreate, commitMsg);
+ }
+
+ private static void tag(Git git, String name) throws Exception {
+ TagCommand tag = git.tag();
+ tag.setName(name);
+ PersonIdent committer = new PersonIdent(TestUtil.TESTCOMMITTER_NAME,
+ TestUtil.TESTCOMMITTER_EMAIL);
+ tag.setTagger(committer);
+ Repository repo = git.getRepository();
+ RevCommit headCommit = repo.parseCommit(
+ repo.exactRef(Constants.HEAD).getLeaf().getObjectId());
+ tag.setObjectId(headCommit);
+ tag.call();
+ }
+
+ private void resetHard(Git git, String to) throws Exception {
+ ResetCommand reset = git.reset();
+ reset.setRef(to);
+ reset.setMode(ResetType.HARD);
+ reset.call();
+ }
+
+ private void push(Git git) throws Exception {
+ PushCommand push = git.push();
+ push.setPushAll();
+ push.call();
+ }
+
+ private void fetch(Git git) throws Exception {
+ FetchCommand fetch = git.fetch();
+ fetch.call();
+ }
+
+ private void setupAdditionalCommits() throws Exception {
+ Repository repo = myRepoViewUtil.lookupRepository(repoFile);
+
+ try (Git git = Git.wrap(repo)) {
+ createSimpleRemoteRepository(repoFile);
+
+ checkout(git, "master", false);
+ checkout(git, "testR", true);
+ commitNewFile("testR.txt", "testR");
+ push(git);
+ resetHard(git, "HEAD~");
+
+ checkout(git, "master", false);
+ checkout(git, "testD", true);
+ commitNewFile("testDa.txt", "testDa");
+ push(git);
+ fetch(git);
+ resetHard(git, "HEAD~");
+ commitNewFile("testDb.txt", "testDb");
+
+ checkout(git, "master", false);
+ checkout(git, "test1", true);
+ commitNewFile("test1.txt", "test1");
+
+ commitNewFile("test1t.txt", "test1t");
+ tag(git, "TEST1t");
+ resetHard(git, "HEAD~");
+
+ checkout(git, "master", false);
+ checkout(git, "test2", true);
+ commitNewFile("test2.txt", "test2");
+
+ checkout(git, "master", false);
+ checkout(git, "test12", true);
+ commitNewFile("test12.txt", "test12");
+
+ checkout(git, "master", false);
+ }
}
@Test
@@ -314,7 +441,6 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
@Test
public void testSelectBranch() throws Exception {
- toggleShowAllBranchesButton(false);
SWTBotTable commitTable = getHistoryViewTable(PROJ1);
assertEquals("Unexpected number of commits", commitCount,
commitTable.rowCount());
@@ -421,23 +547,226 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
assertEquals(commit[0].getId().name(), repo.getBranch());
}
+ private String[] getCommitMsgsFromUi(final SWTBotTable table) {
+ int length = table.rowCount();
+ String[] result = new String[length];
+
+ for (int i = 0; i < length; i++) {
+ RevCommit commit = getCommitInLine(table, i)[0];
+ String msg = commit.getFullMessage();
+ // Want newest commit last.
+ result[length - (1 + i)] = msg;
+ }
+
+ return result;
+ }
+
+ private SWTBotMenu getFilterMenuItem(
+ SWTBotToolbarDropDownButton selectedRefs, String refFilter) {
+ return selectedRefs.menuItem(new TypeSafeMatcher<MenuItem>() {
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText(
+ "MenuItem for RefFilter \"" + refFilter + "\"");
+ }
+
+ @Override
+ protected boolean matchesSafely(MenuItem item) {
+ return item.getText().startsWith(refFilter);
+ }
+
+ });
+ }
+
+ private void uncheckRefFilter(SWTBotToolbarDropDownButton selectedRefs,
+ String refFilter) {
+ SWTBotMenu filter = getFilterMenuItem(selectedRefs, refFilter);
+ assertTrue("Expected " + refFilter + " to be checked",
+ filter.isChecked());
+ filter.click();
+ }
+
+ private void checkRefFilter(SWTBotToolbarDropDownButton selectedRefs,
+ String refFilter) {
+ SWTBotMenu filter = getFilterMenuItem(selectedRefs, refFilter);
+ assertTrue("Expected " + refFilter + " to be unchecked",
+ !filter.isChecked());
+ filter.click();
+ }
+
+ private void assertNoCommit(SWTBotTable table) {
+ bot.waitUntil(new DefaultCondition() {
+
+ @Override
+ public boolean test() throws Exception {
+ return table.rowCount() == 0;
+ }
+
+ @Override
+ public String getFailureMessage() {
+ return "CommitGraphTable did not become empty";
+ }
+
+ });
+ Assert.assertThat("Expected no commit", getCommitMsgsFromUi(table),
+ emptyArray());
+ }
+
+ private void assertCommitsAfterBase(SWTBotTable table, String... commitMsgs)
+ throws Exception {
+ TestUtil.waitForJobs(50, 5000);
+ // There are three expected fixed commits, plus then the ones given in
+ // the parameter.
+ int expectedNumberOfCommits = commitMsgs.length + 3;
+ bot.waitUntil(new DefaultCondition() {
+
+ @Override
+ public boolean test() throws Exception {
+ return table.rowCount() == expectedNumberOfCommits;
+ }
+
+ @Override
+ public String getFailureMessage() {
+ return "CommitGraphTable did not get expected number of rows: "
+ + expectedNumberOfCommits;
+ }
+
+ });
+ List<Matcher<? super String>> matchers = new ArrayList<>();
+ matchers.add(equalTo("Initial commit"));
+ matchers.add(startsWith("Touched at"));
+ matchers.add(equalTo("A new file in a new folder"));
+
+ for (String msg : commitMsgs) {
+ matchers.add(equalTo(msg));
+ }
+
+ Assert.assertThat("Expected different commits",
+ getCommitMsgsFromUi(table),
+ is(arrayContainingInAnyOrder(matchers)));
+ }
+
@Test
- public void testShowAllBranches() throws Exception {
- try {
- toggleShowAllBranchesButton(true);
- final SWTBotTable table = getHistoryViewTable(PROJ1);
- int commits = getHistoryViewTable(PROJ1).rowCount();
- checkoutLine(table, 1);
-
- toggleShowAllBranchesButton(false);
- assertEquals("Wrong number of commits", commits - 1,
- getHistoryViewTable(PROJ1).rowCount());
- toggleShowAllBranchesButton(true);
- assertEquals("Wrong number of commits", commits,
- getHistoryViewTable(PROJ1).rowCount());
- } finally {
- toggleShowAllBranchesButton(false);
+ public void testSelectShownRefs() throws Exception {
+ Set<RefFilter> filters = refFilterHelper.getRefFilters();
+ filters.add(refFilterHelper.new RefFilter("refs/heads/test1"));
+ filters.add(refFilterHelper.new RefFilter("refs/heads/test?"));
+ filters.add(refFilterHelper.new RefFilter("refs/heads/test*"));
+ refFilterHelper.setRefFilters(filters);
+
+ Repository repo = myRepoViewUtil.lookupRepository(repoFile);
+
+ SWTBotTable table = getHistoryViewTable(PROJ1);
+ SWTBotView view = bot.viewById(IHistoryView.VIEW_ID);
+ SWTBotToolbarDropDownButton selectedRefs = (SWTBotToolbarDropDownButton) view
+ .toolbarButton(UIText.GitHistoryPage_showingHistoryOfHead);
+
+ try(Git git = Git.wrap(repo)) {
+ checkout(git, "testD", false);
}
+ assertCommitsAfterBase(table, "testDb");
+
+ uncheckRefFilter(selectedRefs, "HEAD");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/**/[CURRENT-BRANCH]");
+ assertCommitsAfterBase(table, "testDa", "testDb");
+
+ uncheckRefFilter(selectedRefs, "refs/**/[CURRENT-BRANCH]");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/heads/**");
+ assertCommitsAfterBase(table, "test1", "test2", "test12", "testDb");
+
+ uncheckRefFilter(selectedRefs, "refs/heads/**");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/remotes/**");
+ assertCommitsAfterBase(table, "testDa", "testR");
+
+ uncheckRefFilter(selectedRefs, "refs/remotes/**");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/tags/**");
+ assertCommitsAfterBase(table, "test1", "test1t");
+
+ uncheckRefFilter(selectedRefs, "refs/tags/**");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/heads/test1");
+ assertCommitsAfterBase(table, "test1");
+
+ uncheckRefFilter(selectedRefs, "refs/heads/test1");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/heads/test?");
+ assertCommitsAfterBase(table, "test1", "test2", "testDb");
+
+ uncheckRefFilter(selectedRefs, "refs/heads/test?");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "refs/heads/test*");
+ assertCommitsAfterBase(table, "test1", "test2", "test12", "testDb");
+
+ uncheckRefFilter(selectedRefs, "refs/heads/test*");
+ assertNoCommit(table);
+ }
+
+ @Test
+ public void testToggleShownRefs() throws Exception {
+ SWTBotTable table = getHistoryViewTable(PROJ1);
+ SWTBotView view = bot.viewById(IHistoryView.VIEW_ID);
+ SWTBotToolbarDropDownButton selectedRefs = (SWTBotToolbarDropDownButton) view
+ .toolbarButton(UIText.GitHistoryPage_showingHistoryOfHead);
+
+ checkRefFilter(selectedRefs, "refs/heads/**");
+ checkRefFilter(selectedRefs, "refs/remotes/**");
+ checkRefFilter(selectedRefs, "refs/tags/**");
+
+ assertCommitsAfterBase(table, "test1", "test2", "test12", "testDa",
+ "testDb", "test1t", "testR");
+
+ selectedRefs.click();
+ assertCommitsAfterBase(table);
+
+ uncheckRefFilter(selectedRefs, "HEAD");
+ assertNoCommit(table);
+
+ checkRefFilter(selectedRefs, "HEAD");
+ assertCommitsAfterBase(table);
+
+ selectedRefs.click();
+ assertCommitsAfterBase(table, "test1", "test2", "test12", "testDa",
+ "testDb", "test1t", "testR");
+
+ uncheckRefFilter(selectedRefs, "refs/heads/**");
+ uncheckRefFilter(selectedRefs, "refs/remotes/**");
+ uncheckRefFilter(selectedRefs, "refs/tags/**");
+ }
+
+ @Test
+ public void testOpenRefFilterDialogFromDropdown() throws Exception {
+ getHistoryViewTable(PROJ1); // Make sure the history view is visible
+ SWTBotView view = bot.viewById(IHistoryView.VIEW_ID);
+ SWTBotToolbarDropDownButton selectedRefs = (SWTBotToolbarDropDownButton) view
+ .toolbarButton(UIText.GitHistoryPage_showingHistoryOfHead);
+
+ selectedRefs.menuItem(UIText.GitHistoryPage_configureFilters).click();
+ // This will cause an exception if the dialog is not found
+ bot.shell(UIText.GitHistoryPage_filterRefDialog_dialogTitle).bot()
+ .button(IDialogConstants.OK_LABEL).click();
+ }
+
+ @Test
+ public void testOpenRefFilterDialogFromMenu() throws Exception {
+ getHistoryViewTable(PROJ1); // Make sure the history view is visible
+ SWTBotView view = bot.viewById(IHistoryView.VIEW_ID);
+
+ view.viewMenu(UIText.GitHistoryPage_configureFilters).click();
+ // This will cause an exception if the dialog is not found
+ bot.shell(UIText.GitHistoryPage_filterRefDialog_dialogTitle).bot()
+ .button(IDialogConstants.OK_LABEL).click();
}
@Test
@@ -523,13 +852,11 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
TestUtil.joinJobs(JobFamilies.REBASE);
}
- private RevCommit[] checkoutLine(final SWTBotTable table, int line)
- throws InterruptedException {
+ private RevCommit[] getCommitInLine(SWTBotTable table, int line) {
table.getTableItem(line).select();
final RevCommit[] commit = new RevCommit[1];
PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
-
@Override
public void run() {
TableItem tableItem = table.widget.getSelection()[0];
@@ -538,6 +865,14 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
}
});
+ return commit;
+ }
+
+ private RevCommit[] checkoutLine(final SWTBotTable table, int line)
+ throws InterruptedException {
+ table.getTableItem(line).select();
+ final RevCommit[] commit = getCommitInLine(table, line);
+
ContextMenuHelper.clickContextMenuSync(table,
UIText.GitHistoryPage_CheckoutMenuLabel);
TestUtil.joinJobs(JobFamilies.CHECKOUT);
@@ -554,17 +889,6 @@ public class HistoryViewTest extends GitRepositoriesViewTestBase {
item.setText(item.getText()); // TODO: is there a better solution?
}
- private void toggleShowAllBranchesButton(boolean checked) throws Exception{
- getHistoryViewTable(PROJ1);
- SWTBotView view = bot
- .viewById(IHistoryView.VIEW_ID);
- SWTBotToolbarToggleButton showAllBranches = (SWTBotToolbarToggleButton) view
- .toolbarButton(UIText.GitHistoryPage_showAllBranches);
- boolean isChecked = showAllBranches.isChecked();
- if(isChecked && !checked || !isChecked && checked)
- showAllBranches.click();
- }
-
private static SWTBotTableItem getTableItemWithId(SWTBotTable table,
ObjectId wantedId) {
for (int i = 0; i < table.rowCount(); i++) {
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterHelperTest.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterHelperTest.java
new file mode 100644
index 0000000000..fb99454f32
--- /dev/null
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterHelperTest.java
@@ -0,0 +1,697 @@
+/*******************************************************************************
+ * Copyright (C) 2019, Tim Neumann <Tim.Neumann@advantest.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.egit.ui.test.history;
+
+import static org.eclipse.egit.ui.test.history.RefFilterUtil.newRefFilterMatcher;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.hamcrest.MockitoHamcrest.argThat;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.eclipse.egit.core.RepositoryUtil;
+import org.eclipse.egit.ui.Activator;
+import org.eclipse.egit.ui.UIPreferences;
+import org.eclipse.egit.ui.common.LocalRepositoryTestCase;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper.RefFilter;
+import org.eclipse.egit.ui.test.TestUtil;
+import org.eclipse.egit.ui.view.repositories.GitRepositoriesViewTestUtils;
+import org.eclipse.jface.preference.IPersistentPreferenceStore;
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.TagCommand;
+import org.eclipse.jgit.lib.Constants;
+import org.eclipse.jgit.lib.PersonIdent;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.lib.Repository;
+import org.eclipse.jgit.revwalk.RevCommit;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RefFilterHelperTest extends LocalRepositoryTestCase {
+
+ private Repository repo;
+
+ private RefFilterHelper refFilterHelper;
+
+ private IPersistentPreferenceStore prefStore;
+
+ private GitRepositoriesViewTestUtils myRepoViewUtil;
+
+ @SuppressWarnings("boxing")
+ @Before
+ public void setupTests() throws Exception {
+ myRepoViewUtil = new GitRepositoriesViewTestUtils();
+ File repoFile = createProjectAndCommitToRepository();
+ createSimpleRemoteRepository(repoFile);
+
+ RepositoryUtil repositoryUtil = Activator.getDefault()
+ .getRepositoryUtil();
+ repositoryUtil.addConfiguredRepository(repoFile);
+
+ repo = myRepoViewUtil.lookupRepository(repoFile);
+
+ try (Git git = Git.wrap(repo)) {
+ TagCommand tag = git.tag();
+ tag.setName("TestTag");
+ PersonIdent committer = new PersonIdent(TestUtil.TESTCOMMITTER_NAME,
+ TestUtil.TESTCOMMITTER_EMAIL);
+ tag.setTagger(committer);
+ RevCommit headCommit = repo.parseCommit(
+ repo.exactRef(Constants.HEAD).getLeaf().getObjectId());
+ tag.setObjectId(headCommit);
+ tag.call();
+ }
+ prefStore = mock(IPersistentPreferenceStore.class);
+
+ when(prefStore.needsSaving()).thenReturn(true);
+ when(prefStore.getDefaultString(anyString())).thenReturn("");
+
+ refFilterHelper = new RefFilterHelper(repo, prefStore);
+ }
+
+ @After
+ public void teardown() {
+ myRepoViewUtil.dispose();
+ }
+
+ private String getRepoSpecificPrefKeyForConfiguredFilters() {
+ return Activator.getDefault().getRepositoryUtil()
+ .getRepositorySpecificPreferenceKey(this.repo,
+ UIPreferences.RESOURCEHISTORY_REF_FILTERS);
+ }
+
+ @Test
+ public void testConstructor() throws Exception {
+ verify(prefStore)
+ .getDefaultString(UIPreferences.RESOURCEHISTORY_REF_FILTERS);
+ verify(prefStore, times(2)).getDefaultString(
+ UIPreferences.RESOURCEHISTORY_SELECTED_REF_FILTERS);
+ verify(prefStore).getDefaultString(
+ UIPreferences.RESOURCEHISTORY_LAST_SELECTED_REF_FILTERS);
+ verify(prefStore).setDefault(
+ eq(getRepoSpecificPrefKeyForConfiguredFilters()), eq(""));
+ verify(prefStore).setDefault(
+ eq(getRepoSpecificPrefKeyForSelectedFilters()), eq(""));
+ verify(prefStore).setDefault(
+ eq(getRepoSpecificPrefKeyForLastSelectedFilters()), eq(""));
+ }
+
+ @Test
+ public void testGetConfiguredFilters() throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForConfiguredFilters())))
+ .thenReturn("Mock:test:filter");
+ List<String> result = refFilterHelper.getConfiguredFilters();
+ assertThat("Expected different list of configured filters", result,
+ containsInAnyOrder("Mock", "test", "filter"));
+ }
+
+ @Test
+ public void testSetConfiguredFiltersNoSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setConfiguredFilters(filters, false);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForConfiguredFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore, never()).save();
+ }
+
+ @Test
+ public void testSetConfiguredFiltersWithSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setConfiguredFilters(filters, true);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForConfiguredFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore).save();
+ }
+
+ private String getRepoSpecificPrefKeyForSelectedFilters() {
+ return Activator.getDefault().getRepositoryUtil()
+ .getRepositorySpecificPreferenceKey(this.repo,
+ UIPreferences.RESOURCEHISTORY_SELECTED_REF_FILTERS);
+ }
+
+ @Test
+ public void testGetSelectedFilters() throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForSelectedFilters())))
+ .thenReturn("Mock:test:filter");
+ List<String> result = refFilterHelper.getSelectedFilters();
+ assertThat("Expected different list of selected filters", result,
+ containsInAnyOrder("Mock", "test", "filter"));
+ }
+
+ @Test
+ public void testSetSelectedFiltersNoSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setSelectedFilters(filters, false);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore, never()).save();
+ }
+
+ @Test
+ public void testSetSelectedFiltersWithSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setSelectedFilters(filters, true);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore).save();
+ }
+
+ private String getRepoSpecificPrefKeyForLastSelectedFilters() {
+ return Activator.getDefault().getRepositoryUtil()
+ .getRepositorySpecificPreferenceKey(this.repo,
+ UIPreferences.RESOURCEHISTORY_LAST_SELECTED_REF_FILTERS);
+ }
+
+ @Test
+ public void testGetLastSelectedFilters() throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForLastSelectedFilters())))
+ .thenReturn("Mock:test:filter");
+ List<String> result = refFilterHelper.getLastSelectedFilters();
+ assertThat("Expected different list of last selected filters", result,
+ containsInAnyOrder("Mock", "test", "filter"));
+ }
+
+ @Test
+ public void testSetLastSelectedFiltersNoSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setLastSelectedFilters(filters, false);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForLastSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore, never()).save();
+ }
+
+ @Test
+ public void testSetLastSelectedFiltersWithSave() throws Exception {
+ List<String> filters = Arrays.asList("Mock", "test", "filter");
+
+ refFilterHelper.setLastSelectedFilters(filters, true);
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForLastSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+ verify(prefStore).save();
+ }
+
+ private RefFilter newRefFilter(String filterString, boolean preConfigured,
+ boolean selected) {
+ return RefFilterUtil.newRefFilter(refFilterHelper, filterString,
+ preConfigured, selected);
+ }
+
+ @Test
+ public void testGetFilters() throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForConfiguredFilters())))
+ .thenReturn("Mock:test:filter");
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForSelectedFilters())))
+ .thenReturn("HEAD:test");
+ Set<RefFilter> result = refFilterHelper.getRefFilters();
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, true));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, false));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, false));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, false));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, true));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ assertThat("Expected different filters", result,
+ containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testRestoreLastSelectionState() throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForLastSelectedFilters())))
+ .thenReturn("HEAD:test");
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, true));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, false));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, false));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, false));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, true));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ refFilterHelper.restoreLastSelectionState(testSet);
+ assertThat("Expected different filters", testSet,
+ containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testSetFilters() throws Exception {
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ refFilterHelper.setRefFilters(testSet);
+
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForConfiguredFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("Mock", "test", "filter"))));
+
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("refs/heads/**", "filter"))));
+
+ verify(prefStore).save();
+ }
+
+ @Test
+ public void testSaveSelectionStateAsLastSelectionState() throws Exception {
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ refFilterHelper.saveSelectionStateAsLastSelectionState(testSet);
+
+ verify(prefStore).setValue(
+ eq(getRepoSpecificPrefKeyForLastSelectedFilters()),
+ argThat(refFilterConfigStringOf(
+ containsInAnyOrder("refs/heads/**", "filter"))));
+
+ verify(prefStore).save();
+ }
+
+ @Test
+ public void testResetLastSelectionStateToDefault() throws Exception {
+ refFilterHelper.resetLastSelectionStateToDefault();
+
+ verify(prefStore).setToDefault(
+ eq(getRepoSpecificPrefKeyForLastSelectedFilters()));
+
+ verify(prefStore).save();
+ }
+
+ private Matcher<Ref> ref(Matcher<String> refName) {
+ return new TypeSafeMatcher<Ref>() {
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("A ref with the name ");
+ refName.describeTo(description);
+ }
+
+ @Override
+ protected boolean matchesSafely(Ref item) {
+ return refName.matches(item.getName());
+ }
+ };
+ }
+
+ private void checkMatchingRefsForSelectedRefFilters(
+ String selectedRefConfig, List<Matcher<? super Ref>> expected)
+ throws Exception {
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForSelectedFilters())))
+ .thenReturn(selectedRefConfig);
+ when(prefStore
+ .getString(eq(getRepoSpecificPrefKeyForConfiguredFilters())))
+ .thenReturn("");
+ Set<Ref> result = refFilterHelper
+ .getMatchingRefsForSelectedRefFilters();
+
+ assertThat("Expected different refs for config: " + selectedRefConfig,
+ result, containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testGetMatchingRefsForSelectedRefFilters()
+ throws Exception {
+ checkMatchingRefsForSelectedRefFilters("HEAD",
+ Arrays.asList(ref(equalTo("HEAD"))));
+ checkMatchingRefsForSelectedRefFilters("refs/**/[CURRENT-BRANCH]",
+ Arrays.asList(ref(equalTo("refs/heads/master")),
+ ref(equalTo("refs/remotes/origin/master"))));
+ checkMatchingRefsForSelectedRefFilters("refs/heads/**",
+ Arrays.asList(ref(equalTo("refs/heads/master")),
+ ref(equalTo("refs/heads/stable"))));
+ checkMatchingRefsForSelectedRefFilters("refs/remotes/**",
+ Arrays.asList(ref(equalTo("refs/remotes/origin/master"))));
+ checkMatchingRefsForSelectedRefFilters("refs/tags/**",
+ Arrays.asList(ref(equalTo("refs/tags/TestTag"))));
+ }
+
+ @Test
+ public void testSelectOnlyHEAD() throws Exception {
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, true));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, false));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, false));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, false));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, false));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ refFilterHelper.selectOnlyHEAD(testSet);
+ assertThat("Expected different filters", testSet,
+ containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testIsOnlyHEADSelected() throws Exception {
+ Set<RefFilter> testSet1 = new HashSet<>();
+ testSet1.add(newRefFilter("HEAD", true, false));
+ testSet1.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet1.add(newRefFilter("refs/heads/**", true, true));
+ testSet1.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet1.add(newRefFilter("refs/tags/**", true, false));
+ testSet1.add(newRefFilter("Mock", false, false));
+ testSet1.add(newRefFilter("test", false, false));
+ testSet1.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only head selected",
+ refFilterHelper.isOnlyHEADSelected(testSet1));
+
+ Set<RefFilter> testSet2 = new HashSet<>();
+ testSet2.add(newRefFilter("HEAD", true, true));
+ testSet2.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet2.add(newRefFilter("refs/heads/**", true, true));
+ testSet2.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet2.add(newRefFilter("refs/tags/**", true, false));
+ testSet2.add(newRefFilter("Mock", false, false));
+ testSet2.add(newRefFilter("test", false, false));
+ testSet2.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only head selected",
+ refFilterHelper.isOnlyHEADSelected(testSet2));
+
+ Set<RefFilter> testSet3 = new HashSet<>();
+ testSet3.add(newRefFilter("HEAD", true, true));
+ testSet3.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet3.add(newRefFilter("refs/heads/**", true, false));
+ testSet3.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet3.add(newRefFilter("refs/tags/**", true, false));
+ testSet3.add(newRefFilter("Mock", false, false));
+ testSet3.add(newRefFilter("test", false, false));
+ testSet3.add(newRefFilter("filter", false, false));
+
+ assertTrue("Only head selected!",
+ refFilterHelper.isOnlyHEADSelected(testSet3));
+
+ }
+
+ @Test
+ public void testSelectOnlyCurrentBranch() throws Exception {
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, false));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, true));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, false));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, false));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, false));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, false));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ refFilterHelper.selectOnlyCurrentBranch(testSet);
+ assertThat("Expected different filters", testSet,
+ containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testIsOnlyCurrentBranchSelected() throws Exception {
+ Set<RefFilter> testSet1 = new HashSet<>();
+ testSet1.add(newRefFilter("HEAD", true, false));
+ testSet1.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet1.add(newRefFilter("refs/heads/**", true, true));
+ testSet1.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet1.add(newRefFilter("refs/tags/**", true, false));
+ testSet1.add(newRefFilter("Mock", false, false));
+ testSet1.add(newRefFilter("test", false, false));
+ testSet1.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only current branch selected",
+ refFilterHelper.isOnlyCurrentBranchSelected(testSet1));
+
+ Set<RefFilter> testSet2 = new HashSet<>();
+ testSet2.add(newRefFilter("HEAD", true, false));
+ testSet2.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, true));
+ testSet2.add(newRefFilter("refs/heads/**", true, true));
+ testSet2.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet2.add(newRefFilter("refs/tags/**", true, false));
+ testSet2.add(newRefFilter("Mock", false, false));
+ testSet2.add(newRefFilter("test", false, false));
+ testSet2.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only current branch selected",
+ refFilterHelper.isOnlyCurrentBranchSelected(testSet2));
+
+ Set<RefFilter> testSet3 = new HashSet<>();
+ testSet3.add(newRefFilter("HEAD", true, false));
+ testSet3.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, true));
+ testSet3.add(newRefFilter("refs/heads/**", true, false));
+ testSet3.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet3.add(newRefFilter("refs/tags/**", true, false));
+ testSet3.add(newRefFilter("Mock", false, false));
+ testSet3.add(newRefFilter("test", false, false));
+ testSet3.add(newRefFilter("filter", false, false));
+
+ assertTrue("Only current branch selected!",
+ refFilterHelper.isOnlyCurrentBranchSelected(testSet3));
+
+ }
+
+ @Test
+ public void testSelectExactlyAllBranchesAndTags() throws Exception {
+ Set<RefFilter> testSet = new HashSet<>();
+ testSet.add(newRefFilter("HEAD", true, false));
+ testSet.add(newRefFilter("refs/**/[CURRENT-BRANCH]", true,
+ false));
+ testSet.add(newRefFilter("refs/heads/**", true, true));
+ testSet.add(newRefFilter("refs/remotes/**", true, false));
+ testSet.add(newRefFilter("refs/tags/**", true, false));
+ testSet.add(newRefFilter("Mock", false, false));
+ testSet.add(newRefFilter("test", false, false));
+ testSet.add(newRefFilter("filter", false, true));
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, true));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, true));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, true));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, true));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, false));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ refFilterHelper.selectExactlyAllBranchesAndTags(testSet);
+ assertThat("Expected different filters", testSet,
+ containsInAnyOrder(expected));
+ }
+
+ @Test
+ public void testIsExactlyAllBranchesAndTagsSelected() throws Exception {
+ Set<RefFilter> testSet1 = new HashSet<>();
+ testSet1.add(newRefFilter("HEAD", true, false));
+ testSet1.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet1.add(newRefFilter("refs/heads/**", true, true));
+ testSet1.add(
+ newRefFilter("refs/remotes/**", true, false));
+ testSet1.add(newRefFilter("refs/tags/**", true, false));
+ testSet1.add(newRefFilter("Mock", false, false));
+ testSet1.add(newRefFilter("test", false, false));
+ testSet1.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only current branch selected",
+ refFilterHelper.isExactlyAllBranchesAndTagsSelected(testSet1));
+
+ Set<RefFilter> testSet2 = new HashSet<>();
+ testSet2.add(newRefFilter("HEAD", true, true));
+ testSet2.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet2.add(newRefFilter("refs/heads/**", true, true));
+ testSet2.add(newRefFilter("refs/remotes/**", true, true));
+ testSet2.add(newRefFilter("refs/tags/**", true, true));
+ testSet2.add(newRefFilter("Mock", false, false));
+ testSet2.add(newRefFilter("test", false, false));
+ testSet2.add(newRefFilter("filter", false, true));
+
+ assertFalse("Not only current branch selected",
+ refFilterHelper.isExactlyAllBranchesAndTagsSelected(testSet2));
+
+ Set<RefFilter> testSet3 = new HashSet<>();
+ testSet3.add(newRefFilter("HEAD", true, true));
+ testSet3.add(newRefFilter("refs/**/[CURRENT-BRANCH]",
+ true, false));
+ testSet3.add(newRefFilter("refs/heads/**", true, true));
+ testSet3.add(newRefFilter("refs/remotes/**", true, true));
+ testSet3.add(newRefFilter("refs/tags/**", true, true));
+ testSet3.add(newRefFilter("Mock", false, false));
+ testSet3.add(newRefFilter("test", false, false));
+ testSet3.add(newRefFilter("filter", false, false));
+
+ assertTrue("Only current branch selected!",
+ refFilterHelper.isExactlyAllBranchesAndTagsSelected(testSet3));
+
+ }
+
+ @Test
+ public void testGetDefaults() throws Exception {
+ when(prefStore.getDefaultString(
+ eq(UIPreferences.RESOURCEHISTORY_REF_FILTERS)))
+ .thenReturn("Mock:test:filter");
+ when(prefStore.getDefaultString(
+ eq(UIPreferences.RESOURCEHISTORY_SELECTED_REF_FILTERS)))
+ .thenReturn("HEAD:test");
+ Set<RefFilter> result = refFilterHelper.getDefaults();
+
+ List<Matcher<? super RefFilter>> expected = new ArrayList<>();
+ expected.add(newRefFilterMatcher("HEAD", true, true));
+ expected.add(
+ newRefFilterMatcher("refs/**/[CURRENT-BRANCH]", true, false));
+ expected.add(newRefFilterMatcher("refs/heads/**", true, false));
+ expected.add(newRefFilterMatcher("refs/remotes/**", true, false));
+ expected.add(newRefFilterMatcher("refs/tags/**", true, false));
+ expected.add(newRefFilterMatcher("Mock", false, false));
+ expected.add(newRefFilterMatcher("test", false, true));
+ expected.add(newRefFilterMatcher("filter", false, false));
+
+ assertThat("Expected different filters", result,
+ containsInAnyOrder(expected));
+ }
+
+ private Matcher<String> refFilterConfigStringOf(
+ Matcher<Iterable<? extends String>> items) {
+ return new RefFilterConfigStringMatcher(items);
+ }
+
+ private static class RefFilterConfigStringMatcher
+ extends TypeSafeMatcher<String> {
+
+ private final Matcher<Iterable<? extends String>> itemsMatcher;
+
+ public RefFilterConfigStringMatcher(
+ Matcher<Iterable<? extends String>> itemsMatcher) {
+ this.itemsMatcher = itemsMatcher;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("A ref filter config string containing ");
+ itemsMatcher.describeTo(description);
+ }
+
+ @Override
+ protected boolean matchesSafely(String item) {
+ return itemsMatcher.matches(Arrays.asList(item.split(":")));
+ }
+
+ }
+}
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterUtil.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterUtil.java
new file mode 100644
index 0000000000..9e6c76b38c
--- /dev/null
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/history/RefFilterUtil.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (C) 2019, Tim Neumann <Tim.Neumann@advantest.com>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.egit.ui.test.history;
+
+import static org.mockito.Mockito.when;
+
+import java.util.Objects;
+
+import org.eclipse.egit.ui.internal.history.RefFilterHelper;
+import org.eclipse.egit.ui.internal.history.RefFilterHelper.RefFilter;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.mockito.Mockito;
+
+public class RefFilterUtil {
+ private RefFilterUtil() {
+ // Forbid instantiation
+ }
+
+ public static Matcher<RefFilter> newRefFilterMatcher(String filterString,
+ boolean preConfigured,
+ boolean selected) {
+ return new TypeSafeMatcher<RefFilterHelper.RefFilter>() {
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("a ref filter with ");
+ description.appendValue(filterString);
+ description.appendText(" which is ");
+ if (!preConfigured) {
+ description.appendText("_not_ ");
+ }
+ description.appendText("preconfigured and ");
+ if (!selected) {
+ description.appendText("_not_ ");
+ }
+ description.appendText("selected");
+ }
+
+ @Override
+ protected boolean matchesSafely(RefFilter item) {
+ if (item.isPreconfigured() != preConfigured) {
+ return false;
+ }
+
+ if (item.isSelected() != selected) {
+ return false;
+ }
+
+ return Objects.equals(filterString, item.getFilterString());
+ }
+ };
+ }
+
+ @SuppressWarnings("boxing")
+ public static RefFilter newRefFilter(RefFilterHelper helper,
+ String filterString, boolean preConfigured,
+ boolean selected) {
+ RefFilter mock = Mockito.mock(RefFilter.class);
+ when(mock.getFilterString()).thenReturn(filterString);
+ when(mock.isPreconfigured()).thenReturn(preConfigured);
+ when(mock.isSelected()).thenReturn(selected);
+ return helper.new RefFilter(mock);
+ }
+
+}

Back to the top