It's time to finish up our Robolectric testing

by making sure that our launch activity button is working correctly.

Let's create a new test method at the bottom of the class and name it

buttonLaunchesOtherActivity.

And let's make sure it can throw an exception.

Then let's copy and paste in the arrange/act/assert comments and

get started arranging our test.

First, just like in main activity presenter test,

we'll need a class variable.

Class clazz = OtherActivity.class.

Next, in the act section, we need to click the button.

Let's type activity.launchActivityButton.callOnClick.

And finally for

the assert section, we just need to verify that we launched our other activity.

This is where things start to get a little bit tricky.

Remember, Robolectric isn't actually running our app.

So when we call the on click method of our launch activity button

It's not actually going to launch the other activity.

So instead of checking that we launched our other activity.

We'll just check that main activity calls start activity with the correct intent.

An easy way for us to do this with Robolectric is to use a Shadow Class.

A Shadow Class functions similarly to a mocked class,

like our mocked view we created earlier.

But behind the scenes, it's a little different.

When an Android framework class is first created, Robolectric looks for

a corresponding Shadow Class.

And if it finds one, it creates the corresponding shadow object.

Then, whenever a method is called on that framework class,

Robolectric first calls that method on the Shadow Class.

This way, the developers of Robolectric are able to capture

whatever is being called on the framework.

But, more importantly for us, it lets them add helpful methods to the shadow classes

to make testing less of a hassle.

One of these helpful methods from the Activity Shadow Class is called

getNextStartedActivity, which gives us null if there hasn't been a next activity,

or if there has it returns the intent of the next started activity.

Just what we're looking for.

So right below our assert comment, let's create a new ShadowActivity,

named shadowActivity.

And let's set it equal to Shadows.shadowOf and pass in our activity.

Alt+Enter to import shadows.

Then let's create a new Intent variable called actualIntent

and set it equal to, after importing the Intent class,

shadowActivity.getNextStartedActivity.

Now, we just need to create the expected intent,

which will do in the arrange section.

Intent, expected

intent and on second glance it looks like

this variable up here should probably be called actual color.

So let's change that real quick and

then back to our intent which equals a new intent and

we can pass in our activity for the context.

And then our clazz variable or the class.

And last but

not least, let's assert that the actual intent matches the expected intent.

assertEquals(expectedIntent, actualIntent),

nice.

Now let's comment out the act section so we can see the test fail.

Then let's right-click and run our test.

And just like we expected, it failed.

There was no next started activity, and we ended up with a null intent.

Now let's uncomment out the act section and run our test again.

And what?

It failed again?

If we look at the differences between these two Intents

they look basically the same, but

it does look like there might be an extra space on the left side here.

Either way here's what we need to know.

Intents can have small differences which can make two

seemingly identical Intents not actually equal to one another.

But using the filter equals method of the Intent class,

lets us ignore the small differences and instead

just tells us if the two Intents are equivalent from a functional standpoint.

Let's delete the assert statement and

rewrite it to instead make use of this filter equals method.

AssertTrue(expectedIntent.filterEquals(ac- tualIntent)).

Then let's run the test again.

And [LAUGH] there we go!

A passing test.

Finally let's right click somewhere at the top of the class and choose

run main activity test to run all 3 tests at once and

what do we get 3 passing test

Robolectric is a supremely cool way to test your Android apps.

It lets us write tests as if there's an actual device there

even though there's not but that's not always the best solution.

Sometimes you just can't get around using an actual device and the next stage.

We'll see how we can test the UI directly using espresso.