Merge branch 'master' of https://github.com/lumijiez/ExpenseTrackerFAF into front-v3

src/main/java/com/faf223/expensetrackerfaf/model/Expense.java

@@ -4,10 +4,7 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
 import jakarta.persistence.*;
 import jakarta.validation.constraints.DecimalMin;
 import jakarta.validation.constraints.NotNull;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.ToString;
+import lombok.*;
 
 import java.math.BigDecimal;
 import java.time.LocalDate;
@@ -16,6 +13,7 @@ import java.time.LocalDate;
 @AllArgsConstructor
 @NoArgsConstructor
 @Entity(name = "expenses")
+@Builder
 public class Expense implements IMoneyTransaction {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/com/faf223/expensetrackerfaf/model/Income.java

@@ -13,6 +13,7 @@ import java.time.LocalDate;
 @AllArgsConstructor
 @NoArgsConstructor
 @Entity(name = "incomes")
+@Builder
 public class Income implements IMoneyTransaction {
     @Id
     @GeneratedValue(strategy = GenerationType.IDENTITY)

src/main/java/com/faf223/expensetrackerfaf/model/User.java

@@ -34,8 +34,8 @@ public class User {
     private String username;
 
     @Transient
-    @NotNull(message = "Password must not be null")
-    @NotEmpty(message = "Password must not be empty")
+//    @NotNull(message = "Password must not be null")
+//    @NotEmpty(message = "Password must not be empty")
     private String password;
 
     @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)

src/main/java/com/faf223/expensetrackerfaf/service/ExpenseService.java

@@ -58,6 +58,7 @@ public class ExpenseService implements ITransactionService {
 
     @Override
     public List<Expense> getTransactionsByMonth(Month month) {
+        System.out.println(expenseRepository.filterByMonth(month.getValue()));
         return expenseRepository.filterByMonth(month.getValue());
     }
 

src/test/java/com/faf223/expensetrackerfaf/repository/ExpenseRepositoryTest.java

@@ -0,0 +1,189 @@
+package com.faf223.expensetrackerfaf.repository;
+
+import com.faf223.expensetrackerfaf.model.*;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@DataJpaTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+public class ExpenseRepositoryTest {
+
+    @Autowired
+    private ExpenseRepository expenseRepository;
+    @Autowired
+    private ExpenseCategoryRepository expenseCategoryRepository;
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    public void ExpenseRepository_SaveAll_ReturnExpense() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
+
+        Expense expense = Expense.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(expenseCategory)
+                .date(LocalDate.now())
+                .build();
+
+        Expense savedExpense = expenseRepository.save(expense);
+
+        Assertions.assertThat(savedExpense).isNotNull();
+        Assertions.assertThat(savedExpense.getId()).isGreaterThan(0L);
+    }
+
+    @Test
+    public void ExpenseRepository_GateAll_ReturnsMoreThenOneExpense() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
+
+        List<Expense> expenseList = expenseRepository.findAll();
+        int qtyBefore = expenseList.size();
+
+        Expense expense1 = Expense.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(expenseCategory)
+                .date(LocalDate.now())
+                .build();
+        Expense expense2 = Expense.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(177))
+                .category(expenseCategory)
+                .date(LocalDate.now())
+                .build();
+
+        expenseRepository.save(expense1);
+        expenseRepository.save(expense2);
+
+        expenseList = expenseRepository.findAll();
+
+        Assertions.assertThat(expenseList).isNotNull();
+        Assertions.assertThat(expenseList.size()).isEqualTo(qtyBefore + 2);
+    }
+
+    @Test
+    public void ExpenseRepository_FindById_ReturnExpense() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(1L);
+
+        Expense expense = Expense.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(expenseCategory)
+                .date(LocalDate.now())
+                .build();
+
+        expenseRepository.save(expense);
+
+        Optional<Expense> expenseReturn = expenseRepository.findById(expense.getId());
+        Assertions.assertThat(expenseReturn.isPresent()).isTrue();
+    }
+
+    @Test
+    public void ExpenseRepository_FindByUser_ReturnExpenses() {
+
+        Optional<User> user = userRepository.findByUsername("Balaban");
+        Assertions.assertThat(user.isPresent()).isTrue();
+
+        List<Expense> expenses = expenseRepository.findByUser(user.get());
+
+        Assertions.assertThat(expenses).isNotNull();
+    }
+
+    @Test
+    public void ExpenseRepository_FindByDate_ReturnExpenses() {
+
+        List<Expense> expenses = expenseRepository.findByDate(LocalDate.of(2023, 10, 7));
+
+        Assertions.assertThat(expenses).isNotNull();
+    }
+
+    @Test
+    public void ExpenseRepository_UpdateExpense_ReturnExpenseNotNull() {
+
+        Optional<User> user = userRepository.findByUsername("Deep Deep");
+        Assertions.assertThat(user.isPresent()).isTrue();
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(4L);
+
+        Expense expense = Expense.builder()
+                .user(user.get())
+                .amount(BigDecimal.valueOf(700))
+                .category(expenseCategory)
+                .date(LocalDate.of(2023, 10, 5))
+                .build();
+
+        expenseRepository.save(expense);
+
+        Optional<Expense> expenseSave = expenseRepository.findById(expense.getId());
+        Assertions.assertThat(expenseSave).isNotNull();
+
+        Expense expenseToUpdate = expenseSave.get();
+        expenseToUpdate.setDate(LocalDate.of(2023, 10, 6));
+        expenseToUpdate.setAmount(BigDecimal.valueOf(777));
+
+        Expense updatedExpense = expenseRepository.save(expenseToUpdate);
+
+        Assertions.assertThat(updatedExpense).isNotNull();
+        Assertions.assertThat(updatedExpense.getAmount()).isEqualTo(BigDecimal.valueOf(777));
+    }
+
+    @Test
+    public void ExpenseRepository_DeleteExpense_ReturnExpenseNull() {
+
+        Optional<User> user = userRepository.findByUsername("Deep Deep");
+        Assertions.assertThat(user.isPresent()).isTrue();
+        ExpenseCategory expenseCategory = expenseCategoryRepository.getReferenceById(4L);
+
+        Expense expense = Expense.builder()
+                .user(user.get())
+                .amount(BigDecimal.valueOf(700))
+                .category(expenseCategory)
+                .date(LocalDate.of(2023, 10, 5))
+                .build();
+
+        expenseRepository.save(expense);
+        expenseRepository.deleteById(expense.getId());
+
+        Optional<Expense> deletedExpense = expenseRepository.findById(expense.getId());
+
+        Assertions.assertThat(deletedExpense.isPresent()).isFalse();
+    }
+}

