package org.zanata.webtrans.client.presenter;
import java.util.Date;
import java.util.List;
import org.hamcrest.Matchers;
import org.mockito.Answers;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import org.zanata.common.ContentState;
import org.zanata.webtrans.client.events.CopyDataToEditorEvent;
import org.zanata.webtrans.client.events.KeyShortcutEvent;
import org.zanata.webtrans.client.events.NotificationEvent;
import org.zanata.webtrans.client.events.ReviewCommentEvent;
import org.zanata.webtrans.client.keys.KeyShortcut;
import org.zanata.webtrans.client.keys.Keys;
import org.zanata.webtrans.client.resources.WebTransMessages;
import org.zanata.webtrans.client.rpc.CachingDispatchAsync;
import org.zanata.webtrans.client.service.GetTransUnitActionContextHolder;
import org.zanata.webtrans.client.ui.TranslationHistoryDisplay;
import org.zanata.webtrans.shared.model.ComparableByDate;
import org.zanata.webtrans.shared.model.DocumentId;
import org.zanata.webtrans.shared.model.ReviewComment;
import org.zanata.webtrans.shared.model.ReviewCommentId;
import org.zanata.webtrans.shared.model.TransHistoryItem;
import org.zanata.webtrans.shared.model.TransUnitId;
import org.zanata.webtrans.shared.rpc.AddReviewCommentAction;
import org.zanata.webtrans.shared.rpc.AddReviewCommentResult;
import org.zanata.webtrans.shared.rpc.GetTranslationHistoryAction;
import org.zanata.webtrans.shared.rpc.GetTranslationHistoryResult;
import com.google.common.collect.Lists;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.user.cellview.client.ColumnSortEvent;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.google.gwt.view.client.SelectionChangeEvent;
import net.customware.gwt.presenter.client.EventBus;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* @author Patrick Huang <a
* href="mailto:pahuang@redhat.com">pahuang@redhat.com</a>
*/
@Test(groups = "unit-tests")
public class TranslationHistoryPresenterTest {
private TranslationHistoryPresenter presenter;
@Mock
private TranslationHistoryDisplay display;
@Mock
private EventBus eventBus;
@Mock
private CachingDispatchAsync dispatcher;
@Mock
private WebTransMessages messages;
@Mock
private TargetContentsPresenter targetContentsPresenter;
@Mock
private SelectionChangeEvent selectionChangeEvent;
@Captor
private ArgumentCaptor<ColumnSortEvent.ListHandler<TransHistoryItem>> sortHandlerCaptor;
@Captor
private ArgumentCaptor<GetTranslationHistoryAction> actionCaptor;
@Captor
private ArgumentCaptor<AsyncCallback<GetTranslationHistoryResult>> resultCaptor;
private final TransUnitId transUnitId = new TransUnitId(1L);
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private GetTransUnitActionContextHolder contextHolder;
@Mock
private KeyShortcutPresenter keyShortcutPresenter;
@Captor
private ArgumentCaptor<KeyShortcut> keyShortcutCapture;
@BeforeMethod
public void beforeMethod() {
MockitoAnnotations.initMocks(this);
presenter =
new TranslationHistoryPresenter(display, eventBus, dispatcher,
messages, contextHolder, keyShortcutPresenter);
presenter.setCurrentValueHolder(targetContentsPresenter);
doNothing().when(dispatcher).execute(actionCaptor.capture(),
resultCaptor.capture());
verify(eventBus).addHandler(ReviewCommentEvent.TYPE, presenter);
verify(keyShortcutPresenter).register(keyShortcutCapture.capture());
}
private static TransHistoryItem historyItem(String versionNum) {
return new TransHistoryItem(versionNum, Lists.newArrayList("a"),
ContentState.Approved, "admin", new Date());
}
@Test
public void willNotifyErrorAndHideTranslationHistoryOnFailure() {
// Given:
when(messages.translationHistory()).thenReturn("translation history");
// When: request history for trans unit id 1
presenter.showTranslationHistory(transUnitId);
// Then:
verify(display).setTitle("translation history");
verify(display).resetView();
verify(display).center();
assertThat(actionCaptor.getValue().getTransUnitId(),
Matchers.equalTo(transUnitId));
// And on failure
AsyncCallback<GetTranslationHistoryResult> result =
resultCaptor.getValue();
result.onFailure(new RuntimeException());
verify(eventBus).fireEvent(isA(NotificationEvent.class));
verify(display).hide();
}
@Test
public void willShowTranslationHistoryOnSuccess() {
// Given: text flow has one history item and one latest translation
when(messages.translationHistory()).thenReturn("translation history");
TransHistoryItem historyItem = historyItem("1");
String latestVersion = "2";
TransHistoryItem latest = historyItem(latestVersion);
// latest contents and current contents are equal
when(targetContentsPresenter.getNewTargets()).thenReturn(
Lists.newArrayList(latest.getContents()));
when(messages.latest()).thenReturn("latest");
// When: request history for trans unit id 1
presenter.showTranslationHistory(transUnitId);
// Then:on success
verify(display).setTitle("translation history");
verify(display).resetView();
verify(display).center();
AsyncCallback<GetTranslationHistoryResult> result =
resultCaptor.getValue();
result.onSuccess(createTranslationHistory(latest, historyItem));
verify(display).setData(
Lists.<ComparableByDate> newArrayList(latest, historyItem));
}
@Test
public void willShowTranslationHistoryWithUnsavedValueOnSuccess() {
// Given: text flow has one history item and one latest translation
TransHistoryItem historyItem = historyItem("1");
String latestVersion = "2";
TransHistoryItem latest = historyItem(latestVersion);
// latest contents and current contents are NOT equal
when(targetContentsPresenter.getNewTargets()).thenReturn(
Lists.newArrayList("b"));
when(messages.latest()).thenReturn("latest");
when(messages.unsaved()).thenReturn("unsaved");
// When: request history for trans unit id 1
presenter.showTranslationHistory(transUnitId);
// Then: on success
AsyncCallback<GetTranslationHistoryResult> result =
resultCaptor.getValue();
result.onSuccess(createTranslationHistory(latest, historyItem));
ArgumentCaptor<List> listArgumentCaptor =
ArgumentCaptor.forClass(List.class);
verify(display).setData(listArgumentCaptor.capture());
assertThat((List<ComparableByDate>) listArgumentCaptor.getValue(),
Matchers.<ComparableByDate> hasSize(3));
}
private static GetTranslationHistoryResult createTranslationHistory(
TransHistoryItem latest, TransHistoryItem... historyItems) {
return new GetTranslationHistoryResult(
Lists.newArrayList(historyItems), latest,
Lists.<ReviewComment> newArrayList());
}
@Test
public void canCopyIntoEditor() {
List<String> contents = Lists.newArrayList("a");
presenter.copyIntoEditor(contents);
ArgumentCaptor<CopyDataToEditorEvent> eventCaptor =
ArgumentCaptor.forClass(CopyDataToEditorEvent.class);
verify(eventBus).fireEvent(eventCaptor.capture());
assertThat(eventCaptor.getValue().getTargetResult(),
Matchers.equalTo(contents));
}
@Test
public void testAddComment() throws Exception {
when(contextHolder.getContext().getDocument().getId()).thenReturn(
new DocumentId(1L, "doc"));
ArgumentCaptor<AddReviewCommentAction> actionCaptor =
ArgumentCaptor.forClass(AddReviewCommentAction.class);
ArgumentCaptor<AsyncCallback> resultCaptor =
ArgumentCaptor.forClass(AsyncCallback.class);
presenter.addComment("some comment");
verify(dispatcher).execute(actionCaptor.capture(),
resultCaptor.capture());
assertThat(actionCaptor.getValue().getContent(),
Matchers.equalTo("some comment"));
AsyncCallback<AddReviewCommentResult> callback =
resultCaptor.getValue();
AddReviewCommentResult result =
new AddReviewCommentResult(new ReviewComment());
callback.onSuccess(result);
verify(display).addCommentToList(result.getComment());
verify(display).clearInput();
}
@Test
public void canDisplayEntriesInOrder() {
// no unsaved content
when(targetContentsPresenter.getNewTargets()).thenReturn(
Lists.newArrayList("a"));
long now = new Date().getTime();
// items in time order
TransHistoryItem latest =
new TransHistoryItem("5", Lists.newArrayList("a"),
ContentState.Approved, "admin", new Date(now - 1000));
TransHistoryItem item =
new TransHistoryItem("4", Lists.newArrayList("a"),
ContentState.Approved, "admin", new Date(now - 2000));
ReviewComment comment =
new ReviewComment(new ReviewCommentId(1L), "comment", "admin",
new Date(now), 5);
presenter.displayEntries(latest, Lists.newArrayList(item),
Lists.newArrayList(comment));
ArgumentCaptor<List> listArgumentCaptor =
ArgumentCaptor.forClass(List.class);
verify(display).setData(listArgumentCaptor.capture());
List<ComparableByDate> result =
(List<ComparableByDate>) listArgumentCaptor.getValue();
assertThat(result,
Matchers.<ComparableByDate> contains(comment, latest, item));
}
@Test
public void onCompareClickedWhenThePairIsNotFull() {
// the pair is empty initially
presenter.compareClicked(historyItem("5"));
verify(display).disableComparison();
}
@Test
public void onCompareClickedWhichMakesTwoItems() {
when(messages.translationHistoryComparison("5", "4")).thenReturn(
"comparison of 5 and 4");
TransHistoryItem one = historyItem("5");
presenter.compareClicked(one);
verify(display).disableComparison();
TransHistoryItem two = historyItem("4");
presenter.compareClicked(two);
verify(display).showDiff(one, two, "comparison of 5 and 4");
}
@Test
public void testKeyShortcutForAddComment() {
when(display.getComment()).thenReturn("blah");
KeyShortcut keyShortcut = keyShortcutCapture.getValue();
assertThat(keyShortcut.getAllKeys().iterator().next(),
Matchers.equalTo(new Keys(Keys.CTRL_KEY, KeyCodes.KEY_ENTER)));
keyShortcut.getHandler().onKeyShortcut(mock(KeyShortcutEvent.class));
verify(display).getComment();
verify(dispatcher).execute(Mockito.isA(AddReviewCommentAction.class),
Mockito.isA(AsyncCallback.class));
}
}