account management tests

account-management/src/test/java/cz/muni/pa165/banking/application/api/AccountControllerTest.java

+package cz.muni.pa165.banking.application.api;
+
+import cz.muni.pa165.banking.account.management.dto.AccountDto;
+import cz.muni.pa165.banking.account.management.dto.NewAccountDto;
+import cz.muni.pa165.banking.account.management.dto.ScheduledPaymentDto;
+import cz.muni.pa165.banking.account.management.dto.ScheduledPaymentsDto;
+import cz.muni.pa165.banking.application.facade.AccountFacade;
+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.http.ResponseEntity;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class AccountControllerTest {
+    @Mock
+    private AccountFacade accountFacade;
+    @InjectMocks
+    private AccountController accountController;
+
+    @Test
+    void createAccount_ValidRequest_ReturnsAccount() {
+        // Arrange
+        NewAccountDto newAccountDto = new NewAccountDto();
+        AccountDto createdAccountDto = new AccountDto();
+        when(accountFacade.createAccount(any(NewAccountDto.class))).thenReturn(createdAccountDto);
+
+        // Act
+        ResponseEntity<AccountDto> responseEntity = accountController.createAccount(newAccountDto);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(accountFacade).createAccount(newAccountDto);
+    }
+
+    @Test
+    void getAccount_ValidAccountNumber_ReturnsAccount() {
+        // Arrange
+        String accountNumber = "123456789";
+        AccountDto accountDto = new AccountDto();
+        when(accountFacade.getAccount(accountNumber)).thenReturn(accountDto);
+
+        // Act
+        ResponseEntity<AccountDto> responseEntity = accountController.getAccount(accountNumber);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(accountFacade).getAccount(accountNumber);
+    }
+
+    @Test
+    void getAccount_InvalidAccountNumber_ReturnsNull() {
+        // Arrange
+        String invalidAccountNumber = "123456789";
+        when(accountFacade.getAccount(invalidAccountNumber)).thenReturn(null);
+
+        // Act
+        ResponseEntity<AccountDto> responseEntity = accountController.getAccount(invalidAccountNumber);
+
+        // Assert
+        assertNull(responseEntity.getBody());
+        verify(accountFacade).getAccount(invalidAccountNumber);
+    }
+
+    @Test
+    void getScheduledPayments_ValidAccountNumber_ReturnsPayments() {
+        // Arrange
+        String accountNumber = "123456789";
+        ScheduledPaymentsDto scheduledPaymentsDto = new ScheduledPaymentsDto();
+        when(accountFacade.getScheduledPaymentsOfAccount(accountNumber)).thenReturn(scheduledPaymentsDto);
+
+        // Act
+        ResponseEntity<ScheduledPaymentsDto> responseEntity = accountController.getScheduledPayments(accountNumber);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(accountFacade).getScheduledPaymentsOfAccount(accountNumber);
+    }
+
+    @Test
+    void getScheduledPayments_InvalidAccountNumber_ReturnsNull() {
+        // Arrange
+        String invalidAccountNumber = "123456789";
+        when(accountFacade.getScheduledPaymentsOfAccount(invalidAccountNumber)).thenReturn(null);
+
+        // Act
+        ResponseEntity<ScheduledPaymentsDto> responseEntity = accountController.getScheduledPayments(invalidAccountNumber);
+
+        // Assert
+        assertNull(responseEntity.getBody());
+        verify(accountFacade).getScheduledPaymentsOfAccount(invalidAccountNumber);
+    }
+
+    @Test
+    void schedulePayment_ValidRequest_ReturnsPayment() {
+        // Arrange
+        ScheduledPaymentDto scheduledPaymentDto = new ScheduledPaymentDto();
+        when(accountFacade.schedulePayment(any(ScheduledPaymentDto.class))).thenReturn(scheduledPaymentDto);
+
+        // Act
+        ResponseEntity<ScheduledPaymentDto> responseEntity = accountController.schedulePayment(scheduledPaymentDto);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(accountFacade).schedulePayment(scheduledPaymentDto);
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/api/UserControllerTest.java

+package cz.muni.pa165.banking.application.api;
+
+import cz.muni.pa165.banking.account.management.dto.NewUserDto;
+import cz.muni.pa165.banking.account.management.dto.UserDto;
+import cz.muni.pa165.banking.application.facade.UserFacade;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class UserControllerTest {
+    @Mock
+    private UserFacade userFacade;
+    @InjectMocks
+    private UserController userController;
+
+    @Test
+    void createUser_ValidRequest_ReturnsUser() {
+        // Arrange
+        NewUserDto newUserDto = new NewUserDto();
+        UserDto createdUserDto = new UserDto();
+        when(userFacade.createUser(any(NewUserDto.class))).thenReturn(createdUserDto);
+
+        // Act
+        ResponseEntity<UserDto> responseEntity = userController.createUser(newUserDto);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(userFacade).createUser(newUserDto);
+    }
+
+    @Test
+    void getUser_ValidUserId_ReturnsUser() {
+        // Arrange
+        Long userId = 1L;
+        UserDto userDto = new UserDto();
+        when(userFacade.getUser(userId)).thenReturn(userDto);
+
+        // Act
+        ResponseEntity<UserDto> responseEntity = userController.getUser(userId);
+
+        // Assert
+        assertNotNull(responseEntity.getBody());
+        verify(userFacade).getUser(userId);
+    }
+
+    @Test
+    void getUser_InvalidUserId_ReturnsNull() {
+        // Arrange
+        Long userId = 123L;
+        when(userFacade.getUser(userId)).thenReturn(null);
+
+        // Act
+        ResponseEntity<UserDto> responseEntity = userController.getUser(userId);
+
+        // Assert
+        assertNull(responseEntity.getBody());
+        verify(userFacade).getUser(userId);
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/facade/AccountFacadeTest.java

+package cz.muni.pa165.banking.application.facade;
+
+import cz.muni.pa165.banking.account.management.dto.NewAccountDto;
+import cz.muni.pa165.banking.account.management.dto.AccountDto;
+import cz.muni.pa165.banking.account.management.dto.ScheduledPaymentDto;
+import cz.muni.pa165.banking.account.management.dto.ScheduledPaymentsDto;
+import cz.muni.pa165.banking.application.mapper.DtoMapper;
+import cz.muni.pa165.banking.application.service.AccountService;
+import cz.muni.pa165.banking.domain.account.Account;
+import cz.muni.pa165.banking.domain.scheduled.ScheduledPayment;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+class AccountFacadeTest {
+
+    @Mock
+    private AccountService accountService;
+
+    @Mock
+    private DtoMapper mapper;
+
+    @InjectMocks
+    private AccountFacade accountFacade;
+
+    @Test
+    void createAccount_ValidRequest_ReturnsAccountDto() {
+        // Arrange
+        NewAccountDto newAccountDto = new NewAccountDto();
+        AccountDto accountDto = new AccountDto();
+        when(mapper.map(any(Account.class))).thenReturn(accountDto);
+        when(accountService.createAccount(any())).thenReturn(new Account());
+
+        // Act
+        AccountDto result = accountFacade.createAccount(newAccountDto);
+
+        // Assert
+        assertEquals(accountDto, result);
+        verify(accountService).createAccount(any());
+        verify(mapper).map(any(Account.class));
+    }
+
+    @Test
+    void getAccount_ValidAccountNumber_ReturnsAccountDto() {
+        // Arrange
+        String accountNumber = "123456789";
+        AccountDto accountDto = new AccountDto();
+        when(mapper.map(any(Account.class))).thenReturn(accountDto);
+        when(accountService.getAccountByNumber(accountNumber)).thenReturn(new Account());
+
+        // Act
+        AccountDto result = accountFacade.getAccount(accountNumber);
+
+        // Assert
+        assertEquals(accountDto, result);
+        verify(accountService).getAccountByNumber(accountNumber);
+        verify(mapper).map(any(Account.class));
+    }
+
+    @Test
+    void getAccount_InvalidAccountNumber_ReturnsNull() {
+        // Arrange
+        String invalidAccountNumber = "invalidAccountNumber";
+        when(accountService.getAccountByNumber(invalidAccountNumber)).thenReturn(null);
+
+        // Act & Assert
+        assertNull(accountFacade.getAccount(invalidAccountNumber));
+    }
+
+    @Test
+    void schedulePayment_ValidRequest_ReturnsScheduledPaymentDto() {
+        // Arrange
+        ScheduledPaymentDto scheduledPaymentDto = new ScheduledPaymentDto();
+        when(mapper.map(any(ScheduledPayment.class))).thenReturn(scheduledPaymentDto);
+        when(accountService.schedulePayment(any())).thenReturn(new ScheduledPayment());
+
+        // Act
+        ScheduledPaymentDto result = accountFacade.schedulePayment(scheduledPaymentDto);
+
+        // Assert
+        assertEquals(scheduledPaymentDto, result);
+        verify(accountService).schedulePayment(any());
+        verify(mapper).map(any(ScheduledPayment.class));
+    }
+
+    @Test
+    void schedulePayment_InvalidRequest_ReturnsNull() {
+        // Arrange
+        ScheduledPaymentDto scheduledPaymentDto = new ScheduledPaymentDto();
+        when(accountService.schedulePayment(any())).thenReturn(null);
+
+        // Act
+        ScheduledPaymentDto result = accountFacade.schedulePayment(scheduledPaymentDto);
+
+        // Assert
+        assertNull(result);
+        verify(accountService).schedulePayment(any());
+    }
+
+    @Test
+    void getScheduledPaymentsOfAccount_ValidAccountNumber_ReturnsPayments() {
+        // Arrange
+        String validAccountNumber = "123456789";
+        ScheduledPaymentsDto scheduledPaymentsDto = new ScheduledPaymentsDto();
+        List<ScheduledPayment> scheduledPaymentsList = new ArrayList<>();
+        Account account = new Account();
+        account.setId(1L);
+        when(accountService.getAccountByNumber(validAccountNumber)).thenReturn(account);
+        when(accountService.getScheduledPaymentsOfAccount(any(Long.class))).thenReturn(scheduledPaymentsList);
+        when(mapper.map(scheduledPaymentsList)).thenReturn(scheduledPaymentsDto);
+
+        // Act
+        ScheduledPaymentsDto result = accountFacade.getScheduledPaymentsOfAccount(validAccountNumber);
+
+        // Assert
+        assertNotNull(result);
+        verify(accountService).getScheduledPaymentsOfAccount(eq(1L));
+        verify(mapper).map(scheduledPaymentsList);
+    }
+
+
+    @Test
+    void getScheduledPaymentsOfAccount_InvalidAccountNumber_ThrowsException() {
+        // Arrange
+        String invalidAccountNumber = "invalidAccountNumber";
+        when(accountService.getAccountByNumber(invalidAccountNumber)).thenReturn(null);
+
+        // Act & Assert
+        assertThrows(RuntimeException.class, () -> accountFacade.getScheduledPaymentsOfAccount(invalidAccountNumber));
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/facade/UserFacadeTest.java

+package cz.muni.pa165.banking.application.facade;
+
+import cz.muni.pa165.banking.account.management.dto.NewUserDto;
+import cz.muni.pa165.banking.account.management.dto.UserDto;
+import cz.muni.pa165.banking.application.mapper.DtoMapper;
+import cz.muni.pa165.banking.application.service.UserService;
+import cz.muni.pa165.banking.domain.user.User;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+class UserFacadeTest {
+
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private DtoMapper mapper;
+
+    @InjectMocks
+    private UserFacade userFacade;
+
+    @Test
+    void createUser_ValidRequest_ReturnsUserDto() {
+        // Arrange
+        NewUserDto newUserDto = new NewUserDto();
+        UserDto userDto = new UserDto();
+        when(userService.createUser(any())).thenReturn(new User());
+        when(mapper.map(any(User.class))).thenReturn(userDto);
+
+        // Act
+        UserDto result = userFacade.createUser(newUserDto);
+
+        // Assert
+        assertEquals(userDto, result);
+        verify(userService).createUser(any());
+        verify(mapper).map(any(User.class));
+    }
+
+    @Test
+    void getUser_ValidUserId_ReturnsUserDto() {
+        // Arrange
+        Long userId = 1L;
+        UserDto userDto = new UserDto();
+        when(userService.getUser(userId)).thenReturn(new User());
+        when(mapper.map(any(User.class))).thenReturn(userDto);
+
+        // Act
+        UserDto result = userFacade.getUser(userId);
+
+        // Assert
+        assertEquals(userDto, result);
+        verify(userService).getUser(userId);
+        verify(mapper).map(any(User.class));
+    }
+
+    @Test
+    void getUser_InvalidUserId_ReturnsNull() {
+        // Arrange
+        Long invalidUserId = 123L;
+        when(userService.getUser(invalidUserId)).thenReturn(null);
+
+        // Act
+        UserDto result = userFacade.getUser(invalidUserId);
+
+        // Assert
+        assertNull(result);
+        verify(userService).getUser(invalidUserId);
+    }
+}
+

account-management/src/test/java/cz/muni/pa165/banking/application/mapper/DtoMapperTest.java

+package cz.muni.pa165.banking.application.mapper;
+
+import cz.muni.pa165.banking.account.management.dto.AccountDto;
+import cz.muni.pa165.banking.account.management.dto.ScheduledPaymentDto;
+import cz.muni.pa165.banking.domain.scheduled.ScheduledPayment;
+import cz.muni.pa165.banking.domain.user.UserType;
+import cz.muni.pa165.banking.domain.account.Account;
+import cz.muni.pa165.banking.domain.account.AccountType;
+import cz.muni.pa165.banking.account.management.dto.UserDto;
+import cz.muni.pa165.banking.domain.user.User;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mapstruct.factory.Mappers;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@ExtendWith(MockitoExtension.class)
+class DtoMapperTest {
+    private final DtoMapper mapper = Mappers.getMapper(DtoMapper.class);
+
+    @Test
+    public void mapUserToUserDto() {
+        // Arrange
+        User user = new User();
+        user.setId(1L);
+        user.setFirstName("John");
+        user.setLastName("Doe");
+        user.setUserType(UserType.EMPLOYEE);
+
+        // Act
+        UserDto userDto = mapper.map(user);
+
+        // Assert
+        assertEquals(user.getId(), userDto.getId());
+        assertEquals(user.getFirstName(), userDto.getFirstName());
+        assertEquals(user.getLastName(), userDto.getLastName());
+        assertEquals(user.getUserType(), mapper.map(userDto.getUserType()));
+    }
+
+    @Test
+    public void mapScheduledPaymentToScheduledPaymentDto() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        scheduledPayment.setId(1L);
+        scheduledPayment.setAmount(100);
+
+        // Act
+        ScheduledPaymentDto scheduledPaymentDto = mapper.map(scheduledPayment);
+
+        // Assert
+        assertEquals(scheduledPayment.getId(), scheduledPaymentDto.getId());
+        assertEquals(scheduledPayment.getAmount(), scheduledPaymentDto.getAmount());
+    }
+
+    @Test
+    public void mapAccountToAccountDto() {
+        // Arrange
+        Account account = new Account();
+        account.setId(1L);
+        account.setUserId(2L);
+        account.setMaxSpendingLimit(500);
+        account.setType(AccountType.SAVING);
+
+        // Act
+        AccountDto accountDto = mapper.map(account);
+
+        // Assert
+        assertEquals(account.getId(), accountDto.getId());
+        assertEquals(account.getUserId(), accountDto.getUserId());
+        assertEquals(account.getMaxSpendingLimit(), accountDto.getMaxSpendingLimit());
+        assertEquals(account.getType(), mapper.map(accountDto.getType()));
+    }
+}
\ No newline at end of file

account-management/src/test/java/cz/muni/pa165/banking/application/repository/AccountRepositoryImplTest.java

+package cz.muni.pa165.banking.application.repository;
+
+import cz.muni.pa165.banking.domain.account.Account;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.springframework.boot.test.context.SpringBootTest;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+@SpringBootTest
+class AccountRepositoryImplTest {
+    @InjectMocks
+    private AccountRepositoryImpl accountRepository;
+
+    @Test
+    void addAccount_ValidAccount_ReturnsAccount() {
+        // Arrange
+        Account account = new Account();
+
+        // Act
+        Account result = accountRepository.addAccount(account);
+
+        // Assert
+        assertEquals(account, result);
+    }
+
+    @Test
+    void getById_ExistingId_ReturnsAccount() {
+        // Arrange
+        Account account = new Account();
+        accountRepository.addAccount(account);
+        Long id = account.getId();
+
+        // Act
+        Account result = accountRepository.getById(id);
+
+        // Assert
+        assertEquals(account, result);
+    }
+
+    @Test
+    void getById_NonExistingId_ReturnsNull() {
+        // Arrange
+        Long nonExistingId = 123L;
+
+        // Act
+        Account result = accountRepository.getById(nonExistingId);
+
+        // Assert
+        assertNull(result);
+    }
+
+    @Test
+    void getByAccountNumber_ExistingAccountNumber_ReturnsAccount() {
+        // Arrange
+        Account account = new Account();
+        accountRepository.addAccount(account);
+        String accountNumber = account.getAccountNumber();
+
+        // Act
+        Account result = accountRepository.getByAccountNumber(accountNumber);
+
+        // Assert
+        assertEquals(account, result);
+    }
+
+    @Test
+    void getByAccountNumber_NonExistingAccountNumber_ReturnsNull() {
+        // Arrange
+        String nonExistingAccountNumber = "NonExistingAccountNumber";
+
+        // Act
+        Account result = accountRepository.getByAccountNumber(nonExistingAccountNumber);
+
+        // Assert
+        assertNull(result);
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/repository/ScheduledPaymentRepositoryImplTest.java

+package cz.muni.pa165.banking.application.repository;
+
+import cz.muni.pa165.banking.domain.scheduled.ScheduledPayment;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.springframework.boot.test.context.SpringBootTest;
+import java.util.Map;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+@SpringBootTest
+class ScheduledPaymentRepositoryImplTest {
+    @InjectMocks
+    private ScheduledPaymentRepositoryImpl scheduledPaymentRepository;
+
+    @Test
+    void addScheduledPayment_ValidScheduledPayment_ReturnsScheduledPayment() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+
+        // Act
+        ScheduledPayment result = scheduledPaymentRepository.addScheduledPayment(scheduledPayment);
+
+        // Assert
+        assertEquals(scheduledPayment, result);
+    }
+
+    @Test
+    void getById_ExistingId_ReturnsScheduledPayment() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        scheduledPaymentRepository.addScheduledPayment(scheduledPayment);
+        Long id = scheduledPayment.getId();
+
+        // Act
+        ScheduledPayment result = scheduledPaymentRepository.getById(id);
+
+        // Assert
+        assertEquals(scheduledPayment, result);
+    }
+
+    @Test
+    void getById_NonExistingId_ReturnsNull() {
+        // Arrange
+        Long nonExistingId = 123L;
+
+        // Act
+        ScheduledPayment result = scheduledPaymentRepository.getById(nonExistingId);
+
+        // Assert
+        assertNull(result);
+    }
+
+    @Test
+    void getAllPayments_ReturnsAllPayments() {
+        // Arrange
+        ScheduledPayment scheduledPayment1 = new ScheduledPayment();
+        ScheduledPayment scheduledPayment2 = new ScheduledPayment();
+        scheduledPaymentRepository.addScheduledPayment(scheduledPayment1);
+        scheduledPaymentRepository.addScheduledPayment(scheduledPayment2);
+
+        // Act
+        Map<Long, ScheduledPayment> result = scheduledPaymentRepository.getAllPayments();
+
+        // Assert
+        assertEquals(2, result.size());
+        assertEquals(scheduledPayment1, result.get(scheduledPayment1.getId()));
+        assertEquals(scheduledPayment2, result.get(scheduledPayment2.getId()));
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/repository/UserRepositoryImplTest.java

+package cz.muni.pa165.banking.application.repository;
+
+import cz.muni.pa165.banking.domain.user.User;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+@SpringBootTest
+class UserRepositoryImplTest {
+
+    private UserRepositoryImpl userRepository;
+
+    @BeforeEach
+    void setUp() {
+        userRepository = new UserRepositoryImpl();
+    }
+
+    @Test
+    void addUser_ValidUser_ReturnsUser() {
+        // Arrange
+        User user = new User();
+
+        // Act
+        User result = userRepository.addUser(user);
+
+        // Assert
+        assertEquals(user, result);
+    }
+
+    @Test
+    void getById_ExistingId_ReturnsUser() {
+        // Arrange
+        User user = new User();
+        userRepository.addUser(user);
+        Long id = user.getId();
+
+        // Act
+        User result = userRepository.getById(id);
+
+        // Assert
+        assertEquals(user, result);
+    }
+
+    @Test
+    void getById_NonExistingId_ReturnsNull() {
+        // Arrange
+        Long nonExistingId = 123L;
+
+        // Act
+        User result = userRepository.getById(nonExistingId);
+
+        // Assert
+        assertNull(result);
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/service/AccountServiceTest.java

+package cz.muni.pa165.banking.application.service;
+
+import cz.muni.pa165.banking.domain.account.Account;
+import cz.muni.pa165.banking.domain.account.repository.AccountRepository;
+import cz.muni.pa165.banking.domain.scheduled.ScheduledPayment;
+import cz.muni.pa165.banking.domain.scheduled.repository.ScheduledPaymentRepository;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.boot.test.context.SpringBootTest;
+import java.util.ArrayList;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+class AccountServiceTest {
+
+    @Mock
+    private AccountRepository accountRepository;
+
+    @Mock
+    private ScheduledPaymentRepository scheduledPaymentRepository;
+
+    @InjectMocks
+    private AccountService accountService;
+
+    @Test
+    void createAccount_ValidAccount_ReturnsAccount() {
+        // Arrange
+        Account account = new Account();
+        when(accountRepository.addAccount(account)).thenReturn(account);
+
+        // Act
+        Account result = accountService.createAccount(account);
+
+        // Assert
+        assertEquals(account, result);
+        verify(accountRepository).addAccount(account);
+    }
+
+    @Test
+    void getAccount_ValidAccountId_ReturnsAccount() {
+        // Arrange
+        Long accountId = 1L;
+        Account account = new Account();
+        when(accountRepository.getById(accountId)).thenReturn(account);
+
+        // Act
+        Account result = accountService.getAccount(accountId);
+
+        // Assert
+        assertEquals(account, result);
+        verify(accountRepository).getById(accountId);
+    }
+
+    @Test
+    void getAccount_InvalidAccountId_ReturnsNull() {
+        // Arrange
+        Long accountId = 1L;
+        when(accountRepository.getById(accountId)).thenReturn(null);
+
+        // Act & Assert
+        assertNull(accountService.getAccount(accountId));
+        verify(accountRepository).getById(accountId);
+    }
+
+    @Test
+    void getAccountByNumber_ValidAccountNumber_ReturnsAccount() {
+        // Arrange
+        String accountNumber = "123456789";
+        Account account = new Account();
+        when(accountRepository.getByAccountNumber(accountNumber)).thenReturn(account);
+
+        // Act
+        Account result = accountService.getAccountByNumber(accountNumber);
+
+        // Assert
+        assertEquals(account, result);
+        verify(accountRepository).getByAccountNumber(accountNumber);
+    }
+
+    @Test
+    void getAccountByNumber_InvalidAccountNumber_ReturnsNull() {
+        // Arrange
+        String accountNumber = "123456789";
+        when(accountRepository.getByAccountNumber(accountNumber)).thenReturn(null);
+
+        // Act & Assert
+        assertNull(accountService.getAccountByNumber(accountNumber));
+        verify(accountRepository).getByAccountNumber(accountNumber);
+    }
+
+    @Test
+    void schedulePayment_ValidScheduledPayment_ReturnsScheduledPayment() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        when(scheduledPaymentRepository.addScheduledPayment(scheduledPayment)).thenReturn(scheduledPayment);
+
+        // Act
+        ScheduledPayment result = accountService.schedulePayment(scheduledPayment);
+
+        // Assert
+        assertEquals(scheduledPayment, result);
+        verify(scheduledPaymentRepository).addScheduledPayment(scheduledPayment);
+    }
+
+    @Test
+    void schedulePayment_InvalidScheduledPayment_ReturnsNull() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        when(scheduledPaymentRepository.addScheduledPayment(scheduledPayment)).thenReturn(null);
+
+        // Act & Assert
+        assertNull(accountService.schedulePayment(scheduledPayment));
+        verify(scheduledPaymentRepository).addScheduledPayment(scheduledPayment);
+    }
+
+    @Test
+    void getScheduledPaymentsOfAccount_ValidAccountId_ReturnsScheduledPayments() {
+        // Arrange
+        Long accountId = 1L;
+        Account account = new Account();
+        List<ScheduledPayment> scheduledPayments = new ArrayList<>();
+        account.setScheduledPayments(scheduledPayments);
+        when(accountRepository.getById(accountId)).thenReturn(account);
+
+        // Act
+        List<ScheduledPayment> result = accountService.getScheduledPaymentsOfAccount(accountId);
+
+        // Assert
+        assertEquals(scheduledPayments, result);
+    }
+}

account-management/src/test/java/cz/muni/pa165/banking/application/service/UserServiceTest.java

+package cz.muni.pa165.banking.application.service;
+
+import cz.muni.pa165.banking.domain.user.User;
+import cz.muni.pa165.banking.domain.user.repository.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.springframework.boot.test.context.SpringBootTest;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@SpringBootTest
+class UserServiceTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private UserService userService;
+
+    @Test
+    void createUser_ValidUser_ReturnsUser() {
+        // Arrange
+        User user = new User();
+        when(userRepository.addUser(user)).thenReturn(user);
+
+        // Act
+        User result = userService.createUser(user);
+
+        // Assert
+        assertEquals(user, result);
+        verify(userRepository).addUser(user);
+    }
+
+    @Test
+    void getUser_ValidUserId_ReturnsUser() {
+        // Arrange
+        Long userId = 1L;
+        User user = new User();
+        when(userRepository.getById(userId)).thenReturn(user);
+
+        // Act
+        User result = userService.getUser(userId);
+
+        // Assert
+        assertEquals(user, result);
+        verify(userRepository).getById(userId);
+    }
+
+    @Test
+    void getUser_InvalidUserId_ReturnsNull() {
+        // Arrange
+        Long userId = 1L;
+        when(userRepository.getById(userId)).thenReturn(null);
+
+        // Act & Assert
+        assertNull(userService.getUser(userId));
+        verify(userRepository).getById(userId);
+    }
+}
+

account-management/src/test/java/cz/muni/pa165/banking/domain/account/AccountTest.java

+package cz.muni.pa165.banking.domain.account;
+
+import cz.muni.pa165.banking.domain.scheduled.ScheduledPayment;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AccountTest {
+    @Test
+    public void testGettersAndSetters() {
+        // Arrange
+        Account account = new Account();
+        Long id = 1L;
+        String accountNumber = "123456789";
+        Long userId = 2L;
+        Integer maxSpendingLimit = 1000;
+        AccountType type = AccountType.CREDIT;
+        List<ScheduledPayment> scheduledPayments = new ArrayList<>();
+
+        // Act
+        account.setId(id);
+        account.setAccountNumber(accountNumber);
+        account.setUserId(userId);
+        account.setMaxSpendingLimit(maxSpendingLimit);
+        account.setType(type);
+        account.setScheduledPayments(scheduledPayments);
+
+        // Assert
+        assertEquals(id, account.getId());
+        assertEquals(accountNumber, account.getAccountNumber());
+        assertEquals(userId, account.getUserId());
+        assertEquals(maxSpendingLimit, account.getMaxSpendingLimit());
+        assertEquals(type, account.getType());
+        assertEquals(scheduledPayments, account.getScheduledPayments());
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        // Act
+        Account account = new Account();
+
+        // Assert
+        assertNull(account.getId());
+        assertNull(account.getAccountNumber());
+        assertNull(account.getUserId());
+        assertNull(account.getMaxSpendingLimit());
+        assertNull(account.getType());
+        assertNull(account.getScheduledPayments());
+    }
+
+}
\ No newline at end of file

account-management/src/test/java/cz/muni/pa165/banking/domain/scheduled/ScheduledPaymentProcessorTest.java

+package cz.muni.pa165.banking.domain.scheduled;
+
+import cz.muni.pa165.banking.application.repository.ScheduledPaymentRepositoryImpl;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+
+public class ScheduledPaymentProcessorTest {
+
+    @Mock
+    private ScheduledPaymentRepositoryImpl scheduledPaymentRepository;
+
+    @InjectMocks
+    private ScheduledPaymentProcessor scheduledPaymentProcessor;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    public void testExecuteScheduledPayments() {
+        // Arrange
+        Map<Long, ScheduledPayment> scheduledPayments = new HashMap<>();
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        scheduledPayment.setSenderAccountId(1L);
+        scheduledPayment.setReceiverAccountId(2L);
+        scheduledPayment.setAmount(100);
+        scheduledPayments.put(1L, scheduledPayment);
+
+        when(scheduledPaymentRepository.getAllPayments()).thenReturn(scheduledPayments);
+
+        // Act
+        scheduledPaymentProcessor.executeScheduledPayments();
+
+        // Assert
+        verify(scheduledPaymentRepository, times(1)).getAllPayments();
+    }
+}
+

account-management/src/test/java/cz/muni/pa165/banking/domain/scheduled/ScheduledPaymentTest.java

+package cz.muni.pa165.banking.domain.scheduled;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ScheduledPaymentTest {
+    @Test
+    public void testGettersAndSetters() {
+        // Arrange
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+        Long id = 1L;
+        Long senderAccountId = 2L;
+        Long receiverAccountId = 3L;
+        Integer amount = 1000;
+
+        // Act
+        scheduledPayment.setId(id);
+        scheduledPayment.setSenderAccountId(senderAccountId);
+        scheduledPayment.setReceiverAccountId(receiverAccountId);
+        scheduledPayment.setAmount(amount);
+
+        // Assert
+        assertEquals(id, scheduledPayment.getId());
+        assertEquals(senderAccountId, scheduledPayment.getSenderAccountId());
+        assertEquals(receiverAccountId, scheduledPayment.getReceiverAccountId());
+        assertEquals(amount, scheduledPayment.getAmount());
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        // Act
+        ScheduledPayment scheduledPayment = new ScheduledPayment();
+
+        // Assert
+        assertNull(scheduledPayment.getId());
+        assertNull(scheduledPayment.getSenderAccountId());
+        assertNull(scheduledPayment.getReceiverAccountId());
+        assertNull(scheduledPayment.getAmount());
+    }
+
+}
\ No newline at end of file

account-management/src/test/java/cz/muni/pa165/banking/domain/user/UserTest.java

+package cz.muni.pa165.banking.domain.user;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserTest {
+
+    @Test
+    public void testGettersAndSetters() {
+        // Arrange
+        User user = new User();
+        Long id = 1L;
+        String email = "john.doe@example.com";
+        String password = "password";
+        String firstName = "John";
+        String lastName = "Doe";
+        UserType userType = UserType.EMPLOYEE;
+        List<String> accounts = new ArrayList<>();
+
+        // Act
+        user.setId(id);
+        user.setEmail(email);
+        user.setPassword(password);
+        user.setFirstName(firstName);
+        user.setLastName(lastName);
+        user.setUserType(userType);
+        user.setAccounts(accounts);
+
+        // Assert
+        assertEquals(id, user.getId());
+        assertEquals(email, user.getEmail());
+        assertEquals(password, user.getPassword());
+        assertEquals(firstName, user.getFirstName());
+        assertEquals(lastName, user.getLastName());
+        assertEquals(userType, user.getUserType());
+        assertEquals(accounts, user.getAccounts());
+    }
+
+    @Test
+    public void testDefaultConstructor() {
+        // Act
+        User user = new User();
+
+        // Assert
+        assertNull(user.getId());
+        assertNull(user.getEmail());
+        assertNull(user.getPassword());
+        assertNull(user.getFirstName());
+        assertNull(user.getLastName());
+        assertNull(user.getUserType());
+        assertNull(user.getAccounts());
+    }
+}
\ No newline at end of file