Skip to content

Commit

Permalink
[TEST] refactor Offer related unit tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@nogamsung
nogamsung committed Nov 10, 2023
1 parent dd2acff commit 6cbd28d
Show file tree
Hide file tree
Showing 2 changed files with 213 additions and 74 deletions.
221 changes: 147 additions & 74 deletions src/test/java/com/gabojait/gabojaitspring/domain/offer/OfferTest.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,129 +7,203 @@
import com.gabojait.gabojaitspring.domain.user.Position;
import com.gabojait.gabojaitspring.domain.user.User;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.EnumSource;
import org.junit.jupiter.params.provider.MethodSource;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.stream.Stream;

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

class OfferTest {

@Test
@DisplayName("팀장의 제안을 생성한다.")
void givenOfferedByLeader_whenBuilder_thenReturn() {
// given
User user1 = createDefaultUser("tester1@gabojait.com", "000000", "tester1", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
User user2 = createDefaultUser("tester2@gabojait.com", "000000", "tester2", "password1!", "테스터이", Gender.M,
private static Stream<Arguments> providerBuilder() {
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());

Team team = createTeam("가보자잇", (byte) 3);
TeamMember teamMember = createTeamMember(Position.BACKEND, true, user1, team);
OfferedBy offeredBy = OfferedBy.LEADER;
Position position = Position.MANAGER;

return Stream.of(
Arguments.of(OfferedBy.LEADER, Position.BACKEND, user, team),
Arguments.of(OfferedBy.USER, Position.BACKEND, user, team)
);
}

@ParameterizedTest(name = "[{index}] {0}가 제안을 생성한다.")
@MethodSource("providerBuilder")
@DisplayName("제안을 생성한다.")
void givenProvider_whenBuilder_thenReturn(OfferedBy offeredBy, Position position, User user, Team team) {
// when
Offer offer = createOffer(offeredBy, position, user2, team);
Offer offer = createOffer(offeredBy, position, user, team);

// then
assertThat(offer)
.extracting("offeredBy", "position", "isAccepted", "isDeleted")
.containsExactly(offeredBy, position, null, false);
}

@Test
@DisplayName("회원의 제안을 생성한다.")
void givenOfferedByUser_whenBuilder_thenReturn() {
// given
User user1 = createDefaultUser("tester1@gabojait.com", "000000", "tester1", "password1!", "테스터일", Gender.M,
private static Stream<Arguments> providerAccept() {
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
User user2 = createDefaultUser("tester2@gabojait.com", "000000", "tester2", "password1!", "테스터이", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());

Team team = createTeam("가보자잇", (byte) 3);
TeamMember teamMember = createTeamMember(Position.BACKEND, true, user1, team);
OfferedBy offeredBy = OfferedBy.USER;
Position position = Position.FRONTEND;

// when
Offer offer = createOffer(offeredBy, position, user2, team);

// then
assertThat(offer)
.extracting("offeredBy", "position", "isAccepted", "isDeleted")
.containsExactly(offeredBy, position, null, false);
return Stream.of(
Arguments.of(OfferedBy.LEADER, Position.BACKEND, user, team),
Arguments.of(OfferedBy.USER, Position.BACKEND, user, team)
);
}

@Test
@ParameterizedTest(name = "[{index}] {0}가 제안을 수락한다.")
@EnumSource(OfferedBy.class)
@DisplayName("제안을 수락한다.")
void accept() {
void givenEnum_whenAccept_thenReturn(OfferedBy offeredBy) {
// given
User user1 = createDefaultUser("tester1@gabojait.com", "000000", "tester1", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
User user2 = createDefaultUser("tester2@gabojait.com", "000000", "tester2", "password1!", "테스터이", Gender.M,
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Team team = createTeam("가보자잇", (byte) 2);
TeamMember teamMember = createTeamMember(Position.BACKEND, true, user1, team);
Team team = createTeam("가보자잇", (byte) 3);
Position position = Position.BACKEND;

Offer offer = createOffer(OfferedBy.LEADER, Position.DESIGNER, user2, team);
Offer offer = createOffer(offeredBy, position, user, team);

// when
offer.accept();

// then
assertThat(offer)
.extracting("isAccepted", "isDeleted")
.containsExactly(true, true);
.extracting("offeredBy", "position", "isAccepted", "isDeleted")
.containsExactly(offeredBy, position, true, true);
}

@Test
@ParameterizedTest(name = "[{index}] {0}가 제안을 거절한다.")
@EnumSource(OfferedBy.class)
@DisplayName("제안을 거절한다.")
void decline() {
void givenEnum_whenDecline_thenReturn(OfferedBy offeredBy) {
// given
User user1 = createDefaultUser("tester1@gabojait.com", "000000", "tester1", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
User user2 = createDefaultUser("tester2@gabojait.com", "000000", "tester2", "password1!", "테스터이", Gender.M,
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Team team = createTeam("가보자잇", (byte) 2);
TeamMember teamMember = createTeamMember(Position.BACKEND, true, user1, team);
Team team = createTeam("가보자잇", (byte) 3);
Position position = Position.BACKEND;

Offer offer = createOffer(OfferedBy.LEADER, Position.DESIGNER, user2, team);
Offer offer = createOffer(offeredBy, position, user, team);

// when
offer.decline();

// then
assertThat(offer)
.extracting("isAccepted", "isDeleted")
.containsExactly(false, true);
.extracting("offeredBy", "position", "isAccepted", "isDeleted")
.containsExactly(offeredBy, position, false, true);
}

@Test
@ParameterizedTest(name = "[{index}] {0}가 제안을 취소한다.")
@EnumSource(OfferedBy.class)
@DisplayName("제안을 취소한다.")
void cancel() {
void givenEnum_whenCancel_thenReturn(OfferedBy offeredBy) {
// given
User user1 = createDefaultUser("tester1@gabojait.com", "000000", "tester1", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
User user2 = createDefaultUser("tester2@gabojait.com", "000000", "tester2", "password1!", "테스터이", Gender.M,
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터일", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Team team = createTeam("가보자잇", (byte) 2);
TeamMember teamMember = createTeamMember(Position.BACKEND, true, user1, team);
Team team = createTeam("가보자잇", (byte) 3);
Position position = Position.BACKEND;

Offer offer = createOffer(OfferedBy.USER, Position.DESIGNER, user2, team);
Offer offer = createOffer(offeredBy, position, user, team);

// when
offer.cancel();

// then
assertThat(offer)
.extracting("isAccepted", "isDeleted")
.containsExactly(null, true);
.extracting("offeredBy", "position", "isAccepted", "isDeleted")
.containsExactly(offeredBy, position, null, true);
}

private static Stream<Arguments> providerEquals() {
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Team team = createTeam("가보자잇", (byte) 3);
Offer offer = createOffer(OfferedBy.USER, Position.BACKEND, user, team);

User user1 = createDefaultUser("tester@gabojait.com", "000000", "tester1", "password1!", "테스터", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Offer userOffer1 = createOffer(OfferedBy.USER, Position.BACKEND, user1, team);
User user2 = createDefaultUser("tester@gabojait.com", "000000", "tester2", "password1!", "테스터", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Offer userOffer2 = createOffer(OfferedBy.USER, Position.BACKEND, user2, team);

Team team1 = createTeam("가보자잇1", (byte) 3);
Offer teamOffer1 = createOffer(OfferedBy.USER, Position.BACKEND, user, team1);
Team team2 = createTeam("가보자잇2", (byte) 3);
Offer teamOffer2 = createOffer(OfferedBy.USER, Position.BACKEND, user, team2);

Offer isAccepted1 = createOffer(OfferedBy.USER, Position.BACKEND, user, team);
Offer isAccepted2 = createOffer(OfferedBy.USER, Position.BACKEND, user, team);
isAccepted2.accept();

return Stream.of(
Arguments.of(offer, offer, true),
Arguments.of(offer, new Object(), false),
Arguments.of(
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
true
),
Arguments.of(userOffer1, userOffer2, false),
Arguments.of(teamOffer1, teamOffer2, false),
Arguments.of(isAccepted1, isAccepted2, false),
Arguments.of(
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
createOffer(OfferedBy.LEADER, Position.BACKEND, user, team),
false
),
Arguments.of(
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
createOffer(OfferedBy.USER, Position.FRONTEND, user, team),
false
)
);
}

@ParameterizedTest(name = "[{index}] 제안 객체를 비교한다.")
@MethodSource("providerEquals")
@DisplayName("제안 객체를 비교한다.")
void givenProvider_whenEquals_thenReturn(Offer offer, Object object, boolean result) {
// when & then
assertThat(offer.equals(object)).isEqualTo(result);
}

private static Stream<Arguments> providerHashCode() {
User user = createDefaultUser("tester@gabojait.com", "000000", "tester", "password1!", "테스터", Gender.M,
LocalDate.of(1997, 2, 11), LocalDateTime.now());
Team team = createTeam("가보자잇", (byte) 3);

return Stream.of(
Arguments.of(
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
true
),
Arguments.of(
createOffer(OfferedBy.USER, Position.BACKEND, user, team),
createOffer(OfferedBy.LEADER, Position.BACKEND, user, team),
false
)
);
}

@ParameterizedTest(name = "[{index}] 제안 해시코드를 비교한다.")
@MethodSource("providerHashCode")
@DisplayName("제안 해시코드를 비교한다.")
void givenProvider_whenHashCode_thenReturn(Offer offer1, Offer offer2, boolean result) {
// when
int hashCode1 = offer1.hashCode();
int hashCode2 = offer2.hashCode();

// then
assertThat(hashCode1 == hashCode2).isEqualTo(result);
}

private Offer createOffer(OfferedBy offeredBy, Position position, User user, Team team) {
private static Offer createOffer(OfferedBy offeredBy, Position position, User user, Team team) {
return Offer.builder()
.offeredBy(offeredBy)
.position(position)
Expand All @@ -138,7 +212,7 @@ private Offer createOffer(OfferedBy offeredBy, Position position, User user, Tea
.build();
}

private TeamMember createTeamMember(Position position, boolean isLeader, User user, Team team) {
private static TeamMember createTeamMember(Position position, boolean isLeader, User user, Team team) {
return TeamMember.builder()
.position(position)
.isLeader(isLeader)
Expand All @@ -147,8 +221,7 @@ private TeamMember createTeamMember(Position position, boolean isLeader, User us
.build();
}

private Team createTeam(String projectName,
byte maxCnt) {
private static Team createTeam(String projectName, byte maxCnt) {
return Team.builder()
.projectName(projectName)
.projectDescription("프로젝트 설명입니다.")
Expand All @@ -161,14 +234,14 @@ private Team createTeam(String projectName,
.build();
}

private User createDefaultUser(String email,
String verificationCode,
String username,
String password,
String nickname,
Gender gender,
LocalDate birthdate,
LocalDateTime lastRequestAt) {
private static User createDefaultUser(String email,
String verificationCode,
String username,
String password,
String nickname,
Gender gender,
LocalDate birthdate,
LocalDateTime lastRequestAt) {
Contact contact = Contact.builder()
.email(email)
.verificationCode(verificationCode)
Expand Down
66 changes: 66 additions & 0 deletions src/test/java/com/gabojait/gabojaitspring/domain/offer/OfferedByTest.java
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,66 @@
package com.gabojait.gabojaitspring.domain.offer;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.stream.Stream;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

class OfferedByTest {

private static Stream<Arguments> providerGetText() {
return Stream.of(
Arguments.of(OfferedBy.USER, "회원"),
Arguments.of(OfferedBy.LEADER, "리더")
);
}

@ParameterizedTest(name = "[{index}] {0} 제안자 텍스트는 {1}다.")
@MethodSource("providerGetText")
@DisplayName("제안자 텍스트를 반환한다.")
void givenProvider_whenGetText_thenReturn(OfferedBy offeredBy, String text) {
// when & then
assertThat(offeredBy.getText()).isEqualTo(text);
}

@Test
@DisplayName("전체 제안자를 반환한다.")
void values() {
// given & when
OfferedBy[] offeredBys = OfferedBy.values();

// then
assertThat(offeredBys).containsExactlyInAnyOrder(OfferedBy.USER, OfferedBy.LEADER);
}

private static Stream<Arguments> providerValueOf() {
return Stream.of(
Arguments.of("USER", OfferedBy.USER),
Arguments.of("LEADER", OfferedBy.LEADER)
);
}

@ParameterizedTest(name = "[{index}] {0} 값을 {1} 제안자로 변환한다.")
@MethodSource("providerValueOf")
@DisplayName("제안자 값을 반환한다.")
void givenProvider_whenValueOf_thenReturn(String value, OfferedBy offeredBy) {
// when & then
assertThat(OfferedBy.valueOf(value)).isEqualTo(offeredBy);
}

@Test
@DisplayName("잘못된 값을 제안자로 변환하면 예외가 발생한다.")
void givenInvalid_whenValueOf_thenThrow() {
// given
String value = "INVALID";

// when & then
assertThatThrownBy(() -> OfferedBy.valueOf(value))
.isInstanceOf(IllegalArgumentException.class);
}
}

0 comments on commit 6cbd28d

Please sign in to comment.