Finish the book

Author: Indosaram

slides/ch14.md

@@ -65,7 +65,7 @@ let nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
 ## 벡터
 
-벡터는 러스트에서 가장 널리 사용되는 자료형 중 하나로, 여러 개의 값을 하나로 묶어서 사용할 수 있습니다. 벡터의 특징은 길이를 런타임에 동적으로 변경 가능하다는 점입니다. 이러한 특징 떄문에 런타임에서는 값이 힙 영역에 저장됩니다.
+벡터는 러스트에서 가장 널리 사용되는 자료형 중 하나로, 여러 개의 값을 하나로 묶어서 사용할 수 있습니다. 벡터의 특징은 길이를 런타임에 동적으로 변경 가능하다는 점입니다. 이러한 특징 때문에 런타임에서는 값이 힙 영역에 저장됩니다.
 
 
 ---

slides/ch14.pdf

@@ -59,9 +59,8 @@
     - [rayon](./ch13-03.md)
 - [테스트](./ch14-00.md)
     - [유닛 테스트](./ch14-01.md)
-    - [소스코드 살펴보기](./ch14-02.md)
-    - [문서 테스트](./ch14-03.md)
-    - [모킹](./ch14-04.md)
+    - [문서 테스트](./ch14-02.md)
+    - [모킹](./ch14-03.md)
 - [파이썬 바인딩](./ch15-00.md)
     - [파이썬 가상환경 만들기](./ch15-01.md)
     - [PyO3 프로젝트 생성하기](./ch15-02.md)

slides/ch15.md

@@ -1 +1,26 @@
-# CH14. 테스트
+# CH14. 테스트
+
+
+
+## 프로그래밍에서 테스트가 필요한 이유
+
+테스트는 소프트웨어 제품이 요구 사항을 충족하고 예상대로 작동하는지 확인하는 데 도움이 되므로 소프트웨어 개발의 필수적인 부분입니다. 테스트가 필요하고 중요한 이유는 여러 가지가 있습니다:
+
+- 소프트웨어 적응성을 확인하기 위해: 테스트는 소프트웨어가 다양한 환경과 다양한 구성에서 올바르게 작동할 수 있는지 확인합니다.
+- 오류 식별: 테스트는 소프트웨어의 버그와 오류를 식별하여 제품 출시 전에 수정할 수 있도록 도와줍니다.
+- 추가 비용 방지: 개발 프로세스 초기에 버그를 발견하고 수정하면 출시 후에 버그를 발견하는 것보다 시간과 비용을 절약할 수 있습니다.
+- 소프트웨어 개발 가속화: 테스트를 통해 코드 변경 사항에 대한 빠른 피드백을 제공함으로써 개발 속도를 높일 수 있습니다.
+- 위험 방지: 테스트는 소프트웨어 제품 사용과 관련된 잠재적 위험을 식별하는 데 도움이 됩니다.
+
+## 테스트의 종류
+
+단위 테스트(unit test)와 통합 테스트(integration test)는 서로 다른 목적을 가진 두 가지 테스트 유형입니다.
+
+단위 테스트는 고립된 작은 코드 조각이 의도한 대로 작동하는지 확인하기 위한 자동화된 테스트의 한 유형입니다. 일반적으로 개발자가 개발 중에 수행하며 함수나 프로시저와 같은 개별 소프트웨어 구성 요소에 중점을 둡니다.
+
+반면에 통합 테스트는 여러 소프트웨어 구성 요소가 함께 작동하는 방식을 테스트하는 프로세스입니다. 통합 테스트는 통합된 유닛 간의 인터페이스가 올바른지 확인하는 데 중점을 둡니다. 통합 테스트는 일반적으로 단위 테스트가 완료된 후 시스템 테스트 전에 수행됩니다.
+
+단위 테스트와 통합 테스트의 주요 차이점은 단위 테스트는 개별 코드 단위에 초점을 맞추고 통합 테스트는 이들이 함께 작동하는 방식에 초점을 맞춘다는 점입니다. 단위 테스트는 개발자가 코드가 원자 수준에서 올바르게 작동하는지 확인하는 데 도움이 되며, 통합 테스트는 시스템의 여러 부분이 올바르게 함께 작동하는지 확인하는 데 도움이 됩니다.
+
+
+

slides/ch15.pdf

@@ -1,16 +1,91 @@
 
-## 유닛 테스트
 
-유닛 테스트란, 
 
-### 파이썬
+
+## 유닛 테스트
+
+### 소스코드 살펴보기
 
 파이썬에서 유닛테스트를 위해서 사용하는 라이브러리로, 내장 라이브러리인 `unittest` 가 있습니다. 하지만 실제 현업에서는 일반적으로  `pytest` 패키지를 많이 사용합니다. 아래 명령어로 패키지를 설치합니다.
 
 ```bash
 pip install pytest
 ```
 
