-
Test-Driven Development (TDD) ์ ๋ชฉํ๋ Clean Code ์ด๋ค
-
Clean Code ๊ฐ ์๋ฏธ ์๋ ๋ชฉํ์ธ ์ด์
-
๋ฒ๊ทธ์ ๋ช์ ๊ฑฑ์ ํ์ง ์๊ณ ๊ฐ๋ฐ์ ์์ฑ์ ์์ ํ ์ ์๋ค
-
์์ฑํ๋ ค๋ ์ฝ๋์ ๋ชจ๋ ๋ถ๋ถ์ ๋ณผ ์ ์๋ ๊ธฐํ๋ฅผ ์ค๋ค (๋๋ฌด๋ณด๋ค๋ ์ฒ)
-
-
Rules for Development with TDD
-
์์ฑํ automated test ๊ฐ ์คํจํ์ ๊ฒฝ์ฐ์๋ง ์ ์ฝ๋๋ฅผ ์์ฑ (์ฝ๋ ์์ฑ ์ ์คํจํ๋ automated test ์์ฑ)
-
์ค๋ณต์ฝ๋ ์ ๊ฑฐ
-
-
TDD๋ ํ๋ก๊ทธ๋๋ฐ ์ค ๊ฒฐ์ ๊ณผ ํผ๋๋ฐฑ ์ฌ์ด์ ์๊ฐํ๋ ๊ณผ์ ์ด์ ๊ทธ ์ฌ์ด์ ๊ฐญ์ ๋ฉ๊ฟ์ฃผ๋ ๊ธฐ์ ์ด๋ค
์ด๋ ๊ธ์์ผ, ๋งค๋์ ๊ฐ ๊ณ ๊ฐ Peter๋ฅผ ์๊ฐ์์ผ์ค๋ค. ํผํฐ๋ ์ฐ๋ฆฌ๊ฐ ๊ฐ๋ฐํ ์์ฐ๊ด๋ฆฌ ์ดํ๋ฆฌ์ผ์ด์
WyCash๋ฅผ ์ฐ๊ณ ์๋ค.
ํผํฐ๋ ๋ชจ๋ ๊ธฐ๋ฅ์ ๋ง์กฑํ์ง๋ง USD๋ง ์ง์ํ๋ ๊ธฐ๋ฅ์ ๋ํด์ ๋ค๋ฅธ ํตํ๋ค๋ ์ง์๊ฐ๋ฅํ ์ง ๋ฌป๋๋ค.
์ด ์ฑ
์์๋ ์ด ๋ฌธ์ ๋ฅผ Test-Driven Development(TDD)๋ฅผ ํตํด ๋ค๋ฃฐ ๊ฒ์ด๋ค.
๋ค์ ๋ ๊ฐ์ง ๊ฐ๋จํ rule๋ง ๋ฐ๋ฅด๋ฉด ๋๋ค.
1. ์ฝ๋ ์์ฑ ์ ์ ์คํจํ๋ ์คํ ๋ฉ์ด์
ํ
์คํธ๋ฅผ ์์ฑํด๋ผ
2. Duplication์ ์ ๊ฑฐํด๋ผ
ํ์ฌ ์ง์ํ๋ ๋ฆฌํฌํธ๋ ๋ค์ํ ํตํ๋ฅผ ์ง์ํ์ง ์๊ธฐ ๋๋ฌธ์ ์ค๋ฅธ์ชฝ ๋ฆฌํฌํธ์ ๊ฐ์ด ์
๋ฐ์ดํธ ๋์ด์ผ ํ๋ค
ํ์ฌ ์ง์ํ๋ ๋ฆฌํฌํธ | ๋ค์ํ ํตํ๊ฐ ํ๊ธฐ๋ ๋ฆฌํฌํธ | ํ์ ์จ | ||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
|
์๋ก์ด ๋ฆฌํฌํธ๋ฅผ ์ง์ํ๊ธฐ ์ํด ์ด๋ค ๊ธฐ๋ฅ๋ค์ด ํ์ํ ๊น?
๋ฐ๊พธ์ด ๋งํด์ ์ด๋ค ํ ์คํธ๋ฅผ ์์ฑํ๊ณ , ํต๊ณผํ์ ๋ ์์ฑํ ์ฝ๋ํ ํตํด ์์ ๊ฐ ์๊ฒ ์๋ก์ด ๋ฆฌํฌํธ๋ฅผ ์ ํํ๊ฒ ์ง์ํ๋ค๊ณ ํ ์ ์์๊น?
-
๋ ๊ฐ์ ๋ค๋ฅธ ํตํ๋ก ์ด๋ฃจ์ด์ง ๋์ ํ์จ๋ก ๋น๊ตํด ๋ํ ์ ์์ด์ผ ํ๋ค
-
์ฃผ์ด์ง Shares ์ Price ๋ฅผ ๊ณฑํด์ Total์ ๊ณ์ฐํด์ผ ํ๋ค
์ด ๋๊ฐ์ง ํ ์คํธ๋ฅผ ๊ฐ๋จํ๊ฒ ๋ฐ๊พธ์ด to-do list๋ก ๋ณํํด ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค
@ To-do list
$5 + 10 KRW = $10 (ํ์จ์ด 2:1์ผ ๋)
$5 * 2 = $10
๋ ๋ฒ์งธ ๊ณฑ์ ๋ถํฐ ํ ์คํธ๋ฅผ ์์ฑํด๋ณด์. ํ ์คํธ๋ฅผ ์์ฑํ ๋๋ ํ ์คํธ๋ฅผ ์ํ ์๋ฒฝํ interface๊ฐ ์๋ค๊ณ ๊ฐ์ ํ์.
public void testMultiplication() {
Dollar five = new Dollar(5);
five.times(2);
assertEquals(10, five.amount);
}
์ฝ๋ ์์ฑ ํ์ to-do list
@ To-do list
$5 + 10 KRW = $10 (ํ์จ์ด 2:1์ผ ๋)
$5 * 2 = $10
Make "amount" private
Dollar side-effects?
Money rounding?
์ด ์ฝ๋๋ ํ์ฌ ์ปดํ์ผ๋ ์ ๋์ง๋ง ์ฝ๊ฒ ๊ณ ์น ์ ์๋ ์ํ์ด๋ค. ์ฝ๋๊ฐ ์ปดํ์ผ ๋๊ฒ ํ๊ธฐ ์ํด์ ์ด๋ค ๊ฒ๋ค์ ๊ณ ์ณ์ผ ํ ๊น?
์ด 4๊ฐ์ง ์ปดํ์ผ ์๋ฌ๊ฐ ์กด์ฌํ๋ค.
- No class Dollar
- No constructor
- No Method times(int)
- No field amount
์ด ์๋ฌ๋ค์ ๊ณ ์น๊ธฐ ์ํด์ ํ์ํ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค
- No class Dollar
class Dollar
- No constructor
Dollar(int amount) {}
- No Method times(int)
void times(int multiplier) {}
- No field amount
int amount;
์์ ๊ฐ์ด ๊ณ ์น ํ ํ ์คํธ๋ฅผ ์คํํ๋ฉด ์ปดํ์ผ์ ๋์ง๋ง ํ ์คํธ๋ ์คํจํ๋ค. 10์ ์์ํ์ง๋ง ์ค์ ๊ฐ์ 0์ด ๋์ค๊ธฐ ๋๋ฌธ์ด๋ค.
ํ ์คํธ ์คํจ๋ ๊ณผ์ ์ด๋ค. ์ด๋ค ๊ฒ์ด ๋ฌธ์ ์ธ์ง ์๋ ๊ฒ์, ๋ฌธ์ ๊ฐ ๋ฌด์์ธ์ง ๋ชจ๋ฅด๋ ์ฑ ์คํจํ๋ ๊ฒ๋ณด๋ค ๋ซ๋ค.
์ด์ ์ฐ๋ฆฌ์ ๋ฌธ์ ๋ ๋ค์ํ ํตํ ์ง์
์์ ํ์ฌ ํ
์คํธ pass, ๊ทธ๋ฆฌ๊ณ ๊ทธ ๋ค์ ํ
์คํธ pass
๋ก ๋ณํ๋ค.
์ฐ๋ฆฌ๋ ์ด ํ ์คํธ ์คํจ๋ฅผ ๋ค์ ์ฝ๋๋ก ๊ณ ์น ์ ์๋ค.
int amount = 10;
๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ๊ธฐ ์ ์ ์ฐ๋ฆฌ๋ ์ด ์ฝ๋๋ฅผ ๋ฆฌํฉํ ๋ง ํด์ผ ํ๋ค. ์๋ cycle ์ ์์ง ๋ง์.
1. ์์ ํ
์คํธ ์์ฑ
2. ๋ชจ๋ ํ
์คํธ ์คํ > ์คํจ
3. ์์ ์ฝ๋ ๋ณ๊ฒฝ
4. ๋ชจ๋ ํ
์คํธ ์คํ > ์ฑ๊ณต
5. Duplication ์ ๊ฑฐ๋ฅผ ์ํด ๋ฆฌํฉํ ๋ง
amount์ 10์ด๋ผ๋ ๊ฐ์ ์ฃผ๋ฉด์ ์ฐ๋ฆฌ๋ 1๋ฒ๋ถํฐ 4๋ฒ๊น์ง ์์ฑํ๋ค. 5๋ฒ์ ์งํ ํด์ผ ํ๋๋ฐ ์ด๋์์ duplication์ ์ฐพ์ ์ ์์๊น?
๋ณดํต duplication์ ์ฝ๋๋ค ์ฌ์ด์์ ๋ณด์ด์ง๋ง ์ฌ๊ธฐ์๋ ํ ์คํธ์ ๋ฐ์ดํฐ์ ์ฝ๋์ ๋ฐ์ดํฐ ์ฌ์ด์์ ์ฐพ์ ์ ์๋ค. ์ฐพ๊ธฐ ์ด๋ ต๋ค๋ฉด ์ฝ๋๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ๋ฐ๊พธ๋ฉด ์ด๋จ๊น?
int amount = 5 * 2;
10์ ์ฐ๋ฆฌ๋ ๋ชจ๋ฅด๋ ์ฌ์ด์ ์ฐ๋ฆฌ์ ๋จธ๋ฆฟ ์์์ ๊ณ์ฐ๋ ๊ฐ์ด๋ค. ์ด์ 5์ 2๋ ๋ ๊ตฐ๋ฐ(ํ ์คํธ, ์ฝ๋)์ ์กด์ฌํ๋ค. ์ด๋ป๊ฒ ํ๋ฉด ์ด duplication ์ ์์จ ์ ์์๊น?
@ To-do list
$5 + 10 KRW = $10 (ํ์จ์ด 2:1์ผ ๋)
$5 * 2 = $10
Make "amount" private
Dollar side-effects?
Money rounding?
๋ง์ฝ ๊ฐ์ times()
๋ฉ์๋ ์์ผ๋ก ์์ง์ด๋ฉด?
int amount;
void times(int multiplier) {
amount = 5 * 2;
}
ํ ์คํธ๋ ์ฌ์ ํ ํต๊ณผํ๋ค. ๋๋ฌด ์์ ์ฝ๋ ๋ณํ๋ผ๊ณ ์๊ฐํ๋๊ฐ?
TDD๋ ์๋ ์์ ๊ณผ์ ์ ์งํํ๋ ๊ฒ ์๋๋ผ ๊ทธ ์๋ ์์ ๊ณผ์ ์ ์งํํ ์ ์๊ฒ ๋ง๋๋ ๊ฒ์ด๋ผ๋ ๊ฒ์ ๊ธฐ์ตํ์.
๋งค ๋ฒ ์ด๋ฐ ๊ณผ์ ์ ๊ฑฐ์น ์๋ ์์ง๋ง ๋งค ๋ฒ ํฐ ๊ณผ์ ๋ค๋ง ์งํํ๋ค ๋ณด๋ฉด ๊ทธ ์์ ์์ ๊ณผ์ ๋ค์ด ์ ํฉํ์ง ์ ์ ์์ ๊ฒ์ด๋ค.
๋ค์์ผ๋ก 5๋ ์ด๋์ ์ป์ ์ ์๋ ๊ฐ์ธ๊ฐ? Constructor๋ก ์ ๋ฌ๋ ๊ฐ์ด๋ฏ๋ก ์ด๋ ๊ฒ ๋ฐ๊ฟ ์ ์๋ค.
Dollar(int amount) {
this.amount = amount;
}
์ด์ด์ ์ด์ ๋ times()์์ ์ด ๊ฐ์ ์ธ ์ ์๋ค.
void times(int multiplier) {
amount = amount * 2;
}
๋ค์์ผ๋ก multiplier๋ก ์ ๋ฌ๋๋ ๊ฐ์ด 2์ด๋ฏ๋ก ์ด ์ญ์ ๋ฐ๊ฟ ์ ์๋ค
void times(int multiplier) {
amount = amount * multiplier;
}
๋ง์ง๋ง์ผ๋ก Java syntax๋ฅผ ์๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๋ฐ๊ฟ ์ ์๋ค
void times(int multiplier) {
amount *= multiplier;
}
์ด๋ ๊ฒ to-do list ์ค ํ๋๋ฅผ ์ง์ธ ์ ์๊ฒ ๋์๋ค.
@ To-do list
$5 + 10 KRW = $10 (ํ์จ์ด 2:1์ผ ๋)
$5 * 2 = $10
**
Make "amount" private
Dollar side-effects?
Money rounding?
ETC.
Dependency and Duplication; ์์กด์ฑ๊ณผ ์ค๋ณต๋ ์ฝ๋
์ฆ์์ ์ ๊ฑฐํ์ ๋ ๋ค๋ฅธ ๊ณณ์์ ๋ ์ข์ง ์์ ๋ฌธ์ ๋ค์ด ์ผ์ด๋๋ ์ค์ํ์ ๋ฌธ์ ๋ค๊ณผ๋ ๋ฌ๋ฆฌ, ํ๋ก๊ทธ๋จ์์์ ์ฆ์ ์ ๊ฑฐ๋ ์์กด์ฑ์ ์ ๊ฑฐํ๋ ๊ฒ ๊ณผ ๊ฐ๋ค.
TDD์ ๋๋ฒ์งธ ๋ฃฐ์ด 'Duplication์ ์ ๊ฑฐํ๋ผ'์ธ ์ด์ ๋ ๋ค์ ํ ์คํธ๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์ค๋ณต๋ ์ฝ๋๋ฅผ ์ ๊ฑฐํจ์ผ๋ก์จ, ๋ค์ ํ ์คํธ ์์ฑ ์์์ฃผ ์์
์ฝ๋ ๋ณํ๋ง์ผ๋ก ํ ์คํธ๋ฅผ ์ฑ๊ณต์ํฌ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.