(회원 관리 예제) 회원 서비스 테스트

mac : window 단축키 관련

^ : ctrl

⬆ : shift

위에서 아래모양 : alt

이전 내용 다시 실행 : shift + f10

 

 

Create New Test : Ctrl + shift + t

 

OK이후

Test에서는 메소드 이름을 한글로 적어도 된다. (실제 많이 사용된다.)

 

중복 정리

MemberServiceTest

    MemberService memberService = new MemberService();


    @Test
    public void 중복_회원_예외(){
        // given
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        // when
        // join을 두번 할 때, member1 : spring, member2 : spring
        // 중복됨, MemberService.java/validateDuplicateMethod메소드에서 잡힌다.
        memberService.join(member1);

        // 중복이 예외가 발생했을 때, 이미 존재하는 회원이라고 출력해준다.
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));

        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

//        try{
//            memberService.join(member2);
//        }catch(IllegalStateException e){
//            // 중복으로 나온 예외
//            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.123");
//        }


        // then
    }

MemberService

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;

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

public class MemberService {

    private final MemberRepository memberRepository = new MemoryMemberRepository();

    /*
    * 회원 가입
    * */

    public Long join(Member member){
        // 같은 이름이 있는 중복 회원 x
//        Optional<Member> result = memberRepository.findByName(member.getName());
//        result.ifPresent(m->{
//            throw new IllegalStateException("이미 존재하는 회원입니다.");
//
//        });
        validateDuplicateMethod(member);   // 중복 회원 검증


        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMethod(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m->{
            throw new IllegalStateException("이미 존재하는 회원입니다.");

        });
    }


    /*
    * 전체 회원 조회
    * */
    public List<Member> findMembers(){
        return memberRepository.findAll();
    }

    public Optional<Member> findOne(Long memberId){
        return memberRepository.findById(memberId);
    }
}

member1을 생성한 후, "spring"을 입력한다.

member2을 생성한 후, "spring"을 입력한다.

memberService 클래스의 join 메소드 입력인자 member1을 입력하여 검증한다.

 

중복회원이라면 memberService/validateDuplicateMethod메소드에서 예외가 발생한다. ("이미 존재하는 회원입니다.")

   Member member1 = new Member();
    member1.setName("spring");

    Member member2 = new Member();
    member2.setName("spring");

    // when
    // join을 두번 할 때, member1 : spring, member2 : spring
    // 중복됨, MemberService.java/validateDuplicateMethod메소드에서 잡힌다.
    memberService.join(member1);

member2를 입력했을 때 IllegalStateException이 발생한다면, 이미 존재하는 회원입니다. 라고 출력한다.

        // 중복이 예외가 발생했을 때, 이미 존재하는 회원이라고 출력해준다.
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));

        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

@AfterEach : 실행이 종료되고 나면 내부 db내용을 지워준다.

    // @AfterEach : save, findByName, findAll 메소드가 각각 끝나고 afterEach 메소드를 호출한다.
    @AfterEach
    public void afterEach(){
        memberRepository.clearStore();
    }

 

 

생성자 공통 2개를 하나로 줄이기

new MemoryMemberRepository() 생성자 두번 호출

 

생성자 한 번 호출로 변경 (Dependency Injection)

MemberService

public class MemberService {

    private final MemberRepository memberRepository;


    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

MemberServiceTest.java

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;


    @BeforeEach
    public void beforeEach(){
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }

    ~

MemberServiceTest 실행하기 전, @BeforeEach 실행

test를 실행하기 전, (test에 있는 소스파일을 실행하기 전)

memberRepository에 MemoryMemberRepository를 생성해주고

memberService를 생성할 때, 생성된 memberRepository를 생성 인자로 넣어준다.

넘어간 후, MemberService에서는 생성된 memberRepository를 this.memberRepository에 삽입한다.

이럴 경우,main와 test에서 같은 MemoryMemberRepository를 사용하게 된다.

이를, Dependency Injection이라고 한다.

 

 

 

java

MemberService.java

package hello.hellospring.service;

import hello.hellospring.domain.Member;
import hello.hellospring.repository.MemberRepository;
import hello.hellospring.repository.MemoryMemberRepository;

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

public class MemberService {

    private final MemberRepository memberRepository;

    // 외부에서 넣어준다.
    // Dependency Injection을 사용한다.

    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }



    /*
    * 회원 가입
    * */

