spring vue jpa repository 테스트코드

컴퓨터과학 2023. 11. 26. 02:41

2023. 11. 26. 02:41

2023.11.25 - [웹/Spring vue 웹 개발] - spring vue entity 변경

spring vue entity 변경

테이블을 이번에 전부 변경했습니다. https://www.erdcloud.com/d/TBkodsGPbZev8sBXs 백엔드 Draw ERD with your team members. All states are shared in real time. And it's FREE. Database modeling tool. www.erdcloud.com users package kr.co.kshpro

kwaksh2319.tistory.com

UserRepositoryTest

package kr.co.kshproject.webDemo.Domain.Users;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class UsersRepositoryTest {

    @Autowired
    private UsersRepository usersRepository;

    @Test
    public void save() {
        Users newUser = new Users();
        newUser.setUsername("testuser");
        newUser.setEmail("test@example.com");
        newUser.setName("Test User");
        newUser.setLevel(1L);
        newUser.setPassword("password");
        Users savedUser = usersRepository.save(newUser);
        Optional<Users> foundUser = usersRepository.findById(savedUser.getId());

        assertTrue(foundUser.isPresent());
        assertEquals("testuser", foundUser.get().getUsername());
    }

    @Test
    public void findAll() {
        Users newUser = new Users();
        newUser.setUsername("testuser");
        newUser.setEmail("test@example.com");
        newUser.setName("Test User");
        newUser.setLevel(1L);
        newUser.setPassword("password");
        Users savedUser = usersRepository.save(newUser);

        List<Users> users = usersRepository.findAll();
        assertFalse(users.isEmpty());
    }

    @Test
    public void findById() {
        Users newUser = new Users();
        newUser.setUsername("testuser");
        newUser.setEmail("test@example.com");
        newUser.setName("Test User");
        newUser.setLevel(1L);
        newUser.setPassword("password");
        Users savedUser = usersRepository.save(newUser);

        Optional<Users> foundUser = usersRepository.findById(savedUser.getId());
        assertTrue(foundUser.isPresent());
        assertEquals("testuser", foundUser.get().getUsername());
    }

    @Test
    public void update() {
        Users newUser = new Users();
        newUser.setUsername("testuser");
        newUser.setEmail("test@example.com");
        newUser.setName("Test User");
        newUser.setLevel(1L);
        newUser.setPassword("password");
        Users savedUser = usersRepository.save(newUser);

        Users userToUpdate = usersRepository.findById(savedUser.getId()).get();
        userToUpdate.setName("Updated Name");
        usersRepository.save(userToUpdate);

        Optional<Users> updatedUser = usersRepository.findById(savedUser.getId());
        assertTrue(updatedUser.isPresent());
        assertEquals("Updated Name", updatedUser.get().getName());
    }

    @Test
    public void deleteAll() {
        Users newUser = new Users();
        newUser.setUsername("testuser");
        newUser.setEmail("test@example.com");
        newUser.setName("Test User");
        newUser.setLevel(1L);
        newUser.setPassword("password");
        Users savedUser = usersRepository.save(newUser);

        usersRepository.deleteAll();
        List<Users> users = usersRepository.findAll();
        assertTrue(users.isEmpty());
    }

}

ProductsRepositoryTest

