How to use

AsyncMessageResponderWrapper

in

net.usikkert.kouchat.net

/**
 * Receives a file transfer, which may take a long time. Needs to run in a different thread.
 * Handles unidentified users.
 */
@Override
public void fileSend(final int userCode, final long byteSize, final String fileName,
           final String user, final int fileHash) {
  if (controller.isNewUser(userCode)) {
    askUserToIdentify(userCode);
  }
  executorService.execute(new Runnable() {
    @Override
    public void run() {
      waitForUserToIdentify(userCode);
      messageResponder.fileSend(userCode, byteSize, fileName, user, fileHash);
    }
  });
}

  @Override
  public void run() {
    waitForUserToIdentify(userCode);
    messageResponder.fileSend(userCode, byteSize, fileName, user, fileHash);
  }
});

@Test
public void fileSendShouldWaitForUserToIdentifyAndPassThroughUsingExecutor() {
  wrapper.fileSend(100, 3000, "fileName", "user", 98765);
  final ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
  verifyZeroInteractions(messageResponder);
  verify(wrapper, never()).waitForUserToIdentify(anyInt());
  verify(executorService).execute(runnableCaptor.capture());
  runnableCaptor.getValue().run();
  verify(wrapper).waitForUserToIdentify(100);
  verify(messageResponder).fileSend(100, 3000, "fileName", "user", 98765);
}

@Test
public void messageArrivedShouldPassThroughAndNeverAskOrWaitIfExistingUser() {
  when(controller.isNewUser(100)).thenReturn(false);
  wrapper.messageArrived(100, "msg", 200);
  verify(messageResponder).messageArrived(100, "msg", 200);
  verifyZeroInteractions(executorService);
  verify(wrapper, never()).askUserToIdentify(anyInt());
  verify(wrapper, never()).waitForUserToIdentify(anyInt());
}

@Before
public void setUp() {
  messageResponder = mock(MessageResponder.class);
  controller = mock(Controller.class);
  waitingList = mock(WaitingList.class);
  when(controller.getWaitingList()).thenReturn(waitingList);
  wrapper = spy(new AsyncMessageResponderWrapper(messageResponder, controller));
  executorService = TestUtils.setFieldValueWithMock(wrapper, "executorService", ExecutorService.class);
  sleeper = TestUtils.setFieldValueWithMock(wrapper, "sleeper", Sleeper.class);
}

@Test
public void awayChangedShouldPassThroughIfExistingUser() {
  when(controller.isNewUser(100)).thenReturn(false);
  wrapper.awayChanged(100, true, "awayMsg");
  verify(wrapper, never()).askUserToIdentify(anyInt());
  verify(messageResponder).awayChanged(100, true, "awayMsg");
}

@Test
public void fileSendShouldNotAskUserToIdentifyIfExistingUser() {
  when(controller.isNewUser(100)).thenReturn(false);
  wrapper.fileSend(100, 3000, "fileName", "user", 98765);
  verify(wrapper, never()).askUserToIdentify(anyInt());
}

@Test
public void topicChangedShouldPassThroughIfExistingUser() {
  when(controller.isNewUser(100)).thenReturn(false);
  wrapper.topicChanged(100, "newTopic", "nick", 300);
  verify(wrapper, never()).askUserToIdentify(anyInt());
  verify(messageResponder).topicChanged(100, "newTopic", "nick", 300);
}

@Test
public void nickChangedShouldAskUserToIdentifyIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.nickChanged(100, "newNick");
  verify(wrapper).askUserToIdentify(100);
  verify(messageResponder, never()).nickChanged(anyInt(), anyString());
}

@Test
public void userIdleShouldPassThroughIfExistingUser() {
  when(controller.isNewUser(100)).thenReturn(false);
  wrapper.userIdle(100, "ipAddress");
  verify(wrapper, never()).askUserToIdentify(anyInt());
  verify(messageResponder).userIdle(100, "ipAddress");
}

@Test
public void messageArrivedShouldWaitForUserToIdentifyAndPassThroughUsingExecutorIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.messageArrived(100, "msg", 200);
  final ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
  verifyZeroInteractions(messageResponder);
  verify(wrapper, never()).waitForUserToIdentify(anyInt());
  verify(executorService).execute(runnableCaptor.capture());
  runnableCaptor.getValue().run();
  verify(wrapper).waitForUserToIdentify(100);
  verify(messageResponder).messageArrived(100, "msg", 200);
}

@Test
public void messageArrivedShouldAskUserToIdentifyIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.messageArrived(100, "msg", 200);
  verify(wrapper).askUserToIdentify(100);
}

@Test
public void fileSendAcceptedShouldPassThroughUsingExecutor() {
  wrapper.fileSendAccepted(100, "fileName", 98765, 1050);
  final ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
  verifyZeroInteractions(messageResponder);
  verify(executorService).execute(runnableCaptor.capture());
  runnableCaptor.getValue().run();
  verify(messageResponder).fileSendAccepted(100, "fileName", 98765, 1050);
}

@Test
public void exposeRequestedShouldPassThrough() {
  wrapper.exposeRequested();
  verify(messageResponder).exposeRequested();
}

@Test
public void fileSendAbortedShouldPassThrough() {
  wrapper.fileSendAborted(100, "fileName", 98765);
  verify(messageResponder).fileSendAborted(100, "fileName", 98765);
}

@Test
public void clientInfoShouldPassThrough() {
  wrapper.clientInfo(100, "client", 70000, "os",
            4500, 6000);
  verify(messageResponder).clientInfo(100, "client", 70000, "os",
                    4500, 6000);
}

@Test
public void constructorShouldThrowExceptionIfMessageResponderIsNull() {
  expectedException.expect(IllegalArgumentException.class);
  expectedException.expectMessage("MessageResponder can not be null");
  new AsyncMessageResponderWrapper(null, controller);
}

@Test
public void awayChangedShouldAskUserToIdentifyIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.awayChanged(100, true, "awayMsg");
  verify(wrapper).askUserToIdentify(100);
  verify(messageResponder, never()).awayChanged(anyInt(), anyBoolean(), anyString());
}

@Test
public void fileSendShouldAskUserToIdentifyIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.fileSend(100, 3000, "fileName", "user", 98765);
  verify(wrapper).askUserToIdentify(100);
}

@Test
public void topicChangedShouldAskUserToIdentifyIfNewUser() {
  when(controller.isNewUser(100)).thenReturn(true);
  wrapper.topicChanged(100, "newTopic", "nick", 300);
  verify(wrapper).askUserToIdentify(100);
  verify(messageResponder, never()).topicChanged(anyInt(), anyString(), anyString(), anyLong());
}