young_209.log

스프링 핵심 원리 이해1

Wed, 09 Feb 2022 02:03:13 GMT

비즈니스 요구사항과 설계

요구사항

회원
- 회원을 가입하고 조회할 수 있다.
- 회원은 일반과 VIP 두 가지 등급이 있다.
- 회원 데이터는 자체 DB를 구축할 수 있고, 외부 시스템과 연동할 수 있다. (미확정)
주문과 할인 정책
- 회원은 상품을 주문할 수 있다.
- 회원 등급에 따라 할인 정책을 적용할 수 있다.
- 할인 정책은 모든 VIP는 1000원을 할인해주는 고정 금액 할인을 적용해달라. (나중에 변경 될 수 있다.)
- 할인 정책은 변경 가능성이 높다. 회사의 기본 할인 정책을 아직 정하지 못했고, 오픈 직전까지 고민을 미루고 싶다. 최악의 경우 할인을 적용하지 않을 수 도 있다. (미확정)

회원 도메인 설계

회원 도메인 협력 관계

회원 클래스 다이어그램

회원 객체 다이어그램

회원 서비스 : MemberServiceImpl

주문과 할인 도메인 설계

주문 도메인 전체

주문 생성 : 클라이언트는 주문 서비스에 주문 생성을 요청함
회원 조회 : 할인을 위해서는 회원 등급이 필요하므로 회원 저장소에서 회원을 조회함
할인 적용 : 주문 서비스는 회원 등급에 따른 할인 여부를 할인 정책에 위임함
주문 결과 반환 : 주문 서비스는 할인 결과를 반환함

주문 도메인 클래스 다이어그램

주문 도메인 객체 다이어그램 1

회원을 메모리에서 조회하고, 정액 할인 정책(고정 금액)을 지원해도 주문 서비스를 변경하지 않아도 됨
역활들의 협력 관계를 그래도 재사용 할 수 있음

주문 도메인 객체 다이어그램 2

회원을 실제 DB에서 조회하고, 정률 할인 정책(주문 금액에 따라 % 할인)을 지원해도 주문 서비스를 변경하지 않아도 됨
역활들의 협력 관계를 그래도 재사용 할 수 있음

객체 지향 설계와 스프링

Tue, 08 Feb 2022 06:20:10 GMT

1. 스프링이란?

자바 언어 기바의 프레임 워크
- 자바 언어의 가장 큰 특징 - 객체 지향 언어
객체 지향 언어가 가진 강력한 특징을 살려내느 프레임워크
좋은 객체 지향 애플리케이션을 개발할 수 있게 도와 주는 프레임워트

2. 좋은 객체 지향 프로그래밍?

2.1 객체 지향 특징

추상화
캡슐화
상속
다형성

2.2 객체 지향 프로그래밍

프로그램을 유연하고 변경이 용이하게 만들기 때문에 대규모 소프트웨어 개발에 많이 사용됨

✓ 유연하고, 변경이 용이?

레고 플럭 조립하듯
키보드, 카우스 갈아 끼우듯이
컴퓨터 부품 갈아 끼우듯이
컴포넌트를 쉽고 유연하게 변경하며서 개발할 수 있는 방법

2.2.1 다형성(Polymorphism)?

다형성의 실세계 비유?

실세계와 객체 지향을 1:1로 매칭 X
그래도 실세계의 비유로 이해하기에는 좋음
역활과 구현으로 세상을 구분
운전자 - 자동차

공연 무대

역활과 구현을 분리
- 역활과 구현으로 구분하면 세상이 단순해지고, 유현해지며 변경도 편리해짐
- 장점
  - 대상의 역활(인터페이스)만 알면 됨
  - 구현 대상의 내부 구조를 몰라도 됨
  - 구현 대상의 내부 구조가 변경되어도 영향을 받지 않음
  - 구현 대상 자체를 변경해도 영향을 받지 않음
- 자바 언어의 다형성을 활용
  - 역활 = 인터페이스
  - 구현 = 이너페이스를 구현한 클래스, 구현 객체
  - 객체를 설계 시 역활과 구현을 명확히 분리
    자바에서의 다형성
  - 오버라이딩!
    - 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재정의하여 사용하는 것
  - 다형성으로 인터페이스를 구현한 객체를 실행 시점에 유현하게 변경할 수 있음
  - 클래스 상속 관계도 다형성, 오버라이딩 적용 가능

2.2.2 스프링과 객체 지향

다형성이 가장 중요
스프링은 다형성을 극대화해서 이용할 수 있게 도와줌
스프링에서 이야기하는 제어의 역전(IoC), 의존관계 주입(DI)은 다형성을 활용해서 역활과 구현을 편리하게 다룰 수 있도록 지원함
스프링을 사용하면 구현을 편리하게 변경할 수 있음

3. 좋은 객체 지향 설계의 5가지 원칙 (SOLID)

SRP : 단일 책임 원칙(single responsibility principle)
OCP: 개방-폐쇄 원칙 (Open/closed principle)
LSP: 리스코프 치환 원칙 (Liskov substitution principle)
ISP: 인터페이스 분리 원칙 (Interface segregation principle)
DIP: 의존관계 역전 원칙 (Dependency inversion principle)

SRP 단일 책임 원칙

한 클래스는 하나의 책임만 가져야 한다.
하나의 책임이라는 것은 모호하다.
- 클 수도 있고, 작을 수도 있다.
- 문맥과 상황에 따라 다르다.
중요한 기준으 변경
- 변경이 있을 때 파급 효과가 적으면 단일 책임 원칙을 잘 지킨것
예) UI 변경, 객체의 생성과 사용을 분리

OCP 개방-폐쇄 원칙

확장에는 열려 있으나 변경에는 닫혀 있어야함
다형성을 활용할 필요
인터페이스를 구현한 새로운 클래스를 하나 만들어 새로운 기능을 구현
문제점
- 구현 객체를 변경하려면 클라이언트 코드를 변경해야함
- 객체를 생성하고, 연관관계를 맺어주는 별도의 조립, 설정자가 필요함

LSP 리스코프 치환 원칙

프로그램의 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야함
예) 자동차 인터페이스의 엑셀은 앞으로 가라는 기능, 뒤로 가게 구현하면 LSP 위반, 느리 더라도 앞으로 가야함

ISP 인터페이스 분리 원칙

특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나 보다 낫다
자동차 인터페이스 -> 운전 / 정비 인터페이스 분리
사용자 클라이언트 -> 운전자 / 정비사 클라이언트 분리

DIP 의존관계 역전 원칙

구현 클래스에 의존하지 X, 인터페이스에 의존하라는 뜻
역활(Role)에 의존하게 해야 한다는 것과 같음

운영 이슈 테스트 : Chaos Monkey

Mon, 10 Jan 2022 05:48:38 GMT

1. 소개

