Your SlideShare is downloading. ×
  • Like
Test Driven Development - Overview and Adoption
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Test Driven Development - Overview and Adoption

  • 2,484 views
Published

- What is TDD …

- What is TDD
- TDD adoption stages
- Adopting a test strategy
- Making TDD stick

Published in Technology , Education
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
  • Não consegui realizar o download, poderia me disponibilizar por e-mail?

    thinaregina@gmail.com
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
2,484
On SlideShare
0
From Embeds
0
Number of Embeds
2

Actions

Shares
Downloads
86
Comments
1
Likes
2

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Test-Driven Development
  • 2. Why Test-Driven Development (TDD)?
    • Agile implies adapting to change quickly…
    • In code, this translates to “easy to maintain & refactor” and implies…
      • Clean design
      • No duplication
      • Low/loose coupling
      • Eliminating “code smells”
      • Thorough test coverage
    • TDD is a technique that helps getting there
  • 3. What is TDD?
    • Originates from test-first programming concepts of Extreme Programming (XP)
    • Is a software design method more than a testing method
    • Developers create automated unit tests that define code requirements before writing the code itself
  • 4. Extreme Programming Practices Overview source: www.xprogramming.com
  • 5. The TDD cycle
    • Add a test
    • Run all tests and see if the new one fails
    • Write code
    • Run all tests and see the new test succeed
    • Refactor the code
    Test Code Refactor source: Test-Driven Development by Example, by Kent Beck
  • 6. TDD Key Principles
    • Write code if and only if an automated unit test fails
    • Eliminate duplication and other “ smells”
  • 7. Benefits
    • If done well, TDD can bring tons of benefits:
    • Better test coverage
      • A safety net for refactoring
      • Helps prevent regression
      • Measurable
    • Better design
      • Developer acts as user of his own code
      • Looser coupling
      • Easier to test
      • Constant elimination of “code smells”
  • 8. Benefits (continued)
    • Functionality required only
      • “ You Ain’t Gonna Need It” (YAGNI) principle
      • Lower maintenance cost
    • Helps managing fear in face of complexity
      • Brings confidence in the code base
      • Decreases pressure
    • Documents code
      • Lots of example usage of the code
  • 9. Benefits (continued)
    • Improves overall quality
      • Reduces number of bugs released
      • Reduces chances of bugs reoccuring
  • 10. TDD Adoption Stages
    • The developer starts writing unit tests around their code using a test framework like JUnit or TestNG.
    • As the body of tests increases the developer begins to enjoy a strongly increased sense of confidence in their work.
    • At some point the developer has the insight (or are shown) that writing the tests before writing the code, helps them focus on only writing the code that they need.
  • 11. TDD Adoption Stages (continued)
    • The developer also notices that when they return to some code that they haven't seen for a while, the tests serve to document how the code works.
    • A point of revelation occurs when the developer realizes that writing tests in this way helps them to "discover" the API to their code. TDD has now become a design process.
    • Expertise in TDD begins to be drawn at the point where the developer realizes that TDD is not about testing, it is about defining behavior.
    • Behavior is about the interactions between components of the system and so the use of mocking is a fundamental to advanced TDD.
    source: www.behaviour-driven.org
  • 12. Pitfall stopping midway
    • Too many integration tests vs unit tests
    • Tests more complex
    • Tests become constraint on change
    • Tests take much time to run
    • Tests code tightly coupled to implementation
    • A common failure mode for code bases on Agile projects
    • A solution: Use Mocks!
  • 13. Adopting a test strategy Unit tests Integration tests Functional tests Acceptance tests + - $$
  • 14. Another Categorization Unit tests Integration tests + - $$ Unit tests Integration tests End-to-end tests Customer tests Developer tests
  • 15. Making TDD stick
    • Classroom training
    • Use measurement tools
    • Pair programming
    • Support from management
    • Community
    • Coding dojos
    • Reading workshops
    • Patience… it will take more time than you expect!
    • Pizza
    source: www.infoq.com, Making TDD stick, Problems and Solutions for Adopters, by Mark Levison
  • 16. References
    • Test-Driven Development by Example ,
    • Kent Beck – Addison-Wesley, 2002
    • http://www.xprogramming.com
    • http://www.behaviour-driven.org
    • Making TDD Stick, Problems and Solutions for Adopters , Mark Levison, http://www.infoq.com, January 2009
  • 17. Questions ?