Merge branch 'main' of gitlab.stud.idi.ntnu.no:team_fullastack/backend_fullstack

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/AnswerRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import ntnu.idatt2105.group44.trivioServer.model.Answer;
+import ntnu.idatt2105.group44.trivioServer.model.Question;
+
+@DataJpaTest
+class AnswerRepositoryTest {
+    @Autowired
+    private AnswerRepository answerRepository;
+
+    @Autowired
+    private QuestionRepository questionRepository;
+
+    @Test
+    void testFindAnswersByQuestionId() {
+        Question question1 = new Question();
+        question1.setQuestion("What is the capital of Norway?");
+        questionRepository.save(question1);
+
+        Answer answer1 = new Answer();
+        answer1.setAnswer("Oslo");
+        answer1.setQuestion(question1);
+        answerRepository.save(answer1);
+
+        Answer answer2 = new Answer();
+        answer2.setAnswer("Stockholm");
+        answer2.setQuestion(question1);
+        answerRepository.save(answer2);
+
+        assertEquals(2, answerRepository.findAnswersByQuestionId(question1.getQuestionId()).size());
+    }
+
+    @Test
+    void testDeleteAll() {
+        Question question1 = new Question();
+        question1.setQuestion("What is the capital of Norway?");
+        questionRepository.save(question1);
+
+        Answer answer1 = new Answer();
+        answer1.setAnswer("Oslo");
+        answer1.setQuestion(question1);
+        answerRepository.save(answer1);
+
+        Answer answer2 = new Answer();
+        answer2.setAnswer("Stockholm");
+        answer2.setQuestion(question1);
+        answerRepository.save(answer2);
+
+        answerRepository.deleteAll();
+
+        assertEquals(0, answerRepository.findAnswersByQuestionId(question1.getQuestionId()).size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/MessageRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import ntnu.idatt2105.group44.trivioServer.model.Message;
+
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@DataJpaTest
+class MessageRepositoryTest {
+
+    @Autowired
+    private MessageRepository messageRepository;
+
+    @Test
+    void testFindBySenderName() {
+        Message message1 = new Message("John", "john@example.com", "Hello");
+        Message message2 = new Message("John", "john@example.com", "Hi");
+        Message message3 = new Message("Jane", "jane@example.com", "Hey");
+
+        messageRepository.save(message1);
+        messageRepository.save(message2);
+        messageRepository.save(message3);
+
+        List<Message> messagesByJohn = messageRepository.findBySenderName("John");
+        List<Message> messagesByJane = messageRepository.findBySenderName("Jane");
+
+        assertEquals(2, messagesByJohn.size());
+        assertEquals(1, messagesByJane.size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/QuestionRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import ntnu.idatt2105.group44.trivioServer.model.Question;
+import ntnu.idatt2105.group44.trivioServer.model.Trivio;
+
+@DataJpaTest
+class QuestionRepositoryTest {
+    @Autowired
+    private QuestionRepository questionRepository;
+
+    @Autowired
+    private TrivioRepository trivioRepository;
+
+    @Test
+    void testFindQuestionByTrivioId() {
+        Trivio trivio1 = new Trivio();
+        trivioRepository.save(trivio1);
+
+        Question question1 = new Question();
+        question1.setQuestion("What is the capital of Norway?");
+        question1.setTrivio(trivio1);
+        questionRepository.save(question1);
+
+        Question question2 = new Question();
+        question2.setTrivio(trivio1);
+        question2.setQuestion("What is the capital of Sweden?");
+        questionRepository.save(question2);
+
+        assertEquals(2, questionRepository.findQuestionByTrivioId(trivio1.getId()).size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/ResultRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import ntnu.idatt2105.group44.trivioServer.model.Result;
+import ntnu.idatt2105.group44.trivioServer.model.Trivio;
+import ntnu.idatt2105.group44.trivioServer.model.User;
+
+@DataJpaTest
+class ResultRepositoryTest {
+    @Autowired
+    private ResultRepository resultRepository;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @Autowired
+    private TrivioRepository trivioRepository;
+
+    @Test
+    void testGetResultsByUserId() {
+        User user = new User();
+        user.setId(1L);
+        userRepository.save(user);
+
+        Trivio trivio1 = new Trivio();
+        trivio1.setUser(user);
+        trivioRepository.save(trivio1);
+
+        Result result1 = new Result();
+        result1.setUser(user);
+        result1.setTrivio(trivio1);
+        resultRepository.save(result1);
+
+        Result result2 = new Result();
+        result2.setUser(user);
+        result2.setTrivio(trivio1);
+        resultRepository.save(result2);
+
+        assertEquals(2, resultRepository.getResultsByUserId(user.getId()).size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/TrivioRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.annotation.DirtiesContext;
+
+import ntnu.idatt2105.group44.trivioServer.model.Trivio;
+import ntnu.idatt2105.group44.trivioServer.model.User;
+import org.springframework.test.annotation.DirtiesContext.ClassMode;
+
+@DataJpaTest
+@DirtiesContext(classMode = ClassMode.BEFORE_EACH_TEST_METHOD)
+class TrivioRepositoryTest {
+    @Autowired
+    private TrivioRepository trivioRepository;
+    
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    void testFindTrivioByTitle() {
+        Trivio trivio1 = new Trivio();
+        trivio1.setTitle("Trivio 1");
+        trivioRepository.save(trivio1);
+
+        Optional<Trivio> trivio = trivioRepository.findTrivioByTitle("Trivio 1");
+        assertEquals("Trivio 1", trivio.get().getTitle());
+    }
+
+    @Test 
+    void testFindTrivioByVisibility() {
+        Trivio trivio1 = new Trivio();
+        trivio1.setVisibility("public");
+        trivioRepository.save(trivio1);
+
+        Trivio trivio2 = new Trivio();
+        trivio2.setVisibility("private");
+        trivioRepository.save(trivio2);
+
+        assertEquals(1, trivioRepository.findTrivioByVisibility("public").size());
+        assertEquals(1, trivioRepository.findTrivioByVisibility("private").size());
+    }
+
+    @Test
+    void testFindTrivioByUserId() {
+        User user = new User();
+        user.setId(1L);
+        userRepository.save(user);
+
+        Trivio trivio1 = new Trivio();
+        trivio1.setUser(user);
+        trivioRepository.save(trivio1);
+
+        Trivio trivio2 = new Trivio();
+        trivio2.setUser(user);
+        trivioRepository.save(trivio2);
+
+        assertEquals(2, trivioRepository.findTrivioByUserId(1L).size());
+    }
+
+    @Test 
+    void testFindTrivioByVisibilityAndUserIdNot() {
+        User user = new User();
+        user.setId(1L);
+        userRepository.save(user);
+
+        User user2 = new User();
+        user2.setId(2L);
+        userRepository.save(user2);
+
+        Trivio trivio1 = new Trivio();
+        trivio1.setVisibility("public");
+        trivio1.setUser(user2);
+
+        Trivio trivio2 = new Trivio();
+        trivio2.setVisibility("public");
+        trivio2.setUser(user2);
+
+        trivioRepository.save(trivio1);
+        trivioRepository.save(trivio2);
+
+        assertEquals(2, trivioRepository.findTrivioByVisibilityAndUserIdNot("public", 1L).size());
+        assertEquals(0, trivioRepository.findTrivioByVisibilityAndUserIdNot("public", 2L).size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/repository/UserRepositoryTest.java

+package ntnu.idatt2105.group44.trivioServer.repository;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import ntnu.idatt2105.group44.trivioServer.model.User;
+import ntnu.idatt2105.group44.trivioServer.model.Role;
+
+@DataJpaTest
+class UserRepositoryTest {
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    void testFindUserByUsername() {
+        User user1 = new User("John", "password", "john@email.com", Role.USER);
+        userRepository.save(user1);
+
+        Optional<User> user = userRepository.findUserByUsername("John");
+        assertEquals("John", user.get().getUsername());
+    }   
+    
+    @Test
+    void testFindUserByEmail() {
+        User user1 = new User("Jane", "password", "jane@email.com", Role.USER);
+        userRepository.save(user1);
+
+        Optional<User> user = userRepository.findUserByEmail("jane@email.com");
+        assertEquals("jane@email.com", user.get().getEmail());
+    }    
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/AuthenticationServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import ntnu.idatt2105.group44.trivioServer.dto.LoginRequest;
+import ntnu.idatt2105.group44.trivioServer.model.User;
+
+@ExtendWith(MockitoExtension.class)
+class AuthenticationServiceTest {
+    
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private PasswordEncoder passwordEncoder;
+
+    @InjectMocks
+    private AuthenticationService authenticationService;
+
+    @Test
+    void testAuthenticateUser() {
+        LoginRequest loginRequest = new LoginRequest();
+        loginRequest.setUsername("username");
+        loginRequest.setPassword("password");
+
+        User user = new User();
+        user.setUsername("username");
+        user.setPassword("password");
+
+        when(userService.checkIfUsernameIsPresent(loginRequest.getUsername())).thenReturn(true);
+        when(userService.getUserByUsername(loginRequest.getUsername())).thenReturn(user);
+        when(passwordEncoder.encode(user.getPassword())).thenReturn(user.getPassword());
+        when(passwordEncoder.matches(loginRequest.getPassword(), user.getPassword())).thenReturn(true);
+
+        boolean result = authenticationService.authenticateUser(loginRequest);
+
+        assertTrue(result);
+    }
+
+    @Test
+    void testAuthenticateUser_UserDoesNotExist() {
+        LoginRequest loginRequest = new LoginRequest();
+        loginRequest.setUsername("username");
+        loginRequest.setPassword("password");
+
+        when(userService.checkIfUsernameIsPresent(loginRequest.getUsername())).thenReturn(false);
+
+        boolean result = authenticationService.authenticateUser(loginRequest);
+
+        assertTrue(!result);
+    }
+
+    @Test
+    void testAuthenticateUser_WrongPassword() {
+        LoginRequest loginRequest = new LoginRequest();
+        loginRequest.setUsername("username");
+        loginRequest.setPassword("WrongPassword");
+
+        User user = new User();
+        user.setUsername("username");
+        user.setPassword("pass");
+
+        when(userService.checkIfUsernameIsPresent(loginRequest.getUsername())).thenReturn(true);
+        when(userService.getUserByUsername(loginRequest.getUsername())).thenReturn(user);
+        when(passwordEncoder.encode(user.getPassword())).thenReturn(user.getPassword());
+        when(passwordEncoder.matches(loginRequest.getPassword(), user.getPassword())).thenReturn(false);
+
+        boolean result = authenticationService.authenticateUser(loginRequest);
+
+        assertTrue(!result);
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/MessageServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import ntnu.idatt2105.group44.trivioServer.model.Message;
+import ntnu.idatt2105.group44.trivioServer.repository.MessageRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class MessageServiceTest {
+
+    @Mock
+    private MessageRepository messageRepository;
+
+    @InjectMocks
+    private MessageService messageService;
+
+    @Test
+    void testCreateMessage() {
+        Message message = new Message();
+        message.setContent("Test message");
+
+        when(messageRepository.save(message)).thenReturn(message);
+
+        Message createdMessage = messageService.createMessage(message);
+
+        assertEquals("Test message", createdMessage.getContent());
+
+        verify(messageRepository, times(1)).save(message);
+    }
+
+    @Test
+    void testGetAllMessages() {
+        Message message1 = new Message();
+        message1.setContent("Message 1");
+
+        Message message2 = new Message();
+        message2.setContent("Message 2");
+
+        List<Message> messages = new ArrayList<>();
+        messages.add(message1);
+        messages.add(message2);
+
+        when(messageRepository.findAll()).thenReturn(messages);
+
+        List<Message> returnedMessages = messageService.getAllMessages();
+
+        assertEquals(2, returnedMessages.size());
+
+        verify(messageRepository, times(1)).findAll();
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/QuestionServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import ntnu.idatt2105.group44.trivioServer.model.Answer;
+import ntnu.idatt2105.group44.trivioServer.model.Question;
+import ntnu.idatt2105.group44.trivioServer.repository.AnswerRepository;
+import ntnu.idatt2105.group44.trivioServer.repository.QuestionRepository;
+
+@ExtendWith(MockitoExtension.class)
+class QuestionServiceTest {
+
+    @Mock
+    private QuestionRepository questionRepository;
+
+    @Mock
+    private AnswerRepository answerRepository;
+
+    @InjectMocks
+    private QuestionService questionService;
+
+    @Test
+    void testAddQuestion() {
+        Question question = new Question();
+        question.setQuestion("Test question");
+
+        questionService.addQuestion(question);
+
+        verify(questionRepository, times(1)).save(question);
+    }
+
+    @Test
+    void testAddQuestionWithAnswers() {
+        Answer answer1 = new Answer();
+        answer1.setAnswer("Answer 1");
+
+        Answer answer2 = new Answer();
+        answer2.setAnswer("Answer 2");
+
+        Question question = new Question();
+        question.setQuestion("Test question");
+
+        questionService.addQuestionWithAnswers(question, java.util.List.of(answer1, answer2));
+
+        verify(questionRepository, times(1)).save(question);
+        verify(answerRepository, times(1)).save(answer1);
+        verify(answerRepository, times(1)).save(answer2);
+    }
+
+    @Test
+    void testDeleteQuestionWithAnswers() {
+        Answer answer1 = new Answer();
+        answer1.setAnswer("Answer 1");
+
+        Answer answer2 = new Answer();
+        answer2.setAnswer("Answer 2");
+
+        Question question = new Question();
+        question.setQuestion("Test question");
+
+        questionService.deleteQuestionWithAnswers(question, java.util.List.of(answer1, answer2));
+
+        verify(answerRepository, times(1)).deleteAll(java.util.List.of(answer1, answer2));
+        verify(questionRepository, times(1)).delete(question);
+    }
+
+    @Test
+    void testGetAllQuestions() {
+        Question question1 = new Question();
+        question1.setQuestion("Question 1");
+
+        Question question2 = new Question();
+        question2.setQuestion("Question 2");
+
+        when(questionRepository.findAll()).thenReturn(java.util.List.of(question1, question2));
+
+        assertEquals(2, questionService.getAllQuestions().size());
+
+        verify(questionRepository, times(1)).findAll();
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/ResultServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import ntnu.idatt2105.group44.trivioServer.dto.ResultDTO;
+import ntnu.idatt2105.group44.trivioServer.model.Result;
+import ntnu.idatt2105.group44.trivioServer.model.Trivio;
+import ntnu.idatt2105.group44.trivioServer.model.User;
+import ntnu.idatt2105.group44.trivioServer.repository.ResultRepository;
+
+@ExtendWith(MockitoExtension.class)
+class ResultServiceTest {
+
+    @Mock
+    private ResultRepository resultRepository;
+
+    @Mock 
+    private UserService userService;
+
+    @Mock
+    private TrivioService trivioService;
+
+    @InjectMocks
+    private ResultService resultService;
+
+    @Test
+    void testAddResult() {
+        ResultDTO resultDTO = new ResultDTO("TestUser", 5, 5L);
+        
+        resultService.addResult(resultDTO);
+        
+        verify(resultRepository).save(any(Result.class));
+    }
+    
+    @Test
+    void testGetResultById() {
+        Result result = new Result();
+
+        when(resultRepository.findById(5L)).thenReturn(java.util.Optional.of(result));
+
+        Result foundResult = resultService.getResultbyId(5L);
+
+        verify(resultRepository, times(2)).findById(5L);
+
+        assertEquals(result, foundResult);
+    }
+
+    @Test
+    void testGetResultByIdReturnNull() {
+        when(resultRepository.findById(5L)).thenReturn(java.util.Optional.empty());
+
+        Result foundResult = resultService.getResultbyId(5L);
+
+        verify(resultRepository, times(1)).findById(5L);
+
+        assertEquals(null, foundResult);
+    }
+
+    @Test
+    void testGetResultsByUserId() {
+        Result result1 = new Result();
+
+        Result result2 = new Result();
+    
+        when(resultRepository.getResultsByUserId(5L)).thenReturn(java.util.List.of(result1, result2));
+
+        assertEquals(2, resultService.getResultbyUserId(5L).size());
+    }
+
+    @Test
+    void testConvertToDTO() {
+        Result result = new Result();
+        User user = new User();
+        user.setUsername("TestUser");
+        Trivio trivio = new Trivio();
+        result.setUser(user);
+        result.setTrivio(trivio);
+        result.setScore(5);
+
+        ResultDTO resultDTO = resultService.convertToDTO(result);
+
+        assertEquals("TestUser", resultDTO.getUsername());
+        assertEquals(5, resultDTO.getScore());
+    }
+
+    @Test
+    void testConvertToEntity() {
+        ResultDTO resultDTO = new ResultDTO("TestUser", 5, 5L);
+        User user = new User();
+        user.setUsername("TestUser");
+        Trivio trivio = new Trivio();
+
+        when(userService.getUserByUsername("TestUser")).thenReturn(user);
+        when(trivioService.getTrivioById(5L)).thenReturn(trivio);
+
+        Result result = resultService.convertToEntity(resultDTO);
+
+        assertEquals("TestUser", result.getUser().getUsername());
+        assertEquals(5, result.getScore());
+    }
+
+    @Test
+    void testGetAllResults() {
+        Result result1 = new Result();
+        Result result2 = new Result();
+
+        when(resultRepository.findAll()).thenReturn(java.util.List.of(result1, result2));
+
+        assertEquals(2, resultService.getAllResults().size());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/TrivioServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import ntnu.idatt2105.group44.trivioServer.dto.QuestionWithAnswers;
+import ntnu.idatt2105.group44.trivioServer.dto.TrivioWithQAndA;
+import ntnu.idatt2105.group44.trivioServer.model.Answer;
+import ntnu.idatt2105.group44.trivioServer.model.Question;
+import ntnu.idatt2105.group44.trivioServer.model.Trivio;
+import ntnu.idatt2105.group44.trivioServer.model.User;
+import ntnu.idatt2105.group44.trivioServer.repository.TrivioRepository;
+
+@ExtendWith(MockitoExtension.class)
+public class TrivioServiceTest {
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private TrivioRepository trivioRepository;
+
+    @Mock
+    private QuestionService questionService;
+
+    @InjectMocks
+    private TrivioService trivioService;
+
+    @Test
+    void testGetAllTrivios() {
+        Trivio trivio1 = new Trivio();
+
+        Trivio trivio2 = new Trivio();
+
+        when(trivioRepository.findAll()).thenReturn(java.util.List.of(trivio1, trivio2));
+
+        assertEquals(2, trivioService.getAllTrivios().size());
+    }
+
+    @Test
+    void testGetAllPublicTrivios() {
+        Trivio trivio1 = new Trivio();
+        trivio1.setVisibility("public");
+
+        Trivio trivio2 = new Trivio();
+        trivio2.setVisibility("public");
+
+        when(trivioRepository.findTrivioByVisibility("public")).thenReturn(java.util.List.of(trivio1, trivio2));
+
+        assertEquals(2, trivioService.getAllPublicTrivios().size());
+    }
+
+    @Test
+    void testGetAllPublicTriviosFromOtherUsers() {
+        Trivio trivio1 = new Trivio();
+        trivio1.setVisibility("public");
+
+        Trivio trivio2 = new Trivio();
+        trivio2.setVisibility("public");
+
+        when(trivioRepository.findTrivioByVisibilityAndUserIdNot("public", 1L))
+                .thenReturn(java.util.List.of(trivio1, trivio2));
+
+        assertEquals(2, trivioService.getAllPublicTriviosFromOtherUsers(1L).size());
+    }
+
+    @Test
+    void testGetTriviosByUserId() {
+        Trivio trivio1 = new Trivio();
+
+        Trivio trivio2 = new Trivio();
+
+        Trivio trivio3 = new Trivio();
+
+        when(trivioRepository.findTrivioByUserId(1L)).thenReturn(java.util.List.of(trivio1, trivio2, trivio3));
+
+        assertEquals(3, trivioService.getTriviosByUserId(1L).size());
+    }
+
+    @Test
+    void testGetTrivioById() {
+        Trivio trivio = new Trivio();
+        trivio.setTitle("Trivio 1");
+
+        when(trivioRepository.findById(1L)).thenReturn(java.util.Optional.of(trivio));
+
+        assertEquals("Trivio 1", trivioService.getTrivioById(1L).getTitle());
+    }
+
+    @Test
+    void testGetTrivioByIdThrowsException() {
+        when(trivioRepository.findById(1L)).thenReturn(java.util.Optional.empty());
+
+        try {
+            trivioService.getTrivioById(1L);
+        } catch (Exception e) {
+            assertEquals("Trivio id: 1 does not exist!", e.getMessage());
+        }
+    }
+
+    @Test
+    void testGetTrivioByTitle() {
+        Trivio trivio = new Trivio();
+        trivio.setTitle("Trivio 1");
+
+        when(trivioRepository.findTrivioByTitle("Trivio 1")).thenReturn(java.util.Optional.of(trivio));
+
+        assertEquals("Trivio 1", trivioService.getTrivioByTitle("Trivio 1").getTitle());
+    }
+
+    @Test
+    void testGetTrivioByTitleReturnsNull() {
+        when(trivioRepository.findTrivioByTitle("Trivio 1")).thenReturn(java.util.Optional.empty());
+
+        assertEquals(null, trivioService.getTrivioByTitle("Trivio 1"));
+    }
+
+    @Test
+    void testCreateTrivio() {
+        Trivio trivio = new Trivio();
+        trivio.setTitle("Trivio 1");
+
+        TrivioWithQAndA trivioWithQAndA = new TrivioWithQAndA();
+        trivioWithQAndA.setTrivio(trivio);
+
+        Answer answer = new Answer();
+        answer.setAnswer("Answer 1");
+
+        Answer answer2 = new Answer();
+        answer2.setAnswer("Answer 2");
+
+        Question question = new Question();
+        question.setQuestion("Question 1");
+
+        QuestionWithAnswers questionWithAnswers = new QuestionWithAnswers();
+        questionWithAnswers.setQuestion(question);
+        questionWithAnswers.setAnswers(java.util.List.of(answer, answer2));
+
+        trivioWithQAndA.setQuestionsWithAnswers(java.util.List.of(questionWithAnswers));
+
+        User user = new User();
+        user.setId(1L);
+
+        when(userService.getUserById(1L)).thenReturn(user);
+        when(trivioRepository.save(any(Trivio.class))).thenReturn(trivio);
+
+        trivioService.createTrivio(trivioWithQAndA, 1L);
+
+        verify(trivioRepository, times(1)).save(any(Trivio.class));
+        verify(questionService, times(1)).addQuestionWithAnswers(any(Question.class), anyList());
+    }
+
+    @Test
+    void testEditTrivio() {
+        Trivio originalTrivio = new Trivio();
+        originalTrivio.setTitle("Original Trivio");
+
+        when(trivioRepository.findById(1L)).thenReturn(java.util.Optional.of(originalTrivio));
+
+        Trivio newTrivio = new Trivio();
+        newTrivio.setTitle("New Trivio");
+
+        TrivioWithQAndA editedTrivioWithQAndA = new TrivioWithQAndA();
+        editedTrivioWithQAndA.setTrivio(newTrivio);
+
+        trivioService.editTrivio(editedTrivioWithQAndA, 1L);
+
+        verify(trivioRepository, times(1)).findById(1L);
+        assertEquals("New Trivio", originalTrivio.getTitle());
+    }
+}

src/test/java/ntnu/idatt2105/group44/trivioServer/service/UserServiceTest.java

+package ntnu.idatt2105.group44.trivioServer.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import ntnu.idatt2105.group44.trivioServer.model.User;
+import ntnu.idatt2105.group44.trivioServer.repository.UserRepository;
+
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private UserService userService;
+
+    @Test
+    void testGetUserById() {
+        User user = new User();
+        user.setId(5L);
+        user.setUsername("Mary");
+        when(userRepository.findById(5L)).thenReturn(java.util.Optional.of(user));
+
+        User foundUser = userService.getUserById(5L);
+        assertEquals("Mary", foundUser.getUsername());
+    }
+
+    @Test
+    void testGetUserByUsername() {
+        User user = new User();
+        user.setId(5L);
+        user.setUsername("Mary");
+        when(userRepository.findUserByUsername("Mary")).thenReturn(java.util.Optional.of(user));
+
+        User foundUser = userService.getUserByUsername("Mary");
+        assertEquals(5L, foundUser.getId());
+    }
+
+    @Test
+    void testGetAllUsers() {
+        User user1 = new User();
+        user1.setUsername("Mary");
+
+        User user2 = new User();
+        user2.setUsername("John");
+        when(userRepository.findAll()).thenReturn(java.util.List.of(user1, user2));
+
+        assertEquals(2, userService.getAllUsers().size());
+    }
+
+    @Test
+    void testCheckIfUsernameIsPresent() {
+        User user = new User();
+        user.setUsername("Mary");
+        when(userRepository.findUserByUsername("Mary")).thenReturn(java.util.Optional.of(user));
+
+        boolean isPresent = userService.checkIfUsernameIsPresent("Mary");
+        assertEquals(true, isPresent);
+
+        boolean isNotPresent = userService.checkIfUsernameIsPresent("Belle");
+        assertEquals(false, isNotPresent);
+    }
+
+    @Test
+    void testCheckIfEmailIsPresent() {
+        User user = new User();
+        user.setEmail("mary@email.com");
+        when(userRepository.findUserByEmail("mary@email.com")).thenReturn(java.util.Optional.of(user));
+
+        boolean isPresent = userService.checkIfEmailIsPresent("mary@email.com");
+        assertEquals(true, isPresent);
+
+        boolean isNotPresent = userService.checkIfEmailIsPresent("null@email.com");
+        assertEquals(false, isNotPresent);
+    }
+}
\ No newline at end of file