The document discusses the misconceptions about Test-Driven Development (TDD), emphasizing that it is not merely about writing unit tests before coding or writing tests after code is completed. It outlines key principles of TDD and provides a detailed example of implementing prime factorization through TDD, highlighting the iterative process and the importance of test coverage. Additionally, it addresses the benefits and challenges of adopting TDD in software development.

1. Test driven development
The right way
Paweł Głasek
@PawelGlasek

4. The right way?

5. Czym TDD nie jest
Napisaniem testów wszystkich obiektów, przed
implementacją funkcjonalności.

6. Czym TDD nie jest
Wszystkie testy przed implementacją
● Ciężko zaprojektować odpowiedni design oraz zmieniać
go w trakcie kodowania
● Ciężko przewidzieć zmiany w obiektach klas już obecnych
w systemie
● Ciężko przewidzieć współdziałanie komponentów
● Niektóre warunki brzegowe nigdy nie występują – zbyt
duża ilość niepotrzebnych testów
● Często niepełne pokrycie

7. Czym TDD nie jest
Sztuką pisania unit testów

8. Czym TDD nie jest
Just Unit tests
● Błyskawicznie prowadzi do „przemockowania”
● Nie testuje współdziałania poszczególnych obiektów
● Pomimo zmian w powiązanych, ale zmockowanych
klasach testy przechodzą
● Niektóre warunki brzegowe nigdy nie występują – zbyt
duża ilość niepotrzebnych testów
● Brak motywacji do pisania testów

9. Czym TDD nie jest
Napisaniem testów po zakończeniu pisania kodu
produkcyjnego.

10. Czym TDD nie jest
Testy po napisaniu kodu produkcyjnego
● Brak motywacji do pisania testów po fakcie
● Wiele przypadków pozostaje nieprzetestowanych
● Niektóre warunki brzegowe nigdy nie występują
● Brak poczucia sensu pisania testów w ten sposób
● Częste problemy z testowalnością napisanego kodu
● Nuda

11. The right way

12. TDD
Agile'owa technika wytwarzania
programowania

13. Kent Beck

14. Test Driven
Development
By Example

16. Red – green – refactor
Zasady wujka Boba:
1. Nie wolno pisać kodu produkcyjnego, dopóki nie istnieje
failujący test.
2. Nie wolno napisać więcej testów, niż jest to niezbędne
do faila (niekompilujący się kod również uznajemy jako
fail).
3. Nie wolno pisać więcej kodu produkcyjnego niż jest to
niezbędne, by testy przechodziły.

17. Powiedz mi, a zapomnę.
Pokaż mi, a zapamiętam.

18. Rozkład liczby na czynniki
pierwsze

19. TDD style

20. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))

21. Prime factorization – TDD style
>> nose2 test.prime_factors
==================================================
ERROR: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
NameError: global name 'prime_factors' is not defined
----------------------------------------------------------------------
Ran 1 test in 0.000s
FAILED (errors=1)

22. Prime factorization – TDD style
def prime_factors(number):
"""
Performs prime factorization.
:param number: Number to be factorized.
:type number: int
:rtype: list
"""
return []

23. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

24. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))

25. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [2] != []
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

26. Prime factorization – TDD style
def prime_factors(number):
return []
def prime_factors(number):
factors = []
if number > 1:
factors.append(2)
return factors

27. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

28. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))

29. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [3] != [2]
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

30. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
factors.append(2)
return factors
def prime_factors(number):
factors = []
if number > 1:
factors.append(number)
return factors

31. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

32. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))

33. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [2, 2] != [4]
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

34. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
factors.append(number)
return factors

35. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [2] != [2, 1]
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

36. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
factors.append(number)
return factors
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors

37. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

38. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors

39. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

40. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))

41. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

42. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))
self.assertListEqual([2, 3], prime_factors(6))

43. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

44. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))
self.assertListEqual([2, 3], prime_factors(6))
self.assertListEqual([7], prime_factors(7))

45. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

46. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))
self.assertListEqual([2, 3], prime_factors(6))
self.assertListEqual([7], prime_factors(7))
self.assertListEqual([2, 2, 2], prime_factors(8))

47. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [2, 2, 2] != [2, 4]
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

48. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
if number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
if number > 1:
while number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors

49. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

50. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))
self.assertListEqual([2, 3], prime_factors(6))
self.assertListEqual([7], prime_factors(7))
self.assertListEqual([2, 2, 2], prime_factors(8))
self.assertListEqual([3, 3], prime_factors(9))

51. Prime factorization – TDD style
>>nose2 test.prime_factors
F
================================================
FAIL: test_prime_factors (test.prime_factors.TestPrimeFactors)
----------------------------------------------------------------------
AssertionError: Lists differ: [3, 3] != [9]
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

52. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
while number % 2 == 0:
factors.append(2)
number /= 2
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
if number > 1:
while number % 2 == 0:
factors.append(2)
number /= 2
while number % 3 == 0:
factors.append(3)
number /= 3
if number > 1:
factors.append(number)
return factors

53. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

54. Prime factorization – TDD style
def prime_factors(number):
factors = []
if number > 1:
while number % 2 == 0:
factors.append(2)
number /= 2
while number % 3 == 0:
factors.append(3)
number /= 3
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
divisor = 2
while number > 1:
while number % divisor == 0:
factors.append(divisor)
number /= divisor
divisor += 1
if number > 1:
factors.append(number)
return factors

55. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

56. Prime factorization – TDD style
def prime_factors(number):
factors = []
divisor = 2
while number > 1:
while number % divisor == 0:
factors.append(divisor)
number /= divisor
divisor += 1
if number > 1:
factors.append(number)
return factors
def prime_factors(number):
factors = []
divisor = 2
while number > 1:
while number % divisor == 0:
factors.append(divisor)
number /= divisor
divisor += 1
return factors

57. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

58. Prime factorization – TDD style
class TestPrimeFactors(unittest.TestCase):
"""
Prime factors test suite.
"""
def test_prime_factors(self):
self.assertListEqual([], prime_factors(1))
self.assertListEqual([2], prime_factors(2))
self.assertListEqual([3], prime_factors(3))
self.assertListEqual([2, 2], prime_factors(4))
self.assertListEqual([5], prime_factors(5))
self.assertListEqual([2, 3], prime_factors(6))
self.assertListEqual([7], prime_factors(7))
self.assertListEqual([2, 2, 2], prime_factors(8))
self.assertListEqual([3, 3], prime_factors(9))
self.assertListEqual([2, 2, 3, 3, 5, 7 , 11, 13], prime_factors(2*2*3*3*5*7*11*13))

59. Prime factorization – TDD style
>>nose2 test.prime_factors
.
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK

60. Clean code that works

61. Zalety TDD
● Prostota iteracji designu
● Pokrycie testami
● Możliwość refactoringu
● Zdecouplowany, testowalny kod
● Nietrywialny design
● Ograniczenie wykorzystania debugera
● Brak strachu przez zmianami w kodzie

62. Problemy z TDD
● Konieczność zmiany stylu myślenia
● Początkowo mało intuicyjna technika
● Pokusa pisania kodu produkcyjnego bez testów

63. Pytania

64. Dziękuję