diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 000000000..181426ad5
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,11 @@
+# 지하철 노선도 경로 조회
+
+## 기능 요구사항
+
+- 경로 조회 기능을 제공한다.
+  - 경로 조회 기준은 최단 거리 / 최소 시간 의 두 가지 기준을 사용한다.
+  - 경로 조회 기준을 선택한다.
+    - 잘못된 메뉴 입력시 예외 발생
+      - 1, 2를 제외한 모든 입력에서 예외 발생
+  - 출발열과 도착역을 입력하면 경로 조회 기준에 따라 조회 결과를 출력한다.
+    - [EXCEPTION] 출발 역과 도착 역이 같으면 예외 발생
\ No newline at end of file
diff --git a/src/main/java/subway/Application.java b/src/main/java/subway/Application.java
index 0bcf786cc..de0399db1 100644
--- a/src/main/java/subway/Application.java
+++ b/src/main/java/subway/Application.java
@@ -1,10 +1,76 @@
 package subway;
 
 import java.util.Scanner;
+import subway.controller.exception.RetryHandler;
+import subway.domain.PathResult;
+import subway.domain.Station;
+import subway.domain.SubwayService;
+import subway.domain.repository.RepositoryConfig;
+import subway.domain.repository.StationRepository;
+import subway.view.View;
 
 public class Application {
+    private static final View view = new View();
+    private static final RetryHandler handler = new RetryHandler();
+    private static SubwayService subwayService;
+
     public static void main(String[] args) {
         final Scanner scanner = new Scanner(System.in);
-        // TODO: 프로그램 구현
+        RepositoryConfig.initRepository();
+        subwayService = new SubwayService();
+
+        handler.runOrRetry(() -> run(scanner));
+    }
+
+    public static void run(Scanner scanner){
+        while(true) {
+            view.printMenuView();
+            String input = scanner.nextLine();
+            if (input.equals("Q")) {
+                return;
+            }
+            if (input.equals("1")) {
+                handler.runOrRetry(() -> findPath(scanner));
+                continue;
+            }
+            throw new IllegalArgumentException("잘못된 메뉴 입력입니다.");
+        }
+    }
+
+    private static void findPath(Scanner scanner) {
+        view.printPathMenu();
+        String input = scanner.nextLine();
+        if (input.equals("B")) {
+            return;
+        }
+        if (input.equals("1") || input.equals("2")) {
+            _findPath(scanner, input);
+            return;
+        }
+
+        //todo
+        throw new IllegalArgumentException("잘못된 메뉴 입력입니다.");
     }
+
+    private static void _findPath(Scanner scanner, String input) {
+        view.guideStartStation();
+        Station start = getStation(scanner);
+        view.guideEndStation();
+        Station end = getStation(scanner);
+        PathResult result = null;
+        if(input.equals("1")){
+            result = subwayService.findShortestPath(start, end);
+        }
+        if (input.equals("2")) {
+            result = subwayService.findFastestPath(start, end);
+        }
+        view.printPathResult(result);
+    }
+
+    private static Station getStation(Scanner scanner) {
+        String stationName = scanner.nextLine();
+        return StationRepository.getStationByName(stationName);
+    }
+
+
 }
