unit test

zanata-war/src/test/java/org/zanata/model/TestFixture.java

@@ -35,15 +35,21 @@
 
 public class TestFixture
 {
-   public static TransUnit makeTransUnit(int id)
+   public static TransUnit makeTransUnit(long id)
    {
       return makeTransUnit(id, ContentState.New);
    }
 
-   public static TransUnit makeTransUnit(int id, ContentState contentState)
+   public static TransUnit makeTransUnit(long id, ContentState contentState, String targetContent)
    {
       return TransUnit.Builder.newTransUnitBuilder().setId(id).setResId("resId" + id).setVerNum(0)
-            .setLocaleId("en").addSource("source").addTargets("target").setStatus(contentState).setRowIndex(id).build();
+            .setLocaleId("en").addSource("source").addTargets(targetContent).setStatus(contentState).setRowIndex((int) id).build();
+   }
+
+   public static TransUnit makeTransUnit(long id, ContentState contentState)
+   {
+      return TransUnit.Builder.newTransUnitBuilder().setId(id).setResId("resId" + id).setVerNum(0)
+            .setLocaleId("en").addSource("source").addTargets("target").setStatus(contentState).setRowIndex((int) id).build();
    }
 
    public static HTextFlow makeHTextFlow(long id, HLocale hLocale, ContentState contentState)

zanata-war/src/test/java/org/zanata/webtrans/client/service/SinglePageDataModelImplTest.java

@@ -0,0 +1,135 @@
+package org.zanata.webtrans.client.service;
+
+import java.util.List;
+
+import org.hamcrest.Matchers;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import org.zanata.common.ContentState;
+import org.zanata.model.TestFixture;
+import org.zanata.webtrans.shared.model.TransUnit;
+import org.zanata.webtrans.shared.model.TransUnitId;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+import static org.hamcrest.MatcherAssert.*;
+import static org.zanata.webtrans.client.service.NavigationService.UNSELECTED;
+
+/**
+ * @author Patrick Huang <a href="mailto:pahuang@redhat.com">pahuang@redhat.com</a>
+ */
+@Test(groups = "unit-tests")
+public class SinglePageDataModelImplTest
+{
+   private SinglePageDataModelImpl model;
+   // @formatter:off
+   private List<TransUnit> data = Lists.newArrayList(
+         TestFixture.makeTransUnit(1),
+         TestFixture.makeTransUnit(2),
+         TestFixture.makeTransUnit(3)
+   );
+   // @formatter:on
+
+
+   @BeforeMethod
+   public void setUp() throws Exception
+   {
+      model = new SinglePageDataModelImpl();
+   }
+
+
+   @Test
+   public void canSetDataAndResetCurrentRowToUnselected()
+   {
+      assertThat(model.getData(), Matchers.is(Matchers.<TransUnit>empty()));
+
+      model.setData(data);
+
+      assertThat(model.getCurrentRow(), Matchers.equalTo(UNSELECTED));
+      assertThat(model.getData(), Matchers.is(data));
+
+      model.setSelected(1);
+      assertThat(model.getCurrentRow(), Matchers.equalTo(1));
+      model.setData(data);
+      assertThat(model.getCurrentRow(), Matchers.equalTo(UNSELECTED));
+   }
+
+   @Test
+   public void canGetByIdOrNull()
+   {
+      model.setData(data);
+
+      TransUnit found = model.getByIdOrNull(new TransUnitId(2));
+      assertThat(found, Matchers.equalTo(data.get(1)));
+
+      TransUnit notFound = model.getByIdOrNull(new TransUnitId(99));
+      assertThat(notFound, Matchers.is(Matchers.nullValue()));
+   }
+
+   @Test
+   public void canFindIndexById()
+   {
+      model.setData(data);
+
+      int index = model.findIndexById(new TransUnitId(3));
+      assertThat(index, Matchers.is(2));
+
+      int notFoundIndex = model.findIndexById(new TransUnitId(99));
+      assertThat(notFoundIndex, Matchers.is(UNSELECTED));
+   }
+
+   @Test
+   public void canSetSelectedByIndex()
+   {
+      model.setData(data);
+
+      model.setSelected(2);
+
+      assertThat(model.getCurrentRow(), Matchers.is(2));
+      assertThat(model.getSelectedOrNull(), Matchers.sameInstance(data.get(2)));
+   }
+
+   @Test
+   public void selectedIsNullIfIndexIsOutOfRange()
+   {
+      model.setData(data);
+
+      model.setSelected(-1);
+
+      TransUnit result = model.getSelectedOrNull();
+      assertThat(result, Matchers.is(Matchers.nullValue()));
+   }
+
+   @Test
+   public void willUpdateModelIfInCurrentPage()
+   {
+      TransUnitId updatedTUId = new TransUnitId(3);
+      TransUnit updatedTransUnit = TestFixture.makeTransUnit(3, ContentState.Approved);
+      List<TransUnit> oldData = ImmutableList.copyOf(data);
+
+      model.setData(data);
+      assertThat(model.getByIdOrNull(updatedTUId), Matchers.not(Matchers.sameInstance(updatedTransUnit)));
+
+      boolean updated = model.updateIfInCurrentPage(updatedTransUnit);
+
+      assertThat(updated, Matchers.is(true));
+      assertThat(model.getData(), Matchers.not(Matchers.equalTo(oldData)));
+      assertThat(model.getByIdOrNull(updatedTUId), Matchers.sameInstance(updatedTransUnit));
+   }
+
+   @Test
+   public void willNotUpdateModelIfNotInCurrentPage()
+   {
+      TransUnitId updatedTUId = new TransUnitId(9);
+      TransUnit updatedTransUnit = TestFixture.makeTransUnit(9, ContentState.Approved);
+      List<TransUnit> oldData = ImmutableList.copyOf(data);
+
+      model.setData(data);
+      assertThat(model.getByIdOrNull(updatedTUId), Matchers.not(Matchers.sameInstance(updatedTransUnit)));
+
+      boolean updated = model.updateIfInCurrentPage(updatedTransUnit);
+
+      assertThat(updated, Matchers.is(false));
+      assertThat(model.getData(), Matchers.equalTo(oldData));
+   }
+}

zanata-war/src/test/java/org/zanata/webtrans/client/service/TransUnitSaveServiceTest.java

@@ -0,0 +1,231 @@
+package org.zanata.webtrans.client.service;
+
+import org.hamcrest.Matchers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+import org.zanata.common.ContentState;
+import org.zanata.model.TestFixture;
+import org.zanata.webtrans.client.editor.table.TargetContentsPresenter;
+import org.zanata.webtrans.client.events.NotificationEvent;
+import org.zanata.webtrans.client.events.TransUnitSaveEvent;
+import org.zanata.webtrans.client.resources.TableEditorMessages;
+import org.zanata.webtrans.client.rpc.CachingDispatchAsync;
+import org.zanata.webtrans.client.ui.GoToRowLink;
+import org.zanata.webtrans.client.ui.InlineLink;
+import org.zanata.webtrans.client.ui.UndoLink;
+import org.zanata.webtrans.shared.model.DocumentId;
+import org.zanata.webtrans.shared.model.TransUnit;
+import org.zanata.webtrans.shared.model.TransUnitId;
+import org.zanata.webtrans.shared.model.TransUnitUpdateInfo;
+import org.zanata.webtrans.shared.model.TransUnitUpdateRequest;
+import org.zanata.webtrans.shared.rpc.TransUnitUpdated;
+import org.zanata.webtrans.shared.rpc.UpdateTransUnit;
+import org.zanata.webtrans.shared.rpc.UpdateTransUnitResult;
+import com.google.common.collect.Lists;
+import com.google.gwt.user.client.rpc.AsyncCallback;
+import com.google.inject.Provider;
+
+import net.customware.gwt.presenter.client.EventBus;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+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 TransUnitSaveServiceTest
+{
+   private TransUnitSaveService service;
+   @Mock
+   private EventBus eventBus;
+   @Mock
+   private CachingDispatchAsync dispatcher;
+   @Mock
+   private Provider<UndoLink> undoProvider;
+   @Mock
+   private TargetContentsPresenter targetContentsPresenter;
+   @Mock
+   private TableEditorMessages messages;
+   @Mock
+   private NavigationService navigationService;
+   @Mock
+   private Provider<GoToRowLink> goToRowProvider;
+   @Captor
+   private ArgumentCaptor<UpdateTransUnit> actionCaptor;
+   @Captor
+   private ArgumentCaptor<AsyncCallback<UpdateTransUnitResult>> resultCaptor;
+   private static final TransUnitId TRANS_UNIT_ID = new TransUnitId(1);
+   private static final int VER_NUM = 9;
+   @Mock
+   private UndoLink undoLink;
+   @Mock
+   private GoToRowLink goToLink;
+
+   @BeforeMethod
+   public void setUp() throws Exception
+   {
+      MockitoAnnotations.initMocks(this);
+      service = new TransUnitSaveService(eventBus, dispatcher, undoProvider, targetContentsPresenter, messages, navigationService, goToRowProvider);
+   }
+
+   private static TransUnitSaveEvent event(String newContent, ContentState status, TransUnitId transUnitId, int verNum, String oldContent)
+   {
+      return new TransUnitSaveEvent(Lists.newArrayList(newContent), status, transUnitId, verNum, Lists.newArrayList(oldContent));
+   }
+
+   @Test
+   public void onSaveDoNothingIfStateHasNotChanged()
+   {
+      // Given: old state and content are equal to saving state and content
+      TransUnit old = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.Approved, "old content");
+      when(navigationService.getByIdOrNull(TRANS_UNIT_ID)).thenReturn(old);
+
+
+      // When:
+      service.onTransUnitSave(event("old content", ContentState.Approved, TRANS_UNIT_ID, VER_NUM, "old content"));
+
+      // Then:
+      verify(navigationService).getByIdOrNull(TRANS_UNIT_ID);
+      verifyNoMoreInteractions(navigationService);
+      verifyZeroInteractions(dispatcher, eventBus, targetContentsPresenter);
+   }
+
+   @Test
+   public void willSaveIfSomethingHasChanged()
+   {
+      // Given:
+      TransUnit old = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "old content");
+      when(navigationService.getByIdOrNull(TRANS_UNIT_ID)).thenReturn(old);
+
+      // When: save as approved
+      service.onTransUnitSave(event("new content", ContentState.Approved, TRANS_UNIT_ID, VER_NUM, "old content"));
+
+      // Then:
+      verify(dispatcher).execute(actionCaptor.capture(), resultCaptor.capture());
+
+      UpdateTransUnit updateTransUnit = actionCaptor.getValue();
+      assertThat(updateTransUnit.getUpdateRequests(), hasSize(1));
+      assertThat(updateTransUnit.getUpdateType(), equalTo(TransUnitUpdated.UpdateType.WebEditorSave));
+
+      TransUnitUpdateRequest request = updateTransUnit.getUpdateRequests().get(0);
+      assertThat(request.getTransUnitId(), equalTo(TRANS_UNIT_ID));
+      assertThat(request.getNewContents(), Matchers.contains("new content"));
+      assertThat(request.getBaseTranslationVersion(), equalTo(VER_NUM));
+      assertThat(request.getNewContentState(), equalTo(ContentState.Approved));
+   }
+
+   @Test
+   public void onRPCSuccessAndSaveReturnSuccess()
+   {
+      // Given:
+      TransUnit old = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "old content");
+      when(navigationService.getByIdOrNull(TRANS_UNIT_ID)).thenReturn(old);
+
+      // When: save as fuzzy
+      service.onTransUnitSave(event("new content", ContentState.NeedReview, TRANS_UNIT_ID, VER_NUM, "old content"));
+
+      // Then:
+      verify(dispatcher).execute(actionCaptor.capture(), resultCaptor.capture());
+      assertThat(actionCaptor.getValue().getUpdateType(), equalTo(TransUnitUpdated.UpdateType.WebEditorSaveFuzzy));
+
+      // on save success
+      // Given: result comes back with saving successful
+      int rowIndex = 1;
+      when(messages.notifyUpdateSaved(rowIndex, TRANS_UNIT_ID.toString())).thenReturn("saved row 1, id 1");
+      when(navigationService.findRowIndexById(TRANS_UNIT_ID)).thenReturn(rowIndex);
+      when(undoProvider.get()).thenReturn(undoLink);
+
+      AsyncCallback<UpdateTransUnitResult> callback = resultCaptor.getValue();
+      TransUnit updatedTU = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "new content");
+      UpdateTransUnitResult result = result(true, updatedTU, ContentState.NeedReview);
+
+      // When:
+      callback.onSuccess(result);
+
+      // Then:
+      ArgumentCaptor<NotificationEvent> notificationEventCaptor = ArgumentCaptor.forClass(NotificationEvent.class);
+      verify(eventBus).fireEvent(notificationEventCaptor.capture());
+      NotificationEvent event = notificationEventCaptor.getValue();
+      assertThat(event.getSeverity(), is(NotificationEvent.Severity.Info));
+      assertThat(event.getMessage(), equalTo("saved row 1, id 1"));
+      verify(undoLink).prepareUndoFor(result);
+      verify(targetContentsPresenter).addUndoLink(rowIndex, undoLink);
+   }
+
+   @Test
+   public void onPRCSuccessButSaveUnsuccessfulInResult()
+   {
+      // Given:
+      TransUnit old = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "old content");
+      when(navigationService.getByIdOrNull(TRANS_UNIT_ID)).thenReturn(old);
+
+      // When: save as fuzzy
+      service.onTransUnitSave(event("new content", ContentState.NeedReview, TRANS_UNIT_ID, VER_NUM, "old content"));
+
+      // Then:
+      verify(dispatcher).execute(actionCaptor.capture(), resultCaptor.capture());
+
+      // on save success
+      // Given: result comes back but saving operation failed
+      when(messages.notifyUpdateFailed("id " + TRANS_UNIT_ID)).thenReturn("update failed");
+      when(goToRowProvider.get()).thenReturn(goToLink);
+
+      AsyncCallback<UpdateTransUnitResult> callback = resultCaptor.getValue();
+      TransUnit updatedTU = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "new content");
+      UpdateTransUnitResult result = result(false, updatedTU, ContentState.NeedReview);
+
+      // When:
+      callback.onSuccess(result);
+
+      // Then:
+      verify(goToLink).prepare("", TRANS_UNIT_ID);
+      ArgumentCaptor<NotificationEvent> notificationEventCaptor = ArgumentCaptor.forClass(NotificationEvent.class);
+      verify(eventBus).fireEvent(notificationEventCaptor.capture());
+      NotificationEvent event = notificationEventCaptor.getValue();
+      assertThat(event.getSeverity(), is(NotificationEvent.Severity.Error));
+      assertThat(event.getMessage(), equalTo("update failed"));
+      assertThat(event.getInlineLink(), Matchers.<InlineLink>sameInstance(goToLink));
+   }
+
+   @Test
+   public void onPRCFailure()
+   {
+      // Given:
+      TransUnit old = TestFixture.makeTransUnit(TRANS_UNIT_ID.getId(), ContentState.NeedReview, "old content");
+      when(navigationService.getByIdOrNull(TRANS_UNIT_ID)).thenReturn(old);
+
+      // When: save as fuzzy
+      TransUnitSaveEvent saveEvent = event("new content", ContentState.NeedReview, TRANS_UNIT_ID, VER_NUM, "old content");
+      service.onTransUnitSave(saveEvent);
+      verify(dispatcher).execute(actionCaptor.capture(), resultCaptor.capture());
+      // on rpc failure:
+
+      // Then: will reset value back
+      AsyncCallback<UpdateTransUnitResult> callback = resultCaptor.getValue();
+      when(messages.notifyUpdateFailed("doh")).thenReturn("update failed");
+      when(goToRowProvider.get()).thenReturn(goToLink);
+      callback.onFailure(new RuntimeException("doh"));
+      verify(targetContentsPresenter).updateTargets(saveEvent.getTransUnitId(), saveEvent.getOldContents());
+      ArgumentCaptor<NotificationEvent> notificationEventCaptor = ArgumentCaptor.forClass(NotificationEvent.class);
+      verify(eventBus).fireEvent(notificationEventCaptor.capture());
+      NotificationEvent event = notificationEventCaptor.getValue();
+      assertThat(event.getSeverity(), is(NotificationEvent.Severity.Error));
+      assertThat(event.getMessage(), equalTo("update failed"));
+      assertThat(event.getInlineLink(), Matchers.<InlineLink>sameInstance(goToLink));
+   }
+
+   private static UpdateTransUnitResult result(boolean success, TransUnit transUnit, ContentState previousState)
+   {
+      return new UpdateTransUnitResult(new TransUnitUpdateInfo(success, true, new DocumentId(1), transUnit, 9, VER_NUM, previousState));
+   }
+}