package kr.co.kshproject.webDemo.Domain.Products;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class ProductsRepositoryTest {
    @Autowired
    private ProductsRepository productsRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        productsRepository.deleteAll();
    }

    @Test
    public void save() {
        Products product=new Products();

        product.setProductName("testProduct");
        product.setPicture("testPicture");
        product.setDescribe("test");
        product.setPrice(100L);
        product.setSoldOut(false);
        product.setCreatedDate("20231125");
        product.setUpdateDate("20231125");

        product.setCategory(null);

        Products savedProduct = productsRepository.save(product);
        Optional<Products> foundProduct = productsRepository.findById(savedProduct.getId());

        assertTrue(foundProduct.isPresent());
        assertEquals("testProduct", foundProduct.get().getProductName());
    }

    @Test
    public void findAll() {
        Products product=new Products();
        product.setProductName("testProduct");
        product.setPicture("testPicture");
        product.setDescribe("test");
        product.setPrice(100L);
        product.setSoldOut(false);
        product.setCreatedDate("20231125");
        product.setUpdateDate("20231125");

        Products savedProducts = productsRepository.save(product);

        List<Products> products = productsRepository.findAll();
        assertFalse(products.isEmpty());
    }

    @Test
    public void findById() {
        Products product=new Products();
        product.setProductName("testProduct");
        product.setPicture("testPicture");
        product.setDescribe("test");
        product.setPrice(100L);
        product.setSoldOut(false);
        product.setCreatedDate("20231125");
        product.setUpdateDate("20231125");
        Products savedProducts = productsRepository.save(product);

        Optional<Products> foundProduct = productsRepository.findById(savedProducts.getId());
        assertTrue(foundProduct.isPresent());
        assertEquals("testProduct", foundProduct.get().getProductName());
    }

    @Test
    public void update() {
        Products product=new Products();
        product.setProductName("testProduct");
        product.setPicture("testPicture");
        product.setDescribe("test");
        product.setPrice(100L);
        product.setSoldOut(false);
        product.setCreatedDate("20231125");
        product.setUpdateDate("20231125");
        Products savedProduct = productsRepository.save(product);

        Products productToUpdate = productsRepository.findById(savedProduct.getId()).get();
        productToUpdate.setProductName("Updated Product");
        productsRepository.save(productToUpdate);

       Optional<Products> updatedProduct = productsRepository.findById(savedProduct.getId());
       assertTrue(updatedProduct.isPresent());
        assertEquals("Updated Product", updatedProduct.get().getProductName());
    }

    @Test
    public void deleteAll() {
        Products product=new Products();
        product.setProductName("testProduct");
        product.setPicture("testPicture");
        product.setDescribe("test");
        product.setPrice(100L);
        product.setSoldOut(false);
        product.setCreatedDate("20231125");
        product.setUpdateDate("20231125");
        Products savedProduct = productsRepository.save(product);

        productsRepository.deleteAll();
        List<Products> products = productsRepository.findAll();
        assertTrue(products.isEmpty());
    }
}

OrdersRepositoryTest

package kr.co.kshproject.webDemo.Domain.Orders;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class OrdersRepositoryTest {
    @Autowired
    private OrdersRepository ordersRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        ordersRepository.deleteAll();
    }

    @Test
    public void save() {
        Orders order=new Orders();
        order.setStatus("T");
        order.setPrice(100L);
        order.setPayment("card");
        order.setCancel(false);
        order.setCreatedDate("20231125");
        order.setUpdateDate("20231125");
        order.setUsers(null);
        Orders savedOrder = ordersRepository.save(order);
        Optional<Orders> foundOrder = ordersRepository.findById(savedOrder.getId());

        assertTrue(foundOrder.isPresent());
        assertEquals("card", foundOrder.get().getPayment());
    }

    @Test
    public void findAll() {
        Orders order=new Orders();
        order.setStatus("T");
        order.setPrice(100L);
        order.setPayment("card");
        order.setCancel(false);
        order.setCreatedDate("20231125");
        order.setUpdateDate("20231125");
        order.setUsers(null);
        Orders savedOrders = ordersRepository.save(order);

        List<Orders> Orders  = ordersRepository.findAll();
        assertFalse(Orders.isEmpty());
    }

    @Test
    public void findById() {
        Orders order=new Orders();
        order.setStatus("T");
        order.setPrice(100L);
        order.setPayment("card");
        order.setCancel(false);
        order.setCreatedDate("20231125");
        order.setUpdateDate("20231125");
        order.setUsers(null);
        Orders savedOrder = ordersRepository.save(order);

        Optional<Orders> foundOrder = ordersRepository.findById(savedOrder.getId());
        assertTrue(foundOrder.isPresent());
        assertEquals("card", foundOrder.get().getPayment());
    }

    @Test
    public void update() {
        Orders order=new Orders();
        order.setStatus("T");
        order.setPrice(100L);
        order.setPayment("card");
        order.setCancel(false);
        order.setCreatedDate("20231125");
        order.setUpdateDate("20231125");
        order.setUsers(null);
        Orders savedOrder = ordersRepository.save(order);

        Orders orderToUpdate = ordersRepository.findById(savedOrder.getId()).get();
        orderToUpdate.setPayment("cash");
        ordersRepository.save(orderToUpdate);

        Optional<Orders> updatedOrder = ordersRepository.findById(savedOrder.getId());
        assertTrue(updatedOrder.isPresent());
        assertEquals("cash", updatedOrder.get().getPayment());
    }

    @Test
    public void deleteAll() {
        Orders order=new Orders();
        order.setStatus("T");
        order.setPrice(100L);
        order.setPayment("card");
        order.setCancel(false);
        order.setCreatedDate("20231125");
        order.setUpdateDate("20231125");
        order.setUsers(null);
        Orders orderProduct = ordersRepository.save(order);

        ordersRepository.deleteAll();
        List<Orders> orders = ordersRepository.findAll();
        assertTrue(orders.isEmpty());
    }
}