카오스 엔지니어링(http://channy.creation.net/blog/1173) 툴
- 프로덕션 환경, 특히 분산 시스템 환경에서 불확실성을 파악하고 해결 방안을 모색하는데 사용하는 툴
운영 환경 불확실성의 예
- 네트워크 지연
- 서버 장애
- 디스크 오작동
- 메모리 누수
- 등등
Chaos Monkey 스프링 부트 (https://codecentric.github.io/chaos-monkey-spring-boot/latest/)
- 스프링 부트 애플리케이션에 카오스 멍키를 손쉽게 적용해 볼 수 있는 툴
- 즉, 스프링 부트 애플리케이션을 망가트릴 수 있는 툴
카오스 멍키 스프링 부트 주요 개념
- 공격 대상 (Watcher)
  - @RestController
  - @Controller
  - @Service
  - @Repository
  - @Component
- 공격 유형 (Assaults)
  - 응답 지연 (Latency Assault)
  - 예외 발생 (Exception Assault)
  - 애플리케이션 종료 (AppKiller Assault)
  - 메모리 누수 (Memory Assault)

2. 설치 (CM4SB)

의존성 추가

    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'de.codecentric:chaos-monkey-spring-boot:2.5.4'

de.codecentric:chaos-monkey-spring-boot
- https://codecentric.github.io/chaos-monkey-spring-boot/latest/
- 스프링 부트용 카오스 멍키
Spring-boot-starter-actuator
- 스프링 부트 운영 툴로, 런타임 중에 카오스 멍키 설정을 변경할 수 있다.
- 그밖에도 헬스 체크, 로그 레벨 변경, 매트릭스 데이터 조회 등 다양한 운영 툴로 사용 가능.
- /actuator

application.properties에 추가

# profile이 chaos-monkey로 되어 있어야 테스트 가능
spring.profiles.active=chaos-monkey

# chaosmonkey endpoints 활성화
management.endpoint.chaosmonkey.enabled=true
management.endpoints.web.exposure.include=health,info,chaosmonkey

3. 테스트

테스트를 위한 사용 툴

HTTPies
- 카오스 멍키 설정 변경
JMeter
- 카오스 멍키 설정 변경 후 Assault 확인

응답 지연 테스트

https://codecentric.github.io/chaos-monkey-spring-boot/latest/#_latency_assault
Repository Watcher 활성화
- chaos.monkey.watcher.repository=true
카오스 멍키 활성화
- http post localhost:8080/actuator/chaosmonkey/enable
카오스 멍키 활성화 확인
- http localhost:8080/actuator/chaosmonkey/status
카오스 멍키 와처 확인
- http localhost:8080/actuator/chaosmonkey/watchers
카오스 멍키 지연 공격 설정
- http POST localhost:8080/actuator/chaosmonkey/assaults level=3 latencyRangeStart=2000 latencyRangeEnd=5000 latencyActive=true
테스트
- JMeter 확인

에러 테스트

https://codecentric.github.io/chaos-monkey-spring-boot/latest/#_exception_assault
카오스 멍키 활성화
- http post localhost:8080/actuator/chaosmonkey/enable
카오스 멍키 활성화 확인
- http localhost:8080/actuator/chaosmonkey/status
카오스 멍키 와처 확인
- http localhost:8080/actuator/chaosmonkey/watchers
카오스 멍키 지연 공격 설정
- http POST localhost:8080/actuator/chaosmonkey/assaults level=3 latencyActive=false exceptionsActive=true exception.type=java.lang.RuntimeException

성능 테스트 : JMeter

Mon, 10 Jan 2022 02:23:36 GMT

1. 소개

성능 측정 및 부하(load) 테스트 기능을 제공하는 오픈 소스 자바 어플리케이션 (https://jmeter.apache.org/)
다양한 형태의 어플리케이션 테스트 지원
- 웹 - HTTP, HTTPS
- SOAP / REST 웹 서비스
- FTP
- 데이터베이스 (JDBC 사용)
- Mail (SMTP, POP3, IMAP)
- 등등
CLI 지원
- CI 또는 CD 툴과 연동할 때 편리함.
- UI 사용하는 것보다 메모리 등 시스템 리소스를 적게 사용.
주요 개념
- Thread Group: 한 쓰레드 당 유저 한명
- Sampler: 어떤 유저가 해야 하는 액션
- Listener: 응답을 받았을 할 일 (리포팅, 검증, 그래프 그리기 등)
- Configuration: Sampler 또는 Listener가 사용할 설정 값 (쿠키, JDBC 커넥션 등)
- Assertion: 응답이 성공적인지 확인하는 방법 (응답 코드, 본문 내용 등)
대체제
- Gatling
- nGrinder

2. 설치

https://jmeter.apache.org/download_jmeter.cgi
압축 파일 받고 압축 파일 풀기. 원한다면 PATH에 bin 디렉토리를 추가.
bin/jmeter 실행하기

3. 사용하기

Thread Group 만들기
- Number of Threads: 쓰레드 개수
- Ramp-up period: 쓰레드 개수를 만드는데 소요할 시간
- Loop Count
  - infinite 체크 하면 위에서 정한 쓰레드 개수로 계속 요청 보냄
  - 값을 입력하면 해당 쓰레드 개수 X 루프 개수 만큼 요청 보냄
Sampler 만들기
- 여러 종류의 샘플러가 있으나 그 중에 사용할 샘플러는 HTTP Request 샘플러
- HTTP Sampler
  - 요청을 보낼 호스트, 포트, URI, 요청 본문 등을 설정
- 여러 샘플러를 순차적으로 등록하는 것도 가능
Listener 만들기
- View Results Tree
- View Resulrts in Table
- Summary Report
- Aggregate Report
- Response Time Graph
- Graph Results
- 등등
Assertion 만들기
- 응답 코드 확인
- 응답 본문 확인
CLI 사용하기
- jmeter -n -t 설정 파일 -l 리포트 파일

도커와 테스트 : Testcontainers 소개 / 설치 / 기능

Wed, 05 Jan 2022 02:30:56 GMT

1. Testcontainers 소개

테스트에서 도커 컨테이너를 실행할 수 있는 라이브러리 (https://www.testcontainers.org/)
테스트 실행시 DB를 설정하거나 별도의 프로그램 또는 스크립트를 실행할 필요 없음
보다 Production에 가까운 테스트를 만들 수 있음
테스트가 느려짐

전제 조건

로컬 PC에 Docker가 설치되어 있어야 함

2. Testcontainers 설치

Gradle 설정 추가

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.projectlombok:lombok:1.18.20'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'org.postgresql:postgresql:42.3.1'

    /* testcontainers */
    testImplementation 'org.testcontainers:postgresql:1.16.2'
    testImplementation 'org.testcontainers:junit-jupiter'
}

dependencyManagement {
    imports {
        mavenBom("org.testcontainers:testcontainers-bom:1.16.2")
    }
}

application-test.properties 추가

src/test/resources/application-test.properties

spring.datasource.url=jdbc:tc:postgresql:///postgres
// Spring Boot version 2.3.0 이면 추가 해야함
// spring.datasource.driver-class-name=org.testcontainers.jdbc.ContainerDatabaseDriver
spring.jpa.hibernate.ddl-auto=create-drop

Test 소스

@SpringBootTest
@ExtendWith(MockitoExtension.class)
@ActiveProfiles("test")
@Testcontainers
class TestcontainersTest {

    @Mock
    MemberService memberService;

    @Autowired
    StudyRepository studyRepository;

    @Container
    static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer("postgres").withDatabaseName("study-db");

    @BeforeAll
    static void beforeAll() {
        String jdbcUrl = postgreSQLContainer.getJdbcUrl();
        String databaseName = postgreSQLContainer.getDatabaseName();

        System.out.println("databaseName : " + databaseName + " / jdbcUrl : " + jdbcUrl);
    }

    @BeforeEach
    void beforeEach() {
        studyRepository.deleteAll();
    }

    @Test
    void createNewStudy() {
        StudyService studyService = new StudyService(memberService, studyRepository);
        assertNotNull(studyService);

        Member member = new Member();
        member.setId(1L);
        member.setEmail("lee@gamil.com");

        Study study = new Study(10, "테스트");

        when(memberService.findById(1L)).thenReturn(Optional.of(member));

        studyService.createNewStudy(1L, study);

        assertNotNull(study.getOwnerId());
        assertEquals(member.getId(), study.getOwnerId());

        verify(memberService, times(1)).notify(study);

        verifyNoMoreInteractions(memberService);
    }

    @DisplayName("다른 사용자가 볼 수 있도록 스터디를 공개한다.")
    @Test
    void openStudy() {
        // Given
        StudyService studyService = new StudyService(memberService, studyRepository);
        Study study = new Study(10, "the Java, Test");
//        given(studyRepository.save(study)).willReturn(study);

        // When
        studyService.openStudy(study);

        // Then
        assertEquals(study.getStatus(),StudyStatus.OPENED);
        assertNotNull(study.getOpenedDateTime());
        then(memberService).should().notify(study);
    }
}

3. Testcontainers 기능

어노테이션

@Testcontainers
- JUnit 5 확장팩으로 테스트 클래스에 @Container를 사용한 필드를 찾아서 컨테이너 라이프사이클 관련 메소드를 실행
@Container
- 인스턴스 필드에 사용하면 모든 테스트 마다 컨테이너를 재시작 하고, 스태틱 필드에 사용하면 클래스 내부 모든 테스트에서 동일한 컨테이너를 재사용
  컨테이너 만들기
  New GenericContainer(String imageName)

네트워크

withExposedPorts(int...)
- DB port가 같다면 테스트 DB 및 운영서버 DB 중 랜덤하게 사용(충돌하지 않는 포트 우선사용)
getMappedPort(int)
- 내 호스트가 어떤 포트를 사용했는지 확인

환경 변수 설정

withEnv(key, value)

명령어 실행

withCommand(String cmd...)

사용할 준비가 됐는지 확인하기

waitingFor(Wait)
- 언제 서버가 가용되는데 시간이 걸리는지
Wait.forHttp(String url)
- Http요청으로 응답을 확인 및 해당 컨테이너가 가용한지 확인 후 테스트 진행
Wait.forLogMessage(String message)
- 특정한 로그 메세지가 출력이 되었는지 확인 후 테스트 진행

로그 살펴보기

getLogs()
- 현재까지의 컨테이너의 로그들을 모두 가져오기
followOutput()
- 스트리밍으로 로그를 출력

Mockito : Mock 객체 확인 및 BDD 스타일 Mockito API

Tue, 04 Jan 2022 08:05:06 GMT

1. Mock 객체 확인

Mock 객체가 어떻게 사용이 됐는지 확인할 수 있음
- 1) 특정 메소드가 특정 매개변수로 몇번 호출 되었는지, 최소 한번은 호출 됐는지, 전혀 호출되지 않았는지 확인
  - https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#exact_verification
- 2) 어떤 순서대로 호출했는지 확인
  - https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#in_order_verification
- 3) 특정 시간 이내에 호출됐는지 확인
  - https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#verification_timeout
- 4) 특정 시점 이후에 아무 일도 벌어지지 않았는지 확인
  - https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#finding_redundant_invocations

// 1,2 만 확인함
    @Test
    void createNewStudy() {
        StudyService studyService = new StudyService(memberService, studyRepository);
        assertNotNull(studyService);

        Member member = new Member();
        member.setId(1L);
        member.setEmail("lee@gamil.com");

        Study study = new Study(10, "테스트");

        when(memberService.findById(1L)).thenReturn(Optional.of(member));
        when(studyRepository.save(study)).thenReturn(study);

        studyService.createNewStudy(1L, study);

        assertNotNull(study.getOwner());
        assertEquals(member, study.getOwner());

        verify(memberService, times(1)).notify(study);

        verifyNoMoreInteractions(memberService);
//
//        verify(memberService, times(1)).notify(member);
//        verify(memberService, never()).validate(any());
//
//        InOrder inOrder = inOrder(memberService);
//        inOrder.verify(memberService).notify(study);
//
//        inOrder.verify(memberService).notify(member);
    }

