Back To Course Home

Test-Driven Development with Java

0% completed

Getting Started

Introduction and Prerequisites

Building the Case for TDD

Introduction: Building the Case for TDD

Writing Code Badly

Recognizing Bad Code

Decreasing Team Performance

Diminishing Business Outcomes

Summar & Quiz: Building the Case for TDD

Using TDD to Create Good Code

Introduction: Using TDD to Create Good Code Designing Good Quality Code Revealing Design Flaws Preventing Logic Flaws Avoiding Future Defects and Documenting Codes Summary & Quiz: Using TDD to Create Good Code

Dispelling Common Myths about TDD

Introduction: Dispelling Common Myths about TDD Writing Tests Slows Me Down Tests Cannot Prevent Every Bug How Do You Know the Tests Are Right?TDD Guarantees Good Code Our Code Is Too Complex To Test I Don’t Know What To Test Until I Write the Code Summary & Quiz: Dispelling Common Myths about TDD

Building an Application Using TDD

Introduction: Building an Application Using TDD Introducing the Wordz Application Exploring Agile Methods Summary & Quiz: Building an Application Using TDD

Writing Our First Test

Introduction: Writing Our First Test Starting TDD: Arrange-Act-Assert Defining a Good Test Catching Common Errors and Asserting Exceptions Preserving Encapsulation Finding Design Flaws With Unit Testing Beginning Wordz Exercise: Extending Wordz Summary & Quiz: Writing Our First Test Challenge: Basic String Manipulation

Following the Rhythms of TDD

Introduction: Following the Rhythms of TDD Following the Red-Green-Refactor Cycle Writing Our Next Tests for Wordz Advancing the Design With Two-letter Combinations Summary & Quiz: Following the Rhythms of TDD Exercise: Email Validator Challenge: FizzBuzz

Driving Design—TDD and SOLID

Introduction: Driving Design—TDD and SOLID Test Design with SOLID Principles Simplifying Maintenance with SRP Implementing DIP for Enhanced Flexibility Understanding LSP in OOP Implementing OCP in OOP Effective Interface with ISP Summary & Quiz: Driving Design—TDD and SOLID Exercise: Transforming Shape Area Calculation Challenge: PigLatin

Test Doubles—Stubs and Mocks

Introduction: Test Doubles—Stubs and Mocks Testing Challenges in Collaborative Software Development Mastering Test Challenges with Test Doubles and SOLID Principles Using Stubs for Controlled Testing Exploring Mock Objects in Testing Understanding When Test Doubles Are Appropriate Automating Test Doubles with Mockito Mockito for Efficient Test Double Creation Testing Exception Handling with Mockito Testing an Error Condition in Wordz Summary & Quiz: Test Doubles – Stubs and Mocks Challenge: Grade System - Stubs & Mocks

Hexagonal Architecture—Decoupling External Systems

Introduction: Hexagonal Architecture—Decoupling External Systems Challenges of External Systems Enhancing Testability and Maintainability through SOLID Principle Abstracting External Systems in Hexagonal Architecture Crafting the Domain Model Efficient Testing with FIRST Unit Tests in Hexagonal Architecture Abstracting the Database Using Hexagonal Architecture Summary & Quiz: Hexagonal Architecture—Decoupling External System Challenge: Hexagonal Architecture for CRUD Operations

FIRST Tests and the Test Pyramid

Introduction: FIRST Tests and the Test Pyramid Test Pyramid: A Structured Approach to Effective Testing Integration Tests in Test Pyramid Understanding End-to-End and User Acceptance Tests CI/CD Pipelines for Optimizing Software Development Workflow CI/CD Pipelines and Test Environments in Production Integration Testing in Wordz Summary & Quiz: FIRST Tests and the Test Pyramid

Exploring TDD with Quality Assurance

Introduction: Exploring TDD with Quality Assurance Exploring TDD's Role in Software Quality Assurance Manual Exploratory Testing—Discovering the Unexpected Balancing Automation and Human Review Crafting User-Centric Interfaces by UI and UX Testing Development Through Secure Operations and Balanced Practices Summary & Quiz: Exploring TDD with Quality Assurance

Test First, Test Later, Test Never

Introduction: Test First, Test Later, Test Never Adding Tests First Risks Associated with Delayed Testing in TDD Consequences of Avoiding Test Automation Inside-Out vs. Outside-In Testing in TDD Mastering Test Strategies with Hexagonal Architecture Summary & Quiz: Test First, Test Later, Test Never

Driving the Domain Layer

Introduction: Driving the Domain Layer Initiating a New Wordz Game Instance Tracking the Progress of the Wordz Game Triangulating Word Selection in Wordz Using Mock Setup Asserting Word Selection and Refactoring Using Mock Setup Designing the Gameplay Interface for Wordz Triangulating Game Progress Tracking by Refactoring Handling Guesses, Attempts, and Game Over Conditions Wordz Design Evaluation and Optimization Summary & Quiz: Driving the Domain Layer Challenge: PigLatin Game Domain Layer

Driving the Database Layer

Introduction: Driving the Database Layer Database Integration Test with DBRider Production Code for Database Integration Test Building WordRepository and GameRepository Adapters Summary & Quiz: Driving the Database Layer

Driving the Web Layer

Introduction: Driving the Web Layer Configuring and Testing HTTP Endpoints Building HTTP Server for Wordz Application Streamlining Game Initialization in Wordz Managing Game Start Errors in Wordz Handling Multiple Guess in Wordz Gameplay Integrating Core Components of Wordz Application Navigating Wordz Game with Microservice Architecture Summary & Quiz: Driving the Web Layer

Wrap Up

Takeaways and Future Directions

Appendix

Technical Requirements

Recognizing Bad Code

Let's identify indicators of poor code quality and understand the reasons behind its creation.

We'll cover the following

Identifying bad code
Bad variable names
Bad function, method, and class names
A name’s length depends on namespacing
Error-prone constructs
Coupling and cohesion
- Low cohesion inside a class
  - Curse of low cohesion
- High coupling between classes
  - Curse of high coupling

Identifying bad code

Now that we’ve seen an example of code that is difficult to work with, and understood how it came about, let’s turn to the obvious next question: how can we recognize bad code? Admitting that our code is difficult to work with is one thing, but to move past that and write good code, we need to understand why code is bad. Let’s identify the technical issues.

Bad variable names

Good code is self-describing and safe to change. Bad code is not.

Get hands-on with 1200+ tech skills courses.