NoticeRepositorylTest

package kr.co.kshproject.webDemo.Domain.Notice;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class NoticeRepositorylTest {
    @Autowired
    private NoticeRepository noticeRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        noticeRepository.deleteAll();
    }

    @Test
    public void save() {
        Notice notice=new Notice();
        notice.setUsername("testUserName");
        notice.setTitle("test");
        notice.setContents("testcontent");
        notice.setUsers(null);
        notice.setEmail("test@mail.com");
        notice.setCreatedDate("20231125");

        Notice savedNotice = noticeRepository.save(notice);
        Optional<Notice> foundNotice = noticeRepository.findById(savedNotice.getId());

        assertTrue(foundNotice.isPresent());
        assertEquals("test", foundNotice.get().getTitle());
    }

    @Test
    public void findAll() {
        Notice notice=new Notice();
        notice.setUsername("testUserName");
        notice.setTitle("test");
        notice.setContents("testcontent");
        notice.setUsers(null);
        notice.setEmail("test@mail.com");
        notice.setCreatedDate("20231125");

        Notice savedNotice = noticeRepository.save(notice);

        List<Notice> notices  = noticeRepository.findAll();
        assertFalse(notices.isEmpty());
    }

    @Test
    public void findById() {
        Notice notice=new Notice();
        notice.setUsername("testUserName");
        notice.setTitle("test");
        notice.setContents("testcontent");
        notice.setUsers(null);
        notice.setEmail("test@mail.com");
        notice.setCreatedDate("20231125");

        Notice savedNotice = noticeRepository.save(notice);

        Optional<Notice> foundNotice = noticeRepository.findById(savedNotice.getId());
        assertTrue(foundNotice.isPresent());
        assertEquals("test", foundNotice.get().getTitle());
    }

    @Test
    public void update() {
        Notice notice=new Notice();
        notice.setUsername("testUserName");
        notice.setTitle("test");
        notice.setContents("testcontent");
        notice.setUsers(null);
        notice.setEmail("test@mail.com");
        notice.setCreatedDate("20231125");

        Notice savedNotice = noticeRepository.save(notice);

        Notice noticeToUpdate = noticeRepository.findById(savedNotice.getId()).get();
        noticeToUpdate.setTitle("update test");
        noticeRepository.save(noticeToUpdate);

        Optional<Notice> updatedNotice = noticeRepository.findById(savedNotice.getId());
        assertTrue(updatedNotice.isPresent());
        assertEquals("update test", updatedNotice.get().getTitle());
    }

    @Test
    public void deleteAll() {
        Notice notice=new Notice();
        notice.setUsername("testUserName");
        notice.setTitle("test");
        notice.setContents("testcontent");
        notice.setUsers(null);
        notice.setEmail("test@mail.com");
        notice.setCreatedDate("20231125");

        Notice savedNotice = noticeRepository.save(notice);
        noticeRepository.deleteAll();
        List<Notice> notices = noticeRepository.findAll();
        assertTrue(notices.isEmpty());
    }
}

CommentRepositoryTest