2. BDD 스타일 Mockito API

BDD란?

애플리케이션이 어떻게 “행동”해야 하는지에 대한 공통된 이해를 구성하는 방법으로, TDD에서 창안

행동에 대한 스팩

Title
Narrative
- As a / I want / so that
Acceptance criteria
- Given / When / Then

Mockito BDD 스타일의 API

BddMockito라는 클래스 존재

    @Test
    void bddStyle() {
        // Given
        StudyService studyService = new StudyService(memberService, studyRepository);
        assertNotNull(studyService);

        Member member = new Member();
        member.setId(1L);
        member.setEmail("lee@gamil.com");

        Study study = new Study(10, "테스트");

//        when(memberService.findById(1L)).thenReturn(Optional.of(member));
//        when(studyRepository.save(study)).thenReturn(study);
        given(memberService.findById(1L)).willReturn(Optional.of(member));
        given(studyRepository.save(study)).willReturn(study);

        // When
        studyService.createNewStudy(1L, study);

        // Then
        assertEquals(member, study.getOwner());

//        verify(memberService, times(1)).notify(study);
        then(memberService).should(times(1)).notify(study);

//        verifyNoMoreInteractions(memberService);
        then(memberService).shouldHaveNoMoreInteractions();
    }

Mockito : Mock 객체 Stubbing

Tue, 28 Dec 2021 01:50:52 GMT

1. Mock 객체의 행동?

Null을 리턴한다. (Optional 타입은 Optional.empty 리턴)
Primitive 타입은 기본 Primitive 값.
콜렉션은 비어있는 콜렉션.
Void 메소드는 예외를 던지지 않고 아무런 일도 발생하지 않는다.

2. Stubbing 이란?

Mock 객체의 행동을 조작하는 것
- 특정한 매개변수를 받은 경우 특정한 값을 리턴하거나 예뢰를 던지도록 만들 수 있음
  - Mock 객체 메서드의 파라미터 값을 하드 코딩하고 싶지 않다면 Mockito의 Argument Matchers를 이용 (ex. any() 등)

```
@Test
void stubbing1Test() {
    StudyService studyService = new StudyService(memberService, studyRepository);
    assertNotNull(studyService);

    Member member = new Member();
    member.setId(1L);
    member.setEmail("lee@gamil.com");

    when(memberService.findById(any())).thenReturn(Optional.of(member));

    Study study = new Study(10, "java");

    studyService.createNewStudy(1L, study);
}
```
- Void 메소드 특정 매개변수를 받거나 호출된 경우 예외를 발생 시킬 수 있음
```

@Test
void stubbing2Test() {
    StudyService studyService = new StudyService(memberService, studyRepository);
    assertNotNull(studyService);

    Member member = new Member();
    member.setId(1L);
    member.setEmail("lee@gamil.com");

    when(memberService.findById(any())).thenReturn(Optional.of(member));

    assertEquals("lee@gamil.com", memberService.findById(1L).get().getEmail());
    assertEquals("lee@gamil.com", memberService.findById(2L).get().getEmail());

    doThrow(new IllegalArgumentException()).when(memberService).validate(1L);

    assertThrows(IllegalArgumentException.class, () -> {
       memberService.findById(1L);
    });

    memberService.validate(2L);
}
```

- 메소드가 동일한 매개변수로 여러번 호출될 때 각기 다르게 행동하도록 조작할 수도 있음
```
@Test
void stubbing3Test() {
    StudyService studyService = new StudyService(memberService, studyRepository);
    assertNotNull(studyService);

    Member member = new Member();
    member.setId(1L);
    member.setEmail("lee@gamil.com");

    when(memberService.findById(any()))
            .thenReturn(Optional.of(member))
            .thenThrow(new RuntimeException())
            .thenReturn(Optional.empty());

    Optional byId = memberService.findById(1L);
    assertEquals("lee@gamil.com", byId.get().getEmail());

    assertThrows(RuntimeException.class, () -> {
       memberService.findById(2L);
    });

    assertEquals(Optional.empty(), memberService.findById(3L));
}
```

3. 연습 문제

    @Test
    void stubbing4Test() {
        StudyService studyService = new StudyService(memberService, studyRepository);
        assertNotNull(studyService);

        Member member = new Member();
        member.setId(1L);
        member.setEmail("lee@gamil.com");

        Study study = new Study(10, "테스트");

        // TODO memberService 객체에 findById 메소드를 1L 값으로 호출하면 Optional.of(member) 객체를 리턴하도록 Stubbing
        when(memberService.findById(1L)).thenReturn(Optional.of(member));
        // TODO studyRepository 객체에 save 메소드를 study 객체로 호출하면 study 객체 그대로 리턴하도록 Stubbing
        when(studyRepository.save(study)).thenReturn(study);

        studyService.createNewStudy(1L, study);

        assertNotNull(study.getOwner());
        assertEquals(member, study.getOwner());
    }

Mockito : 소개 및 시작

Fri, 24 Dec 2021 07:51:23 GMT

1. Mockito란?

Mock을 지원하는 Framework
Mock은 진짜 객체와 비슷하게 동작하지만 프로그래머가 직접 그 객체의 행동을 관리하는 객체, 가짜 객체임
Mockito는 Mock 객체를 쉽게 만들고 관리하고 검증할 수 있는 방법을 제공

2. Mockito 시작하기

스프링 부트 2.2+ 프로젝트 생성시 spring-boot-starter-test에서 자동으로 Mockito 추가해 줌

스프링 부트 쓰지 않는다면, 의존성 직접 추가

Maven 기준

  
      org.mockito
      mockito-core
      3.1.0
      test

    
        org.mockito
        mockito-junit-jupiter
        3.1.0
        test


# 3. Mock 객체 만들기
### Mockito.mock() 메소드로 만드는 방법

class StudyServiceTest {

@Test
void create_study_service() {
    MemberService memberService = mock(MemberService.class);
    StudyRepository studyRepository = mock(StudyRepository.class);

    StudyService studyService = new StudyService(memberService, studyRepository);

    assertNotNull(studyService);
}

}


### @Mock 애노테이션으로 만드는 방법
- JUnit 5 extension으로 MockitoExtension을 사용해야 한다.

#### 1) 필드

@ExtendWith(MockitoExtension.class) class StudyServiceTest {

@Mock
MemberService memberService;

@Mock
StudyRepository studyRepository;

@Test
void create_study_service() {

    StudyService studyService = new StudyService(memberService, studyRepository);

    assertNotNull(studyService);
}

}


#### 2) 메소드 매개변수

@ExtendWith(MockitoExtension.class) class StudyServiceTest {

@Test
void createStudyService(@Mock MemberService memberService,
                        @Mock StudyRepository studyRepository) {
    StudyService studyService = new StudyService(memberService, studyRepository);
    assertNotNull(studyService);
}

}

JUnit 5 : 확장 모델 & JUnit 설정 파일

Fri, 24 Dec 2021 06:09:29 GMT

1. 확장 모델

JUnit 4의 확장 모델은 @RunWith(Runner), TestRule, MethodRule.
JUnit 5의 확장 모델은 단 하나, Extension.

확장 등록 방법

선언적인 등록 @ExtendWith
- Extendtion 뒤에 인자로 확장할 Extension을 추가하여 사용

@ExtendWith(FindSlowTestExtension.class)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class StudyTest {
}

프로그래밍 등록 @RegisterExtension
- 생성자(Constructor)를 통해 확장기능에 의존성을 주입하거나, 빌더등을 통해서 프로그램을 통한 설정이 가능
- 생명주기에 맞춰 static으로 선언
- @RegisterExtension으로 등록하고자 하는 필드는 null이거나 private으로 지정되면 안됨

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class StudyTest {

    @RegisterExtension
    static FindSlowTestExtension findSlowTestExtension = new FindSlowTestExtension(1000L);
}

2. JUnit 설정 파일

JUnit 설정 파일로, 클래스패스 루트 (src/test/resources/)에 넣어두면 적용된다.

junit-platform.properties

#테스트 인스턴스 라이프사이클 설정
junit.jupiter.testinstance.lifecycle.default = per_class

#@Disabled 무시하고 실행하기 junit.jupiter.conditions.deactivate = org.junit.*DisabledCondition

#테스트 이름 표기 전략 설정 junit.jupiter.displayname.generator.default = org.junit.jupiter.api.DisplayNameGenerator$ReplaceUnderscores

JUnit 5 : 테스트 인스턴스 & 순서

Fri, 24 Dec 2021 02:33:34 GMT

1. 테스트 인스턴스

JUnit은 테스트 메소드 마다 테스트 인스턴스를 새로 만든다.

