Sometimes we want our code to fail in certain ways.

We want to be sure and

raise a value error when someone sends us a string instead of a number.

We want to trigger a does not exist when a database record hasn't been created yet.

So of course we want to test that these exceptions get raised.

Let's look at the assert raises assertion.

So when we read our Roll class and we look here, we see the description is this.

And we have this die_pattern.match, which if we go look at die_pattern,

we see it has to be a number, and then the letter d and then another number.

And if it doesn't do that, we see it raises this value error.

So we know that, that'll happen, right?

If we pass in a bad value then we're gonna get this value error back.

So let's write a test to cover that,

to make sure that it works the way that we think it does.

So we're gonna write a def test_bad_description.

And we're gonna use what's called a context manager which is this width.

It's where we're able to control the context,

we're able to change variable inside, within here.

So we're gonna say self.assertRaises and it's going to raise a value error.

And then we're gonna call dice.Roll and we're gonna pass it in 2b6.

All right? We know that, that's wrong.

So 2b6 because the b and the d don't match, so we know this is wrong.

This assertion is

used a little bit differently than the others that we've used.

We had that width keyword I talked about, the context manager.

And then we're also passing in a value of what the exception is going to be.

And it's a block.

Within that block, then we call the code.

So if the code actually causes the exception, then the test passes and

if it doesn't then it fails.

It's slightly backwards thinking but you really get used to it.

So let's try running this one.

So that works.

So all of our tests have passed and it's because we're so

super smart, or it's because we know what the code's gonna do and

we're writing our test for exactly what the code's gonna do.

Let's write a new test that won't pass, 'kay?

So let's actually go up here to the we're gonna do it down here.

And we're gonna write def_test_small_die.

'Kay, so we're gonna have a small die in this.

So we're gonna do with self.assertRaises(ValueError).

So just like before we're expecting this to,

to fail, we're going to do Roll 1d2.

Now this is actually a totally acceptable die, we can roll a two sided die,

it's called a coin.

So, we know this is valid, so this test should fail.

So lets run this, and it fails.

The value error was not raised, 'kay?

So that's great, we, we know how this fails.

Now we can go in here and we can actually mark this as expected to fail,

if you look at the docs which I'll link to, you'll see that you can mark this.

That's kinda silly.

We know this one's going to fail because this is a bad test case.

So we're just gonna delete it.

Okay.

So, testing for exceptions though, as we've done here with assertRaises

is a great way of making sure that your code fails like you're expecting it to,

and like you want it to.

Somewhat related to assertRaises are the assertWarns and assertLogs assertions.

You can use these to make sure that warnings, or log entries,

are created by your code.