Explore writing unit tests for Java applications using JUnit, delve into JUnit organization, assertions, quality practices, design relevance, refactoring, and using mock objects for dependencies.

Pragmatic Unit Testing in Java 8 with Junit by The Pragmatic Programmer.png

junit.tar.gz

java

test2

test4 - Our first passing test

test6

test14

test16-branch-persistence

AssertTest-13

test15

test15-profile

test15-ProfilePoolTest

test16-BearingTest

test16-RectangleTest

test16-SparseTest

test16-TransmissionTest

test16-ProfileTest

test20m-ProfileTest

test21-Profile

big1-Profile

big1-MatchSet

big4-MatchSetTest

big4-MatchSet

big6

mock-2-AddressRetrieverTest

mock-4-AddressRetrieverTest

mock-5-AddressRetrieverTest

test1-SearchTest

test3-SearchTest

tdd-1-ProfileTest.java 

tdd-2-ProfileTest.java

tdd-3-ProfileTest.java

tdd-4-Profile.java

tdd-5-ProfileTest.java

tdd-9-ProfileTest.java

tdd-10-ProfileTest.java

tdd-10-AnswerTest.java

tdd-11-ProfileTest.java

tdd-12-ProfileTest.java

tdd-14-ProfileTest.java

tdd-15-ProfileTest.java

thread-2-ProfileMatcherTest

thread-3-ProfileMatcherTest

thread-4-ProfileMatcherTest

test16-branch-persistence-redesign-QCTest

AssertHamcrest-13

test16-branch-persistence-redesign-StatCompilerTest

test16-ProfilePoolTest

test15-ProfilePoolTest-copy 16

test3-SearchTest-ContainsMatches

tdd-11-ProfileTest.java-Supporting Multiple Answers

thread-2-ProfileMatcherTest-Testing Multithreaded Code

test2-Our First passing test

test4 - AAA your way to a test

test2-final-intro-junit

In this course, you will learn how to write a unit test for Java applications using JUnit. You'll start by covering unit-testing foundations, which provide you with a starter set of information about writing basic tests in JUnit. You’ll learn about JUnit organization and assertions, and you’ll pick up a few core quality practices for unit testing such as the Right BICEP and the CORRECT way. 

Towards the end, the bigger design picture focuses on the relevance of design to unit testing and vice versa. You’ll refactor your tests, and you’ll learn how to use mock objects to deal with trouble-some dependencies.

Pragmatic Unit Testing in Java 8 with JUnit

# Fast test
We still want the vast majority of our JUnit tests to be fast. This shouldn’t be a problem. If we isolate all of our persistence interaction to one place in the system, we end up with a reasonably small amount of code that must be integration-tested.

# In-memory database
We  might be tempted to consider using an in-memory database such as H2 to emulate our production database for testing purposes. This would help us get the speed we want, but otherwise can be a mess. Attempts we’ve made to use in-memory databases  were fraught with problems due to sometimes subtle differences between the in-memory database and the production RDBMS.

>When we write integration tests for code that interacts with the real database, the data in the database and how it gets there become important considerations. To verify that the database operations return query results as expected, for example, we need to either put appropriate data into the database or assume it’s already there.

# Breaking tests
Assuming that data is already in the database is a recipe for long-term pain. Over time, the data will change without our knowledge, thus breaking tests. Divorcing the data from the test code makes it a lot harder to understand why a particular test passes or not. The meaning of the data with respect to the tests is lost by dumping it all into the database. 

>It’s preferable to let the tests create and manage the data.

# Your own database
If it’s our database on our own machine, the simplest route might be for each test to start with a clean database (or one prepopulated with necessary reference data). Each test then becomes responsible for adding and working with its own data. This minimizes intertest dependency issues, where one test breaks because of data that another test left lying around, which  can be a headache to debug!

# Shared database


Learn how to work with data and the importance of refactoring code.

The Data Problem

Before We Begin

JUnit Test Foundations

Digging Deeper into JUnit Assertions

Organizing Your Tests

Mastering Manic Mnemonics!

What to Test: The Right-BICEP

Boundary Conditions: The CORRECT Way

The Bigger Design Picture

Bigger Design Issues

Using Mock Objects

Refactoring Tests

The Bigger Unit-Testing Picture

Testing Some Tough Stuff

Testing on a Project

Wrapping Up

Appendix - Setting up JUnit

The Data Problem

Fast test

In-memory database