테스트 메소드를 독립적으로 실행하여 예상치 못한 부작용을 방지하기 위함이다.
이 전략을 JUnit 5에서 변경할 수 있음
@TestInstance(Lifecycle.PER_CLASS)
- 테스트 클래스당 인스턴스를 하나만 만들어 사용함
- 경우에 따라, 테스트 간에 공유하는 모든 상태를 @BeforeEach 또는 @AfterEach에서 초기화 할 필요가 있음
- @BeforeAll과 @AfterAll을 인스턴스 메소드 또는 인터페이스에 정의한 default 메소드로 정의할 수도 있음

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class StudyTest {

    int value = 1;
    @BeforeAll
    void beforeAll() {
        System.out.println("BeforeAll!");
    }

    @AfterAll
    void afterAll() {
        System.out.println("AfterAll!");
    }

    @BeforeEach
    void setUp() {
        System.out.println("BeforeEach!");
    }

    @AfterEach
    void tearDown() {
        System.out.println("AfterEach!");
    }

    @Test
    void instenceCheck1() {
        System.out.println(this);
        System.out.println(value++);
    }

    @Test
    void instenceCheck2() {
        System.out.println(this);
        System.out.println(value++);
    }
}

2. 테스트 순서

실행할 테스트 메소드 특정한 순서에 의해 실행되지만 어떻게 그 순서를 정하는지는 의도적으로 분명히 하지 않는다. (테스트 인스턴스를 테스트 마다 새로 만드는 것과 같은 이유)

경우에 따라, 특정 순서대로 테스트를 실행하고 싶을 때도 있다. 그 경우에는 테스트 메소드를 원하는 순서에 따라 실행하도록 @TestInstance(Lifecycle.PER_CLASS)와 함께 @TestMethodOrder를 사용할 수 있다.

MethodOrderer 구현체
- 기본 구현체
  - MethodName : 메소드명으로 오름차순 정렬 (a~ㄱ), 메소드명이 같다면 파라미터 타입명으로 오름차순 정렬
    - @TestMethodOrder(MethodOrderer.MethodName.class)
      - DisplayName : @DisplayName의 값으로 오름차순 정렬
      - @TestMethodOrder(value = MethodOrderer.DisplayName.class)
      - Random : 랜덤으로 순서를 정하는 방법
      - @TestMethodOrder(MethodOrderer.Random.class)
      - OrderAnnoation : @Order(n) 어노테이션으로 순서를 정하는 방법
      - @TestMethodOrder(value = MethodOrderer.OrderAnnotation.class)

JUnit 5 : 테스트 반복하기

Fri, 24 Dec 2021 01:26:46 GMT

1. @RepeatedTest

반복 횟수와 반복 테스트 이름을 설정할 수 있다.
- {displayName}
  - @DisplayName로 선언된 이름을 가지고 옴
- {currentRepetition}
  - 현재 반복되어 지는 번호
- {totalRepetitions}
  - 전체 반복하는 횟수
RepetitionInfo 타입의 인자를 받을 수 있다.

    @DisplayName("반복 테스트")
    @RepeatedTest(value = 10, name = "{displayName}, {currentRepetition} / {totalRepetitions}")
    void repeatTest(RepetitionInfo info) {
        System.out.println("test " + info.getCurrentRepetition() + "/" + info.getTotalRepetitions());
    }

2. @ParameterizedTest

테스트에 여러 다른 매개변수를 대입해가며 반복 실행한다.
- {displayName}
  - @DisplayName로 선언된 이름을 가지고 옴
- {index}
  - 현재 반복되어 지는 번호
- {arguments}
  - 전달되는 파라미터 값
- {0}, {1}, ...
  - 전달되는 파라미터 값의 인덱스 번호

    @DisplayName("Parameter 반복 테스트")
    @ParameterizedTest(name = "{index} {displayName} stringVal = {0}")
    @ValueSource(strings = {"11111111", "22222222222", "3333333333", "444444444444"})
    void stringValueSourceTest(String s) {
        System.out.println(s);

    }

3. 인자(Parameter) 값에 관련된 Annotation

@ValueSource
- 지정한 배열을 파라미터 값으로 순서대로 넘겨줌
- 테스트 메소드 실행 당 하나의 인수(argument)만을 전달할 때 사용됨
- 리터럴 값의 배열을 테스트 메소드에 전달
  - 리터럴 값(literal vales)이란?
    - 변수에 넣는 변하지 않는 데이터를 의미
    - 보통은 기본형의 데이터를 의미하지만, 특정 객체(Immutable class , VO class)에 한에서는 리터럴이 될 수 있음
    - short, byte, int, long, float, double, char, java.lang.String, java.lang.Class
@NullSource, @EmptySource, @NullAndEmptySource
- @NullSource
  - null을 인자로 추가
- @EmptySource
  - 빈 문자열을 인자로 추가
- @NullAndEmptySource
  - null과 빈 문자열 모두를 인자로 추가
@CsvSource
- 기본 구분자로는 콤마(',')
- delimiter 을 직접 정의함으로써 구분자를 지정

4. 인자 값 타입 변환

암묵적인 타입 변환
- 레퍼런스 참고 (https://junit.org/junit5/docs/current/user-guide/#writing-tests-parameterized-tests-argument-conversion-implicit)

명시적인 타입 변환

SimpleArgumentConverter 상속 받은 구현체 제공

하나의 인자값만 가능
반드시 static inner class 거나 public class 여야 함

@ConvertWith 활용하여 구현한 class를 입력

  @DisplayName("Custom(domain 객체) Parameter 반복 테스트")
  @ParameterizedTest(name = "{index} {displayName} stringVal = {0}")
  @ValueSource(ints = {10, 20, 30})
  void convertValueSourceTest(@ConvertWith(StudyConverter.class) Study study) {
      System.out.println(study.getLimit());

  }

  // public 클래스 혹은 static 인너클래스로 작성해야함
  static class StudyConverter extends SimpleArgumentConverter {

      @Override
      protected Object convert(Object source, Class targetType) throws ArgumentConversionException {
          assertEquals(Study.class, targetType, "Can only convert to Study");
          return new Study(Integer.parseInt(source.toString()));
      }
  }

5. 인자 값 조합

ArgumentsAccessor

두개 이상의 인자값을 받을 수 있음

@DisplayName("Parameter 반복 테스트")
@ParameterizedTest(name = "{index} {displayName} stringVal = {0}")
@CsvSource({"10, '자바 스터디'", "20, '스프링'"})
void convertCvsTest(ArgumentsAccessor argumentsAccessor) {
  Study study = new Study(argumentsAccessor.getInteger(0),
          argumentsAccessor.getString(1));
  System.out.println(study);

}

커스텀 Accessor

AgumentsAggregator 인터페이스 구현

반드시 static inner class 거나 public class 여야 함

@AggregateWith 활용하여 구현한 class를 입력

  @DisplayName("Parameter 반복 테스트")
  @ParameterizedTest(name = "{index} {displayName} stringVal = {0}")
  @CsvSource({"10, '자바 스터디'", "20, '스프링'"})
  void convertCvsTest(@AggregateWith(StudyArgregator.class) Study study) {
      System.out.println(study);

  }

  // public 클래스 혹은 static 인너클래스로 작성해야함
  static class StudyArgregator implements ArgumentsAggregator {
      @Override
      public Object aggregateArguments(ArgumentsAccessor accessor, ParameterContext context) throws ArgumentsAggregationException {
          Study study = new Study(accessor.getInteger(0),
                  accessor.getString(1));
          return study;
      }
  }

JUnit 5 : @Tag 및 커스텀 태그

Thu, 23 Dec 2021 08:21:15 GMT

1. @Tag

테스트 클래스, 메소드에 테스트 구분을 태깅하기 위해 사용

소스

  @DisplayName("스터디 만들기 fast")
  @Tag("fast")
  @Test
  void testTaging() {
      Study study = new Study(1);

      assertAll(
              () -> assertNotNull(study),
              () -> assertEquals(StudyStatus.DRAFT, study.getStatus(),
                      () -> "스터디를 처음 만들면 상태값이 " + StudyStatus.DRAFT + "이어야 한다."),
              () -> assertTrue(study.getLimit() > 0, "스터디 최대 참석 가능 인원은 0보다 커야한다.")
      );
  }

  @DisplayName("스터디 만들기 slow")
  @Tag("slow")
  @Test
  void testTaging2() {
      Study study = new Study(1);

      assertAll(
              () -> assertNotNull(study),
              () -> assertEquals(StudyStatus.DRAFT, study.getStatus(),
                      () -> "스터디를 처음 만들면 상태값이 " + StudyStatus.DRAFT + "이어야 한다."),
              () -> assertTrue(study.getLimit() > 0, "스터디 최대 참석 가능 인원은 0보다 커야한다.")
      );
  }

실행

원하는 @Tag만 테스트할려면 별도 설정 필요
Edit Configurations 클릭
노란 영역부분 Tags로 변경 및 실행할 태그명 입력

2. 커스텀 태그

JUnit 5 애노테이션을 조합하여 커스텀 태그를 만들 수 있다.

커스텀 Annotation 작성

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Test
@Tag("fast")
public @interface FastTest {
}

JUnit 5 : 조건에 따라 테스트 실행하기

Thu, 23 Dec 2021 05:31:56 GMT

1. Assumption

org.junit.jupiter.api.Assumptions.*

assumeTrue(조건)
- 파라미터의 값이 true일 때 테스트를 계속 진행하고, false일 때 테스트를 생략하는 것이지 실패하는 것은 아님

assumingThat(조건, 테스트)

지정한 가정을 충족한 경우 지정한 검증을 수행

@Test
void assumeTrueTest() {
String test_env = System.getenv("TEST_ENV");
System.out.println(test_env);
assumeTrue("LOCAL".equalsIgnoreCase(test_env));

Study study = new Study(10);
assertThat(study.getLimit()).isGreaterThan(0);
}

@Test void assumeThatTest() { String test_env = System.getenv("TEST_ENV");

assumingThat("LOCAL".equalsIgnoreCase(test_env),

      () -> {
          System.out.println("local");
          Study study = new Study(10);
          assertThat(study.getLimit()).isGreaterThan(0);
      });

assumingThat("DEV".equalsIgnoreCase(test_env),

      () -> {
          System.out.println("dev");
          Study study = new Study(20);
          assertThat(study.getLimit()).isGreaterThan(0);
      });

}

2. @Enabled 와 @Disabled

OS 따라 테스트 실행
- @EnabledOnOs(OS조건) / @DisabledOnOs(OS조건)
자바 환경변수에 따라 실행
- @EnabledOnJre(JRE.JAVA_8) / @EnabledOnJre(JRE.JAVA_8)

    @Test
    @EnabledOnOs(OS.WINDOWS)
    void enabledOnOsTest() {
        System.out.println("EnabledOnOs");
    }

    @Test
    @DisabledOnOs(OS.WINDOWS)
    void disabledOnOsTest() {
        System.out.println("DisabledOnOs");
    }

    @Test
    @EnabledOnJre(JRE.JAVA_8)
    void enabledOnJreTest() {
        System.out.println("JAVA_8");
    }

    @Test
    @EnabledOnJre(JRE.OTHER)
    void disabledOnJreTest() {
        System.out.println("JRE_OTHER");
    }

JUnit 5 : Assertion

Thu, 23 Dec 2021 02:18:40 GMT

1. Assertion

값 검증을 위한 assert로 시작하는 static(정적) 메서드를 제공하고 있음
JUnit4로부터 온 assertion 메소드와 새롭게 자바 8 람다 표현식으로 추가된 메소드들이 있음
assertEqulas(expected, actual)
- 실제 값이 기대한 값과 같은지 확인
assertNotNull(actual)
- 값이 null이 아닌지 확인
assertTrue(boolean)
- 다음 조건이 참(true)인지 확인
assertAll(executables...)
- 모든 확인 구문 확인
- 함수형인터페이스인 Executable 목록을 파라미터로 갖음
  - 람다식을 사용해서 여러개의 검증을 목록으로 전달 할 수 있음
assertThrows(expectedType, executable)
- 예외 발생 확인
assertTimeout(duration, executable)
- 특정 시간 안에 실행이 완료되는지 확인

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
class StudyTest {

    @DisplayName("스터디 만들기")
    @Test
    void assertAllTest() {
        Study study = new Study(-1);

        assertAll(
                () -> assertNotNull(study),
                () -> assertEquals(StudyStatus.DRAFT, study.getStatus(),
                        () -> "스터디를 처음 만들면 상태값이 " + StudyStatus.DRAFT + "이어야 한다."),
                () -> assertTrue(study.getLimit() > 0, "스터디 최대 참석 가능 인원은 0보다 커야한다.")
        );
    }

    @Test
    void assertThrowsTest() {
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new Study(-10));
        String message = exception.getMessage();
        assertEquals("limit은 0보다 커야 한다.", message);
    }

    @Test
    void assertTimeoutTest() {
//        assertTimeout(Duration.ofMillis(10), () -> new Study(-10));
        assertTimeout(Duration.ofMillis(10), () -> {
            new Study(10);
            Thread.sleep(100);
        });

//        정해진 시간이 됬을 때 바로 끝남
//        Thead관련 문제가 발생 할 수 있으므로 사용에 주의의
//       assertTimeoutPreemptively(Duration.ofMillis(100), () -> {
//            new Study(10);
//            Thread.sleep(200);
//        });
    }

    @BeforeAll
    static void beforeAll() {
        System.out.println("BeforeAll!");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("AfterAll!");
    }

    @BeforeEach
    void setUp() {
        System.out.println("BeforeEach!");
    }

    @AfterEach
    void tearDown() {
        System.out.println("AfterEach!");
    }
}

