HomeCoursesTest-Driven Development in Java

Intermediate

32h

Updated 5 months ago

Test-Driven Development in Java
Save

Gain insights into test-driven development and hexagonal architecture. Learn about uncovering design flaws, using SOLID principles, and integrating domain logic with databases and web layers for defect-free code.

Join 2.7 million developers at

Overview

Content

Reviews

Test-driven development (TDD) and hexagonal architecture enable developers to engineer code that is known to work and easy to work with. The techniques described in this course enable code to be delivered to production with few defects and a structure that can be easily and safely changed. You’ll begin by learning the importance of test-driven development (TDD) and its costs and benefits, with examples of bad code and its impact on team performance. You’ll learn how good code and TDD can uncover design and logic flaws early. You’ll also learn how SOLID principles and hexagonal architecture create well-engineered, testable code and how test doubles manage external dependencies. Finally, you’ll integrate the sample application’s domain logic with the database and web layers. By the end of this course, you’ll have mastered testing complexities and learned to integrate code with external systems with a deep understanding of practical techniques to elevate your development practices.

Test-driven development (TDD) and hexagonal architecture enable developers to engineer code that is known to work and easy to wo...Show More

WHAT YOU'LL LEARN

An understanding of the need for automated testing and test-driven development (TDD)

The ability to write well-engineered and well-tested code

Working knowledge of TDD techniques such as SOLID principles, hexagonal architecture, and test doubles

Hands-on experience writing integration tests to test-drive the database and API implementation for a sample application

An understanding of the need for automated testing and test-driven development (TDD)

Content

131 Lessons59 Quizzes

Getting Started

1 Lessons

Get familiar with essential TDD techniques and principles for robust Java development.

Introduction and Prerequisites

Building the Case for TDD

6 Lessons

Walk through the impact of bad code and the benefits of Test-Driven Development.

Introduction: Building the Case for TDD

Writing Code Badly

Recognizing Bad Code

Decreasing Team Performance

Diminishing Business Outcomes

Summary and Quiz: Building the Case for TDD

Using TDD to Create Good Code

6 Lessons

Examine how TDD fosters high-quality code, prevents logic flaws, and documents effectively.

Introduction: Using TDD to Create Good Code

Designing Good Quality Code

Revealing Design Flaws

Preventing Logic Flaws

Avoiding Future Defects and Documenting Codes

Summary and Quiz: Using TDD to Create Good Code

Dispelling Common Myths about TDD

8 Lessons

Grasp the fundamentals of dispelling myths to appreciate TDD's benefits and efficacy.

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

We Don’t Know What to Test Until We Write the Code

Summary and Quiz: Dispelling Common Myths About TDD

Building an Application Using TDD

4 Lessons

Solve problems in iterative development using TDD, focusing on agile methods and user feedback.

Introduction: Building an Application Using TDD

Introducing the Wordz Application

Exploring Agile Methods

Summary and Quiz: Building an Application Using TDD

Writing Our First Test

12 Lessons

See how it works to write, optimize, and validate unit tests with TDD principles.

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

Solution: Extending Wordz

Summary and Quiz: Writing Our First Test

Challenge: Basic String Manipulation

Solution: Basic String Manipulation

Following the Rhythms of TDD

9 Lessons

Build on the Test-Driven Development (TDD) cycle to refine code, enhance applications, and validate functionality.

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 and Quiz: Following the Rhythms of TDD

Exercise: Email Address Validator

Solution Email Address Validator

Challenge: FizzBuzz

Solution: FizzBuzz

Driving Design—TDD and SOLID

12 Lessons

Try out TDD techniques and apply SOLID principles to design flexible, maintainable Java code.

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 and Quiz: Driving Design—TDD and SOLID

Exercise: Transforming Shape Area Calculation

Solution: Transforming Shape Area Calculation

Challenge: Pig Latin

Solution: Pig Latin

Test Doubles—Stubs and Mocks

13 Lessons

Walk through using stubs and mocks to facilitate reliable and maintainable unit tests in Java.

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 and Quiz: Test Doubles—Stubs and Mocks

Challenge: Grade System—Stubs and Mocks

Solution: Grade System—Stubs and Mocks

10.

Hexagonal Architecture—Decoupling External Systems

10 Lessons

Examine hexagonal architecture to decouple systems, enhancing testability, maintainability, and robust software design.

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 and Quiz: Hexagonal Architecture—Decoupling External System

Challenge: Hexagonal Architecture for CRUD Operations

Solution: Hexagonal Architecture for CRUD Operations

11.

FIRST Tests and the Test Pyramid

8 Lessons

Break down complex ideas on FIRST tests, the test pyramid, and CI/CD pipelines.

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 and Quiz: FIRST Tests and the Test Pyramid

12.

Exploring TDD with Quality Assurance

7 Lessons

Map out the steps for integrating TDD with quality assurance and manual testing methods.

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 and Quiz: Exploring TDD with Quality Assurance

13.

Test First, Test Later, Test Never