+
+
+먼저 파이썬 코드를 살펴보겠습니다. `logic.py` 모듈은 다음과 같습니다.
+
+```python
+from typing import Optional
+
+CARDS = ["Rock", "Scissors", "Paper"]
+
+
+def play(card1: str, card2: str) -> Optional[bool]:
+    assert card1 in CARDS, "Invalid card1"
+    assert card2 in CARDS, "Invalid card2"
+
+    if card1 == card2:
+        return None
+
+    if (
+        (card1 == "Rock" and card2 == "Scissors")
+        or (card1 == "Scissors" and card2 == "Paper")
+        or (card1 == "Paper" and card2 == "Rock")
+    ):
+        return True
+    else:
+        return False
+
+
+def stop():
+    raise Exception("stop!")
+
+```
+
+`play()` 함수는 입력받은 두 카드의 값을 비교해 첫 번째 카드의 승패 유무를 리턴하는 함수입니다. 가위바위보에서 이기면 `True`, 지면 `False` , 비기면 `None` 을 리턴합니다. `stop()` 함수는 무조건 에러를 발생시켜 프로그램을 종료시킵니다.
+
+이제 `test.py` 모듈을 보겠습니다. `@pytest.mark.parametrize` 는 테스트의 각 파라미터를 테스트 수행 중에 동적으로 넣을 수 있는 데코레이터입니다. 여기서 승, 무, 패 3가지를 테스트하는 함수 `test_win`, `test_draw`, `test_lose` 와 함께 함수 `stop()` 이 에러를 발생시키는지를 검사하는 `test_stop` 까지 총 4개의 테스트가 존재합니다.
+
+```python
+import pytest
+
+from logic import play, stop
+
+
+@pytest.mark.parametrize(
+    "card1, card2",
+    [("Rock", "Scissors"), ("Scissors", "Paper"), ("Paper", "Rock")],
+)
+def test_win(card1, card2):
+    assert play(card1, card2) == True
+
+
+@pytest.mark.parametrize(
+    "card1, card2",
+    [("Rock", "Rock"), ("Scissors", "Scissors"), ("Paper", "Paper")],
+)
+def test_draw(card1, card2):
+    assert play(card1, card2) == None
+
+
+@pytest.mark.parametrize(
+    "card1, card2",
+    [("Scissors", "Rock"), ("Rock", "Paper"), ("Paper", "Scissors")],
+)
+def test_lose(card1, card2):
+    assert play(card1, card2) == False
+
+
+def test_stop():
+    with pytest.raises(Exception) as exc:
+        stop()
+
+```
+
+여기에 승무패 테스트에는 파라미터가 3종류씩 들어가므로 총 10개의 테스트가 수행되게 됩니다.
+
 `pytest` 에는 정말 다양한 사용법이 존재하지만, 여기서는 기본적으로 테스트 모듈을 실행하는 것만 해보겠습니다. 현재 파이썬 폴더 밑에 `test.py` 파일에 정의된 테스트들을 수행해줍니다.
 
 ```bash
@@ -33,11 +108,81 @@ test.py ..........                                                       [100%]
 
 
 
-### 러스트
+
+
+러스트 코드도 살펴봅시다. 여기서는 크레이트 루트로 라이브러리 크레이트를 사용합니다.
+
+```rust,ignore
+#[derive(PartialEq)]
+pub enum Cards {
+    Rock,
+    Scissors,
+    Paper,
+}
+
+/// Demonstrate Rock, Scissors, Paper
+///
+/// ```
+/// use rust_part::{play, Cards};
+/// 
+/// let result = play(Cards::Rock, Cards::Scissors);
+/// assert_eq!(result, Some(true));
+/// ```
+pub fn play(card1: Cards, card2: Cards) -> Option<bool> {
+    if card1 == card2 {
+        return None;
+    }
+    match (card1, card2) {
+        (Cards::Rock, Cards::Scissors) => Some(true),
+        (Cards::Scissors, Cards::Paper) => Some(true),
+        (Cards::Paper, Cards::Rock) => Some(true),
+        _ => Some(false),
+    }
+}
+
+pub fn stop() {
+    panic!("stop!");
+}
+
+#[cfg(test)]
+pub mod test {
+    // import everything in this module
+    use super::*;
+
+    // No parametrized tests out of the box in Rust.
+    #[test]
+    fn test_win() {
+        assert_eq!(play(Cards::Paper, Cards::Rock), Some(true));
+        assert_eq!(play(Cards::Scissors, Cards::Paper), Some(true));
+        assert_eq!(play(Cards::Paper, Cards::Rock), Some(true));
+    }
+    #[test]
+    fn test_draw() {
+        assert_eq!(play(Cards::Rock, Cards::Rock), None);
+        assert_eq!(play(Cards::Scissors, Cards::Scissors), None);
+        assert_eq!(play(Cards::Paper, Cards::Paper), None);
+    }
+    #[test]
+    fn test_lose() {
+        assert_eq!(play(Cards::Rock, Cards::Paper), Some(false));
+        assert_eq!(play(Cards::Paper, Cards::Scissors), Some(false));
+        assert_eq!(play(Cards::Scissors, Cards::Rock), Some(false));
+    }
+
+    #[test]
+    #[should_panic(expected="stop!")]
+    fn test_stop(){
+        stop();
+    }
+}
+
+```
+
+
 
 `cargo` 에 내장된 test 러너로 유닛 테스트 실행이 가능합니다. 러스트는 테스트 파일을 별도로 만들지 않고, 같은 파일 안에 `test` 모듈을 넣어서 작성합니다. 이렇게 하면 테스트 모듈에서 대상 모듈에 대한 접근이 쉬워집니다. 다시 말해, private으로 선언된 함수에도 접근할 수 있기 때문에 테스트가 용이해집니다.
 
-아래 명령어로 `lib.rs` 에 정의된 테스트 모듈의 테스트들을 수행합니다.
+아래 명령어로 테스트 모듈의 테스트들을 수행합니다.
 
 ```bash
 cargo test