diff --git a/src/main/java/subway/controller/SubwayController.java b/src/main/java/subway/controller/SubwayController.java
new file mode 100644
index 000000000..6db2c51d6
--- /dev/null
+++ b/src/main/java/subway/controller/SubwayController.java
@@ -0,0 +1,37 @@
+package subway.controller;
+
+import subway.view.View;
+
+public class SubwayController {
+    private final View view;
+
+    public SubwayController(View view) {
+        this.view = view;
+    }
+    //todo Button 사용 가능할지 고민해 보기
+
+    /*
+    경로 기준은 경로 탐색 전략을 결정해 준다.
+    이후 시작, 끝 점을 사용해 경로를 탐색한다.
+
+
+    1. 전략 선택 (최단 거리 / 최단 시간)
+    2. 시작 / 끝 역 선택
+    3. 경로 구함
+    4. 결과 출력
+        - 총 거리
+        - 총 시간
+        - 경로 내 모든 역 (이건 라이브러리의 반환 결과 사용하면 됨)
+
+        -> 총 거리, 총 시간은 라이브러리 반환 결과의 경로를 이용해 구하는 것이 맞는 것 같음
+        -> A-B-C-D 경로일 경우
+        각 `Line`을 순회하면서 `A-B` 경로가 존재하는지 확인 후 거리와 시간을 가져온다.
+
+        그럼 경로 정보는 `Line`이 가지고 있어야 하겠네
+
+        StationRepository 는 그냥 입력받은 역들이 존재하는 역인지 판단하는 역할 이상은 못할 것 같음
+
+     */
+
+
+}
diff --git a/src/main/java/subway/controller/exception/RetryHandler.java b/src/main/java/subway/controller/exception/RetryHandler.java
new file mode 100644
index 000000000..f376ed590
--- /dev/null
+++ b/src/main/java/subway/controller/exception/RetryHandler.java
@@ -0,0 +1,33 @@
+package subway.controller.exception;
+
+import java.util.function.Supplier;
+import subway.view.View;
+
+public class RetryHandler {
+    private final View view = new View();
+
+    public <T> T getOrRetry(Supplier<T> supplier){
+        while(true){
+            try {
+                return supplier.get();
+            } catch (IllegalArgumentException e){
+                view.printException(e.getMessage());
+            } finally {
+                view.printLine();
+            }
+        }
+    }
+
+    public void runOrRetry(Runnable runnable){
+        while(true){
+            try {
+                runnable.run();
+                return;
+            } catch (IllegalArgumentException e){
+                view.printException(e.getMessage());
+            } finally {
+                view.printLine();
+            }
+        }
+    }
+}
diff --git a/src/main/java/subway/domain/Line.java b/src/main/java/subway/domain/Line.java
index f4d738d5a..ddb708bf9 100644
--- a/src/main/java/subway/domain/Line.java
+++ b/src/main/java/subway/domain/Line.java
@@ -1,7 +1,14 @@
 package subway.domain;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
 public class Line {
     private String name;
+    private final Set<UnitPath> paths = new HashSet<>();
 
     public Line(String name) {
         this.name = name;
@@ -12,4 +19,17 @@ public String getName() {
     }
 
     // 추가 기능 구현
+    public void addPath(UnitPath path){
+        paths.add(path);
+    }
+
+    public Optional<UnitPath> getPathOf(Station start, Station end) {
+        return paths.stream()
+                .filter(path -> path.isPathOf(start, end))
+                .findFirst();
+    }
+
+    public Set<UnitPath> getPaths() {
+        return Collections.unmodifiableSet(paths);
+    }
 }
diff --git a/src/main/java/subway/domain/PathResult.java b/src/main/java/subway/domain/PathResult.java
new file mode 100644
index 000000000..aee02ae9e
--- /dev/null
+++ b/src/main/java/subway/domain/PathResult.java
@@ -0,0 +1,27 @@
+package subway.domain;
+
+import java.util.List;
+
+public class PathResult {
+    private final List<Station> stations;
+    private final int time;
+    private final int distance;
+
+    public PathResult(List<Station> stations, int time, int distance) {
+        this.stations = stations;
+        this.time = time;
+        this.distance = distance;
+    }
+
+    public List<Station> getStations() {
+        return stations;
+    }
+
+    public int getTime() {
+        return time;
+    }
+
+    public int getDistance() {
+        return distance;
+    }
+}
diff --git a/src/main/java/subway/domain/Station.java b/src/main/java/subway/domain/Station.java
index bdb142590..698cc3982 100644
--- a/src/main/java/subway/domain/Station.java
+++ b/src/main/java/subway/domain/Station.java
@@ -1,5 +1,7 @@
 package subway.domain;
 
+import java.util.Objects;
+
 public class Station {
     private String name;
 
@@ -12,4 +14,31 @@ public String getName() {
     }
 
     // 추가 기능 구현
+    public boolean isName(String name) {
+        return this.name.equals(name);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Station station = (Station) o;
+        return Objects.equals(name, station.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+
+    @Override
+    public String toString() {
+        return "Station{" +
+                "name='" + name + '\'' +
+                '}';
+    }
 }
diff --git a/src/main/java/subway/domain/SubwayService.java b/src/main/java/subway/domain/SubwayService.java
new file mode 100644
index 000000000..414b6a009
--- /dev/null
+++ b/src/main/java/subway/domain/SubwayService.java
@@ -0,0 +1,32 @@
+package subway.domain;
+
+import org.jgrapht.GraphPath;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import subway.domain.pathFinder.DistancePathFinder;
+import subway.domain.pathFinder.StationPathFinder;
+import subway.domain.pathFinder.TimePathFinder;
+import subway.domain.repository.PathRepository;
+
+public class SubwayService {
+    private static final StationPathFinder timePathFinder = new TimePathFinder();
+    private static final StationPathFinder distanceFinder = new DistancePathFinder();
+
+    public PathResult findShortestPath(Station start, Station end) {
+        GraphPath<Station, DefaultWeightedEdge> path = findPath(distanceFinder, start, end);
+        int time = PathRepository.getTotalTime(path.getVertexList());
+        return new PathResult(path.getVertexList(), time, (int)path.getWeight());
+    }
+
+    public PathResult findFastestPath(Station start, Station end) {
+        GraphPath<Station, DefaultWeightedEdge> path = findPath(timePathFinder, start, end);
+        int distance = PathRepository.getTotalDistance(path.getVertexList());
+        return new PathResult(path.getVertexList(), (int) path.getWeight(), distance);
+    }
+    private GraphPath<Station, DefaultWeightedEdge> findPath(StationPathFinder pathFinder, Station start, Station end) {
+        if(start.equals(end)){
+            throw new IllegalArgumentException("출발역과 도착역이 동일합니다.");
+        }
+        return pathFinder.findPath(start, end);
+    }
+
+}
diff --git a/src/main/java/subway/domain/UnitPath.java b/src/main/java/subway/domain/UnitPath.java
new file mode 100644
index 000000000..6a3ea3678
--- /dev/null
+++ b/src/main/java/subway/domain/UnitPath.java
@@ -0,0 +1,45 @@
+package subway.domain;
+
+import java.util.Set;
+
+public class UnitPath {
+    private final Station start;
+    private final Station end;
+
+    //todo 아래 두 값 래핑
+    private final int time;
+    private final int distance;
+
+    public UnitPath(Station start, Station end, int time, int distance) {
+        this.start = start;
+        this.end = end;
+        this.time = time;
+        this.distance = distance;
+    }
+
+    public boolean isPathOf(Station start, Station end) {
+        if (this.start.equals(start) && this.end.equals(end)) {
+            return true;
+        }
+        if (this.start.equals(end) && this.end.equals(start)) {
+            return true;
+        }
+        return false;
+    }
+
+    public Station getEnd() {
+        return end;
+    }
+
+    public Station getStart() {
+        return start;
+    }
+
+    public int getDistance() {
+        return distance;
+    }
+
+    public int getTime() {
+        return time;
+    }
+}
diff --git a/src/main/java/subway/domain/pathFinder/DistancePathFinder.java b/src/main/java/subway/domain/pathFinder/DistancePathFinder.java
new file mode 100644
index 000000000..9e8de580e
--- /dev/null
+++ b/src/main/java/subway/domain/pathFinder/DistancePathFinder.java
@@ -0,0 +1,15 @@
+package subway.domain.pathFinder;
+
+import subway.domain.repository.LineRepository;
+import subway.domain.UnitPath;
+
+public class DistancePathFinder extends StationPathFinder{
+    public DistancePathFinder() {
+        super();
+    }
+
+    @Override
+    protected int getCost(UnitPath path) {
+        return path.getDistance();
+    }
+}
diff --git a/src/main/java/subway/domain/pathFinder/StationPathFinder.java b/src/main/java/subway/domain/pathFinder/StationPathFinder.java
new file mode 100644
index 000000000..151a3c51c
--- /dev/null
+++ b/src/main/java/subway/domain/pathFinder/StationPathFinder.java
@@ -0,0 +1,41 @@
+package subway.domain.pathFinder;
+
+import java.util.Set;
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.jgrapht.graph.WeightedMultigraph;
+import subway.domain.Line;
+import subway.domain.repository.LineRepository;
+import subway.domain.Station;
+import subway.domain.UnitPath;
+
+public abstract class StationPathFinder {
+
+    private final DijkstraShortestPath<Station, DefaultWeightedEdge> dijkstraShortestPath;
+    public StationPathFinder(){
+        WeightedMultigraph<Station, DefaultWeightedEdge> graph = new WeightedMultigraph<>(DefaultWeightedEdge.class);
+        LineRepository.lines().stream()
+                .map(Line::getPaths)
+                .flatMap(Set::stream)
+                .forEach(path -> addPathToGraph(graph, path));
+
+        this.dijkstraShortestPath = new DijkstraShortestPath<>(graph);
+    }
+
+    public GraphPath<Station, DefaultWeightedEdge> findPath(Station start, Station end){
+        return dijkstraShortestPath.getPath(start, end);
+    }
+
+    private void addPathToGraph(WeightedMultigraph<Station, DefaultWeightedEdge> graph, UnitPath path) {
+        graph.addVertex(path.getStart());
+        graph.addVertex(path.getEnd());
+        int cost = getCost(path);
+
+        graph.setEdgeWeight(graph.addEdge(path.getStart(), path.getEnd()), cost);
+        graph.setEdgeWeight(graph.addEdge(path.getEnd(), path.getStart()), cost);
+
+    }
+
+    abstract protected int getCost(UnitPath path);
+}
diff --git a/src/main/java/subway/domain/pathFinder/TimePathFinder.java b/src/main/java/subway/domain/pathFinder/TimePathFinder.java
new file mode 100644
index 000000000..1acbf6e47
--- /dev/null
+++ b/src/main/java/subway/domain/pathFinder/TimePathFinder.java
@@ -0,0 +1,14 @@
+package subway.domain.pathFinder;
+
+import subway.domain.UnitPath;
+
+public class TimePathFinder extends StationPathFinder{
+    public TimePathFinder() {
+        super();
+    }
+
+    @Override
+    protected int getCost(UnitPath path) {
+        return path.getTime();
+    }
+}
diff --git a/src/main/java/subway/domain/LineRepository.java b/src/main/java/subway/domain/repository/LineRepository.java
similarity index 73%
rename from src/main/java/subway/domain/LineRepository.java
rename to src/main/java/subway/domain/repository/LineRepository.java
index 2c4a723c9..f4dcd24fc 100644
--- a/src/main/java/subway/domain/LineRepository.java
+++ b/src/main/java/subway/domain/repository/LineRepository.java
@@ -1,10 +1,16 @@
-package subway.domain;
+package subway.domain.repository;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import subway.domain.Line;
+import subway.domain.Station;
 
+/*
+ * Repository 는 어떻게 사용해야 하나
+ * 필요한 정보 : 각 역 사이의 거리/시간 정보
+ */
 public class LineRepository {
     private static final List<Line> lines = new ArrayList<>();
 
diff --git a/src/main/java/subway/domain/repository/PathRepository.java b/src/main/java/subway/domain/repository/PathRepository.java
new file mode 100644
index 000000000..8e5aa29b4
--- /dev/null
+++ b/src/main/java/subway/domain/repository/PathRepository.java
@@ -0,0 +1,41 @@
+package subway.domain.repository;
+
+import java.util.HashSet;
+import java.util.List;
+import subway.domain.Station;
+import subway.domain.UnitPath;
+
+public class PathRepository {
+    private static HashSet<UnitPath> paths = new HashSet<>();
+
+    public static void addPath(UnitPath path){
+        paths.add(path);
+    }
+
+    public static int getTotalTime(List<Station> totalPath){
+        int time = 0;
+        for (int i = 0; i < totalPath.size() - 1; i++) {
+            int finalI = i;
+            UnitPath unitPath =
+                    paths.stream()
+                    .filter(path -> path.isPathOf(totalPath.get(finalI), totalPath.get(finalI + 1)))
+                    .findFirst()
+                    .orElseThrow(IllegalArgumentException::new);
+            time += unitPath.getTime();
+        }
+        return time;
+    }
+
+    public static int getTotalDistance(List<Station> totalPath){
+        int distance = 0;
+        for (int i = 0; i < totalPath.size() - 1; i++) {
+            int finalI = i;
+            UnitPath unitPath = paths.stream()
+                    .filter(path -> path.isPathOf(totalPath.get(finalI), totalPath.get(finalI + 1)))
+                    .findFirst()
+                    .orElseThrow(IllegalArgumentException::new);
+            distance += unitPath.getDistance();
+        }
+        return distance;
+    }
+}
diff --git a/src/main/java/subway/domain/repository/RepositoryConfig.java b/src/main/java/subway/domain/repository/RepositoryConfig.java
new file mode 100644
index 000000000..ff54c5a2a
--- /dev/null
+++ b/src/main/java/subway/domain/repository/RepositoryConfig.java
@@ -0,0 +1,65 @@
+package subway.domain.repository;
+
+import java.util.Set;
+import subway.domain.Line;
+import subway.domain.Station;
+import subway.domain.UnitPath;
+
+public class RepositoryConfig {
+
+    public static void initRepository(){
+        initStationRepository();
+        initLineRepository();
+        initPathRepository();
+    }
+
+    private static void initStationRepository(){
+        //todo enum 추출 가능할 듯 - 근데 class로 이미 있어서 의미 있나
+        addStationToRepository(new Station("교대역"));
+        addStationToRepository(new Station("강남역"));
+        addStationToRepository(new Station("역삼역"));
+        addStationToRepository(new Station("남부터미널역"));
+        addStationToRepository(new Station("양재역"));
+        addStationToRepository(new Station("매봉역"));
+        addStationToRepository(new Station("양재시민의숲"));
+    }
+
+    public static void addStationToRepository(Station station){
+        if(StationRepository.contains(station)){
+            return;
+        }
+        StationRepository.addStation(station);
+    }
+
+    private static void initLineRepository() {
+        Line line2 = new Line("2호선");
+        line2.addPath(makePath("교대역", "강남역", 2, 3));
+        line2.addPath(makePath("강남역", "역삼역", 2, 3));
+        LineRepository.addLine(line2);
+
+        Line line3 = new Line("3호선");
+        line3.addPath(makePath("교대역", "남부터미널역", 3, 2));
+        line3.addPath(makePath("남부터미널역", "양재역", 6, 5));
+        line3.addPath(makePath("양재역", "매봉역", 1, 1));
+        LineRepository.addLine(line3);
+
+        Line shinbundang = new Line("신분당선");
+        shinbundang.addPath(makePath("강남역", "양재역", 2, 8));
+        shinbundang.addPath(makePath("양재역", "양재시민의숲", 10, 3));
+        LineRepository.addLine(shinbundang);
+    }
+
+    public static UnitPath makePath(String startName, String endName, int distance, int time) {
+        Station start = StationRepository.getStationByName(startName);
+        Station end = StationRepository.getStationByName(endName);
+        return new UnitPath(start, end, time, distance);
+    }
+
+    private static void initPathRepository(){
+        LineRepository.lines().stream()
+                .map(Line::getPaths)
+                .flatMap(Set::stream)
+                .forEach(PathRepository::addPath);
+
+    }
+}
diff --git a/src/main/java/subway/domain/StationRepository.java b/src/main/java/subway/domain/repository/StationRepository.java
similarity index 54%
rename from src/main/java/subway/domain/StationRepository.java
rename to src/main/java/subway/domain/repository/StationRepository.java
index 8ed9d103f..27ce1a86f 100644
--- a/src/main/java/subway/domain/StationRepository.java
+++ b/src/main/java/subway/domain/repository/StationRepository.java
@@ -1,9 +1,10 @@
-package subway.domain;
+package subway.domain.repository;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
+import subway.domain.Station;
 
 public class StationRepository {
     private static final List<Station> stations = new ArrayList<>();
@@ -23,4 +24,17 @@ public static boolean deleteStation(String name) {
     public static void deleteAll() {
         stations.clear();
     }
+
+    //
+    public static boolean contains(Station input) {
+        return stations.stream()
+                .anyMatch(station -> station.equals(input));
+    }
+
+    public static Station getStationByName(String name){
+        return stations.stream()
+                .filter(station -> station.isName(name))
+                .findFirst()
+                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 역 이름입니다."));
+    }
 }
diff --git a/src/main/java/subway/view/View.java b/src/main/java/subway/view/View.java
new file mode 100644
index 000000000..2f3ce05c9
--- /dev/null
+++ b/src/main/java/subway/view/View.java
@@ -0,0 +1,69 @@
+package subway.view;
+
+import java.util.List;
+import subway.domain.PathResult;
+import subway.domain.Station;
+import subway.view.io.Printer;
+
+public class View {
+
+    //todo 각 입력에 대해 실행할 메서드를 enum이 가지게 하면?
+    private final Printer printer = new Printer();
+
+    public void printMenuView() {
+        printer.printMessage("## 메인 화면");
+        printer.printMessage("1. 경로 조회");
+        printer.printMessage("Q. 종료");
+        printer.printMessage("");
+        printChooseMenu();
+    }
+
+    public void printPathMenu(){
+        printer.printMessage("## 경로 기준");
+        printer.printMessage("1. 최단 거리");
+        printer.printMessage("2. 최소 시간");
+        printer.printMessage("B. 돌아가기");
+        printer.printMessage("");
+        printChooseMenu();
+    }
+
+    private void printChooseMenu(){
+        printer.printMessage("## 원하는 기능을 선택하세요.");
+
+    }
+
+    public void printInfo(String infoMessage) {
+        //todo 상수 추출
+        printer.printMessage("[INFO] " + infoMessage);
+    }
+
+    public void printException(String exceptionMessage) {
+        //todo 상수 추출
+        printer.printMessage("[ERROR] " + exceptionMessage);
+    }
+
+    public void printLine() {
+        printer.printMessage("");
+    }
+
+    public void printPathResult(PathResult result) {
+        printer.printMessage("## 조회 결과");
+                printInfo("---");
+                printInfo("총 거리: " + result.getDistance() + "km");
+                printInfo("총 소요 시간: " + result.getTime() + "분");
+                printInfo("---");
+                printStations(result.getStations());
+    }
+
+    private void printStations(List<Station> stations){
+        stations.forEach(station -> printInfo(station.getName()));
+    }
+
+    public void guideStartStation() {
+        printer.printMessage("## 출발역을 입력하세요.");
+    }
+
+    public void guideEndStation() {
+        printer.printMessage("## 도착역을 입력하세요.");
+    }
+}
diff --git a/src/main/java/subway/view/io/Printer.java b/src/main/java/subway/view/io/Printer.java
new file mode 100644
index 000000000..f1bd85f96
--- /dev/null
+++ b/src/main/java/subway/view/io/Printer.java
@@ -0,0 +1,8 @@
+package subway.view.io;
+
+public class Printer {
+    public void printMessage(String message) {
+        System.out.println(message);
+    }
+
+}
diff --git a/src/test/java/subway/JGraphtTest.java b/src/test/java/subway/JGraphtTest.java
index 4f5f76536..8d3d14f4b 100644
--- a/src/test/java/subway/JGraphtTest.java
+++ b/src/test/java/subway/JGraphtTest.java
@@ -1,5 +1,6 @@
 package subway;
 
+import org.jgrapht.GraphPath;
 import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
 import org.jgrapht.graph.DefaultWeightedEdge;
 import org.jgrapht.graph.WeightedMultigraph;
@@ -25,4 +26,35 @@ public void getDijkstraShortestPath() {
 
         assertThat(shortestPath.size()).isEqualTo(3);
     }
+
+    @Test
+    public void 학습_테스트() {
+        WeightedMultigraph<String, DefaultWeightedEdge> graph = new WeightedMultigraph(DefaultWeightedEdge.class);
+        graph.addVertex("v1");
+        graph.addVertex("v2");
+        graph.addVertex("v3");
+        graph.addVertex("v4");
+        graph.addVertex("v5");
+        graph.setEdgeWeight(graph.addEdge("v1", "v2"), 2);
+        graph.setEdgeWeight(graph.addEdge("v1", "v3"), 7);
+        graph.setEdgeWeight(graph.addEdge("v1", "v4"), 8);
+        graph.setEdgeWeight(graph.addEdge("v1", "v5"), 5);
+
+        graph.setEdgeWeight(graph.addEdge("v2", "v3"), 2);
+        graph.setEdgeWeight(graph.addEdge("v2", "v4"), 4);
+        graph.setEdgeWeight(graph.addEdge("v2", "v5"), 8);
+
+        graph.setEdgeWeight(graph.addEdge("v3", "v4"), 11);
+        graph.setEdgeWeight(graph.addEdge("v3", "v5"), 7);
+
+        graph.setEdgeWeight(graph.addEdge("v4", "v5"), 8);
+
+        DijkstraShortestPath dijkstraShortestPath = new DijkstraShortestPath(graph);
+
+        GraphPath path = dijkstraShortestPath.getPath("v4", "v1");
+        List<String> shortestPath = path.getVertexList();
+        System.out.println(shortestPath);
+
+        assertThat(shortestPath.size()).isEqualTo(3);
+    }
 }
diff --git a/src/test/java/subway/domain/SubwayServiceTest.java b/src/test/java/subway/domain/SubwayServiceTest.java
new file mode 100644
index 000000000..93704285a
--- /dev/null
+++ b/src/test/java/subway/domain/SubwayServiceTest.java
@@ -0,0 +1,8 @@
+package subway.domain;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SubwayServiceTest {
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/subway/domain/pathFinder/TimePathFinderTest.java b/src/test/java/subway/domain/pathFinder/TimePathFinderTest.java
new file mode 100644
index 000000000..28c69e903
--- /dev/null
+++ b/src/test/java/subway/domain/pathFinder/TimePathFinderTest.java
@@ -0,0 +1,41 @@
+package subway.domain.pathFinder;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.assertj.core.api.Assertions;
+import org.jgrapht.GraphPath;
+import org.jgrapht.graph.DefaultWeightedEdge;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import subway.domain.Station;
+import subway.domain.repository.RepositoryConfig;
+import subway.domain.repository.StationRepository;
+
+class TimePathFinderTest {
+    TimePathFinder pathFinder;
+
+    @BeforeEach
+    void initRepository(){
+        RepositoryConfig.initRepository();
+        pathFinder = new TimePathFinder();
+    }
+
+    @ParameterizedTest
+    @CsvSource({"교대역,양재역,7,2",
+    "강남역,매봉역,9,2"})
+    void 정상_결과_테스트(String startName, String endName, int time, int length){
+        Station start = StationRepository.getStationByName(startName);
+        Station end = StationRepository.getStationByName(endName);
+        GraphPath<Station, DefaultWeightedEdge> path = pathFinder.findPath(start, end);
+        System.out.println(path.getVertexList());
+        Assertions.assertThat(path.getWeight())
+                .isEqualTo(time);
+        Assertions.assertThat(path.getLength())
+                .isEqualTo(length);
+    }
+
+    /*
+     */
+}
\ No newline at end of file