package kr.co.kshproject.webDemo.Domain.Comment;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;
@DataJpaTest
class CommentRepositoryTest {
    @Autowired
    private CommentRepository commentRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        commentRepository.deleteAll();
    }

    @Test
    public void save() {
        Comment comment=new Comment();
        comment.setUserName("testUserName");
        comment.setContents("test");
        comment.setCreatedDate("20231125");
        comment.setNotice(null);
        comment.setUsers(null);

        Comment savedComment = commentRepository.save(comment);
        Optional<Comment> foundComment = commentRepository.findById(savedComment.getId());

        assertTrue(foundComment.isPresent());
        assertEquals("test", foundComment.get().getContents());
    }

    @Test
    public void findAll() {
        Comment comment=new Comment();
        comment.setUserName("testUserName");
        comment.setContents("test");
        comment.setCreatedDate("20231125");
        comment.setNotice(null);
        comment.setUsers(null);

        Comment savedComment = commentRepository.save(comment);

        List<Comment> comments  = commentRepository.findAll();
        assertFalse(comments.isEmpty());
    }

    @Test
    public void findById() {
        Comment comment=new Comment();
        comment.setUserName("testUserName");
        comment.setContents("test");
        comment.setCreatedDate("20231125");
        comment.setNotice(null);
        comment.setUsers(null);

        Comment savedComment = commentRepository.save(comment);

        Optional<Comment> foundComment = commentRepository.findById(savedComment.getId());
        assertTrue(foundComment.isPresent());
        assertEquals("test", foundComment.get().getContents());
    }

    @Test
    public void update() {
        Comment comment=new Comment();
        comment.setUserName("testUserName");
        comment.setContents("test");
        comment.setCreatedDate("20231125");
        comment.setNotice(null);
        comment.setUsers(null);

        Comment savedComment = commentRepository.save(comment);

        Comment commentToUpdate = commentRepository.findById(savedComment.getId()).get();
        commentToUpdate.setContents("update test");
        commentRepository.save(commentToUpdate);

        Optional<Comment> updatedComment = commentRepository.findById(savedComment.getId());
        assertTrue(updatedComment.isPresent());
        assertEquals("update test", updatedComment.get().getContents());
    }

    @Test
    public void deleteAll() {
        Comment comment=new Comment();
        comment.setUserName("testUserName");
        comment.setContents("test");
        comment.setCreatedDate("20231125");
        comment.setNotice(null);
        comment.setUsers(null);

        Comment savedComment = commentRepository.save(comment);
        commentRepository.deleteAll();
        List<Comment> comments = commentRepository.findAll();
        assertTrue(comments.isEmpty());
    }
}

CategoryRepositoryTest

package kr.co.kshproject.webDemo.Domain.Category;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class CategoryRepositoryTest {
    @Autowired
    private CategoryRepository categoryRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        categoryRepository.deleteAll();
    }

    @Test
    public void save() {
        Category category=new Category();
        category.setCategoryName("test");
        category.setParentCategory(null);
        category.setCreatedDate("20231125");
        category.setUpdateDate("20231125");

        Category savedCategory = categoryRepository.save(category);
        Optional<Category> foundCategory = categoryRepository.findById(savedCategory.getId());

        assertTrue(foundCategory.isPresent());
        assertEquals("test", foundCategory.get().getCategoryName());
    }

    @Test
    public void findAll() {
        Category category=new Category();
        category.setCategoryName("test");
        category.setParentCategory(null);
        category.setCreatedDate("20231125");
        category.setUpdateDate("20231125");

        Category savedCategory = categoryRepository.save(category);

        List<Category> categories  = categoryRepository.findAll();
        assertFalse(categories.isEmpty());
    }

    @Test
    public void findById() {
        Category category=new Category();
        category.setCategoryName("test");
        category.setParentCategory(null);
        category.setCreatedDate("20231125");
        category.setUpdateDate("20231125");

        Category savedCategory = categoryRepository.save(category);

        Optional<Category> foundCategory= categoryRepository.findById(savedCategory.getId());
        assertTrue(foundCategory.isPresent());
        assertEquals("test", foundCategory.get().getCategoryName());
    }

    @Test
    public void update() {
        Category category=new Category();
        category.setCategoryName("test");
        category.setParentCategory(null);
        category.setCreatedDate("20231125");
        category.setUpdateDate("20231125");

        Category savedCategory = categoryRepository.save(category);

        Category categoryToUpdate = categoryRepository.findById(savedCategory.getId()).get();
        categoryToUpdate.setCategoryName("update test");
        categoryRepository.save(categoryToUpdate);

        Optional<Category> updatedCategory = categoryRepository.findById(savedCategory.getId());
        assertTrue(updatedCategory.isPresent());
        assertEquals("update test", updatedCategory.get().getCategoryName());
    }

    @Test
    public void deleteAll() {
        Category category=new Category();
        category.setCategoryName("test");
        category.setParentCategory(null);
        category.setCreatedDate("20231125");
        category.setUpdateDate("20231125");

        Category savedCategory = categoryRepository.save(category);
        categoryRepository.deleteAll();
        List<Category> categories = categoryRepository.findAll();
        assertTrue(categories.isEmpty());
    }
}

