[4단계 - 리팩터링] 권장순 과제 제출합니다.

README.md

@@ -1,3 +1,41 @@
-# java-calculator
+# 기능 및 프로그래밍 요구 사항
+
+# Step4
+
+- [x] build.gradle에 AssertJ 의존성을 추가한다.
+- [x] 기존 JUnit5로 작성되어 있던 단위 테스트를 AssertJ로 리팩터링한다. 
+- [x] JUnit5에서 제공하는 기능과 AssertJ에서 제공하는 기능을 사용해보고, 어떠한 차이가 있는지 경험한다.
+- [x] 메인 메서드는 만들지 않는다.
+
+# Step3
+- [x] 쉼표(`,`) 또는 콜론(`:`)을 구분자로 가지는 문자열을 전달하면, 구분자를 기준으로 분리한 숫자들의 합을 반환해야 한다.
+    - 예시:
+        - "" → 0
+        - "1,2" → 3
+        - "1,2,3" → 6
+        - "1,2:3" → 6
+- [x] 입력 문자열을 받아 처리해야 한다.
+- [x] 입력받은 문자열을 쉼표(`,`) 또는 콜론(`:`)을 기준으로 분리할 수 있어야 한다.
+- [x] 분리한 숫자들을 합산하여 반환해야 한다.
+- [x] 기본 구분자(쉼표, 콜론) 외에 **커스텀 구분자**를 지정할 수 있어야 한다.
+    - [x] 쉼표, 콜론은 기본 구분자이다.
+    - [x] 커스텀 구분자를 기본 구분자에 **추가 등록**할 수 있어야 한다.
+    - [x] 커스텀 구분자는 문자열 앞부분 `"//"`와 `"\n"` 사이에 위치한 문자를 추출하여 등록할 수 있어야 한다.
+- [x] 문자열에 숫자가 아닌 값이나 음수가 포함되면 `RuntimeException`을 발생시켜야 한다.
+- [x] 구현한 문자열 계산기가 예상한대로 동작하는지 Junit5를 활용하여 테스트를 자동화한다.
+- [x] 조금 더 복잡한 도메인을 대상으로 테스트를 작성하는 경험을 해본다.
+- [x] 메인 메서드는 만들지 않는다.
+
+
+# Step2
+- [x] 구현한 초간단 계산기가 예상한대로 동작하는지 Junit5를 활용하여 테스트를 자동화한다.
+- [x] 메인 메서드 없이 동작을 검증하는 경험을 해본다.
+- [x] 메인 메서드는 만들지 않는다.
+
+# Step1
+- [x] 인자 2개를 받아 사칙연산을 할 수 있는 계산기를 구현한다.
+- [x] 사칙연산과 매칭되는 4개의 메서드를 제공한다.
+- [x] 계산된 결과는 정수를 반환한다.
+- [x] 메인 메서드는 만들지 않는다.**
+
 
-계산기 미션 저장소

build.gradle

