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

# Misleading organization
Knowing which part of the test is the act part, which is the arrange part, and which is the assert can speed up understanding. With this in mind, we can use AAA to make the test’s intent explicit. The highlighted lines in the following listing show the blank lines to insert (`act` or `assert`) for each test:


package util;

// misleading organization
import java.io.*;
import java.net.*;
import java.util.logging.*;
import org.junit.*;
import static org.junit.Assert.*;
import static util.ContainsMatches.*;

public class SearchTest {
   private static final String A_TITLE = "1";
   private InputStream stream;
   
   @Before
   public void turnOffLogging() {
      Search.LOGGER.setLevel(Level.OFF);
   }
   
   @After
   public void closeResources() throws IOException {
      stream.close();
   }

   @Test
   public void returnsMatchesShowingContextWhenSearchStringInContent() {
      stream = streamOn("There are certain queer times and occasions "
            + "in this strange mixed affair we call life when a man "
            + "takes this whole universe for a vast practical joke, "
            + "though the wit thereof he but dimly discerns, and more "
            + "than suspects that the joke is at nobody's expense but "
            + "his own.");
      Search search = new Search(stream, "practical joke", A_TITLE);
      search.setSurroundingCharacterCount(10);

      search.execute();

      assertThat(search.getMatches(), containsMatches(new Match[]
         { new Match(A_TITLE, "practical joke", 
                              "or a vast practical joke, though t") }));
   }

   @Test
   public void noMatchesReturnedWhenSearchStringNotInContent() 
         throws MalformedURLException, IOException {
      URLConnection connection = 
            new URL("http://bit.ly/15sYPA7").openConnection();
      stream = connection.getInputStream();
      Search search = new Search(stream, "smelt", A_TITLE);

      search.execute();

      assertTrue(search.getMatches().isEmpty());
   }

   private InputStream streamOn(String pageContent) {
      return new ByteArrayInputStream(pageContent.getBytes());
   }
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

What should be inserted in lines 35 and 37?

<p>What should be inserted in lines 35 and 37?</p>


What should be inserted in lines 50 and 52?

<p>What should be inserted in lines 50 and 52?</p>


We’re getting close. Time for a final pass against the two tests!

# Implicit meaning

The biggest question each of our tests must clearly answer is:
>Why does the test expect to see this particular result?

Readers must be able to differentiate between the arranged and assert portions of the test. If the reason for getting the result that the assert expects isn’t clear, our readers waste time digging through the code to find an answer.


# Improve correlation across a test
The `returnsMatchesShowingContextWhenSearchStringInContent` test expects a single match on a search for `practical joke` against a very long string. A reader can eventually spot the place in the string where the phrase "practical joke"  appears and can then do the math to figure out that ten characters before it and ten characters after it represent the string:

```
"or a vast practical joke, though t" 
```
But that makes our test readers dig to find understanding. They’ll be annoyed no matter how amusing the test data is. Make things explicit by choosing better test data like changing the input stream to contain only a small smattering of text. Also, we can change the content so that the surrounding context information doesn’t need to be explicitly counted:


Learn the way developers should use the principles of Arrange, Act, and Assert in writing tests.

Test Smell: Implicit Meaning and Misleading Organization

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

Test Smell: Implicit Meaning and Misleading Organization

Misleading organization