With our test contacts ready to rock, let's get to writing these tests.

The first thing we'll do is Autowire our service under test that is

the Weather Service.

So I'll create an Autowired field here Weather Service, and I'll name it service.

Next, let's tell about our test methods.

Now, we could go crazy testing the service that utilizes the external forecast at

IO API.

Here, we'll just test a few pieces of the actual API response.

First, we'll make sure that the latitude and longitude that come back

from the API response match what we included in the request.

The reason I'm doing this is because I want to make sure that the forecast data

I'm getting back is actually for

the location I requested and not some other location.

So, here's that method stub.

We'll say it's a test method.

Public void, and we want to test if

findByLocation_ShouldReturnSameCoords.

Next, let's make sure we get back eight days of forecast data.

So next, I'll right a test method that's called findByLocation, and

it should return 8DaysForecastData.

Now, that's today and the next seven days.

Cool.

And finally,

let's make a test that ensures we can get back our current conditions.

So, this test method, will be called public

void findByLocation_ShouldReturnCurrentCondit-

ions Great.

Now keep in mind that the purpose of these tests isn't so

much to ensure that the weather API works, that's for the developers of that API.

Rather this is to ensure that our application properly

captures those results and sticks the results into the proper objects.

Okay, that said, let's start in on the first method.

So that should be the findByLocation_ShouldReturnSameCoords.

Since we'll need a set of latitude and longitude coordinates to make these

requests, let's create a field for that and set it up in the before method.

So right here, I'll say private Location and abbreviate it loc.

Of course the wild thing to do would be to name it Tone Loc.

Anyway let's import this and go here hit option enter and

want to make sure I pick my object right here.

There it is cool.

And let's create a before method to set that up.

Before.

So public void set up sometimes you'll see this U capitalized.

Doesn't really matter as long as it's annotated with before.

And we'll say loc = new Location and you can pass in whatever coordinates you like.

I've got a set of coordinates that point to Chicago, somewhere in Chicago at least.

9403795.

And -87.6531804 and

then a bunch of 9's.

Cool, and as we're fetching the data,

we're going to get back a weather object so let's create a field for that and

make the service call that stores a weather object into it.

So the field, I'll make right here private Weather weather,

and I will make that service call right here.

Since in all of these tests I'm going to be making a call to that find by location

method of the service.

So I'll say, weather = service.findByLocation and

I'll pass it loc or Tone Loc, whatever you named it.

Now, to test the coordinates in the test method, I'll use Hamcrest and

test the latitude and longitude separately.

So in here I will assertThat and we'll say that the weather.getlatitude and

let's get that assertThat method imported here and

that comes from hamcrest right here.

Cool.

I want to assert that weather.getlatitude

is close to the latitude that I made the API call with.

Now since geo coordinates may not be exact,

we can use a handy hamcrest matcher called close to.

That checks whether or not the actual value is close to an expected value

within a specified margin of error.

And since I'll be reusing this margin of error for longitude,

I'll quickly create a class field for that.

So up here, I'll say private static final double.

I'll call it ERROR_GEO.

Zero point, I don't know, I'll make it a reasonably precise value.

And now here's how we use that CloseTo method.

So, I'll say, closeTo, okay,

loc.getLongitude, ERROR_GEO.

Okay, now we need to import this closeTo method.

So, that's a static import of the matchers.closeTo method and there we go.

We want to assert that this latitude that we get back in the weather object which is

a result of the service call, we want to assert that the latitude is closeTo

the longitude we made the call with within this margin of error.

Of course, we wanna check latitude with latitude.

So I should probably change this to latitude.

Cool.

Now let's copy and paste this for longitude.

So I'll copy this and I will paste this, changing it to longitude.

All right, let's see if this thing runs with our test context.

So, again, with the editor in focus, I'll hit control, shift, R.

Now, you'll see a little more output this time as spring loads only

the specified components from your test context.

And, great.

Still green.

Next test.

Let me collapse this.

And in our next test, let's assert that

we get eight days of forecast data.

So we want to assert that when we get the daily forecast data,

that this list has the size of eight.

Lots of stuff you can do with these Hamcrest matchers.

Again, these matchers are really nice in that you can create some

cool readable code here.

So we're going to assert that this list has this size.

Okay, let's run that again.

Again, you'll see a lot of output from your test context being loaded and

it looks like indeed our second test passed on to the last method here.

For this one, we wanna make sure that the data we get back is time stamped with

the current time within a reasonable margin of error.

Let's create a field for that error margin too,

and this one will be expressed in milliseconds.

So, I'll go right below this one, and I'll say private static final

double ERROR_TIME this time.

And again it's in milliseconds.

So, say as long as it's in within five seconds then I'll be cool with that.

Now the way will do this is that will first grab the current time

as an instant object.

So we’ll say instant.

I'll call it now equals Instant.now.

Excellent.

Then we'll calculate the duration between that instant and

the instant from the weather data returned by the service.

So let's create a variable for that.

So the duration will say as duration.between.

We'll say it's between now and

weather.getCurrently().getTime and

we will convert that to milliseconds, toMillis().

So we're going to get the duration between now and

whatever time stamp comes back expressed in milliseconds.

Storing that into the double variable we have named duration.

And finally, we will assertThat the duration, again using this closeTo method,

the duration is close to 0 within this margin of error.

All righty, with our final piece of test code written for

the weather service, let's fire it up one more time.

Our test contacts loading and it looks like all three tests passed.

Boom, hey we're seeing a lot of green today, but

I guarantee you that the grass isn't always this green.

There might be a lot of red as you try to get these working on your machine,

whether it's for this project or for another.

But hey keep at it.

You'll eventually get there.