Test Driven Development and Refactoring Legacy Code Using Java

Register this course-$990 online or $1500 in DC class
Pick your class type Total: $

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:


Course Prerequisites

Java SE 5+ programming experience and an understanding of object-oriented design principles like Object Oriented Programming with UML Workshop. Our Java Programming course or equivalent knowledge provides a solid foundation.


Overall Info About our Classes

Highlights

Enrollment Fee

In-person in DC for $1500 or Online for $990 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

Time

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.


11- Continuous Integration Servers/Automated Testing

  • Early Warning of Conflicts
  • Metrics and Tools
  • Checking into Repository
    • Team Foundation Server (TFS)
    • Subversion
  • Continuous Integration Servers
    • CruiseControl.NET
    • Hudson
  • Automating the Build/Deployment

12- Risks Changing Legacy/Production Systems

  • Refactoring
  • Coupling and Cohesion Issues
  • Taking Small Tested Steps
  • Anti-Pattern: Big Bang, Boom

Register this course-$990 online or $1500 in DC class
Pick your class type Discount or coupon code: Total: $

View Other Classes!