With DB units set up for DAO tasks in our test XML data in place for insertion

before the beginning of our DAO test, we're ready to code some test methods.

First there's something we need to take care of in our set up method, so

let's code that.

That's going to be annotated with before public void setup.

Now each of our DAO methods that we're testing contains a custom query that

injects authentication data.

That means our DAO under test is going to need that authentication data available

for injection.

To get that started, let's instantiate the user object that we'd like to impersonate

for our tests, also a user make sure I'm choosing user in my application.

So User user = new User(); and I'll use user one who has an ID of one.

So user.setId we'll say (1L) in the long form then we need

to make sure spring security recognizes this user as the one who authenticated.

One way we can do that is to set the authentication object of the security

content, here's how we do that, we use SecurityContextHolder

right here .getContext( ).setAuthentication( );.

And we will set a (new UsernamePasswordAuthenticationToken

with this user, and we don't care so

much about the actual credentials, so I will use null there.

Now let's write a couple tests.

Let's test the find all method for user one.

So let's create a test for that and I'll say public void.

We'll say that findAll_ShouldReturnTwo favorites.

And as a second test, public void

we'll say that a save_ShouldPersistEntity,

throws Exception.

To facilitate our assertions, I'm going to pull in a couple static imports,

you can use your IDE to do this or you can type them yourselves.

So, import static, I'm gonna use those ham crest matchers,

org.hamcrest.MatcherAssert.* and

then import static, org.hamcrest.Matchers.*.

Okay, now back down to the first test, for

its implementation let's assertThat(dao.findAll( ),

hasSize(2)); and let's code the test for

saving before running our test.

Here we'll create a favorite object and set its place ID.

Now I'm going to use that favorite builder, so Favorite fave

= new_Favorite.FavoriteBuilder.

And then you can say withPlaceId and

then just make one up, I'll say treehouse and it doesn't really matter.

OK cool and then, don't forget when you're using a builder,

don't forget to build that thing.

Okay, if you want to remove this right here,

which is always nice, you can do a static import of that.

So I can go up here, import static

com.teamtreehouse.domain.Favorite.Favorit- eBuilder.

Cool, that whole import statement to save that little bit of typing.

Well I suppose it's up for a debate whether or not that was worth it.

Okay, so cool, I've got my favorite object nonetheless.

So let's use the DAO that is auto-wired up here to save this entity.

So I'll say dao.saveForCurrentUser and

then I'll save that fave, so happy that rhymed.

Now in order to ensure that the entity was indeed persisted,

let's make sure that the find-by-place ID method returns a non null favorite object.

So here I will assert that

the dao.findByPlaceID using the same place ID here.

Now since I'm copying and pasting this text, I should probably create a string

variable for it so I don't end up with a failing test simply because I mistyped.

So it would be nice to do something like this and like this, placeId.

Okay, let's make that possible, placeId, and let's paste that right there.

Cool, let's make sure the dao.findPlaceId is not null,

notNullValue and it is an instance of Favorite.class.

Okay,sSo we want to make sure that when we call the DAO find by place ID passing it

the same ID that what we get back is a non null favorite object.

Just another thing that's available to you in this hamcrest library.

Okay, now for one final time in this workshop, let's run these tests.

Ctrl+Shift+R.

And here you'll see a full application context being created,

which is why you see that Spring Boot logo show up top and look at that, green again!

Now as I said earlier, the test grass aint always this green,

you might get some errors upon running your test that you don't understand.

If there are errors in running tests,

be sure to scroll through all that output to get the root of any exceptions that

might be occurring when the spring test framework attempts to run your tests.

These exceptions can be the fuel for

online searches in pursuit of answers to all your testing questions.