BeginOrderRepositoryTest

package kr.co.kshproject.webDemo.Domain.BeginOrder;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class BeginOrderRepositoryTest {
    @Autowired
    private BeginOrderRepository beginOrderRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        beginOrderRepository.deleteAll();
    }

    @Test
    public void save() {
        BeginOrder beginOrder=new BeginOrder();
        beginOrder.setPicture("test");
        beginOrder.setOrders(null);
        beginOrder.setProducts(null);
        beginOrder.setQuantity(1L);
        beginOrder.setCreatedDate("20231125");
        beginOrder.setUpdateDate("20231125");

        BeginOrder savedBeginOrder = beginOrderRepository.save(beginOrder);
        Optional<BeginOrder> foundBeginOrder= beginOrderRepository.findById(savedBeginOrder.getId());

        assertTrue(foundBeginOrder.isPresent());
        assertEquals("test", foundBeginOrder.get().getPicture());
    }

    @Test
    public void findAll() {
        BeginOrder beginOrder=new BeginOrder();
        beginOrder.setPicture("test");
        beginOrder.setOrders(null);
        beginOrder.setProducts(null);
        beginOrder.setQuantity(1L);
        beginOrder.setCreatedDate("20231125");
        beginOrder.setUpdateDate("20231125");

        BeginOrder savedBeginOrder = beginOrderRepository.save(beginOrder);

        List<BeginOrder> beginOrders  = beginOrderRepository.findAll();
        assertFalse(beginOrders.isEmpty());
    }

    @Test
    public void findById() {
        BeginOrder beginOrder=new BeginOrder();
        beginOrder.setPicture("test");
        beginOrder.setOrders(null);
        beginOrder.setProducts(null);
        beginOrder.setQuantity(1L);
        beginOrder.setCreatedDate("20231125");
        beginOrder.setUpdateDate("20231125");

        BeginOrder savedBeginOrder = beginOrderRepository.save(beginOrder);

        Optional<BeginOrder> foundBeginOrder= beginOrderRepository.findById(savedBeginOrder.getId());
        assertTrue(foundBeginOrder.isPresent());
        assertEquals("test", foundBeginOrder.get().getPicture());
    }

    @Test
    public void update() {
        BeginOrder beginOrder=new BeginOrder();
        beginOrder.setPicture("test");
        beginOrder.setOrders(null);
        beginOrder.setProducts(null);
        beginOrder.setQuantity(1L);
        beginOrder.setCreatedDate("20231125");
        beginOrder.setUpdateDate("20231125");

        BeginOrder savedBeginOrder = beginOrderRepository.save(beginOrder);

        BeginOrder beginOrderToUpdate = beginOrderRepository.findById(savedBeginOrder.getId()).get();
        beginOrderToUpdate.setPicture("update test");
        beginOrderRepository.save(beginOrderToUpdate);

        Optional<BeginOrder> updatedBeginOrder = beginOrderRepository.findById(savedBeginOrder.getId());
        assertTrue(updatedBeginOrder.isPresent());
        assertEquals("update test", updatedBeginOrder.get().getPicture());
    }

    @Test
    public void deleteAll() {
        BeginOrder beginOrder=new BeginOrder();
        beginOrder.setPicture("test");
        beginOrder.setOrders(null);
        beginOrder.setProducts(null);
        beginOrder.setQuantity(1L);
        beginOrder.setCreatedDate("20231125");
        beginOrder.setUpdateDate("20231125");

        BeginOrder savedBeginOrder = beginOrderRepository.save(beginOrder);
        beginOrderRepository.deleteAll();
        List<BeginOrder> beginOrderes = beginOrderRepository.findAll();
        assertTrue(beginOrderes.isEmpty());
    }
}