JUnit 5 : 소개 및 시작

Thu, 23 Dec 2021 02:09:22 GMT

1. 소개 및 시작

1.1. 소개

테스팅 프레임워크
자바 8 이상을 필요함
이전 JUnit 버전과 다르게, JUnt5는 세개의 서브 프로젝트로 이루어져 있음
- JUnit5은 JUnit Platform + JUnit Jupiter + JUnit Vintage
- JUnit Platform
  - JVM에서 테스트 프레임워크를 실행하는데 기초를 제공
  - TestEngine API를 제공해 테스트 프레임워크를 개발할 수 있음
- JUnit Jupiter
  - JUnit 5에서 테스트를 작성하고 확장을 하기 위한 새로운 프로그래밍 모델과 확장 모델의 조합
- JUnit Vintage
  - 하위 호환성을 위해 JUnit3과 JUnt4를 기반으로 돌아가는 플랫폼에 테스트 엔진을 제공

1.2. 시작

의존성 추가

2.2+ 버전의 스프링 부트 프로젝트를 만든다면 기본으로 의존성 추가되어 있음

maven

  
      org.junit.jupiter
      junit-jupiter-engine
      5.5.2
      test

기본 애노테이션

@Test
- 테스트 클래스나 테스트 메소드에 이름을 붙여줄 때 사용
@BeforeAll
- 테스트가 시작하기 전 딱 한 번만 실행
@AfterAll
- 테스트가 완전히 끝난 후 딱 한 번만 실행
@BeforeEach
- 각각 테스트 메소드가 실행되기전에 실행되어야 하는 메소드를 명시해 줌
- 목업 데이터를 미리 세팅해주기 위해 주로 사용
@AfterEach
- @Test , @RepeatedTest , @ParameterizedTest , @TestFactory 가 붙은 테스트 메소드가 실행되고 난 후 실행
@Disabled
- 테스트 클래스나, 메소드의 테스트를 비활성화 함
@DisplayNameGeneration
- Method와 Class 레퍼런스를 사용해서 테스트 이름을 표기하는 방법 설정
- 기본 구현체로 ReplaceUnderscores 제공

@DisplayName
- 어떤 테스트인지 테스트 이름을 보다 쉽게 표현할 수 있는 방법을 제공하는 애노테이션
- @DisplayNameGeneration 보다 우선 순위가 높다.

@DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
class TestStudyTest {

    @DisplayName("스터디 만들기")
    @Test
    void create_new_study() {
        TestStudy testStudy = new TestStudy();
        assertNotNull(testStudy);
        System.out.println("create!");
    }

    @Test
    void create_new_study_again() {
        TestStudy testStudy = new TestStudy();
        assertNotNull(testStudy);
        System.out.println("create2!");
    }

    @BeforeAll
    static void beforeAll() {
        System.out.println("BeforeAll!");
    }

    @AfterAll
    static void afterAll() {
        System.out.println("AfterAll!");
    }

    @BeforeEach
    void setUp() {
        System.out.println("BeforeEach!");
    }

    @AfterEach
    void tearDown() {
        System.out.println("AfterEach!");
    }
}

네이버 로그인 연동

Fri, 03 Dec 2021 14:32:13 GMT

1. 네이버 로그인 연동

1.1 네이버 API 등록

https://developers.naver.com/apps/#/register?api=nvlogin
등록 완료하면 Client ID와 Client Secret가 생성됨

1.2 네이버

1.2.1 application-oauth.properties에 등록

# registration
spring.security.oauth2.client.registration.naver.client-id=클라이언트ID
spring.security.oauth2.client.registration.naver.client-secret=클라이언트 PW
spring.security.oauth2.client.registration.naver.redirect-uri={baseUrl}/{action}/oauth2/code/{registrationId}
spring.security.oauth2.client.registration.naver.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.naver.scope=name,email,profile_image
spring.security.oauth2.client.registration.naver.client-name=Naver

# provider
spring.security.oauth2.client.provider.naver.authorization-uri=https://nid.naver.com/oauth2.0/authorize
spring.security.oauth2.client.provider.naver.token-uri=https://nid.naver.com/oauth2.0/token
spring.security.oauth2.client.provider.naver.user-info-uri=https://openapi.naver.com/v1/nid/me
spring.security.oauth2.client.provider.naver.user-name-attribute=response ⓐ

ⓐ user-name-attribute=response
- 기준이 되는 user_name의 이름을 네이버에서는 response로 해야함
- 네이버의 회원 조회 시 반환되는 JSON 형태 때문임

1.2.2 스프링 시큐리티 설정 등록

OAuthAttributes에 네이버 설정 추가

@Getter
public class OAuthAttributes {

    ---

    public static OAuthAttributes of(String registrationId,
                                     String userNameAttributeName,
                                     Map attributes) {

        if ("naver".equals(registrationId)) {
            return ofNaver("id", attributes);
        }
        return ofGoogle(userNameAttributeName, attributes);

    }

    ---

    private static OAuthAttributes ofNaver(String userNameAttributeName,
                                            Map attributes) {
        return OAuthAttributes.builder()
                .name((String) attributes.get("name"))
                .email((String) attributes.get("email"))
                .picture((String) attributes.get("profileImage"))
                .attributes(attributes)
                .nameAttributeKey(userNameAttributeName)
                .build()
                ;
    }

    ---

}