7 Lessons

Focus on TDD principles, testing approaches, and using hexagonal architecture for efficient software testing.

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 and Quiz: Test First, Test Later, Test Never

14.

Driving the Domain Layer

12 Lessons

Master the steps to apply Test-Driven Development in creating robust game logic.

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 and Quiz: Driving the Domain Layer

Challenge: PigLatin Game Domain Layer

Solution: PigLatin Game Domain Layer

15.

Driving the Database Layer

5 Lessons

Try out database integration using DBRider and Jdbi for test-driven development in Java.

Introduction: Driving the Database Layer

Database Integration Test with DBRider

Production Code for Database Integration Test

Building WordRepository and GameRepository Adapters

Summary and Quiz: Driving the Database Layer

16.

Driving the Web Layer

9 Lessons

Unpack the core of developing and testing web endpoints for a microservice architecture.

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 Guesses in the Wordz Gameplay

Integrating Core Components of Wordz Application

Navigating Wordz Game with Microservice Architecture

Summary and Quiz: Driving the Web Layer

17.

Wrap Up

1 Lessons

Explore the significance of TDD, SOLID principles, and test automation in real-world Java projects.

Takeaways and Future Directions

18.

Appendix

1 Lessons

Find out about setting up a Java development environment with IntelliJ, JDK, JUnit, and Gradle.

Technical Requirements

Certificate of Completion

Showcase your accomplishment by sharing your certificate of completion.

Course Author:

Packt

Developed by MAANG Engineers

Every Educative resource is designed by our in-house team of ex-MAANG software engineers and PhD computer science educators — subject matter experts who’ve shipped production code at scale and taught the theory behind it. The goal is to get you hands-on with the skills you need to stay ahead in today's constantly evolving tech landscape. No videos, no fluff — just interactive, project-based learning with personalized feedback that adapts to your goals and experience.

Trusted by 2.7 million developers working at companies

"These are high-quality courses. Trust me. I own around 10 and the price is worth it for the content quality. EducativeInc came at the right time in my career. I'm understanding topics better than with any book or online video tutorial I've done. Truly made for developers. Thanks"

Anthony Walker

@_webarchitect_

"Just finished my first full #ML course: Machine learning for Software Engineers from Educative, Inc. ... Highly recommend!"

Evan Dunbar

ML Engineer

"You guys are the gold standard of crash-courses... Narrow enough that it doesn't need years of study or a full blown book to get the gist, but broad enough that an afternoon of Googling doesn't cut it."

Software Developer

Carlos Matias La Borde

"I spend my days and nights on Educative. It is indispensable. It is such a unique and reader-friendly site"

Souvik Kundu

Front-end Developer

"Your courses are simply awesome, the depth they go into and the breadth of coverage is so good that I don't have to refer to 10 different websites looking for interview topics and content."

Vinay Krishnaiah

Software Developer

Hands-on Learning Powered by AI

See how Educative uses AI to make your learning more immersive than ever before.

Instant Code Feedback

Evaluate and debug your code with the click of a button. Get real-time feedback on test cases, including time and space complexity of your solutions.

AI Mock Interviews

Test your skills in a simulated interview setting. Receive personalized feedback based on your performance. Available for Coding Interviews, System Design, and more.

Adaptive Learning

At various checkpoints throughout Educative courses, you will be prompted to take a quick assessment. Receive a condensed curriculum tailored to your strengths and skill gaps.

Explain with AI

Select any text within any Educative course, and get an instant explanation — without ever leaving your browser.

AI Code Mentor

AI Code Mentor helps you quickly identify errors in your code, learn from your mistakes, and nudge you in the right direction — just like a 1:1 tutor!

Course

Design a Test Automation Framework with Selenium and Java

Delve into designing a test automation framework using Java and Selenium. Learn about Selenium basics, TestNG, build management, logging, and reporting to automate web applications effectively.

12 h

beginner

Course

Unit Testing Java Applications using JUnit 5

Gain insights into unit testing with JUnit 5. Learn about assertions, assumptions, nested and parameterized tests, advanced JUnit 5 concepts, and integrating tests with Maven and Gradle.

3 h 30 m

intermediate

Course

The Complete Java Crash Course

Gain insights into Java, a versatile and portable programming language. Delve into similarities with C++ and Python and learn essential Java-specific features with practical coding examples.

6 h

intermediate

Course

Java Masterclass for Software Developers

Gain insights into Java fundamentals, conditional and loop statements, and operations on arrays. Learn about debugging and creating your initial programs to advance as a proficient Java developer.

24 h

beginner

Course

The All-in-One Guide to Java Programming

Gain insights into Java 17, cloud and microservices, reactive programming, and top JVM languages. Explore hands-on projects using Scala, Groovy, and Gradle to boost your software development career.

11 h

intermediate

Course

Design a Test Automation Framework with Selenium and Java

beginner

12 hour

Course

Unit Testing Java Applications using JUnit 5

intermediate

3 hour 30 min

Course

The Complete Java Crash Course