회원 관리 예제 2 - 백엔드 개발 ( 회원 서비스 개발 | 회원 서비스 테스트 )

 (( 저번 회원 관리 예제 1에 이어서 진행됩니다 ))

 

 

 

 

 

회원 서비스 개발

 

 

 

 

 

 

 

 

 

service 패키지를 하나 생성합니다

service 패키지 안에는 MemberService 클래스를 하나 생성합니다

 

 

 

 

 

 

 

 

 

package com.ujin.ujinspring.service;

import com.ujin.ujinspring.domain.Member;
import com.ujin.ujinspring.repository.MemberRepository;
import com.ujin.ujinspring.repository.MemoryMemberRepository;

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

public class MemberService {
    private  final MemberRepository memberRepository = new MemoryMemberRepository();
    
    /*
    회원 가입
     */
    public Long join(Member member){
        validateDuplicateMember(member); // 중복 회원 검증
        memberRepository.save(member);
        return member.getId();
    }

    private void validateDuplicateMember(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);
    }
}

회원 가입을 했을 때 중복회원이면 "이미 존재하는 회원입니다" 문구가 제대로 출력되는지 확인해봐야 합니다,

이전에 사용했던 테스트 케이스를 이용하여 확인해보도록 하겠습니다

 

 

 

 

 

---

 

 

 

 

 

회원 서비스 테스트

 

 

 

 

 

 

 

 

 

 

 

 

MemberServiceTest라는 테스트 케이스를 하나 만들어 주었습니다

 

 

 

package com.ujin.ujinspring.service;

import com.ujin.ujinspring.domain.Member;
import com.ujin.ujinspring.repository.MemoryMemberRepository;
import org.assertj.core.api.AbstractBigDecimalAssert;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;



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

public class MemberServiceTest {

    MemberService memberService = new MemberService();
    MemoryMemberRepository memberRepository = new MemoryMemberRepository();

    // DB에 있는 값 clear해줌
    @AfterEach
    public void afterEach(){
        memberRepository.clearStore();
    }
    
    @Test
     void 회원가입(){
        // given
        Member member = new Member();
        member.setName("hello");

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

        // then
        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
        memberService.join(member1);
        IllegalStateException e = assertThrows(IllegalStateException.class, () -> memberService.join(member2));

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

        /*
        try {
            memberService.join(member2);
            fail();
        } catch (IllegalStateException e){
            assertThat(e.getMessage()).isEqualTo("이미 존재하는 회원입니다.");
        }
         */

        // then
    }

    @Test
    void findMembers() {

    }

    @Test
    void findOne() {

    }
}

 

 

[ 테스트 케이스를 만들 때 팁 ]

givn : 어떠한 상황이 주어졌는데 (검증해야 하는 것 )

when : 이것을 실행했을 떄

then : 이러한 결과가 나와야 한다

 

 

 

 

 

 

 

 

 

 

 

 

 

private final MemberRepository memberRepository = new MemoryMemberRepository();

같은 레파지토리를 사용하기 위해서  MemberService 에서 이 부분을 수정해주도록 한다

 

 

 

 

 

 

 

 

 

private final MemberRepository memberRepository;

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

내가 Member 리파지토리를 직접 생성하는것이 아니라 외부에서 넣어주도록 바꾸었습니다

 

 

 

 

 

 

 

 

 

MemberService memberService;
MemoryMemberRepository memberRepository;

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

MemberServiceTest 부분도 이렇게 바뀌었다

 

 

 

 

 

 

 

 

 

 

 

 

 

 

MemberService 메서드 입장에서는 외부에서 넣어주는 방식인 것

Dependency Injection

(DI)이라고 한다.

 

 

 

의존성 주입 (DI) : 두 객체 간의 관계를 맺어주는 것