BasketsRepositoryTest

package kr.co.kshproject.webDemo.Domain.Baskets;

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.test.autoconfigure.orm.jpa.DataJpaTest;

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

import static org.junit.jupiter.api.Assertions.*;

@DataJpaTest
class BasketsRepositoryTest {
    @Autowired
    private BasketsRepository basketsRepository;

    @BeforeEach
    void before(){

    }

    @AfterEach
    void after() {
        // 테스트 데이터 정리
        basketsRepository.deleteAll();
    }

    @Test
    public void save() {
        Baskets basket=new Baskets();
        basket.setProductName("test");
        basket.setQuantity(1L);
        basket.setProductStatus("T");
        basket.setProducts(null);
        basket.setUsers(null);
        basket.setCreateDate("20231125");
        basket.setUpdateDate("20231125");

        Baskets savedBasket = basketsRepository.save(basket);
        Optional<Baskets> foundBBasket= basketsRepository.findById(savedBasket.getId());

        assertTrue(foundBBasket.isPresent());
        assertEquals("test", foundBBasket.get().getProductName());
    }

    @Test
    public void findAll() {
        Baskets basket=new Baskets();
        basket.setProductName("test");
        basket.setQuantity(1L);
        basket.setProductStatus("T");
        basket.setProducts(null);
        basket.setUsers(null);
        basket.setCreateDate("20231125");
        basket.setUpdateDate("20231125");

        Baskets savedBasket = basketsRepository.save(basket);

        List<Baskets> baskets  = basketsRepository.findAll();
        assertFalse(baskets.isEmpty());
    }

    @Test
    public void findById() {
        Baskets basket=new Baskets();
        basket.setProductName("test");
        basket.setQuantity(1L);
        basket.setProductStatus("T");
        basket.setProducts(null);
        basket.setUsers(null);
        basket.setCreateDate("20231125");
        basket.setUpdateDate("20231125");

        Baskets savedBasket = basketsRepository.save(basket);

        Optional<Baskets> foundBasket= basketsRepository.findById(savedBasket.getId());
        assertTrue(foundBasket.isPresent());
        assertEquals("test", foundBasket.get().getProductName());
    }

    @Test
    public void update() {
        Baskets basket=new Baskets();
        basket.setProductName("test");
        basket.setQuantity(1L);
        basket.setProductStatus("T");
        basket.setProducts(null);
        basket.setUsers(null);
        basket.setCreateDate("20231125");
        basket.setUpdateDate("20231125");

        Baskets savedBasket = basketsRepository.save(basket);

        Baskets basketToUpdate = basketsRepository.findById(savedBasket.getId()).get();
        basketToUpdate.setProductName("update test");
        basketsRepository.save(basketToUpdate);

        Optional<Baskets> updatedBaskets = basketsRepository.findById(savedBasket.getId());
        assertTrue(updatedBaskets.isPresent());
        assertEquals("update test", updatedBaskets.get().getProductName());
    }

    @Test
    public void deleteAll() {
        Baskets basket=new Baskets();
        basket.setProductName("test");
        basket.setQuantity(1L);
        basket.setProductStatus("T");
        basket.setProducts(null);
        basket.setUsers(null);
        basket.setCreateDate("20231125");
        basket.setUpdateDate("20231125");

        Baskets savedBasket = basketsRepository.save(basket);
        basketsRepository.deleteAll();
        List<Baskets> beginBaskets = basketsRepository.findAll();
        assertTrue(beginBaskets.isEmpty());
    }
}

'웹 > Spring vue 웹 개발' 카테고리의 다른 글

spring vue swagger 변경 작업01 (1)	2023.12.03
spring vue swagger 사용 및 controller,serivce 코드 완료 (0)	2023.11.27
spring vue entity 변경 (2)	2023.11.25
spring vue 어드민 리팩토링01 (0)	2023.11.18
spring vue 댓글 완료 (0)	2023.11.12

뚭

spring vue jpa repository 테스트코드

'웹 > Spring vue 웹 개발' 카테고리의 다른 글

+ Recent posts

티스토리툴바