Test Driven Development (TDD) in Java - Unit Testing and Refactoring

Tools, patterns and techniques for writing well-designed and testable code
Overview

This course presents a number of modern practices for developing code based on an iterative and incremental development lifecycle. Agility and predictability are two qualities often missing from software development. A test-driven approach, in which design is grown and code delivered incrementally according to functionality or risk, forms the basis of the construction phase of an iterative and incremental development.

Course Code
TDDJ2UTR
Duration
2 Days
Delivery Style
Classroom
Course Type
Private Only
Max Delegates
12
Available as Nutshell
No

Book your team training at your premises

  • Date
  • Venue
  • Cost
  • More info
Purpose of this course

The use of unit testing provides confidence in existing code and supports the ability to refactor code as development unfolds.The course is intended as a practical course: the best way to appreciate how test-driven development works and what it feels like is to do it in practice, making sense of the principles it embodies. In this form the course is based on lecture material, demonstration, discussion and hands-on labs.

Who is this course for

The course is suitable for software developers experienced in Java and familiar with objectoriented principles and practices.

You will learn how to
  • Appreciate the benefits of a continuous and iterative approach to design and delivery
  • Recognise the purpose and practice of refactoring in keeping a system supple and adaptable
  • Know how to build up a set of unit tests in JUnit
  • Understand the consequences of dependency management on testing and code quality
Benefits for your organisation

TDD and Agility offer a wealth of benefits to your organisation, it can cut development costs for example.  Shorten the development Time to Market and increase the programmer’s productivity.  As well as encouraging the writing of quality code.

Benefits for you as an individual

TDD has many benefits but it can be hard to learn alone.  This course will help you write effective, organized and neat code that works.  It will teach you how to shorten the development feedback time and provide proof that your software code works as intended.

Agile Development Microprocess
  • Traditional versus agile development processes
  • Iterative and incremental development
  • Informal and continuous design
  • The role of refactoring
  • Refactoring versus other code changes
  • Extreme Programming
  • Test-Driven Development
Testing in Principle
  • Traditional view and reality of testing
  • Driving development through testing
  • Testing early, often and automatically
  • Testing versus debugging
  • White-box versus black-box testing
  • Functional versus operational testing
Basic Unit Testing in Practice
  • Test plans versus test code
  • Use of Assert
  • Testing at the interface
  • Testing the simplest things first
  • Testing incrementally
  • Testing correctness of failure
Overview of JUnit
  • JUnit and the xUnit family
  • Test cases, test suites and test runners
  • Essential structure of the framework
  • Assertion methods
  • Testing correctness of exceptions
  • Defining common fixture code
  • JUnit pattern usage
  • Extensions to JUnit
Test-Writing Techniques
  • Red, green, refactor
  • None to one to many
  • Faking it
  • Telling the truth
  • Isolated and short tests
  • Refactor common fixture code
  • Declare, prepare, assert
  • Test by method, state or scenario
  • Custom assertions
  • Compile-time constraints
  • Running all tests
Common Refactorings
  • Renaming variables, methods, classes and packages
  • Restructuring class hierarchies by extracting interfaces, superclasses and subclasses
  • Partitioning classes by extracting classes and methods
  • Changing private representation
Decoupling Techniques
  • Unmanaged dependencies
  • Test-driven decoupling
  • Layering
  • Reorganising packages
  • Eliminating cyclic dependencies
  • Mock objects
  • Eliminating Singletons, statics and other globals
  • Testing I/O
Prerequisites

Any previous exposure to JUnit or agile development concepts is beneficial but not essential.

Need help with this course?

About the Lead Trainer

Howie Bartrip

Our Agile ‘evangelist’ and Certified Scrum Trainer (CST), it’s safe to say that Howie lives and breathes an Agile life. Never to be seen without a pack of post it notes and a sharpie pen in his back pocket, Howie coaches and trains our customers by sharing his passion for more efficient ways of working.