index.mustache에 네이버 로그인 버튼 추가

    ---

            {{^userName}}
                Google Login
                Naver Login ⓐ
            {{/userName}}
    ---

ⓐ /oauth2/authorization/naver
- 네이버 로그인 URL은 application-oauth.properties에 등록한 redirect-uri 값에 맞춰 자동으로 등록됨
- /oauth2/authorization/ 까지는 고정, 마지막 Path만 각 소셜 로그인 코드를 사용하면 됨

네이버 로그인 확인

개선 하기(어노테이션 기반 & 세션 저장소로 DB 사용)

Thu, 02 Dec 2021 05:17:05 GMT

1. 어노테이션 기반

1.1 @LoginUser 어노테이션 생성

@Target(ElementType.PARAMETER) ⓐ
@Retention(RetentionPolicy.RUNTIME) ⓑ
public @interface LoginUser { ⓒ
}

ⓐ @Target(ElementType.PARAMETER)
- 해당 어노테이션이 생성될 수 있는 위치를 지정함
- PARAMETER로 지정했으니 메소드의 파라미터로 선언된 객체에서만 사용 할 수 있음
  - ElementType.PACKAGE : 패키지 선언
    - ElementType.TYPE : 타입 선언
    - ElementType.ANNOTATION_TYPE : 어노테이션 타입 선언
    - ElementType.CONSTRUCTOR : 생성자 선언
    - ElementType.FIELD : 멤버 변수 선언
    - ElementType.LOCAL_VARIABLE : 지역 변수 선언
    - ElementType.METHOD : 메서드 선언
    - ElementType.PARAMETER : 전달인자 선언
    - ElementType.TYPE_PARAMETER : 전달인자 타입 선언
    - ElementType.TYPE_USE : 타입 선언
ⓑ @Retention(RetentionPolicy.RUNTIME)
- Annotation 이 실제로 적용되고 유지되는 범위를 의미
- RetentionPolicy.RUNTIME
  - 컴파일 이후에도 JVM 에 의해서 계속 참조가 가능
    - 주로 리플렉션이나 로깅에 많이 사용됨
- RetentionPolicy.CLASS
  - 컴파일러가 클래스를 참조할 때가지 유효함
- RetentionPolicy.SOURCE
  - 컴파일 전까지만 유효함
    - 즉, 컴파일 이후에는 사라지게 됨

1.2 LoginUserArgumentResolver

@RequiredArgsConstructor
@Component
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {

    private final HttpSession httpSession;

    @Override
    public boolean supportsParameter(MethodParameter parameter) { ⓐ
        boolean isLoginUserAnnotation = parameter.getParameterAnnotation(LoginUser.class) != null;
        boolean isUserClass = SessionUser.class.equals(parameter.getParameterType());

        return isLoginUserAnnotation && isUserClass;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception { ⓑ
        return httpSession.getAttribute("user");
    }
}

ⓐ supportsParameter()
- 컨트롤러 메서드의 특정 파라미터를 지원하는지 판단함
- 상기 매서드에서는 파라미터에 @LoginUser 어노테이션이 붙어 있고, 파라미터 클래스 타입이 SessionUser.class인 경우 true를 반환함
ⓑ resolveArgument()
- 파라미터에 전달할 객체를 생성함
- 상기 소스에서는 세션에서 객체를 가져옴

1.3 IndexController 개선

@RequiredArgsConstructor
@Controller
public class IndexController {

    private final PostsService postsService;

    @GetMapping("/")
    public String index(Model model, @LoginUser SessionUser user) { ⓐ
        model.addAttribute("posts", postsService.findAllDesc());

        if (user != null) {
            model.addAttribute("userName", user.getName());
        }
        return "index";
    }
}

ⓐ @LoginUser SessionUser user
- 기존 SessionUser user = (SessionUser) httpSession.getAttribute("user");로 가져오던 세션 정보 값이 개선 됨
- 해당 커스텀 어노테션을 사용하면 세션 정보를 가져올 수 있게 됨

2. 세션 저장소로 데이터베이스 사용하기

2.1 세션(Session)?

클라이언트와 웹서버 간 네트워크 연결이 지속 유지되고 있는 상태를 말함
즉, 사용자가 브라우저를 열어 서버에 접속한 뒤 접속을 종료할 때가지의 시점을 이야기함
HTTP 프로토콜은 비접속형 프로토콜이므로, 매 접속마다 새로운 네트워크 연결이 이루어는데 세션이 연결 유지를 가능하게 함
정보들이 서버단에 저장되기 때문에 보안 면에서 쿠키보다 우수함

2.2 다중 서버 환경에서 세션관리 방법

(참조 : https://hyuntaeknote.tistory.com/6)

2.2.1 Sticky Session

고정된 세션
Load Balance가 기본적으로 라운드 로빈 방식으로 트래픽을 분산
특정 사용자가 접속을 시도했을 때 처음 접속된 서버로 계속해서 접속되도록 트래픽을 처리하는 방식
장점
- 사용자는 세션이 유지되는 동안 동일한 서버만을 사용
- 정합성 이슈에서 자유로움
단점
- 사용자가 접속해야하는 서버가 정해져 있기 때문에 특정 서버에 트래픽이 집중될 위험이 있음
- 사용자가 자신의 세션이 없는 다른서버 이용불가
- 가용성이 떨어짐

2.2.2 Session Clustering(세션 클러스터링)

여러 대의 컴퓨터들이 하나의 시스템 처럼 동작하도록 만드는 것
WAS가 2대 이상 설치 형태일 때 동일한 세션으로 관리하는 것을 의미
장점
- 세션을 복제하여 사용자가 어떤 서버에 접속하더라도 데이터가 세션에 복제됨으로써 정합성 이슈 해결
- 서버 하나에 장애가 발생하더라도 서비스는 중단되지 않고 운영 가능
단점
- 모든 서버가 동일한 세션 객체를 가져야하기 때문에 많은 메모리가 필요
- 세션 저장소에 데이터가 저장될 때마다 모든 서버에 값을 입력해야함
- 서버 수에 비례하여 네트워크 트래픽이 증가하는 등 성능저하가 발생

2.2.3 Session Storage(세션 저장소)

서버가 아무리 늘어나도 세션 스토리지에 대한 정보만 각각의 서버에 입력해주면 세션을 공유할 수 있게됨
트래픽이 비정상적으로 몰리는 현상을 고려하지 않아도 됨
서버가 하나 장애가 발생하더라도 별도의 세션 저장소가 존재하기 때문에 서비스를 계속해서 제공할 수 있음 (가용성을 확보할 수 있음)
여러대의 서버가 하나의 세션을 사용하기 때문에 데이터 불일치가 발생하지 않음 (정합성 문제 해결)
별도의 세션 복제를 할 필요 없기에 성능적인 문제도 해결이 가능
But, 세션 저장소 서버 장애를 방지하기 위해 동일한 세션 저장소 하나를 더 구성하여 복제하는것이 좋음

Disk Based Database
- 디스크에 저장 및 사용
- MySQL, Oracle, MS-SQL 등과 같은 관계형 데이터베이스
- 세션 저장소를 할 수 있는 가장 쉬운방법
- 많은 설정 필요 없음
- 처리 속도가 오래걸림, DB I/O가 발생하여 성능상 이슈가 발생할 수 있음
- 빈번한 Read/Write가 이루어지는 세션 저장소로써 Disk 기반의 데이터베이스는 상대적으로 I/O 속도가 느리기 때문에 적합하지 않음
- 보통 로그인 요청이 많이 없는 백오피스, 사내 시스템 용도에서 많이 사용

In-Memory Database
- 메모리에 저장 및 사용
- Redis, Memcached 등이 있음
- 세션에 저장하는 데이터들은 영구적으로 저장하는 데이터가 아님
- In-Memory 데이터베이스는 전원 공급이 중단되면 데이터를 잃어버리지만, 세션 저장소에 저장되는 데이터는 상대적으로 피해가 적기 때문에 In-Memory 데이터베이스 사용이 적합합니다. (일부 데이터베이스는 Replication을 지원하기 때문에 가용성을 확보할 수 있습니다.)
- 데이터를 메모리에서 Read/Write 할 수 있다는 점에서 빠른 속도로 데이터를 처리할 수 있기 때문에 세션 저장소로써 적합

2.3 세션 저장소로 데이터베이스(Disk Based Database) 설정

gradle에 의존성 추가
- implementation 'org.springframework.session:spring-session-jdbc'
application.properties에 추가
- spring.session.store-type=jdbc

구글 로그인 연동 및 스프링 시큐리티 설정

Sat, 27 Nov 2021 14:19:47 GMT

1. 도메인 User 클래스 생성

User

import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Getter
@NoArgsConstructor
@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String email;

    @Column
    private String picture;

    @Enumerated(EnumType.STRING) ⓐ
    @Column(nullable = false)
    private Role role;

    @Builder
    public User(String name, String email, String picture, Role role) {
        this.name = name;
        this.email = email;
        this.picture = picture;
        this.role = role;
    }

    public User update(String name, String picture) {
        this.name = name;
        this.picture = picture;

        return this;
    }

    public String getRoleKey() {
        return this.role.getKey();
    }
}

ⓐ @Enumerated(EnumType.STRING)
- JPA로 데이터베이스로 저장할 때 Enum 값을 어떤 형대로 저장할지를 결정함
- 기본적으로 int로 된 숫자가 저장됨
- 숫자로 저장되면 데이터베이스로 확인할 때 그 값이 무슨 코드를 의미하는지 알 수가 없음, 그래서 문자열(EnumType.STRING)로 저장될 수 있도록 선언함

Role

사용자의 권한을 관리할 Enum 클래스

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter @RequiredArgsConstructor public enum Role {

GUEST("ROLE_GUEST", "손님"),
USER("ROLE_USER", "일반 사용자");

private final String key;
private final String title;

}

- 스프링 시큐리티에서는 권한 코드에 ***항상 ROLE_이 앞에 있어야만*** 함

### UserRepository

import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface UserRepository extends JpaRepository {

Optional findByEmail(String email);

}


# 2. 스프링 시큐리티 설정
## 2.1 build.gradle 의존성 추가

implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'

- spring-boot-starter-oauth2-client

    - 소셜 로그인 등 클라이언트 입장에서 소셜 기능 구현 시 필요한 의존성임
    - spring-security-oauth2-client와 spring-security-oauth2-jose를 기본으로 관리해줌

## 2.2 config.auth 패키지 생성
- 시큐리티 관련 클래스
### 2.2.1 SecurithConfig

import com.study.aws.studyspringbootaws.domain.user.Role; import lombok.RequiredArgsConstructor; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@RequiredArgsConstructor @EnableWebSecurity ⓐ public class SecurityConfig extends WebSecurityConfigurerAdapter {

private final CustomOAuth2UserService customOAuth2UserService;

@Override
protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
            .headers().frameOptions().disable() ⓑ
            .and()
                .authorizeRequests() ⓒ
                .antMatchers("/", "/css/**", "/images/**", "/js/**", "/h2-console/**")
                    .permitAll()
                .antMatchers("/api/v1/**") ⓓ
                    .hasRole(Role.USER.name())
                .anyRequest() ⓔ
                    .authenticated()
            .and()
                .logout()
                    .logoutSuccessUrl("/") ⓕ
            .and()
                .oauth2Login() ⓖ
                    .userInfoEndpoint() ⓗ
                        .userService(customOAuth2UserService) ⓘ
            ;
}

}

