🚀 2단계 - 요금 조회

src/main/java/nextstep/subway/applicaion/dto/PathResponse.java

@@ -9,11 +9,13 @@ public class PathResponse {
     private List<StationResponse> stations;
     private int distance;
     private int duration;
+    private int fare;
 
-    public PathResponse(List<StationResponse> stations, int distance, int duration) {
+    public PathResponse(List<StationResponse> stations, int distance, int duration, int fare) {
         this.stations = stations;
         this.distance = distance;
         this.duration = duration;
+        this.fare = fare;
     }
 
     public static PathResponse of(Path path) {
@@ -22,8 +24,9 @@ public static PathResponse of(Path path) {
                 .collect(Collectors.toList());
         int distance = path.extractDistance();
         int duration = path.extractDuration();
+        int fare = path.getFare();
 
-        return new PathResponse(stations, distance, duration);
+        return new PathResponse(stations, distance, duration, fare);
     }
 
     public List<StationResponse> getStations() {
@@ -37,4 +40,8 @@ public int getDistance() {
     public int getDuration() {
         return duration;
     }
+
+    public int getFare() {
+        return fare;
+    }
 }

src/main/java/nextstep/subway/constant/EdgeWeightFunction.java

@@ -0,0 +1,7 @@
+package nextstep.subway.constant;
+
+@FunctionalInterface
+public interface EdgeWeightFunction<EdgeWeight, Integer>  {
+    Integer apply(EdgeWeight section);
+
+}

src/main/java/nextstep/subway/constant/FindPathType.java

@@ -1,22 +1,24 @@
 package nextstep.subway.constant;
 
+import nextstep.subway.domain.Section;
+
 public enum FindPathType {
-    DISTANCE("DISTANCE", "거리"),
-    DURATION("DURATION", "시간");
+    DISTANCE("DISTANCE", Section::getDistance),
+    DURATION("DURATION", Section::getDuration);
 
     private final String type;
-    private final String description;
+    private final EdgeWeightFunction<Section, Integer> edgeWeightFunction;
 
-    FindPathType(String type, String description) {
+    FindPathType(String type, EdgeWeightFunction<Section, Integer> edgeWeightFunction) {
         this.type = type;
-        this.description = description;
+        this.edgeWeightFunction = edgeWeightFunction;
     }
 
     public String getType() {
         return type;
     }
 
-    public String getDescription() {
-        return description;
+    public Integer getEdgeWeight(Section section) {
+        return edgeWeightFunction.apply(section);
     }
 }

src/main/java/nextstep/subway/domain/CalculateFareFacade.java

@@ -0,0 +1,16 @@
+package nextstep.subway.domain;
+
+public class CalculateFareFacade {
+
+    private final int distance;
+
+    public CalculateFareFacade(int distance) {
+        this.distance = distance;
+    }
+
+    public int calculateFare() {
+        int calculateOverTen = new CalculateOverTen().calculate(distance);
+        int calculateOverFifty = new CalculateOverFifty().calculate(distance);
+        return calculateOverTen + calculateOverFifty;
+    }
+}

src/main/java/nextstep/subway/domain/CalculateOverFifty.java

@@ -0,0 +1,13 @@
+package nextstep.subway.domain;
+
+import static nextstep.subway.domain.Fare.ADDITIONAL_FARE;
+
+public class CalculateOverFifty {
+    public int calculate(int distance) {
+        int overFiftyDistance = distance - 50;
+        if (overFiftyDistance <= 0) {
+            return 0;
+        }
+        return (int) Math.ceil((double) overFiftyDistance / 8) * ADDITIONAL_FARE;
+    }
+}

src/main/java/nextstep/subway/domain/CalculateOverTen.java

@@ -0,0 +1,13 @@
+package nextstep.subway.domain;
+
+import static nextstep.subway.domain.Fare.ADDITIONAL_FARE;
+import static nextstep.subway.domain.Fare.MAX_OVER_TEN_FARE;
+
+public class CalculateOverTen {
+
+    public int calculate(int distance) {
+        int overTenDistance = distance - 10;
+        int fare = (int) ((Math.ceil((double) overTenDistance / 5)) * ADDITIONAL_FARE);
+        return Math.min(fare, MAX_OVER_TEN_FARE);
+    }
+}

src/main/java/nextstep/subway/domain/Fare.java

@@ -0,0 +1,28 @@
+package nextstep.subway.domain;
+
+public class Fare {
+    private static final int DEFAULT_DISTANCE = 10;
+    private static final int BASE_FARE = 1250;
+    public static final int ADDITIONAL_FARE = 100;
+    public static final int MAX_OVER_TEN_FARE = 800;
+
+    private int fare;
+
+    public Fare() {}
+
+    public void init(int distance) {
+        this.fare = generateFare(distance);
+    }
+
+    public int getFare() {
+        return fare;
+    }
+
+    private int generateFare(int distance) {
+        if (distance <= DEFAULT_DISTANCE) {
+            return BASE_FARE;
+        }
+        int additionalFare = new CalculateFareFacade(distance).calculateFare();
+        return BASE_FARE + additionalFare;
+    }
+}

src/main/java/nextstep/subway/domain/Path.java

@@ -21,6 +21,12 @@ public int extractDuration() {
         return sections.totalDuration();
     }
 
+    public int getFare() {
+        Fare fare = new Fare();
+        fare.init(extractDistance());
+        return fare.getFare();
+    }
+
     public List<Station> getStations() {
         return sections.getStations();
     }

src/main/java/nextstep/subway/domain/SectionEdge.java

@@ -1,16 +1,17 @@
 package nextstep.subway.domain;
 
+import nextstep.subway.constant.FindPathType;
 import org.jgrapht.graph.DefaultWeightedEdge;
 
 public class SectionEdge extends DefaultWeightedEdge {
     private Section section;
 
-    public static SectionEdge of(Section section) {
-        return new SectionEdge(section);
+    private SectionEdge(Section section) {
+        this.section = section;
     }
 
-    public SectionEdge(Section section) {
-        this.section = section;
+    public static SectionEdge of(Section section) {
+        return new SectionEdge(section);
     }
 
     public Section getSection() {

src/main/java/nextstep/subway/domain/SubwayMap.java

@@ -56,11 +56,6 @@ public Path findPath(Station source, Station target) {
     private void addEdge(SimpleDirectedWeightedGraph<Station, SectionEdge> graph, Section it) {
         SectionEdge sectionEdge = SectionEdge.of(it);
         graph.addEdge(it.getUpStation(), it.getDownStation(), sectionEdge);
-        if (type == FindPathType.DISTANCE) {
-            graph.setEdgeWeight(sectionEdge, it.getDistance());
-        }
-        if (type == FindPathType.DURATION) {
-            graph.setEdgeWeight(sectionEdge, it.getDuration());
-        }
+        graph.setEdgeWeight(sectionEdge, type.getEdgeWeight(it));
     }
 }

src/test/java/nextstep/subway/acceptance/FavoriteSteps.java

@@ -3,7 +3,6 @@
 import io.restassured.RestAssured;
 import io.restassured.response.ExtractableResponse;
 import io.restassured.response.Response;
-import nextstep.subway.constant.FindPathType;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
 

src/test/java/nextstep/subway/acceptance/PathAcceptanceTest.java

@@ -84,6 +84,33 @@ void findPathByDuration() {
         assertThat(response.jsonPath().getInt("duration")).isEqualTo(21);
     }
 
+    /**
+     * <pre>
+     * Feature: 지하철 경로 검색
+     *  Scenario: 두 역의 최단 거리 경로를 조회
+     *     Given 지하철역이 등록되어있음
+     *     And 지하철 노선이 등록되어있음
+     *     And 지하철 노선에 지하철역이 등록되어있음
+     *     When 출발역에서 도착역까지의 최단 거리 경로 조회를 요청
+     *     Then 최단 거리 경로를 응답
+     *     And 총 거리와 소요 시간을 함께 응답함
+     *     And 지하철 이용 요금도 함께 응답함
+     * </pre>
+     */
+    @DisplayName("두 역의 최소 거리 경로를 조회하고 이용 요금도 함께 응답한다.")
+    @Test
+    void findPathByDistanceReturnFare() {
+        // given : 선행조건 기술
+
+        // when : 기능 수행
+        ExtractableResponse<Response> response = 두_역의_최단_거리_경로_및_소요시간_조회를_요청(교대역, 양재역, FindPathType.DISTANCE.getType());
+
+        // then : 결과 확인
+        assertThat(response.jsonPath().getList("stations.id", Long.class)).containsExactly(교대역, 남부터미널역, 양재역);
+        assertThat(response.jsonPath().getInt("distance")).isEqualTo(5);
+        assertThat(response.jsonPath().getInt("fare")).isEqualTo(1250);
+    }
+
     private Long 지하철_노선_생성_요청(String name, String color, Long upStation, Long downStation, int distance, int duration) {
         Map<String, String> lineCreateParams;
         lineCreateParams = new HashMap<>();

src/test/java/nextstep/subway/documentation/PathDocumentation.java

@@ -31,7 +31,10 @@ void path() {
                 Lists.newArrayList(
                         new StationResponse(1L, "강남역"),
                         new StationResponse(2L, "역삼역")
-                ), 10, 10
+                ),
+                10,
+                10,
+                1250
         );
 
         when(pathService.findPath(anyLong(), anyLong(), any())).thenReturn(pathResponse);
@@ -48,7 +51,8 @@ void path() {
                                 fieldWithPath("stations[].id").description("역 아이디"),
                                 fieldWithPath("stations[].name").description("역 이름"),
                                 fieldWithPath("distance").description("총 거리"),
-                                fieldWithPath("duration").description("총 소요 시간")
+                                fieldWithPath("duration").description("총 소요 시간"),
+                                fieldWithPath("fare").description("총 요금")
                         )));
 
         두_역의_최단_거리_경로_및_소요시간_조회를_요청_문서화(1L, 2L, requestSpecification, FindPathType.DURATION.getType());

src/test/java/nextstep/subway/unit/FareTest.java

@@ -0,0 +1,56 @@
+package nextstep.subway.unit;
+
+
+import nextstep.subway.domain.Fare;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@DisplayName("요금 단위 테스트")
+class FareTest {
+
+    @DisplayName("기본 요금일때 테스트")
+    @Test
+    void defaultFare() {
+        // given
+        int distance = 10;
+
+        // when
+        Fare fare = new Fare();
+        fare.init(distance);
+
+        // then
+        assertThat(fare.getFare()).isEqualTo(1250);
+    }
+
+    @DisplayName("10km초과 ~ 50km까지(5km마다 100원씩 추가) 테스트")
+    @ParameterizedTest
+    @CsvSource(value = {"15:1350","20:1450","25:1550","30:1650","35:1750","40:1850","45:1950","50:2050"}, delimiter = ':')
+    void additionalFare(int distance, int expectedFare) {
+        // given
+
+        // when
+        Fare fare = new Fare();
+        fare.init(distance);
+
+        // then
+        assertThat(fare.getFare()).isEqualTo(expectedFare);
+    }
+
+    @DisplayName("50km초과 ~ 100km까지(8km마다 100원씩 추가) 테스트")
+    @ParameterizedTest
+    @CsvSource(value = {"51:2150","59:2250","66:2250","67:2350","75:2450","83:2550","90:2550","91:2650", "100:2750"}, delimiter = ':')
+    void additionalFare2(int distance, int expectedFare) {
+        // given
+
+        // when
+        Fare fare = new Fare();
+        fare.init(distance);
+
+        // then
+        assertThat(fare.getFare()).isEqualTo(expectedFare);
+    }
+}

src/test/java/nextstep/subway/unit/LineTest.java

@@ -9,8 +9,8 @@
 
 import java.util.List;
 
-import static org.assertj.core.api.Assertions.*;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
 
 class LineTest {