How to use

builder

method

in

org.apache.james.mailbox.model.MessageMoves

public void setInMailboxesNoCheck(MessageId messageId, MailboxId targetMailboxId, MailboxSession mailboxSession) throws MailboxException {
  MessageIdMapper messageIdMapper = mailboxSessionMapperFactory.getMessageIdMapper(mailboxSession);
  List<MailboxMessage> currentMailboxMessages = messageIdMapper.find(ImmutableList.of(messageId), MessageMapper.FetchType.Full);
  MessageMoves messageMoves = MessageMoves.builder()
    .previousMailboxIds(toMailboxIds(currentMailboxMessages))
    .targetMailboxIds(targetMailboxId)
    .build();
  if (messageMoves.isChange()) {
    applyMessageMoveNoMailboxChecks(mailboxSession, currentMailboxMessages, messageMoves);
  }
}

@Override
public void setInMailboxes(MessageId messageId, Collection<MailboxId> targetMailboxIds, MailboxSession mailboxSession) throws MailboxException {
  assertRightsOnMailboxes(targetMailboxIds, mailboxSession, Right.Read);
  List<MailboxMessage> currentMailboxMessages = findRelatedMailboxMessages(messageId, mailboxSession);
  if (currentMailboxMessages.isEmpty()) {
    LOGGER.info("Tried to access {} not accessible for {}", messageId, mailboxSession.getUser().getUserName());
    return;
  }
  MessageMoves messageMoves = MessageMoves.builder()
    .targetMailboxIds(targetMailboxIds)
    .previousMailboxIds(toMailboxIds(currentMailboxMessages))
    .build();
  if (messageMoves.isChange()) {
    applyMessageMoves(mailboxSession, currentMailboxMessages, messageMoves);
  }
}

private SortedMap<MessageUid, MessageMetaData> copy(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException {
  IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session));
  SortedMap<MessageUid, MessageMetaData> copiedUids = collectMetadata(to.copy(originalRows, session));
  ImmutableMap.Builder<MessageUid, MailboxMessage> messagesMap = ImmutableMap.builder();
  for (MailboxMessage message : originalRows.getEntriesSeen()) {
    messagesMap.put(message.getUid(), immutableMailboxMessageFactory.from(to.getMailboxEntity().getMailboxId(), message));
  }
  dispatcher.added(session, copiedUids, to.getMailboxEntity(), messagesMap.build());
  dispatcher.moved(session,
    MessageMoves.builder()
      .previousMailboxIds(getMailboxEntity().getMailboxId())
      .targetMailboxIds(to.getMailboxEntity().getMailboxId(), getMailboxEntity().getMailboxId())
      .build(),
    messagesMap.build());
  return copiedUids;
}

private SortedMap<MessageUid, MessageMetaData> move(MessageRange set, StoreMessageManager to, MailboxSession session) throws MailboxException {
  IteratorWrapper<MailboxMessage> originalRows = new IteratorWrapper<>(retrieveOriginalRows(set, session));
  MoveResult moveResult = to.move(originalRows, session);
  SortedMap<MessageUid, MessageMetaData> moveUids = collectMetadata(moveResult.getMovedMessages());
  ImmutableMap.Builder<MessageUid, MailboxMessage> messagesMap = ImmutableMap.builder();
  for (MailboxMessage message : originalRows.getEntriesSeen()) {
    messagesMap.put(message.getUid(), immutableMailboxMessageFactory.from(to.getMailboxEntity().getMailboxId(), message));
  }
  dispatcher.added(session, moveUids, to.getMailboxEntity(), messagesMap.build());
  dispatcher.expunged(session, collectMetadata(moveResult.getOriginalMessages()), getMailboxEntity());
  dispatcher.moved(session,
    MessageMoves.builder()
      .previousMailboxIds(getMailboxEntity().getMailboxId())
      .targetMailboxIds(to.getMailboxEntity().getMailboxId())
      .build(),
    messagesMap.build());
  return moveUids;
}

@Test
public void eventShouldCallSpamAssassinSpamLearningWhenTheEventMatches() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(mailboxId1)
      .targetMailboxIds(spamMailboxId)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId1)))
    .build();
  listener.event(messageMoveEvent);
  verify(spamAssassin).learnSpam(any(), any());
}

@Test
public void isEventOnSpamMailboxShouldReturnFalseWhenMailboxIsSpamOtherCase() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(mailboxId1)
      .targetMailboxIds(spamCapitalMailboxId)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId1)))
    .build();
  assertThat(listener.isMessageMovedToSpamMailbox(messageMoveEvent)).isFalse();
}

@Test
public void isEventOnSpamMailboxShouldReturnTrueWhenMailboxIsSpam() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(mailboxId1)
      .targetMailboxIds(spamMailboxId)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId1)))
    .build();
  assertThat(listener.isMessageMovedToSpamMailbox(messageMoveEvent)).isTrue();
}

@Test
public void eventShouldCallSpamAssassinHamLearningWhenTheEventMatches() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(spamMailboxId)
      .targetMailboxIds(mailboxId1)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId1)))
    .build();
  listener.event(messageMoveEvent);
  verify(spamAssassin).learnHam(any(), any());
}

@Test
public void isMessageMovedOutOfSpamMailboxShouldReturnTrueWhenMessageMovedOutOfSpamMailbox() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(spamMailboxId)
      .targetMailboxIds(mailboxId2)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId2)))
    .build();
  assertThat(listener.isMessageMovedOutOfSpamMailbox(messageMoveEvent)).isTrue();
}

