Launch the Spring Tool Suite by using the shortcut link on your desktop.

After double-clicking the shortcut, you will see the STS splash image appear.

You will be asked to select a workspace. You should accept the default location offered. You can optionally check the box labeled use this as the default and do not ask again.

Now that STS is up and running, you'll notice that, within the Package Explorer view on the left, projects are organized by Working Sets. Working Sets are essentially folders that contain a group of Eclipse projects. These working sets represent the various labs you will work through during this course. Notice that they all begin with a number so that the labs are organized in order as they occur in this lab guide.

If it is not already open, expand the 01-spring-intro Working Set. Within you'll find two projects: spring-intro and spring-intro-solution. spring-intro corresponds to the start project. This pair of start and solution projects is a common pattern throughout the labs in this course.

Open the spring-intro project and expand its Referenced Libraries node. Here you'll see a number of dependencies similar to the screenshot below:

For the most part, these dependencies are straightforward and probably similar to what you're used to in your own projects. For example, there are several dependencies on Spring Framework jars, on Hibernate, DOM4J, etc.

In addition to having dependencies on a number of libraries, all lab projects also have a dependency on a common project called rewards-common.

This project is specific to Spring training courseware, and contains a number of types such as MonetaryAmount, SimpleDate, etc. You'll make use of these types throughout the course. Take a moment now to explore the contents of that jar and notice that if you double-click on the classes, the sources are available for you to browse.

In the next labs, you will often be asked to work with TODO instructions. They are displayed in the Tasks view in Eclipse/STS. If not already displayed, click on Window -> Show View -> Tasks (be careful, not Task List). If you can't see the Tasks view, try clicking Other ... and looking under General.

By default, you see the TODOs for all the active projects in Eclipse/STS. To limit the TODOs for a specific project, execute the steps summarized in the following screenshots:

The RewardNetwork is responsible for carrying out rewardAccountFor(Dining) operations. In this step you'll be working in a class that implements this interface. See the implementation class below:

Take a look at your spring-intro project in STS. Navigate into the src/main/java source folder and you'll see the root rewards package. Within that package you'll find the RewardNetwork Java interface definition:

The classes inside the root rewards package fully define the public interface for the application, with RewardNetwork being the central element. Open RewardNetwork.java and review it.

Now expand the rewards.internal package and open the implementation class RewardNetworkImpl.java.

RewardNetworkImpl should rely on three supporting data access services called 'Repositories' to do its job. These include:

This relationship is shown graphically below:

Locate the single constructor and notice all three dependencies are injected when the RewardNetworkImpl is constructed.

In this step you'll implement the application logic necessary to complete a rewardAccountFor(Dining) operation, delegating to your dependents as you go.

Start by reviewing your existing RewardNetworkImpl rewardAccountFor(Dining) implementation. As you will see, it doesn't do anything at the moment.

Inside the task view in Eclipse/STS, complete all the TODOs. Implement them as shown in Figure 1.10

How do you know the application logic you just wrote actually works? You don't, not without a test that proves it. In this step you'll review and run an automated JUnit test to verify what you just coded is correct.

Navigate into the src/test/java source folder and you'll see the root rewards package. All tests for the rewards application reside within this tree at the same level as the source they exercise. Drill down into the rewards.internal package and you'll see RewardNetworkImplTests, the JUnit test for your RewardNetworkImpl class.

Inside RewardNetworkImplTests you can notice that in the setUp() method, 'stub' repositories have been created and injected into the RewardNetworkImpl class using the constructor.

Review the only test method in the class. It calls rewardNetwork.rewardAccountFor(Dining) and then makes assert statements to evaluate the result of calling this method. In this way the unit test is able to construct an instance of RewardNetworkImpl using the mock objects as dependencies and verify that the logic you implemented functions as expected.

Once you reviewed the test logic, run the test. To run, right-click on RewardNetworkImplTests and select Run As -> JUnit Test.

When you have the green bar, congratulations! You've completed this lab. You have just developed and unit tested a component of a realistic Java application, exercising application behavior successfully in a test environment inside your IDE. You used stubs to test your application logic in isolation, without involving external dependencies such as a database or Spring. And your application logic is clean and decoupled from infrastructure APIs.

In the next lab, you'll use Spring to configure this same application from all the real parts, including plugging in real repository implementations that access a relational database.