/*******************************************************************************
* Copyright (c) 2012-2017 Codenvy, S.A.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Codenvy, S.A. - initial API and implementation
*******************************************************************************/
package org.eclipse.che.ide.api.action;
import org.eclipse.che.ide.api.constraints.Constraints;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static org.eclipse.che.ide.api.constraints.Anchor.AFTER;
import static org.eclipse.che.ide.api.constraints.Anchor.BEFORE;
import static org.fest.assertions.Assertions.assertThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
/**
* @author Mihail Kuznyetsov.
*/
@RunWith(MockitoJUnitRunner.class)
public class DefaultActionGroupTest {
@Mock
Action firstAction;
@Mock
Action secondAction;
@Mock
Action thirdAction;
@Mock
Action fourthAction;
@Mock
Action fifthAction;
@Mock
Action sixthAction;
@Mock
ActionManager actionManager;
DefaultActionGroup defaultActionGroup;
@Before
public void setup() {
defaultActionGroup = new DefaultActionGroup(actionManager);
}
@Test
public void shouldNotAddSameActionTwice() {
Action action = mock(Action.class);
defaultActionGroup.add(action, new Constraints(AFTER, "someAction"));
defaultActionGroup.add(action, new Constraints(BEFORE, "someAction"));
assertThat(defaultActionGroup.getChildrenCount()).isEqualTo(1);
}
@Test
public void shouldReturnEmptyArrayWhenThereIsNoActions() {
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).isEmpty();
}
@Test
public void addActionsWithNoExplicitConstraints() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addOneFirst() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, Constraints.FIRST);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
thirdAction,
firstAction,
secondAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addTwoFirst() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, Constraints.FIRST);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction, Constraints.FIRST);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
fifthAction,
thirdAction,
firstAction,
secondAction,
fourthAction,
sixthAction
);
}
@Test
public void addOneLast() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, Constraints.LAST);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addOneBefore() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, new Constraints(BEFORE, "secondAction"));
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
thirdAction,
secondAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addTwoBefore() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, new Constraints(BEFORE, "secondAction"));
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction, new Constraints(BEFORE, "secondAction"));
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
thirdAction,
fifthAction,
secondAction,
fourthAction,
sixthAction
);
}
@Test
public void addOneBeforeNotAdded() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction, new Constraints(BEFORE, "fifthAction"));
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
fourthAction,
thirdAction,
fifthAction,
sixthAction
);
}
@Test
public void addComplexBefore() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(BEFORE, "fourthAction"));
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction, new Constraints(BEFORE, "sixthAction"));
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
thirdAction,
fifthAction,
secondAction,
fourthAction,
sixthAction
);
}
@Test
public void addOneAfter() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction, new Constraints(AFTER, "firstAction"));
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
fourthAction,
secondAction,
thirdAction,
fifthAction,
sixthAction
);
}
@Test
public void addTwoAfter() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(AFTER, "fifthAction"));
defaultActionGroup.add(thirdAction, new Constraints(AFTER, "fifthAction"));
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
//then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
fourthAction,
fifthAction,
thirdAction,
secondAction,
sixthAction
);
}
@Test
public void addComplexAfter() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(AFTER, "fifthAction"));
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction, new Constraints(AFTER, "firstAction"));
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
fifthAction,
secondAction,
thirdAction,
fourthAction,
sixthAction
);
}
@Test
public void addOneAfterNotAdded() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(AFTER, "fifthAction"));
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
thirdAction,
fourthAction,
fifthAction,
secondAction,
sixthAction
);
}
@Test
public void addActionToTheEndWhenConstraintUnsatisfied() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(AFTER, "tenthAction"));
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction,
secondAction
);
}
@Test
public void shouldResortAllActionsAfterAddingOne() {
// add some actions
defaultActionGroup.add(firstAction);
when(actionManager.getId(eq(firstAction))).thenReturn("firstAction");
defaultActionGroup.add(secondAction, Constraints.FIRST);
when(actionManager.getId(eq(secondAction))).thenReturn("secondAction");
defaultActionGroup.add(thirdAction, new Constraints(AFTER, "fourthAction"));
when(actionManager.getId(eq(thirdAction))).thenReturn("thirdAction");
// verify order
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
assertThat(Arrays.asList(result)).containsExactly(
secondAction,
firstAction,
thirdAction
);
// add other actions
defaultActionGroup.add(fourthAction);
when(actionManager.getId(eq(thirdAction))).thenReturn("thirdAction");
defaultActionGroup.add(fifthAction, Constraints.FIRST);
when(actionManager.getId(eq(fifthAction))).thenReturn("fifthAction");
defaultActionGroup.add(sixthAction, new Constraints(BEFORE, "firstAction"));
when(actionManager.getId(eq(sixthAction))).thenReturn("sixthAction");
// verify that actions have been resorted
Action[] newResult = defaultActionGroup.getChildren(mock(ActionEvent.class));
assertThat(Arrays.asList(newResult)).hasSize(6).containsExactly(
fifthAction,
secondAction,
sixthAction,
firstAction,
fourthAction,
thirdAction
);
}
@Test
public void getChildrenCount() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction, new Constraints(AFTER, "fifthAction"));
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
int count = defaultActionGroup.getChildrenCount();
// then
assertThat(count).isEqualTo(6);
}
@Test
public void addActionsAndSeparators() {
// given
mockRegisterActions();
defaultActionGroup.addSeparator();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.addSeparator();
defaultActionGroup.add(thirdAction);
defaultActionGroup.addSeparator();
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
defaultActionGroup.addSeparator();
// when
Action[] newResult = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(newResult)).hasSize(10).containsExactly(
Separator.getInstance(),
firstAction,
secondAction,
Separator.getInstance(),
thirdAction,
Separator.getInstance(),
fourthAction,
fifthAction,
sixthAction,
Separator.getInstance()
);
}
@Test
public void addActionsFromActionGroup() {
// given
mockRegisterActions();
DefaultActionGroup newGroup = new DefaultActionGroup(actionManager);
newGroup.add(firstAction);
newGroup.add(secondAction);
newGroup.add(thirdAction);
newGroup.add(fourthAction);
newGroup.add(fifthAction);
newGroup.add(sixthAction);
defaultActionGroup.addAll(newGroup);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addCollectionOfActions() {
// given
mockRegisterActions();
List<Action> actions = new ArrayList<>(Arrays.asList(new Action[] {
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
}));
defaultActionGroup.addAll(actions);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void addActionsWithVarArg() {
// given
mockRegisterActions();
defaultActionGroup.addAll(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).hasSize(6).containsExactly(
firstAction,
secondAction,
thirdAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void removeOneAction() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
defaultActionGroup.remove(thirdAction);
// when
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
// then
assertThat(Arrays.asList(result)).containsExactly(
firstAction,
secondAction,
fourthAction,
fifthAction,
sixthAction
);
}
@Test
public void removeOneActionAndResortConstraints() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
defaultActionGroup.remove(fourthAction);
// then
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
assertThat(Arrays.asList(result)).containsExactly(
firstAction,
secondAction,
thirdAction,
fifthAction,
sixthAction
);
}
@Test
public void removeAllActions() {
// given
mockRegisterActions();
defaultActionGroup.add(firstAction);
defaultActionGroup.add(secondAction);
defaultActionGroup.add(thirdAction);
defaultActionGroup.add(fourthAction);
defaultActionGroup.add(fifthAction);
defaultActionGroup.add(sixthAction);
// when
defaultActionGroup.removeAll();
// then
Action[] result = defaultActionGroup.getChildren(mock(ActionEvent.class));
assertThat(Arrays.asList(result)).isEmpty();
}
private void mockRegisterActions() {
when(actionManager.getId(eq(firstAction))).thenReturn("firstAction");
when(actionManager.getId(eq(secondAction))).thenReturn("secondAction");
when(actionManager.getId(eq(thirdAction))).thenReturn("thirdAction");
when(actionManager.getId(eq(fourthAction))).thenReturn("fourthAction");
when(actionManager.getId(eq(fifthAction))).thenReturn("fifthAction");
when(actionManager.getId(eq(sixthAction))).thenReturn("sixthAction");
}
}