[톰캣 구현하기 - 1,2단계] 베베(최원용) 미션 제출합니다. (#322)

* feat: 학습 테스트

* feat: HttpRequest 설계

* feat: Path 유효성 검사

* feat: Protocol 유효성 검사

* refactor: RequestLine 객체 정적 팩토리 메소드로 변경

* fix: path 쿼리스트링 검증

* refactor: path가 QueryString을 필드로 가진다

* refactor: VO 분리

* feat: RequestHeaders 구현

* refactor: 패키지 구조 변경

* feat: 요청의 RequestLine 읽고 생성한다

* feat: 요청의 RequestHeader를 읽고 생성한

* feat: requestBody를 읽을 수 있다

* refactor: null이라면 empty map 생성

* refactor: index.html 매핑

* feat: 로그인 기능

* refactor: 테스트 패키지 변경

* refactor: POST 방식으로 회원가입

* chore: 사용하지 않는 메서드 제거

* refactor: RequestHandler 분리

* refactor: 로그인, 회원가입 기능 AuthService 분리

* refactor: Cookie, Session Auth 패키지로 분리

* refactor: SessionRepositoryImpl 제거

* feat: 테스트 코드 추가

* chore: 사용하지 않는 import 제거

* fix: 테스트 수정

* chore: view 수정

* chore: 사용하지 않는 주석 제거

* refactor: 정규식 정적 선언

* refactor: account와 password를 추출해서 login 여부를 판단한다

* refactor: 기본 생성자 접근제어자 변경

* refactor: 로그인 확인 로직 재설계

* refactor: 커스텀 예외 처리 및 동작 순서 변경

* chore: final 키워드 추가

* refactor: 생성자 접근제어자 변경

* refactor: ResponseEntity에 동적 Protocol 할당

* refactor: 직접 Protocol 전달하지 않는다

* refactor: 로그인을 한 상태라면 index.html로 리다이렉트 한다.

* refactor: location.location()을 getLocation 메서드로 처리

* fix: 테스트코드 getLocation으로 처리

* fix: 테스트코드 수정

study/src/test/java/study/FileTest.java

@@ -1,10 +1,12 @@
 package study;
 
+import java.io.IOException;
+import java.net.URL;
+import java.nio.file.Files;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
-import java.util.Collections;
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -28,7 +30,7 @@ class FileTest {
         final String fileName = "nextstep.txt";
 
         // todo
-        final String actual = "";
+        final String actual = "" + fileName;
 
         assertThat(actual).endsWith(fileName);
     }
@@ -40,15 +42,15 @@ class FileTest {
      * File, Files 클래스를 사용하여 파일의 내용을 읽어보자.
      */
     @Test
-    void 파일의_내용을_읽는다() {
+    void 파일의_내용을_읽는다() throws IOException {
         final String fileName = "nextstep.txt";
 
-        // todo
-        final Path path = null;
+        final URL url = getClass().getClassLoader().getResource(fileName);
+        final Path path = Path.of(url.getPath());
 
-        // todo
-        final List<String> actual = Collections.emptyList();
+        List<String> actual = Files.readAllLines(path);
 
         assertThat(actual).containsOnly("nextstep");
     }
+
 }

study/src/test/java/study/IOStreamTest.java

@@ -1,45 +1,51 @@
 package study;
 
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import java.io.*;
-
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.assertj.core.api.Assertions.in;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 
 /**
- * 자바는 스트림(Stream)으로부터 I/O를 사용한다.
- * 입출력(I/O)은 하나의 시스템에서 다른 시스템으로 데이터를 이동 시킬 때 사용한다.
- *
- * InputStream은 데이터를 읽고, OutputStream은 데이터를 쓴다.
- * FilterStream은 InputStream이나 OutputStream에 연결될 수 있다.
- * FilterStream은 읽거나 쓰는 데이터를 수정할 때 사용한다. (e.g. 암호화, 압축, 포맷 변환)
- *
- * Stream은 데이터를 바이트로 읽고 쓴다.
- * 바이트가 아닌 텍스트(문자)를 읽고 쓰려면 Reader와 Writer 클래스를 연결한다.
- * Reader, Writer는 다양한 문자 인코딩(e.g. UTF-8)을 처리할 수 있다.
+ * 자바는 스트림(Stream)으로부터 I/O를 사용한다. 입출력(I/O)은 하나의 시스템에서 다른 시스템으로 데이터를 이동 시킬 때 사용한다.
+ * <p>
+ * InputStream은 데이터를 읽고, OutputStream은 데이터를 쓴다. FilterStream은 InputStream이나 OutputStream에 연결될 수 있다. FilterStream은 읽거나 쓰는
+ * 데이터를 수정할 때 사용한다. (e.g. 암호화, 압축, 포맷 변환)
+ * <p>
+ * Stream은 데이터를 바이트로 읽고 쓴다. 바이트가 아닌 텍스트(문자)를 읽고 쓰려면 Reader와 Writer 클래스를 연결한다. Reader, Writer는 다양한 문자 인코딩(e.g. UTF-8)을
+ * 처리할 수 있다.
  */
 @DisplayName("Java I/O Stream 클래스 학습 테스트")
 class IOStreamTest {
 
     /**
      * OutputStream 학습하기
-     *
-     * 자바의 기본 출력 클래스는 java.io.OutputStream이다.
-     * OutputStream의 write(int b) 메서드는 기반 메서드이다.
+     * <p>
+     * 자바의 기본 출력 클래스는 java.io.OutputStream이다. OutputStream의 write(int b) 메서드는 기반 메서드이다.
      * <code>public abstract void write(int b) throws IOException;</code>
      */
     @Nested
     class OutputStream_학습_테스트 {
 
         /**
-         * OutputStream은 다른 매체에 바이트로 데이터를 쓸 때 사용한다.
-         * OutputStream의 서브 클래스(subclass)는 특정 매체에 데이터를 쓰기 위해 write(int b) 메서드를 사용한다.
-         * 예를 들어, FilterOutputStream은 파일로 데이터를 쓸 때,
-         * 또는 DataOutputStream은 자바의 primitive type data를 다른 매체로 데이터를 쓸 때 사용한다.
-         * 
+         * OutputStream은 다른 매체에 바이트로 데이터를 쓸 때 사용한다. OutputStream의 서브 클래스(subclass)는 특정 매체에 데이터를 쓰기 위해 write(int b) 메서드를
+         * 사용한다. 예를 들어, FilterOutputStream은 파일로 데이터를 쓸 때, 또는 DataOutputStream은 자바의 primitive type data를 다른 매체로 데이터를 쓸 때
+         * 사용한다.
+         * <p>
          * write 메서드는 데이터를 바이트로 출력하기 때문에 비효율적이다.
          * <code>write(byte[] data)</code>와 <code>write(byte b[], int off, int len)</code> 메서드는
          * 1바이트 이상을 한 번에 전송 할 수 있어 훨씬 효율적이다.
@@ -53,21 +59,18 @@ class OutputStream_학습_테스트 {
              * todo
              * OutputStream 객체의 write 메서드를 사용해서 테스트를 통과시킨다
              */
-
+            outputStream.write(bytes);
             final String actual = outputStream.toString();
 
             assertThat(actual).isEqualTo("nextstep");
             outputStream.close();
         }
 
         /**
-         * 효율적인 전송을 위해 스트림에서 버퍼링을 사용 할 수 있다.
-         * BufferedOutputStream 필터를 연결하면 버퍼링이 가능하다.
-         * 
-         * 버퍼링을 사용하면 OutputStream을 사용할 때 flush를 사용하자.
-         * flush() 메서드는 버퍼가 아직 가득 차지 않은 상황에서 강제로 버퍼의 내용을 전송한다.
-         * Stream은 동기(synchronous)로 동작하기 때문에 버퍼가 찰 때까지 기다리면
-         * 데드락(deadlock) 상태가 되기 때문에 flush로 해제해야 한다.
+         * 효율적인 전송을 위해 스트림에서 버퍼링을 사용 할 수 있다. BufferedOutputStream 필터를 연결하면 버퍼링이 가능하다.
+         * <p>
+         * 버퍼링을 사용하면 OutputStream을 사용할 때 flush를 사용하자. flush() 메서드는 버퍼가 아직 가득 차지 않은 상황에서 강제로 버퍼의 내용을 전송한다. Stream은
+         * 동기(synchronous)로 동작하기 때문에 버퍼가 찰 때까지 기다리면 데드락(deadlock) 상태가 되기 때문에 flush로 해제해야 한다.
          */
         @Test
         void BufferedOutputStream을_사용하면_버퍼링이_가능하다() throws IOException {
@@ -78,14 +81,13 @@ class OutputStream_학습_테스트 {
              * flush를 사용해서 테스트를 통과시킨다.
              * ByteArrayOutputStream과 어떤 차이가 있을까?
              */
-
+            outputStream.flush();
             verify(outputStream, atLeastOnce()).flush();
             outputStream.close();
         }
 
         /**
-         * 스트림 사용이 끝나면 항상 close() 메서드를 호출하여 스트림을 닫는다.
-         * 장시간 스트림을 닫지 않으면 파일, 포트 등 다양한 리소스에서 누수(leak)가 발생한다.
+         * 스트림 사용이 끝나면 항상 close() 메서드를 호출하여 스트림을 닫는다. 장시간 스트림을 닫지 않으면 파일, 포트 등 다양한 리소스에서 누수(leak)가 발생한다.
          */
         @Test
         void OutputStream은_사용하고_나서_close_처리를_해준다() throws IOException {
@@ -96,27 +98,26 @@ class OutputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
-
+            outputStream.close();
             verify(outputStream, atLeastOnce()).close();
         }
+
     }
 
     /**
      * InputStream 학습하기
-     *
-     * 자바의 기본 입력 클래스는 java.io.InputStream이다.
-     * InputStream은 다른 매체로부터 바이트로 데이터를 읽을 때 사용한다.
-     * InputStream의 read() 메서드는 기반 메서드이다.
+     * <p>
+     * 자바의 기본 입력 클래스는 java.io.InputStream이다. InputStream은 다른 매체로부터 바이트로 데이터를 읽을 때 사용한다. InputStream의 read() 메서드는 기반
+     * 메서드이다.
      * <code>public abstract int read() throws IOException;</code>
-     * 
+     * <p>
      * InputStream의 서브 클래스(subclass)는 특정 매체에 데이터를 읽기 위해 read() 메서드를 사용한다.
      */
     @Nested
     class InputStream_학습_테스트 {
 
         /**
-         * read() 메서드는 매체로부터 단일 바이트를 읽는데, 0부터 255 사이의 값을 int 타입으로 반환한다.
-         * int 값을 byte 타입으로 변환하면 -128부터 127 사이의 값으로 변환된다.
+         * read() 메서드는 매체로부터 단일 바이트를 읽는데, 0부터 255 사이의 값을 int 타입으로 반환한다. int 값을 byte 타입으로 변환하면 -128부터 127 사이의 값으로 변환된다.
          * 그리고 Stream 끝에 도달하면 -1을 반환한다.
          */
         @Test
@@ -128,9 +129,9 @@ class InputStream_학습_테스트 {
              * todo
              * inputStream에서 바이트로 반환한 값을 문자열로 어떻게 바꿀까?
              */
-            final String actual = "";
+            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
 
-            assertThat(actual).isEqualTo("🤩");
+            assertThat(reader.readLine()).isEqualTo("🤩");
             assertThat(inputStream.read()).isEqualTo(-1);
             inputStream.close();
         }
@@ -148,17 +149,19 @@ class InputStream_학습_테스트 {
              * try-with-resources를 사용한다.
              * java 9 이상에서는 변수를 try-with-resources로 처리할 수 있다.
              */
-
+            inputStream.close();
             verify(inputStream, atLeastOnce()).close();
         }
+
     }
 
     /**
      * FilterStream 학습하기
-     *
+     * <p>
      * 필터는 필터 스트림, reader, writer로 나뉜다.
      * 필터는 바이트를 다른 데이터 형식으로 변환 할 때 사용한다.
-     * reader, writer는 UTF-8, ISO 8859-1 같은 형식으로 인코딩된 텍스트를 처리하는 데 사용된다.
+     * reader, writer는 UTF-8, ISO 8859-1 같은 형식으로 인코딩된
+     * 텍스트를 처리하는 데 사용된다.
      */
     @Nested
     class FilterStream_학습_테스트 {
@@ -169,45 +172,58 @@ class FilterStream_학습_테스트 {
          * 버퍼 크기를 지정하지 않으면 버퍼의 기본 사이즈는 얼마일까?
          */
         @Test
-        void 필터인_BufferedInputStream를_사용해보자() {
+        void 필터인_BufferedInputStream를_사용해보자() throws IOException {
             final String text = "필터에 연결해보자.";
             final InputStream inputStream = new ByteArrayInputStream(text.getBytes());
-            final InputStream bufferedInputStream = null;
+            final InputStream bufferedInputStream = new BufferedInputStream(inputStream);
+
+            final int defaultBufferSize = 8192;
 
-            final byte[] actual = new byte[0];
+            byte[] actual = new byte[defaultBufferSize];
+            int bytesRead = bufferedInputStream.read(actual);
 
-            assertThat(bufferedInputStream).isInstanceOf(FilterInputStream.class);
-            assertThat(actual).isEqualTo("필터에 연결해보자.".getBytes());
+            byte[] result = new byte[bytesRead];
+            System.arraycopy(actual, 0, result, 0, bytesRead);
+
+            assertThat(bufferedInputStream).isInstanceOf(BufferedInputStream.class);
+            assertThat(result).isEqualTo("필터에 연결해보자.".getBytes());
         }
+
     }
 
     /**
-     * 자바의 기본 문자열은 UTF-16 유니코드 인코딩을 사용한다.
-     * 문자열이 아닌 바이트 단위로 처리하려니 불편하다.
-     * 그리고 바이트를 문자(char)로 처리하려면 인코딩을 신경 써야 한다.
-     * reader, writer를 사용하면 입출력 스트림을 바이트가 아닌 문자 단위로 데이터를 처리하게 된다.
+     * 자바의 기본 문자열은 UTF-16 유니코드 인코딩을 사용한다. 문자열이 아닌 바이트 단위로 처리하려니 불편하다.
+     * 그리고 바이트를 문자(char)로 처리하려면 인코딩을 신경 써야 한다. reader,
+     * writer를 사용하면 입출력 스트림을 바이트가 아닌 문자 단위로 데이터를 처리하게 된다.
      * 그리고 InputStreamReader를 사용하면 지정된 인코딩에 따라 유니코드 문자로 변환할 수 있다.
      */
     @Nested
     class InputStreamReader_학습_테스트 {
 
         /**
-         * InputStreamReader를 사용해서 바이트를 문자(char)로 읽어온다.
-         * 읽어온 문자(char)를 문자열(String)로 처리하자.
-         * 필터인 BufferedReader를 사용하면 readLine 메서드를 사용해서 문자열(String)을 한 줄 씩 읽어올 수 있다.
+         * InputStreamReader를 사용해서 바이트를 문자(char)로 읽어온다. 읽어온 문자(char)를 문자열(String)로 처리하자. 필터인 BufferedReader를 사용하면
+         * readLine 메서드를 사용해서 문자열(String)을 한 줄 씩 읽어올 수 있다.
          */
         @Test
-        void BufferedReader를_사용하여_문자열을_읽어온다() {
+        void BufferedReader를_사용하여_문자열을_읽어온다() throws IOException {
             final String emoji = String.join("\r\n",
                     "😀😃😄😁😆😅😂🤣🥲☺️😊",
                     "😇🙂🙃😉😌😍🥰😘😗😙😚",
                     "😋😛😝😜🤪🤨🧐🤓😎🥸🤩",
                     "");
             final InputStream inputStream = new ByteArrayInputStream(emoji.getBytes());
+            final InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
+            final BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
 
             final StringBuilder actual = new StringBuilder();
+            String line;
+            while ((line = bufferedReader.readLine()) != null) {
+                actual.append(line).append("\r\n");
+            }
 
             assertThat(actual).hasToString(emoji);
         }
+
     }
+
 }

study/src/test/java/thread/stage0/SynchronizationTest.java

@@ -9,7 +9,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 /**
- * 다중 스레드 환경에서 두 개 이상의 스레드가 변경 가능한(mutable) 공유 데이터를 동시에 업데이트하면 경쟁 조건(race condition)이 발생한다.
+ * 다중 스레드 환경에서 두 개 이상의 스레드가 변경 가능한(mutable)
+ * 공유 데이터를 동시에 업데이트하면 경쟁 조건(race condition)이 발생한다.
  * 자바는 공유 데이터에 대한 스레드 접근을 동기화(synchronization)하여 경쟁 조건을 방지한다.
  * 동기화된 블록은 하나의 스레드만 접근하여 실행할 수 있다.
  *
@@ -41,7 +42,7 @@ private static final class SynchronizedMethods {
 
         private int sum = 0;
 
-        public void calculate() {
+        public synchronized void calculate() {
             setSum(getSum() + 1);
         }
 

study/src/test/java/thread/stage0/ThreadPoolsTest.java

@@ -31,8 +31,8 @@ void testNewFixedThreadPool() {
         executor.submit(logWithSleep("hello fixed thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
-        final int expectedQueueSize = 0;
+        final int expectedPoolSize = 2;
+        final int expectedQueueSize = 1;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());
         assertThat(expectedQueueSize).isEqualTo(executor.getQueue().size());
@@ -46,7 +46,7 @@ void testNewCachedThreadPool() {
         executor.submit(logWithSleep("hello cached thread pools"));
 
         // 올바른 값으로 바꿔서 테스트를 통과시키자.
-        final int expectedPoolSize = 0;
+        final int expectedPoolSize = 3;
         final int expectedQueueSize = 0;
 
         assertThat(expectedPoolSize).isEqualTo(executor.getPoolSize());

tomcat/src/main/java/nextstep/Application.java

@@ -8,4 +8,5 @@ public static void main(String[] args) {
         final var tomcat = new Tomcat();
         tomcat.start();
     }
+
 }

tomcat/src/main/java/nextstep/jwp/db/InMemoryUserRepository.java

@@ -1,10 +1,9 @@
 package nextstep.jwp.db;
 
-import nextstep.jwp.model.User;
-
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
+import nextstep.jwp.model.User;
 
 public class InMemoryUserRepository {
 
@@ -23,5 +22,11 @@ public static Optional<User> findByAccount(String account) {
         return Optional.ofNullable(database.get(account));
     }
 
-    private InMemoryUserRepository() {}
+    private InMemoryUserRepository() {
+    }
+
+    public static void deleteAll() {
+        database.clear();
+    }
+
 }

tomcat/src/main/java/nextstep/jwp/exception/UncheckedServletException.java

@@ -5,4 +5,5 @@ public class UncheckedServletException extends RuntimeException {
     public UncheckedServletException(Exception e) {
         super(e);
     }
+
 }

tomcat/src/main/java/nextstep/jwp/model/User.java

@@ -35,4 +35,5 @@ public String toString() {
                 ", password='" + password + '\'' +
                 '}';
     }
+
 }