tests.txt

gistfile1.txt

TEST 1

import com.construction_worker_forum_back.exception.MessageNotFoundException;
import com.construction_worker_forum_back.model.chat.ChatMessage;
import com.construction_worker_forum_back.model.chat.MessageStatus;
import com.construction_worker_forum_back.repository.ChatMessageRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MongoDBContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import java.sql.Date;
import java.time.Instant;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;

@Testcontainers
@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
class ChatMessageRepositoryIntegrationTests {

    @Container
    public static MongoDBContainer mongoDBContainer = new MongoDBContainer("mongo");

    @DynamicPropertySource
    public static void setProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl);
    }

    @Autowired
    ChatMessageRepository chatMessageRepository;
    private String obiWanId;
    private String lukeId;
    private String chatId;
    private ChatMessage messageToLuke;
    private ChatMessage messageToObiWan1;
    private ChatMessage messageToObiWan2;

    @BeforeEach
    void setup() {
        obiWanId = "senderId";
        lukeId = "recipientId";
        chatId = String.format("%s_%s", obiWanId, lukeId);

        messageToLuke = ChatMessage.builder()
                .chatId(chatId)
                .senderId(obiWanId)
                .recipientId(lukeId)
                .senderName("Obi Wan")
                .recipientName("Luke")
                .content("Hello There!")
                .timestamp(Date.from(Instant.now()))
                .status(MessageStatus.DELIVERED)
                .build();

        messageToObiWan1 = ChatMessage.builder()
                .chatId(chatId)
                .senderId(lukeId)
                .recipientId(obiWanId)
                .senderName("Luke")
                .recipientName("Obi Wan")
                .content("Hi!")
                .timestamp(Date.from(Instant.now().plusSeconds(1)))
                .status(MessageStatus.DELIVERED)
                .build();

        messageToObiWan2 = ChatMessage.builder()
                .chatId(chatId)
                .senderId(lukeId)
                .recipientId(obiWanId)
                .senderName("Luke")
                .recipientName("Obi Wan")
                .content("What's up old friend?")
                .timestamp(Date.from(Instant.now().plusSeconds(2)))
                .status(MessageStatus.DELIVERED)
                .build();
    }

    @AfterEach
    void cleanup() {
        chatMessageRepository.deleteAll();
    }

    @Test
    void givenSavedMessages_whenCountedBySenderIdAndRecipientIdAndStatus_thenReturnCorrectCount() {

        // given
        chatMessageRepository.saveAll(List.of(messageToLuke, messageToObiWan1, messageToObiWan2));

        // when
        long messagesCount = chatMessageRepository.countBySenderIdAndRecipientIdAndStatus(lukeId, obiWanId, MessageStatus.DELIVERED);

        // then
        assertEquals(2, messagesCount);
    }

    @Test
    void givenSavedMessages_whenCountedWhileNotExisting_thenReturnZero() {

        // given
        chatMessageRepository.saveAll(List.of(messageToLuke, messageToObiWan1, messageToObiWan2));

        // when
        long messagesCount = chatMessageRepository.countBySenderIdAndRecipientIdAndStatus("notExistingId", obiWanId, MessageStatus.DELIVERED);

        // then
        assertEquals(0, messagesCount);
    }

    @Test
    void givenSavedMessages_whenSearchedByChatId_thenReturnListOfMatchingMessages() {

        // given
        chatMessageRepository.saveAll(List.of(messageToLuke, messageToObiWan1, messageToObiWan2));

        // when
        List<ChatMessage> listOfMessagesByChatId = chatMessageRepository.findByChatId(chatId);

        // then
        assertThat(listOfMessagesByChatId)
                .hasSize(3)
                .allMatch(chatMessage -> Objects.nonNull(chatMessage.getId()))
                .allMatch(chatMessage -> Objects.equals(chatMessage.getChatId(), chatId));
    }

    @Test
    void givenSavedMessages_whenDeletedById_thenRemoveMessageFromDb() {

        // given
        chatMessageRepository.saveAll(List.of(messageToLuke, messageToObiWan1, messageToObiWan2));
        String id = chatMessageRepository
                .findByChatId(chatId)
                .stream()
                .findAny()
                .map(ChatMessage::getId)
                .orElseThrow(() ->
                        new MessageNotFoundException("Could not find message")
                );

        // when
        chatMessageRepository.deleteById(id);

        // then
        Optional<ChatMessage> afterDelete = chatMessageRepository.findById(id);
        List<ChatMessage> listOfMessagesByChatId = chatMessageRepository.findByChatId(chatId);

        assertThat(afterDelete).isNotPresent();
        assertThat(listOfMessagesByChatId)
                .hasSize(2)
                .map(ChatMessage::getId)
                .doesNotContain(id);
    }
}


TEST 2

import com.construction_worker_forum_back.exception.MessageNotFoundException;
import com.construction_worker_forum_back.model.chat.ChatMessage;
import com.construction_worker_forum_back.repository.ChatMessageRepository;
import com.construction_worker_forum_back.service.ChatMessageService;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MongoDBContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import java.sql.Date;
import java.time.Instant;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;