    public Long join(Member member){
        // 같은 이름이 있는 중복 회원 x
//        Optional<Member> result = memberRepository.findByName(member.getName());
//        result.ifPresent(m->{
//            throw new IllegalStateException("이미 존재하는 회원입니다.");
//
//        });
        validateDuplicateMethod(member);   // 중복 회원 검증


        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMethod(Member member) {
        memberRepository.findByName(member.getName())
                .ifPresent(m->{
            throw new IllegalStateException("이미 존재하는 회원입니다.");

        });
    }


    /*
    * 전체 회원 조회
    * */
    public List<Member> findMembers(){
        return memberRepository.findAll();
    }

    public Optional<Member> findOne(Long memberId){
        return memberRepository.findById(memberId);
    }
}

test

MemoryMemberRepositoryTest.java

package hello.hellospring.repository;

import hello.hellospring.domain.Member;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;

import java.util.List;

import static org.assertj.core.api.Assertions.*;


class MemoryMemberRepositoryTest {

    MemoryMemberRepository repository = new MemoryMemberRepository();

    // @AfterEach : save, findByName, findAll 메소드가 각각 끝나고 afterEach 메소드를 호출한다.
    @AfterEach
    public void afterEach(){
        repository.clearStore();
    }

    @Test
    public void save(){
        Member member = new Member();
        member.setName("spring");

        repository.save(member);

        Member result = repository.findById(member.getId()).get();
        //Assertions.assertEquals(member,result);
        assertThat(member).isEqualTo(result);
    }

    @Test
    public void findByName(){
        // 회원가입 완료
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        Member result = repository.findByName("spring1").get();
        //Member result = repository.findByName("spring2").get(); 에러 발생

        assertThat(result).isEqualTo(member1);  // result 값이 member1의 값이라면 정상 실행
    }

    @Test
    public void findAll(){
        Member member1 = new Member();
        member1.setName("spring1");
        repository.save(member1);

        Member member2 = new Member();
        member2.setName("spring2");
        repository.save(member2);

        List<Member> result = repository.findAll();

        assertThat(result.size()).isEqualTo(2);
    }
}

MemberServiceTest.java

package hello.hellospring.service;

import hello.hellospring.domain.Member;

import hello.hellospring.repository.MemoryMemberRepository;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import java.util.Optional;

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

class MemberServiceTest {

    MemberService memberService;
    MemoryMemberRepository memberRepository;

    // MemberServiceTest 실행하기 전, beforeEach 실행
    // test를 실행하기 전,
    // memberRepository에 MemoryMemberRepository를 생성해주고
    // memberService를 생성할 때, 생성된 memberRepository를 생성 인자로 넣어준다.
    // 넘어간 후, MemberService에서는
    // 생성된 memberRepository를 this.memberRepository에 삽입한다.
    // 이럴 경우,main와 test에서 같은 MemoryMemberRepository를 사용하게 된다.
    // 이를, Dependency Injection이라고 한다.


    @BeforeEach
    public void beforeEach(){
        memberRepository = new MemoryMemberRepository();
        memberService = new MemberService(memberRepository);
    }





    // @AfterEach : save, findByName, findAll 메소드가 각각 끝나고 afterEach 메소드를 호출한다.
    @AfterEach
    public void afterEach(){
        memberRepository.clearStore();
    }

    @Test
    void 회원가입() {
        // given (검증 부분 주석으로 입력해놓기)
        Member member = new Member();
        member.setName("hello");

        // when
        Long saveId = memberService.join(member);


        // then
        // Optional<Member> one = memberService.findOne(saveId);
        Member findMember = memberService.findOne(saveId).get();
        assertThat(member.getName()).isEqualTo(findMember.getName());
        // 이미 존재하는 이름인지 확인 (중복 확인)

    }

    @Test
    public void 중복_회원_예외(){
        // given
        Member member1 = new Member();
        member1.setName("spring");

        Member member2 = new Member();
        member2.setName("spring");

        // when
        // join을 두번 할 때, member1 : spring, member2 : spring
        // 중복됨, MemberService.java/validateDuplicateMethod메소드에서 잡힌다.
        memberService.join(member1);

        // 중복이 예외가 발생했을 때, 이미 존재하는 회원이라고 출력해준다.
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));

        assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");

//        try{
//            memberService.join(member2);
//        }catch(IllegalStateException e){
//            // 중복으로 나온 예외
//            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.123");
//        }


        // then
    }

    @Test
    void findMembers() {
    }

    @Test
    void findOne() {
    }
}