diff options
Diffstat (limited to 'org.eclipse.egit.ui.test')
6 files changed, 1910 insertions, 33 deletions
diff --git a/org.eclipse.egit.ui.test/META-INF/MANIFEST.MF b/org.eclipse.egit.ui.test/META-INF/MANIFEST.MF index 2a7b8522a5..d81fc7c66e 100644 --- a/org.eclipse.egit.ui.test/META-INF/MANIFEST.MF +++ b/org.eclipse.egit.ui.test/META-INF/MANIFEST.MF @@ -52,4 +52,6 @@ Import-Package: net.bytebuddy;version="[1.7.9,2.0.0)", org.mockito;version="[2.13.0,3.0.0)", org.mockito.junit;version="[2.13.0,3.0.0)", org.mockito.stubbing;version="[2.13.0,3.0.0)", + org.mockito.hamcrest;version="[2.13.0,3.0.0)", + org.mockito.invocation;version="[2.13.0,3.0.0)", org.osgi.framework;version="[1.4.0,2.0.0)" 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); + } + +} |