- ⓐ @EnableWebSecurity     
    - Spring Security 설정들을 활성화시켜 줌
- ⓑ csrf().disable().headers().frameOptions().disable()     
    - h2-console 화면을 사용하기 위해 해당 옵션들을 disable 처리함
- ⓒ authorizeRequests()      
    - URL별 권한 관리를 설정하는 옵션의 시작점
    - authorizeRequests가 선언되어야만 antMatchers 옵션을 사용할 수 있음
- ⓓ antMatchers("/api/v1/**")     
    - 권한 관리 대상을 지정하는 옵션임
    - URL, HTTP 메소드별로 관리가 가능함
    - permitAll() 옵션을 통해 전체 권한을 줌
    - hasRole() 옵션을 통해 해당 권한이 있는 사용자에게 접근 가능하도록 함
- ⓔ anyRequest()      
    - 설정된 값들 이외의 나머지 URL들을 나타냄
    - authenticated()를 추가하여 나머지 URL들을 모두 인증된 사용자들에게 허용하게 함
    - 인증된 사용자 즉, 로그인한 사용자들을 이야기함
- ⓕ logout().logoutSuccessUrl("/") 
    - 로그아웃 기능에 대한 여러 설정 진입점임
    - 로그아웃 성공시 "/" 주소로 이동한다는 의미
- ⓖ oauth2Login() 
    - OAuth 2 로그인 기능에 대한 여려 설정의 진입점임
- ⓗ userInfoEndpoint()  
    - OAuth 2 로그인 성공 이후 사용자 정보를 가져올 때의 설정들을 담당함
- ⓘ userService(특정 UserService) 
    - 소셜 로그인 성공 시 후속 조치를 진행할 UserService 인터페이스의 구현체를 등록함
    - 리소스 서버(즉, 소셜 서비스들)에서 사용자 정보를 가져온 상태에서 추가로 진행하고자 하는 기능을 명시 할 수 있음

### 2.2.2 CustomOAuth2UserService
- 구글 로그인 이후 가져온 사용자의 정보들을 기반으로 가입 및 정보 수정, 세션 저장 등의 기능을 지원함

@RequiredArgsConstructor @Service public class CustomOAuth2UserService implements OAuth2UserService {

private final UserRepository userRepository;
private final HttpSession httpSession;

@Override
public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
    OAuth2UserService delegate = new DefaultOAuth2UserService();
    OAuth2User oAuth2User = delegate.loadUser(userRequest);

    String registrationId = userRequest.getClientRegistration().getRegistrationId(); ⓐ
    String userNameAttributeName =
            userRequest.getClientRegistration()
                    .getProviderDetails()
                    .getUserInfoEndpoint()
                    .getUserNameAttributeName(); ⓑ

    OAuthAttributes attributes = OAuthAttributes.of(registrationId,
            userNameAttributeName,
            oAuth2User.getAttributes()); ⓒ

    User user = saveOrUpdate(attributes);

    httpSession.setAttribute("user", new SessionUser(user)); ⓓ

    return new DefaultOAuth2User(
            Collections.singleton(new SimpleGrantedAuthority(user.getRoleKey())),
            attributes.getAttributes(),
            attributes.getNameAttributeKey()
    );
}

private User saveOrUpdate(OAuthAttributes attributes) {
    User user = userRepository.findByEmail(attributes.getEmail())
            .map(entity -> entity.update(attributes.getName(),
                    attributes.getPicture()))
            .orElse(attributes.toEntity());

    return userRepository.save(user);
}

}

- ⓐ registrationId     
    - 현재 로그인 진행 중인 서비스를 구분하는 코드
    - 현재 상기 코드에서는 구글만 사용하므로 불필요한 값이지만, 기타 다른 로그인 연동 시 다른 서비스인지를 구분하기위해 사용함(ex. 네이버 로그인인지, 구글인지, 카카오인지 확인하기 위한 ID 값)
- ⓑ userNameAttributeName     
    - OAuth2 로그인 진행 시 키가 되는 필드값을 이야기 함 (Primary Key와 같은 의미라 보면 됨)
    - 구글의 경우 기본적으로 코드를 지원하지만, 네이버 카카오 등은 기본으로 지원하지 않음! 구글의 기본 코드는 "sub"임
    - 이후 네이버 로그인과 구글 로그인을 동시 지원할 때 사용할 예정
- ⓒ OAuthAttributes      
    - OAuth2UserService를 통해 가져온 OAuth2User의 attribute를 담을 클래스임
    - 이후 네이버 등 다른 소셜 로그인도 이 클래스를 사용함
- ⓓ SessionUser
    - 세션에 사용자 정보를 저장하기 위한 DTO 클래스임

### 2.2.3 OAuthAttributes
- DTO 패키지를 만들어 클래스 생성

@Getter public class OAuthAttributes {

private Map attributes;
private String nameAttributeKey;
private String name;
private String email;
private String picture;

@Builder
public OAuthAttributes(Map attributes,
                       String nameAttributeKey, String name,
                       String email, String picture) {
    this.attributes = attributes;
    this.nameAttributeKey = nameAttributeKey;
    this.name = name;
    this.email = email;
    this.picture = picture;
}

public static OAuthAttributes of(String registrationId,
                                 String userNameAttributeName,
                                 Map attributes) { ⓐ
    return ofGoogle(userNameAttributeName, attributes);

}

private static OAuthAttributes ofGoogle(String userNameAttributeName,
                                        Map attributes) { 
    return OAuthAttributes.builder()
            .name((String) attributes.get("name"))
            .email((String) attributes.get("email"))
            .picture((String) attributes.get("picture"))
            .attributes(attributes)
            .nameAttributeKey(userNameAttributeName)
            .build()
            ;
}

public User toEntity() { ⓑ
    return User.builder()
            .name(name)
            .email(email)
            .picture(picture)
            .role(Role.GUEST)
            .build();
}

}

- ⓐ of()     
    - OAuth2User에서 반환하는 사용자 정보는 Map이기 때문에 값 하나하나를 변환해야함 함
- ⓑ toEntity()     
    - User 엔티티를 생성함
    - OAuthAttributes에서 엔티티를 생성하는 시점은 처음 가입할 때임
    - 가입할 때의 기본 권한을 GUEST로 주기 위해서 role 빌더값에는 Role.GUEST 값을 주었음
    - OAuthAttributes 클래스 생성이 끝났으면 같은 패키지에 SessionUser 클래스를 생성함

### 2.2.4 SessionUser

@Getter public class SessionUser implements Serializable {

private String name;
private String email;
private String picture;

public SessionUser(User user) {
    this.name = user.getName();
    this.email = user.getEmail();
    this.picture = user.getPicture();
}

}

### 2.2.5 왜 User 클래스를 사용하지 않고 SessionUser를 따로 만들었나?

- 세션에 저장을 위해 클래스의 직렬화가 필요함

    - **User 클래스는 엔티티**이기 때문에 직렬화 하기 힘듬
        - 엔티티 클래스는 언제 다른 엔티티와 관계가 형성될지 모름
       - ex) @OneToMany or @ManytoMany 등 자식 엔티티를 갖고 있다면 직렬화 대상에 해당 엔티티도 포함되므로 **성능이슈, 부수효과**가 발생할 가능성이 높음