@@ -11,7 +11,9 @@ repositories {
 
 dependencies {
     testImplementation platform('org.junit:junit-bom:5.9.1')
+    testImplementation platform('org.assertj:assertj-bom:3.25.1')
     testImplementation('org.junit.jupiter:junit-jupiter')
+    testImplementation('org.assertj:assertj-core')
 }
 
 test {

src/main/java/domain/Calculator.java

@@ -0,0 +1,25 @@
+package domain;
+
+public class Calculator {
+
+    private static final String DIVIDE_BY_ZERO_ERROR_MESSAGE = "[ERROR] 0으로 나눌 수 없습니다.";
+
+    public int add(int firstNumber, int secondNumber) {
+        return firstNumber + secondNumber;
+    }
+
+    public int subtract(int firstNumber, int secondNumber) {
+        return firstNumber - secondNumber;
+    }
+
+    public int multiply(int firstNumber, int secondNumber) {
+        return firstNumber * secondNumber;
+    }
+
+    public int divide(int firstNumber, int secondNumber) {
+        if (secondNumber == 0) {
+            throw new IllegalArgumentException(DIVIDE_BY_ZERO_ERROR_MESSAGE);
+        }
+        return firstNumber / secondNumber;
+    }
+}

src/main/java/domain/Delimiters.java

@@ -0,0 +1,39 @@
+package domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Delimiters {
+
+    private static final String COMMA = ",";
+    private static final String COLON = ":";
+    private static final List<String> DEFAULT_DELIMITERS = List.of(COMMA, COLON);
+
+    private final List<String> delimiters = new ArrayList<>(DEFAULT_DELIMITERS);
+
+    public void registerCustomDelimiter(String customDelimiter) {
+        validate(customDelimiter);
+        delimiters.add(customDelimiter);
+    }
+
+    public List<String> getDelimiters() {
+        return new ArrayList<>(delimiters);
+    }
+
+    private void validate(String customDelimiter) {
+        validateNotBlank(customDelimiter);
+        validateNotDuplicate(customDelimiter);
+    }
+
+    private void validateNotBlank(String customDelimiter) {
+        if (customDelimiter == null || customDelimiter.isBlank()) {
+            throw new IllegalArgumentException("[ERROR] 커스텀 구분자는 비어 있을 수 없습니다.");
+        }
+    }
+
+    private void validateNotDuplicate(String customDelimiter) {
+        if (delimiters.contains(customDelimiter)) {
+            throw new IllegalArgumentException("[ERROR] 이미 등록된 구분자입니다.");
+        }
+    }
+}

src/main/java/domain/PositiveNumber.java

@@ -0,0 +1,43 @@
+package domain;
+
+import java.util.Objects;
+
+public class PositiveNumber {
+
+    private static final String ERROR_NEGATIVE_NUMBER = "[ERROR] 숫자는 0 이상이어야 합니다.";
+
+    private final int positiveNumber;
+
+    public PositiveNumber(int positiveNumber) {
+        validateNonNegative(positiveNumber);
+        this.positiveNumber = positiveNumber;
+    }
+
+    private void validateNonNegative(int positiveNumber) {
+        if (positiveNumber < 0) {
+            throw new IllegalArgumentException(ERROR_NEGATIVE_NUMBER);
+        }
+    }
+
+    public int getPositiveNumber() {
+        return positiveNumber;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PositiveNumber that = (PositiveNumber) o;
+        return positiveNumber == that.positiveNumber;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(positiveNumber);
+    }
+
+    @Override
+    public String toString() {
+        return String.valueOf(positiveNumber);
+    }
+}

src/main/java/domain/PositiveNumbers.java

@@ -0,0 +1,23 @@
+package domain;
+
+import utils.NumberParser;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PositiveNumbers {
+
+    private final List<PositiveNumber> positiveNumbers;
+
+    public PositiveNumbers(List<String> tokens) {
+        this.positiveNumbers = tokens.stream()
+                .map(NumberParser::parse)
+                .collect(Collectors.toCollection(ArrayList::new));
+    }
+
+    public int sum() {
+        return positiveNumbers.stream()
+                .mapToInt(PositiveNumber::getPositiveNumber)
+                .sum();
+    }
+}

src/main/java/domain/StringCalculator.java

@@ -0,0 +1,47 @@
+package domain;
+
+import utils.ExpressionSplitter;
+
+import java.util.List;
+
+public class StringCalculator {
+
+    private final Delimiters delimiters;
+    private final ExpressionSplitter splitter;
+
+    public StringCalculator() {
+        this.delimiters = new Delimiters();
+        this.splitter = new ExpressionSplitter(delimiters);
+    }
+
+    public int calculateSum(String expression) {
+        if (isEmpty(expression)) {
+            return 0;
+        }
+
+        String numbersExpression = extract(expression);
+        List<String> tokens = splitter.split(numbersExpression);
+        PositiveNumbers positiveNumbers = new PositiveNumbers(tokens);
+
+        return positiveNumbers.sum();
+    }
+
+    private boolean isEmpty(String expression) {
+        return expression == null || expression.isBlank();
+    }
+
+    private String extract(String expression) {
+        final String prefix = "//";
+        final String suffix = "\n";
+        if (!expression.startsWith(prefix)) {
+            return expression;
+        }
+        int endIndex = expression.indexOf(suffix);
+        if (endIndex == -1) {
+            throw new IllegalArgumentException("[ERROR] 커스텀 구분자 형식이 잘못되었습니다.");
+        }
+        String customDelimiter = expression.substring(prefix.length(), endIndex);
+        delimiters.registerCustomDelimiter(customDelimiter);
+        return expression.substring(endIndex + 1);
+    }
+}

src/main/java/utils/ExpressionSplitter.java

@@ -0,0 +1,24 @@
+package utils;
+
+import domain.Delimiters;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public class ExpressionSplitter {
+
+    private final Delimiters delimiters;
+
+    public ExpressionSplitter(Delimiters delimiters) {
+        this.delimiters = delimiters;
+    }
+
+    public List<String> split(String expression) {
+        String regex = delimiters.getDelimiters().stream()
+                .map(Pattern::quote)
+                .collect(Collectors.joining("|"));
+        return Arrays.asList(expression.split(regex));
+    }
+}

src/main/java/utils/NumberParser.java

@@ -0,0 +1,17 @@
+package utils;
+
+import domain.PositiveNumber;
+
+public class NumberParser {
+
+    private static final String ERROR_NOT_A_NUMBER = "[ERROR] 입력은 숫자여야 합니다.";
+
+    public static PositiveNumber parse(String input) {
+        try {
+            int number = Integer.parseInt(input);
+            return new PositiveNumber(number);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException(ERROR_NOT_A_NUMBER);
+        }
+    }
+}

src/test/java/domain/CalculatorTest.java

@@ -0,0 +1,77 @@
+package domain;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.*;
+
+class CalculatorTest {
+
+    private final Calculator calculator = new Calculator();
+
+    @ParameterizedTest
+    @CsvSource({
+            "1, 2, 3",
+            "3, 5, 8",
+            "-1, -2, -3",
+            "-5, 5, 0"
+    })
+    @DisplayName("덧셈: 두 수를 더한 결과를 반환한다.")
+    void addMethod(int firstNumber, int secondNumber, int expected) {
+        int result = calculator.add(firstNumber, secondNumber);
+        assertThat(expected).isEqualTo(result);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "5, 2, 3",
+            "10, 5, 5",
+            "0, 0, 0",
+            "-5, -5, 0"
+    })
+    @DisplayName("뺄셈: 두 수를 뺀 결과를 반환한다.")
+    void subtractMethod(int firstNumber, int secondNumber, int expected) {
+        int result = calculator.subtract(firstNumber, secondNumber);
+        assertThat(expected).isEqualTo(result);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "2, 3, 6",
+            "-2, 3, -6",
+            "0, 5, 0",
+            "-3, -3, 9"
+    })
+    @DisplayName("곱셈: 두 수를 곱한 결과를 반환한다.")
+    void multiplyMethod(int firstNumber, int secondNumber, int expected) {
+        int result = calculator.multiply(firstNumber, secondNumber);
+        assertThat(expected).isEqualTo(result);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "6, 3, 2",
+            "9, 3, 3",
+            "-9, 3, -3",
+            "10, -2, -5"
+    })
+    @DisplayName("나눗셈: 두 수를 나눈 결과를 반환한다.")
+    void divideMethod(int firstNumber, int secondNumber, int expected) {
+        int result = calculator.divide(firstNumber, secondNumber);
+        assertThat(expected).isEqualTo(result);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "5, 0",
+            "0, 0",
+            "-3, 0"
+    })
+    @DisplayName("나눗셈: 0으로 나누면 IllegalArgumentException이 발생한다.")
+    void divideByZeroException(int firstNumber, int secondNumber) {
+        assertThatThrownBy(() -> calculator.divide(firstNumber, secondNumber))
+                .isInstanceOf(IllegalArgumentException.class);
+
+    }
+}