@Test
public void isMessageMovedOutOfSpamMailboxShouldReturnFalseWhenMessageMovedOutOfCapitalSpamMailbox() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(spamCapitalMailboxId)
      .targetMailboxIds(mailboxId2)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId2)))
    .build();
  assertThat(listener.isMessageMovedOutOfSpamMailbox(messageMoveEvent)).isFalse();
}

@Test
public void isEventOnSpamMailboxShouldReturnFalseWhenMessageIsMovedToANonSpamMailbox() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(mailboxId1)
      .targetMailboxIds(mailboxId2)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId2)))
    .build();
  assertThat(listener.isMessageMovedToSpamMailbox(messageMoveEvent)).isFalse();
}

@Test
public void isMessageMovedOutOfSpamMailboxShouldReturnFalseWhenMessageMovedBetweenNonSpamMailboxes() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(mailboxId1)
      .targetMailboxIds(mailboxId2)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId2)))
    .build();
  assertThat(listener.isMessageMovedOutOfSpamMailbox(messageMoveEvent)).isFalse();
}

@Test
public void isMessageMovedOutOfSpamMailboxShouldReturnFalseWhenMessageMovedToTrash() {
  MessageMoveEvent messageMoveEvent = MessageMoveEvent.builder()
    .session(MAILBOX_SESSION)
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(spamMailboxId)
      .targetMailboxIds(trashMailboxId)
      .build())
    .messages(ImmutableMap.of(MessageUid.of(45),
      createMessage(mailboxId2)))
    .build();
  assertThat(listener.isMessageMovedOutOfSpamMailbox(messageMoveEvent)).isFalse();
}

@Test
public void builderShouldReturnNoopWhenMessagesIsEmpty() {
  assertThat(MessageMoveEvent.builder()
      .session(MailboxSessionUtil.create("user@james.org"))
      .messageMoves(MessageMoves.builder()
        .previousMailboxIds(TestId.of(1))
        .targetMailboxIds(TestId.of(2))
        .build())
      .build()
    .isNoop()).isTrue();
}

@Test
public void isMoveToShouldReturnFalseWhenMailboxIdIsNotInAddedMailboxIds() {
  MessageMoveEvent event = MessageMoveEvent.builder()
    .session(MailboxSessionUtil.create("user@james.org"))
    .messageMoves(MessageMoves.builder()
        .previousMailboxIds(TestId.of(1))
        .targetMailboxIds(TestId.of(2))
        .build())
    .build();
  assertThat(event.isMoveTo(TestId.of(123))).isFalse();
}

@Test
public void isMoveToShouldReturnTrueWhenMailboxIdIsInAddedMailboxIds() {
  TestId mailboxId = TestId.of(123);
  MessageMoveEvent event = MessageMoveEvent.builder()
    .session(MailboxSessionUtil.create("user@james.org"))
    .messageMoves(MessageMoves.builder()
      .previousMailboxIds(TestId.of(1))
      .targetMailboxIds(TestId.of(2), mailboxId)
      .build())
    .build();
  assertThat(event.isMoveTo(mailboxId)).isTrue();
}

@Test
public void isMoveFromShouldReturnFalseWhenMailboxIdIsNotInRemovedMailboxIds() {
  MessageMoveEvent event = MessageMoveEvent.builder()
    .session(MailboxSessionUtil.create("user@james.org"))
    .messageMoves(MessageMoves.builder()
        .previousMailboxIds(TestId.of(1))
        .targetMailboxIds(TestId.of(2))
        .build())
    .build();
  assertThat(event.isMoveFrom(TestId.of(123))).isFalse();
}

  @Test
  public void isMoveFromShouldReturnTrueWhenMailboxIdIsInRemovedMailboxIds() {
    TestId mailboxId = TestId.of(123);
    MessageMoveEvent event = MessageMoveEvent.builder()
      .session(MailboxSessionUtil.create("user@james.org"))
      .messageMoves(MessageMoves.builder()
        .previousMailboxIds(TestId.of(1), mailboxId)
        .targetMailboxIds(TestId.of(2))
        .build())
      .build();

    assertThat(event.isMoveFrom(mailboxId)).isTrue();
  }
}

@Test
public void builderShouldNotBeNoopWhenFieldsAreGiven() {
  MailboxSession session = MailboxSessionUtil.create("user@james.org");
  MessageMoves messageMoves = MessageMoves.builder()
    .targetMailboxIds(TestId.of(2))
    .previousMailboxIds(TestId.of(1))
    .build();
  MessageMoveEvent event = MessageMoveEvent.builder()
    .session(session)
    .messageMoves(messageMoves)
    .messageId(TestMessageId.of(35))
    .build();
  assertThat(event.isNoop()).isFalse();
}

@Test
public void builderShouldBuildWhenFieldsAreGiven() {
  String username = "user@james.org";
  MailboxSession session = MailboxSessionUtil.create(username);
  MessageMoves messageMoves = MessageMoves.builder()
    .targetMailboxIds(TestId.of(2))
    .previousMailboxIds(TestId.of(1))
    .build();
  TestMessageId messageId = TestMessageId.of(45);
  MessageMoveEvent event = MessageMoveEvent.builder()
    .session(session)
    .messageMoves(messageMoves)
    .messageId(messageId)
    .build();
  softly.assertThat(event.getUser()).isEqualTo(User.fromUsername(username));
  softly.assertThat(event.getMessageMoves()).isEqualTo(messageMoves);
  softly.assertThat(event.getMessageIds()).containsExactly(messageId);
}