@@ -68,4 +213,131 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; fini
 
 러스트는 테스트를 위해 바이너리를 빌드하는 과정이 먼저 수행됩니다. 그리고 유닛 테스트를 수행합니다. 마지막에 "Doc-tests"라는게 추가로 수행되는데 이는 밑에서 더 자세히 설명하겠습니다.
 
+비슷하게 클래스도 테스트할 수 있습니다. 먼저 파이썬에서 다음과 같은 클래스를 정의합니다.
+
+```python
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self._age = age
+
+    @property
+    def age(self):
+        return self._age
+
+    def hi(self):
+        return f"Hi, I'm {self.name}, I'm {self._age} years old."
+
+```
+
+테스트 모듈에서는 객체화를 한 다음 프로퍼티와 메소드가 잘 적용되는지를 테스트합니다.
+
+```python
+def test_hi():
+    name = "John"
+    age = 30
+    person = Person(name, age)
+    assert person.hi() == f"Hi, I'm {name}, I'm {age} years old."
+    assert person.hi() == f"Hi, I'm {person.name}, I'm {person.age} years old."
+
+```
+
+러스트에서는 다음과 같이 구조체를 선언했습니다. 먼저 `person` 모듈을 선언하고 그 다음 `Person` 구조체와 메소드를 정의했습니다. 여기서 별도로 모듈을 만들지 않아도 상관없습니다.
+
+```rust,ignore
+pub mod person {
+
+    pub struct Person {
+        pub name: String,
+        age: u8,
+    }
+
+    impl Person {
+        pub fn new(name: &str, age: u8) -> Person {
+            Person {
+                name: name.to_string(),
+                age: age,
+            }
+        }
+
+        pub fn hi(&self) -> String {
+            format!("Hi, I'm {}, I am {} years old.", self.name, self.age())
+        }
+
+        pub fn age(&self) -> u8 {
+            self.age
+        }
+    }
+}
+
+```
+
+그 다음 테스트 모듈에 아래 함수를 추가합니다.
+
+```rust,ignore
+#[test]
+fn test_hi() {
+  let name = "John";
+  let age: u8 = 30;
+  let person = person::Person::new(name, age);
+  assert_eq!(
+    person.hi(),
+    format!("Hi, I'm {}, I am {} years old.", name, age)
+  );
+  assert_eq!(
+    person.hi(),
+    format!("Hi, I'm {}, I am {} years old.", person.name, person.age())
+  );
+}
+```
+
+파이썬과 마찬가지로 프로퍼티와 메소드가 잘 적용되는지를 테스트합니다. 아래 명령어로 테스트들을 수행합니다.
+
+```bash
+cargo test
+```
+
+
+### 비동기 함수 테스트
+
+`#[tokio::test]`를 함수에 붙여주면 됩니다.
+
+
+
+```rust
+async fn give_order(order: u64) -> u64 {
+    println!("Processing {order}...");
+    tokio::time::sleep(std::time::Duration::from_secs(3 - order)).await;
+    println!("Finished {order}");
+    order
+}
+
+#[tokio::main]
+async fn main() {
+    let result = tokio::join!(give_order(1), give_order(2), give_order(3));
+
+    println!("{:?}", result);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_give_order() {
+        let result = give_order(1).await;
+        assert_eq!(result, 1);
+    }
+}
+
+```
+
+실행 결과
+
+```
+running 1 test
+test tests::test_give_order ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.00s
+```