| Description |
1 online resource |
| Summary |
Drive development with automated tests and gain the confidence you need to write high-quality software Key Features Get up and running with common design patterns and TDD best practices Learn to apply the rhythms of TDD - arrange, act, assert and red, green, refactor Understand the challenges of implementing TDD in the Java ecosystem and build a plan Book Description Test-driven development enables developers to craft well-designed code and prevent defects. It's a simple yet powerful tool that helps you focus on your code design, while automatically checking that your code works correctly. Mastering TDD will enable you to effectively utilize design patterns and become a proficient software architect. The book begins by explaining the basics of good code and bad code, bursting common myths, and why Test-driven development is crucial. You'll then gradually move toward building a sample application using TDD, where you'll apply the two key rhythms -- red, green, refactor and arrange, act, assert. Next, you'll learn how to bring external systems such as databases under control by using dependency inversion and test doubles. As you advance, you'll delve into advanced design techniques such as SOLID patterns, refactoring, and hexagonal architecture. You'll also balance your use of fast, repeatable unit tests against integration tests using the test pyramid as a guide. The concluding chapters will show you how to implement TDD in real-world use cases and scenarios and develop a modern REST microservice backed by a Postgres database in Java 17. By the end of this book, you'll be thinking differently about how you design code for simplicity and how correctness can be baked in as you go. What you will learn Discover how to write effective test cases in Java Explore how TDD can be incorporated into crafting software Find out how to write reusable and robust code in Java Uncover common myths about TDD and understand its effectiveness Understand the accurate rhythm of implementing TDD Get to grips with the process of refactoring and see how it affects the TDD process Who this book is for This book is for expert Java developers and software architects crafting high-quality software in Java. Test-Driven Development with Java can be picked up by anyone with a strong working experience in Java who is planning to use Test-driven development for their upcoming projects. |
| Contents |
Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Part 1: How We Got to TDD -- Chapter 1: Building the Case for TDD -- Writing code badly -- Understanding why bad code is written -- Recognizing bad code -- Bad variable names -- Bad function, method, and class names -- Error-prone constructs -- Coupling and cohesion -- Decreasing team performance -- Diminishing business outcomes -- Summary -- Questions and answers -- Further reading -- Chapter 2: Using TDD to Create Good Code -- Designing good quality code |
|
Say what you mean, mean what you say -- Take care of the details in private -- Avoid accidental complexity -- Revealing design flaws -- Analyzing the benefits of writing tests before production code -- Preventing logic flaws -- Protecting against future defects -- Documenting our code -- Summary -- Questions and answers -- Further reading -- Chapter 3: Dispelling Common Myths about TDD -- Writing tests slows me down -- Understanding the benefits of slowing down -- Overcoming objections to tests slowing us down -- Tests cannot prevent every bug |
|
Understanding why people say tests cannot catch every bug -- Overcoming objections to not catching every bug -- How do you know the tests are right? -- Understanding the concerns behind writing broken tests -- Providing reassurance that we test our tests -- TDD guarantees good code -- Understanding problem-inflated expectations -- Managing your expectations of TDD -- Our code is too complex to test -- Understanding the causes of untestable code -- Reframing the relationship between good design and simple tests -- Managing legacy code without tests |
|
I don't know what to test until I write the code -- Understanding the difficulty of starting with testing -- Overcoming the need to write production code first -- Summary -- Questions and answers -- Further reading -- Part 2: TDD Techniques -- Chapter 4: Building an Application Using TDD -- Technical requirements -- Preparing our development environment -- Installing the IntelliJ IDE -- Setting up the Java project and libraries -- Introducing the Wordz application -- Describing the rules of Wordz -- Exploring agile methods -- Reading user stories -- the building block of planning |
|
Combining agile development with TDD -- Summary -- Questions and answers -- Further reading -- Chapter 5: Writing Our First Test -- Technical requirements -- Starting TDD: Arrange-Act-Assert -- Defining the test structure -- Working backward from outcomes -- Increasing workflow efficiency -- Defining a good test -- Applying the FIRST principles -- Using one assert per test -- Deciding on the scope of a unit test -- Catching common errors -- Asserting exceptions -- Only testing public methods -- Preserving encapsulation -- Learning from our tests -- A messy Arrange step -- A messy Act step |
| Subject |
Java (Computer program language)
|
|
Computer software -- Development.
|
|
Computer software -- Testing.
|
|
Java (Langage de programmation) |
|
Computer software -- Development |
|
Computer software -- Testing |
|
Java (Computer program language) |
| Genre |
Electronic books.
|
| Other Form: |
Print version: 9781803236230 |
| ISBN |
1803237961 (electronic bk.) |
|
9781803237961 (electronic bk.) |
|
paperback |
|
More Resources