src/test/java/com/faf223/expensetrackerfaf/repository/IncomeRepositoryTest.java

@@ -0,0 +1,192 @@
+package com.faf223.expensetrackerfaf.repository;
+
+import com.faf223.expensetrackerfaf.model.Income;
+import com.faf223.expensetrackerfaf.model.IncomeCategory;
+import com.faf223.expensetrackerfaf.model.User;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+@DataJpaTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+public class IncomeRepositoryTest {
+
+    @Autowired
+    private IncomeRepository incomeRepository;
+    @Autowired
+    private IncomeCategoryRepository incomeCategoryRepository;
+    @Autowired
+    private UserRepository userRepository;
+
+    @Test
+    public void IncomeRepository_SaveAll_ReturnIncome() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        IncomeCategory incomeCategory = incomeCategoryRepository.getReferenceById(1L);
+
+        Income income = Income.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(incomeCategory)
+                .date(LocalDate.now())
+                .build();
+
+        Income savedIncome = incomeRepository.save(income);
+
+        Assertions.assertThat(savedIncome).isNotNull();
+        Assertions.assertThat(savedIncome.getId()).isGreaterThan(0L);
+    }
+
+    @Test
+    public void IncomeRepository_GateAll_ReturnsMoreThenOneIncome() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        IncomeCategory incomeCategory = incomeCategoryRepository.getReferenceById(1L);
+
+        List<Income> incomeList = incomeRepository.findAll();
+        int qtyBefore = incomeList.size();
+
+        Income income1 = Income.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(incomeCategory)
+                .date(LocalDate.now())
+                .build();
+        Income income2 = Income.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(177))
+                .category(incomeCategory)
+                .date(LocalDate.now())
+                .build();
+
+        incomeRepository.save(income1);
+        incomeRepository.save(income2);
+
+        incomeList = incomeRepository.findAll();
+
+        Assertions.assertThat(incomeList).isNotNull();
+        Assertions.assertThat(incomeList.size()).isEqualTo(qtyBefore + 2);
+    }
+
+    @Test
+    public void IncomeRepository_FindById_ReturnIncome() {
+
+        User user = User.builder()
+                .firstName("Test")
+                .lastName("TestLast")
+                .username("UserTest")
+                .incomes(new ArrayList<>())
+                .expenses(new ArrayList<>())
+                .build();
+
+        userRepository.save(user);
+        IncomeCategory incomeCategory = incomeCategoryRepository.getReferenceById(1L);
+
+        Income income = Income.builder()
+                .user(user)
+                .amount(BigDecimal.valueOf(77))
+                .category(incomeCategory)
+                .date(LocalDate.now())
+                .build();
+
+        incomeRepository.save(income);
+
+        Optional<Income> incomeReturn = incomeRepository.findById(income.getId());
+        Assertions.assertThat(incomeReturn.isPresent()).isTrue();
+    }
+
+    @Test
+    public void IncomeRepository_FindByUser_ReturnIncomes() {
+
+        Optional<User> user = userRepository.findByUsername("Balaban");
+        Assertions.assertThat(user.isPresent()).isTrue();
+
+        List<Income> incomes = incomeRepository.findByUser(user.get());
+
+        Assertions.assertThat(incomes).isNotNull();
+    }
+
+    @Test
+    public void IncomeRepository_FindByDate_ReturnIncomes() {
+
+        List<Income> incomes = incomeRepository.findByDate(LocalDate.of(2023,10,7));
+
+        Assertions.assertThat(incomes).isNotNull();
+    }
+
+    @Test
+    public void IncomeRepository_UpdateIncome_ReturnIncomeNotNull() {
+
+        Optional<User> user = userRepository.findByUsername("Deep Deep");
+        Assertions.assertThat(user.isPresent()).isTrue();
+        IncomeCategory incomeCategory = incomeCategoryRepository.getReferenceById(4L);
+
+        Income income = Income.builder()
+                .user(user.get())
+                .amount(BigDecimal.valueOf(700))
+                .category(incomeCategory)
+                .date(LocalDate.of(2023,10,5))
+                .build();
+
+        incomeRepository.save(income);
+
+        Optional<Income> incomeSave = incomeRepository.findById(income.getId());
+        Assertions.assertThat(incomeSave).isNotNull();
+
+        Income incomeToUpdate = incomeSave.get();
+        incomeToUpdate.setDate(LocalDate.of(2023,10,6));
+        incomeToUpdate.setAmount(BigDecimal.valueOf(777));
+
+        Income updatedIncome = incomeRepository.save(incomeToUpdate);
+
+        Assertions.assertThat(updatedIncome).isNotNull();
+        Assertions.assertThat(updatedIncome.getAmount()).isEqualTo(BigDecimal.valueOf(777));
+    }
+
+    @Test
+    public void IncomeRepository_DeleteIncome_ReturnIncomeNull() {
+
+        Optional<User> user = userRepository.findByUsername("Deep Deep");
+        Assertions.assertThat(user.isPresent()).isTrue();
+        IncomeCategory incomeCategory = incomeCategoryRepository.getReferenceById(4L);
+
+        Income income = Income.builder()
+                .user(user.get())
+                .amount(BigDecimal.valueOf(700))
+                .category(incomeCategory)
+                .date(LocalDate.of(2023,10,5))
+                .build();
+
+        incomeRepository.save(income);
+        incomeRepository.deleteById(income.getId());
+
+        Optional<Income> deletedIncome = incomeRepository.findById(income.getId());
+
+        Assertions.assertThat(deletedIncome.isPresent()).isFalse();
+    }
+
+}