@Testcontainers
@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
class ChatMessageServiceIntegrationTests {

    @Container
    public static MongoDBContainer mongoDBContainer = new MongoDBContainer("mongo");

    @DynamicPropertySource
    public static void setProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl);
    }

    @Autowired
    private ChatMessageRepository chatMessageRepository;
    private ChatMessageService chatMessageService;
    private String obiWanId;
    private String lukeId;
    private String chatId;
    private ChatMessage messageToLuke;

    @BeforeEach
    void setup() {
        chatMessageService = new ChatMessageService(chatMessageRepository);

        obiWanId = "senderId";
        lukeId = "recipientId";
        chatId = String.format("%s_%s", obiWanId, lukeId);

        messageToLuke = ChatMessage.builder()
                .chatId(chatId)
                .senderId(obiWanId)
                .recipientId(lukeId)
                .senderName("Obi Wan")
                .recipientName("Luke")
                .content("Hello There!")
                .timestamp(Date.from(Instant.now()))
                .build();
    }

    @AfterEach
    void cleanup() {
        chatMessageRepository.deleteAll();
    }

    @Test
    void givenChatMessage_whenSavedToDb_thenIdIsNotNull() {

        // given

        // when
        chatMessageService.save(messageToLuke);

        // then
        String id = messageToLuke.getId();
        assertNotNull(id);

        String actualId = chatMessageRepository
                .findById(id)
                .map(ChatMessage::getId)
                .orElseThrow(() ->
                        new MessageNotFoundException("Could not find message")
                );
        assertEquals(id, actualId);
    }
}

TEST 3

import com.construction_worker_forum_back.model.chat.ChatRoom;
import com.construction_worker_forum_back.repository.ChatRoomRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration;
import org.springframework.boot.test.autoconfigure.data.mongo.DataMongoTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MongoDBContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import java.util.List;
import java.util.Optional;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.*;

@Testcontainers
@DataMongoTest(excludeAutoConfiguration = EmbeddedMongoAutoConfiguration.class)
class ChatRoomRepositoryIntegrationTests {

    @Container
    public static MongoDBContainer mongoDBContainer = new MongoDBContainer("mongo");

    @DynamicPropertySource
    public static void setProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.data.mongodb.uri", mongoDBContainer::getReplicaSetUrl);
    }

    @Autowired
    private ChatRoomRepository chatRoomRepository;

    @AfterEach
    void cleanup() {
        chatRoomRepository.deleteAll();
    }

    private final String senderId = "senderId";
    private final String recipientId = "recipientId";
    private final String chatId = String.format("%s_%s", senderId, recipientId);

    private final ChatRoom senderRecipient = ChatRoom.builder()
            .chatId(chatId)
            .senderId(senderId)
            .recipientId(recipientId)
            .build();

    private final ChatRoom recipientSender = ChatRoom.builder()
            .chatId(chatId)
            .senderId(recipientId)
            .recipientId(senderId)
            .build();

    @Test
    void givenChatRooms_whenSavedToDb_thenReturnSavedChatRooms() {

        // given

        // when
        chatRoomRepository.save(senderRecipient);
        chatRoomRepository.save(recipientSender);

        // then
        Optional<ChatRoom> actualChatRoomSenderRecipient = chatRoomRepository.findBySenderIdAndRecipientId(senderId, recipientId);
        Optional<ChatRoom> actualChatRoomRecipientSender = chatRoomRepository.findBySenderIdAndRecipientId(recipientId, senderId);

        assertTrue(actualChatRoomSenderRecipient.isPresent());
        ChatRoom chatRoomSenderRecipient = actualChatRoomSenderRecipient.get();
        assertEquals(chatId, chatRoomSenderRecipient.getChatId());
        assertEquals(senderId, chatRoomSenderRecipient.getSenderId());
        assertEquals(recipientId, chatRoomSenderRecipient.getRecipientId());
        assertNotNull(chatRoomSenderRecipient.getId());

        assertTrue(actualChatRoomRecipientSender.isPresent());
        ChatRoom chatRoomRecipientSender = actualChatRoomRecipientSender.get();
        assertEquals(chatId, chatRoomRecipientSender.getChatId());
        assertEquals(recipientId, chatRoomRecipientSender.getSenderId());
        assertEquals(senderId, chatRoomRecipientSender.getRecipientId());
        assertNotNull(chatRoomRecipientSender.getId());
    }

    @Test
    void givenChatRooms_whenSavedToDb_thenReturnListOfSavedRoomsByChatId() {

        // given

        // when
        chatRoomRepository.save(senderRecipient);
        chatRoomRepository.save(recipientSender);

        // then
        List<ChatRoom> chatRoomsByChatId = chatRoomRepository.findChatRoomsByChatId(chatId);

        assertThat(chatRoomsByChatId)
                .hasSize(2)
                .allMatch(chatRoom -> chatRoom.getChatId().equals(chatId));
    }
}