ํด๋น ๊ธ์ Kent-Beck์ ํ ์คํธ ์ฃผ๋ ๊ฐ๋ฐ By Example ์ด๋ผ๋ ์ฑ ์ ์ฝ๊ณ ํ์ตํ ๋ด์ฉ์ ์ ๋ฆฌ ๋ฐ ํ๊ณ ํ๋ ๊ธ ์ ๋๋ค. ์์ธํ ์ฌํญ์ YES 24 ํ ์คํธ ์ฃผ๋ ๊ฐ๋ฐ ์์ ํ์ธํด์ฃผ์ธ์.
ํ ์คํธ ์ฃผ๋ ๊ฐ๋ฐ - Test Driven Development By Example (Kent-Beck)
- ์ธ์ฌ์ดํธ(insight)
- ์ง์์ด: Kent-Beck
- ์ฎ์์ด: ๊น์ฐฝ์ค, ๊ฐ๊ท์ญ
- ์ถ๊ฐ์ผ: 2014.02.15
๊ฐ์ฒด ๋ง๋ค๊ธฐ
์ฌ๊ธฐ Dollar ํด๋์ค์ Francํด๋์ค์ times()
๋ฉ์๋๋ฅผ ํ์ธํด๋ณด์.
class Dollar extends Money{
// ... ์๋ต
public Dollar times(int multiplier) {
return new Dollar(amount * multiplier);
}
}
class Franc extends Money {
// ... ์๋ต
public Franc times(int multiplier) {
return new Franc(amount * multiplier);
}
}
์์ฃผ ๊ฑฐ์ ๋น์ทํ๋ค.
์ฌ๊ธฐ์ ๋ฐํํ๋ ๊ฐ์ฒด๋ฅผ Money
๋ก ๋ฐ๊ฟ์ฃผ๋ฉด ๋์ฑ ๋น์ทํด์ง๋ค.
์ฌ๊ธฐ์ ๋ง์ฝ times๋ฅผ ๊ณตํต์ผ๋ก ๋ป๋ค๊ณ ์น์, ๊ทธ๋ผ Dollar์ Franc๋ ์๋ฌด๊ฒ๋ ์๋ ์ ์ธ๋ง ์กด์ฌํ๋ ๋น ํด๋์ค๊ฐ ๋๋ค.
์ด ๋์ ๋ฌด์๋ฏธํจ์ ํ๋ฒ์ ์์ ๊ณ ์ถ์ง๋ง ๋๋ฌด ํฐ ์ผ์ด๋ผ ์์ ์ผ๋ถํฐ ํ ์คํธ๋ก ์ํํด๊ฐ๋ TDD์ ๋ชฉ์ ์ ์๋ง์ง ์๋ค.
์์ ๊ฒ๋ถํฐ ํด๋ณด์.
Dollar์ Franc์ ์์ ๊ธฐ ์ํ ๋ ธ๋ ฅ
1. ์ง์ ์ฐธ์กฐ๋ฅผ ์์ ์.
์ฌ๊ธฐ์ ์์ ๊ฒ์ด๋ Money์ ํ์ ํด๋์ค์ธ Dollar์ Franc์ ๋ํ ์ง์ ์ฐธ์กฐ๊ฐ ์ ์ด์ง๋ค๋ฉด Dollar์ Franc์ ์ ๊ฑฐํ๋๋ฐ ๋์ฑ ์ฌ์ธ ๊ฒ ๊ฐ๋ค.
์ฐ์ ์ฐ๋ฆฌ๋ Factory Method ํจํด์ ์ฌ์ฉํ ๊ฒ์ด๋ค.
Factory Method ํจํด์ ํตํด์ Dollar
๊ฐ ํน์ Franc
์ด ์ง์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ง ์๊ณ Money
์์ ๊ฐ๊ฐ Dollar
์ Franc
๋ฅผ ๋ง๋ค๋๋ก ํ๋ฉด ์๋ง ๋ค์๊ณผ ๊ฐ์ ๊ทธ๋ฆผ์ด ๋์ฌ ๊ฒ์ด๋ค.
TDD๋ต๊ฒ ํ
์คํธ๋ฅผ ๋จผ์ ์ถ๊ฐ ํด๋ณด์.
void testMultiplication() {
Dollar five = Money.dollar(5);
assertEquals(new Dollar(10), five.times(2));
assertEquals(new Dollar(15), five.times(3));
}
๊ทธ๋ผ ๋น์ฐํ ์คํจํ๋ค.
์ด์ ๋ Money์ dollar๋ผ๋ ๋ฉ์๋๊ฐ ์์ด์์ด๋ค.
์ฌ๋น ๋ฅด๊ฒ Green์ผ๋ก ๊ฐ๋ณด์.
static Dollar dollar(int amount) {
return new Dollar(amount);
}
์ด์ Green์ด ๋์๋ค.
์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฒ์ ์ง์ ์ฐธ์กฐ๋ฅผ ์์ ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ five
๋ผ๋ ์ธ์คํด์ค ๋ณ์๊ฐ ์์ Money
๋ผ๋ ํด๋์ค๊ฐ ๋๋ฉด ์ง์ ์ฐธ์กฐ๊ฐ ์ฌ๋ผ์ง ๊ฒ ๊ฐ๋ค.
void testMultiplication() {
Money five = Money.dollar(5);
assertEquals(new Dollar(10), five.times(2));
assertEquals(new Dollar(15), five.times(3));
}
๊ทธ๋ผ ๋น์ฐํ ์คํจํ๋ค.
์? Money ํด๋์ค์๋ times
๋ฉ์๋๊ฐ ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ญ๊ฐ ๊ธฐ์๋ค.
์ฐ๋ฆฌ๊ฐ ์์ ๊ณ ์ถ์ ๊ฒ์ times
๋ฉ์๋๋ฅผ ํต์ผํ๋ ๊ฒ์ธ๋ฐ, ์ฌ๊ธฐ์ ์ง๊ธ Money ํด๋์ค์ times๊ฐ ์์ด์, ์ฆ ํต์ผ๋์ง ์์์ ์ค๋ฅ๋ฅผ ๋ฟ๊ณ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ฐ๋ฆฌ๊ฐ ์ด ๋ฌธ์ ๋ง ๋์ด๊ฐ๋ค๋ฉด times๋ฅผ ํต์ผ ์ํฌ ์ ์๋ค!
์ฌ๊ธฐ์ Money ํด๋์ค๋ฅผ ์ถ์ ํด๋์ค๋ก ๋ฐ๊พธ๊ณ times ๋ฅผ ์ถ์ ๋ฉ์๋๋ก ๋ฐ๊ฟ์ ํ์ ํด๋์ค๊ฐ ๊ตฌํํ๋๋ก ํ๋ฉด ์ข์ ๊ฒ ๊ฐ๋ค.
abstract class Money {
abstract Money times(int multiplier);
protected int amount;
static Dollar dollar(int amount) {
return new Dollar(amount);
}
// ... ์๋ต
}
๊ทธ๋ผ tiems
๋ฉ์๋๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ ์ค๋ฅ๋ ์ฌ๋ผ์ง๋ ๊ฒ์ ์ ์ ์๋ค.
์ด์ ์ฐ๋ฆฌ๊ฐ ๋ณ๊ฒฝํ ๊ฒ์ ์ด์ธ๋ฆฌ๊ฒ ํ ์คํธ ์ฝ๋์์ ํ์ ํด๋์ค๋ฅผ ์ง์ ํธ์ถํ๋ ์ฝ๋๋ฅผ ๋ฐ๊ฟ๋ณด์.
Dollar๋ Franc์ Money๋ก ๋ฐ๊พธ๋ฉด ๋๋ค.
public class MainTest {
@Test
public void testMultiplication() {
Money five = Money.dollar(5);
assertEquals(Money.dollar(10), five.times(2));
assertEquals(Money.dollar(15), five.times(3));
}
@Test
public void testEquality() {
assertEquals(Money.dollar(5), Money.dollar(5));
assertNotEquals(Money.dollar(5), Money.dollar(10));
assertNotEquals(Money.franc(5), Money.franc(15));
}
}
abstract class Money {
protected int amount;
abstract Money times(int multiplier);
static Dollar dollar(int amount) {
return new Dollar(amount);
}
static Franc franc(int amount) {
return new Franc(amount);
}
// ... ์๋ต
}
๋๊ธ