USA & Canada: +1 240-200-6131 International Call: +1 240-391-8360
9am-6pm DC time or 1pm-10pm GMT
Test Driven Development and Refactoring Legacy Code Using Java
Course Code: hsts-c35
What is included in this course
Course Description
This course provides students with hands-on experience learning Test Driven Development (TDD) using JUnit. Students will build unit tests using mocks, fakes, stubs and drivers, and address issues working with databases and other systems. Student will create tests and code that will be more likely to meet and exceed requirements. Code that receives “test coverage” will not break existing systems, because tests are passed before code is checked in.
Students will spend time working with the issues involved in refactoring legacy code, safely cutting into an already deployed system. Students will work on looking for, or creating “seams” to more safely improve code or add features, and work on identifying “code smells” that need attention in a productive system.
Finally, students will explore dependency issues as well as techniques to better understand and improve complex systems.
Students will also examine TDD and refactoring legacy code in other languages like C# to gain a broader view of options and issues working in a multi-language shop. Comprehensive labs using Java provide facilitated hands-on practice crucial to developing competence and confidence with the new skills being learned.
You will learn:
Agile development and the test-driven development paradigm
Creating tests from use cases and/or Agile methodology
Unit testing using JUnit
Testing code that interacts with databases
Using mocks, fakes, and stubs
Automating tests, builds and check-ins using a continuous integration server
Refactoring existing code to improve clarity, readability and maintainability
Identifying patterns useful in TDD including the SOLID principles
Identifying and eliminating dependencies that make code difficult to maintain and extend
Tracking code coverage and analyzing other code metrics to improve code maintainability
Using the seam model to identify appropriate places in the code to make changes safely
Identifying and correcting various types of code smells
Using effect sketches and pinch points to identify optimal places for tests
Using feature sketches to identify opportunistic refactoring
30 hours of hands-on training led by experienced instructors
Digital courseware and online course tracking
Final course project delivery
Certificate of Completion for each course
Session-based assignment
Enrollment Fee
In-person in DC for $1900 or Online for $1300 per course
Course Session Dates
Our courses are offered all year around. Upon registration we enroll you to the earliest available class but you can reschedule it free of charge.
Location
In Person at our DC office @ 3165 Mt Pleasant St NW
Private custom training on site or at your location
Project based training cn site or at your location
Time
Online Monday-Friday: 11 am-5:30 pm EST
DC Monday-Friday: 9 am-3:30 pm EST
DC/Online Saturdays: 11 am-5:30 pm EST
DC/Online Sundays: 1 pm-7:30 pm EST
Private custom & project based training: your preference
Software Versions
Our classes are taught on the most current version of software whenever possible. To request a specific version, please Contact Us or call us at 240-200-6131
Course Outline
Topics Covered in this Course
1- Why TDD? Think Twice, Write Production Code Once
Utilizing a Safety Net of Automated Testing
Agile Development Concepts
Eliminating Bugs Early
Smoothing Out Production Rollouts
Writing Code Faster via Testing
Reducing Technical Debt
Practicing Emergent Design
Making Changes More Safe
The Importance of Regression Testing
2- Basic Unit Testing
JUnit
3.x vs 4.0 JUnit Testing
Adding Complexity to Initial Simple Tests
Making Tests Easy to Run
The TDD Pattern: Red, Green Refactor
Using Methods of the Assert Class
Boundary Testing
Unit Test Limitations
3- Comprehensive Unit Testing Concepts
Using Declarative-Style Attributes
Using Hamcrest Matchers for More Complex Scenarios
Using Test Categories
Exception Handling in Tests
JUnit Test Initialization and Clean Up Methods
Writing Clean and Dirty Tests
Testing with Collections, Generics and Arrays
Negative Testing
4- Mocks, Fakes, Stubs and Drivers
TDD Development Patterns
Naming Conventions for Better Code
Using Mock Objects
Using Fakes
Using Stubs
Test Doubles
Manual Mocking
Mocking with a Mock Framework
Self-Shunt Pattern
5- Database Unit Testing
Mocking the Data Layer
Identifying what Should Be Tested in Databases
Stored Procedure Tests
Schema Testing
Using NDbUnit to Set Up the DB Test Environment
6- Refactoring Basics
Refactoring Existing Code
Restructuring
Extracting Methods
Removing Duplication
Reducing Coupling
Division of Responsibilities
Improving Clarity and Maintainability
Test First - then Refactor
More Complex Refactoring Considerations
7- Patterns and Anti-Patterns in TDD
The SOLID Principles
Factory Methods
Coding to Interface References
Checking Parameters for Validity Test
Open/Closed Principle: Open to Extension, Closed to Change
Breaking Out Method/Object
Extract and Override Call
Extract and Override Factory Method
Singleton Pattern
Decorator Pattern
Facade Pattern
State Pattern
MVP, MVC and MVVM Patterns
Finding and Removing Code Smells/Antipatterns
8- Refactoring Legacy Code
Reducing Risk of Change
Eliminating Dependencies
Characterization Tests as a Safety Net
Introducing Abstractions to Break Dependencies
Analyzing Legacy Code
Identifying Pinch Points with Effect Analysis
Identifying Seams for Expansion and Testing
Listing Markup
Minimizing Risk of Adding New Behavior
Sprout Method
Sprout Class
Wrap Method
Wrap Class
Dealing with Code that's Difficult to Test
Globals and Singletons in Tests
Inaccessible Methods and Fields
Using Smells to Identify What to Refactor
Dealing with Monster Methods
Dealing with Excessively Complex, Large Classes
Identifying and Eliminating Duplication
Other Smells
Dealing with Large Legacy Systems
Preserving Signatures
9- Code Coverage
White Box vs Black Box Testing
Planning to Increase Code Coverage Over Time
Goal 80% or More Test Coverage
Statement Coverage
Condition Coverage
Path Coverage
Test Harnesses
Unit-Testing Harnesses
10- System, Regression and Acceptance Testing
Statistical Sampling
Usability Testing
Test Protocols
Regression Testing
Acceptance Testing
The following topics may be included at the discretion of your instructor.