# 3. 로그인 테스트
## 3.1 화면에 로그인 기능 추가
### 3.1.1 index.mustache

스프링 부트로 시작하는 웹 서비스

``` - ⓐ {{#userName}} - 머스테치는 true/false 여부만 판단함, if문 없음 - 항상 최종값을 넘겨줘야 함 - ⓑ a href="/logout" - 스프링 시큐리티에서 기본적으로 제공하는 로그아웃 URL - 즉, 개발자가 별도로 저 URL에 해당하는 컨트롤러를 만들 필요가 없음 - SecurityConfig 클래스에서 URL 변경 가능 - ⓒ {{^userName}} - 머스테치에서는 해당 값이 존재하지 않을 경우에는 ^를 사용함 - ⓓ a href="/oauth2/authorization/google" - 스프링 시큐리티에서 기본적으로 제공하는 구글 로그인 URL ### 3.1.2 indexController ```

private final HttpSession httpSession;

@GetMapping("/")
public String index(Model model) {
    model.addAttribute("posts", postsService.findAllDesc());

    SessionUser user = (SessionUser) httpSession.getAttribute("user"); 

    if (user != null) { 
        model.addAttribute("userName", user.getName());
    }
    return "index";
}

## 3.2 프로젝트 실행하여 테스트
1. 로그인버튼화면
![](https://images.velog.io/images/young_209/post/eac8c3a7-037d-414b-9c46-9778fcc5937d/image.png)
2. 구글 로그인
![](https://images.velog.io/images/young_209/post/3a8121ae-7fe4-4b60-a64c-c03b0d6cd218/image.png)
3. 로그인 정보 DB 확인
![](https://images.velog.io/images/young_209/post/d22d4efd-ed9d-40a4-b899-7bac0cfedea0/image.png)
4. 게시글 등록 (GUEST 상태일때)
![](https://images.velog.io/images/young_209/post/67fa9fc5-b6dc-4a65-8bba-0717c67aaee7/image.png)
![](https://images.velog.io/images/young_209/post/d91d6939-e9a5-42b9-8efd-6edf332bd059/image.png)
5. 권한 변경 후 등록
![](https://images.velog.io/images/young_209/post/e6916064-fefc-4f43-acfd-4f7e7f6ba44d/image.png)

OAuth 2.0 및 구글 서비스 등록

Sat, 27 Nov 2021 09:11:15 GMT

1. 스프링 부트 2.0 기반의 OAuth 2.0

1.1 OAuth 2.0란?

예시로 만약 로그인 기능을 직접 구현할 경우 로그인 및 회원가입 등등의 기능이 필요하게 됨 but, OAuth 2.0을 사용한다면 대분의 로그인, 개인정보 관리 책임을 Google, Facebook, Kakao 등에게 위임할 수 있음

1.2 스프링 부트 2.0으로 사용하는 이유

스프링 팀에서 기존 1.5에서 사용되던 Spring-security-oauth 프로젝트는 유지 상태(maintenance mode)로 결정했으며 더는 신규 기능은 추가하지 않고 버그 수정 정도의 기능만 추가될 예정, 신규 기능은 새 oauth2 라이브러리에서만 지원 하겠다고 선언
스프링 부트용 라이브러리(starter) 출시
기존에 사용되던 방식은 확장 포인트가 적절하게 오픈되어 있지 않아 직접 상소가거나 오버라이딩 해야 하고 신규 라이브러리의 경우 확장 포인트를 고려해서 설계된 상태
CommonOAuth2Provider라는 enum이 새롭게 추가되어 구글, 깃허브, 페이스북, 옥타(Okta)의 기본 설정 값은 모두 제공해주므로 따로 설정할 필요 없음

2. 구글 서비스 등록 (책 P.166 ~ P.173)

2.1 구글 클라우드 플랫폼에 신규 프로젝트 생성

2.2 사용자 인증 정보 등록

2.3 프로젝트에 properties 추가

스프링 부트에서는 properties의 이름을 application-xxx.properties 로 네이밍하여 만들면 xxx라는 이름의 profile이 생성되어 관리 할 수 있음, 즉 profile=xxx라는 식으로 호출하면 해당 properties의 설정들을 가져올수 있음
해당 책에서는 스프링 부트의 기본 설정 파일인 application.properties에서 application-oauth.properties를 포함하도록 구성
.gitignore 등록
- 구글 로그인을 위한 client Id와 client secret pw는 보안에 중요함ㄴ
- 깃에 해당 정보가 올라가지 않도록 방지해야함

면접 정리

Wed, 24 Nov 2021 04:36:01 GMT

CheckedException / Unchecked Exception

Checked Exception

처리여부 : 반드시 예외 처리 해야함
트랜잭션 Rollback 여부 : Rollback 안됨
대표 Exception : IOException, SQLException
Unchecked Exception
처리여부 : 예외 처리 하지 않아도됨
트랜잭션 Rollback 여부 : Rollback 안됨
대표 Exception : NullPointerException, IllegalArgumentException

참조 : https://cheese10yun.github.io/checked-exception/

JPA N+1 문제

JPA N+1란?

Entity에 대해 하나의 쿼리로 N개의 레코드를 가져왔을 때, 연관관계 Entity를 가져오기 위해 쿼리를 N번 추가적으로 수행하는 문제

해결 방법

Fetch join 사용
@EntityGraph 사용
주의 사항
- JoinFetch는 Inner Join, Entity Graph는 Outer Join
- 카테시안 곱(Cartesian Product)이 발생하여 Subject의 수만큼 Academy가 중복 발생
  - 일대다 필드의 타입을 Set으로 선언
  - distinct를 사용하여 중복을 제거하는 것

참조 : https://jojoldu.tistory.com/165

테이블 정규화

정규화란

테이블 간에 중복된 데이터를 허용하지 않는다는 것
무결성(Integrity)를 유지할 수 있으며, DB의 저장 용량 역시 줄일 수 있음

제1정규화

테이블의 컬럼이 원자값(Atomic Value, 하나의 값)을 갖도록 테이블을 분해하는 것
제2정규화
제1 정규화를 진행한 테이블에 대해 완전 함수 종속을 만족하도록 테이블을 분해하는 것
기본키의 부분집합이 결정자가 되어선 안된다는 것
제3정규화
제2 정규화를 진행한 테이블에 대해 이행적 종속을 없애도록 테이블을 분해하는 것
이행적 종속이라는 것은 A -> B, B -> C가 성립할 때 A -> C가 성립되는 것
BCNF 정규화
제3 정규화를 진행한 테이블에 대해 모든 결정자가 후보키가 되도록 테이블을 분해하는 것

young_209.log

스프링 핵심 원리 이해1

비즈니스 요구사항과 설계

요구사항

회원 도메인 설계

회원 도메인 협력 관계

회원 클래스 다이어그램

회원 객체 다이어그램

주문과 할인 도메인 설계

주문 도메인 전체

주문 도메인 클래스 다이어그램

주문 도메인 객체 다이어그램 1

주문 도메인 객체 다이어그램 2

객체 지향 설계와 스프링

1. 스프링이란?

2. 좋은 객체 지향 프로그래밍?

2.1 객체 지향 특징

2.2 객체 지향 프로그래밍

✓ 유연하고, 변경이 용이?

2.2.1 다형성(Polymorphism)?

다형성의 실세계 비유?

운전자 - 자동차

공연 무대

역활과 구현을 분리

자바에서의 다형성

2.2.2 스프링과 객체 지향

3. 좋은 객체 지향 설계의 5가지 원칙 (SOLID)

SRP 단일 책임 원칙

OCP 개방-폐쇄 원칙

LSP 리스코프 치환 원칙

ISP 인터페이스 분리 원칙

DIP 의존관계 역전 원칙

운영 이슈 테스트 : Chaos Monkey

1. 소개

2. 설치 (CM4SB)

의존성 추가

application.properties에 추가

3. 테스트

테스트를 위한 사용 툴

응답 지연 테스트

에러 테스트

성능 테스트 : JMeter

1. 소개

2. 설치

3. 사용하기

도커와 테스트 : Testcontainers 소개 / 설치 / 기능

1. Testcontainers 소개

전제 조건

2. Testcontainers 설치

Gradle 설정 추가

application-test.properties 추가

Test 소스

3. Testcontainers 기능

어노테이션

컨테이너 만들기

네트워크

환경 변수 설정

명령어 실행

사용할 준비가 됐는지 확인하기

로그 살펴보기

Mockito : Mock 객체 확인 및 BDD 스타일 Mockito API

1. Mock 객체 확인

2. BDD 스타일 Mockito API

BDD란?

행동에 대한 스팩

Mockito BDD 스타일의 API

Mockito : Mock 객체 Stubbing

1. Mock 객체의 행동?

2. Stubbing 이란?

3. 연습 문제

Mockito : 소개 및 시작

1. Mockito란?

2. Mockito 시작하기

JUnit 5 : 확장 모델 & JUnit 설정 파일

1. 확장 모델

확장 등록 방법

2. JUnit 설정 파일

JUnit 5 : 테스트 인스턴스 & 순서

1. 테스트 인스턴스

JUnit은 테스트 메소드 마다 테스트 인스턴스를 새로 만든다.

2. @Enabled 와 @Disabled