So in this video, we're going to think about how to create unit tests that expect an exception to be thrown, which is a little bit backwards in some respects.

But no, we need to test all our logic, and we need to ensure that a code that throws exceptions at certain situations actually does do that.

We've got a class here called PriceCalculator. We've got a function called CalculateFinalPrice and its purpose is in calculating sums of money.

You've probably seen this, some of you will have seen this on previous courses. But, at the top of the function, we've got a couple of if expressions that check to see if a price is less than 0 or a quantity is less than or equal to 0.

And in those two situations, the function is going to throw an argument exception, saying, “You can't give me a parameter that's equal to 0 or less than 0, because that doesn't make any sense. You can't have a negative price, you can't have a negative quantity.”

So, there's an aggressive piece of code here that says if you don't give me good data, you're going to get an exception thrown at you.

And we want to check to make sure this logic works when these bad values get passed in. And I want to do that through unit testing.

So, we've got our calculator test project, we've got the dependency set up, so the calculator test projects referencing the price calculator library projects.

And we've got some unit tests.

We've got unit tests for all the good data and, down the bottom, added a couple more methods that check for argument exception.

And in essence, it's actually quite straightforward.

We've got some arranging of values that we're going to be passing into the function under test, the class under test, the CalculateFinalPrice method, and we're passing in a base price of 0, which we are hoping, for the purpose of this test, will trigger the exception.

And so, the Assert class supports a Throws function or method, and that method is generic.

So it takes, in this case, a particular kind of exception.

We can be very specific about the exception it takes or be more general about the exception it takes.

Here, we're being specific, and we're saying, “I'm expecting this piece of code will throw an argument exception and if it does, the test will pass. If it doesn't, the test will fail.”

OK, the way these things are set up at the moment is if I run this test in isolation, it will pass because the exception does get thrown.

Waiting for that to happen and you can see it's done that.

If I go back into the underlying code and make that exception not get thrown by just commenting out these two lines of code and running that again, we should see that test now fails because the exception was not thrown.

And we look at the messaging beneath.

Just try and grab that and we can see no exception has been thrown.

I expected an argument exception, I didn't get one.

So, the test fails because the exception wasn't thrown, which seems fairly reasonable.

Let's go back and fix that code and then come back to the tests.

Now the other thing we can do, like we saw with earlier unit testing is we can create a theory.

And in this case, we've got four separate inline data attributes, which basically means this one unit test is actually four separate unit tests, because these bits of data will get passed into parameters that the unit test function is expecting to receive.

Now, normally, they don't get any parameters, but here there's an expectation of two parameters, the base price and the quantity.

All of these have issues, they’re either 0 or negative, and therefore they're going to trigger an exception every single time.

And so, we'd expect all four of these tests to pass. In the Explorer window, this is the name of the function and these are the four specialized versions of those calls.

If I right0click on there and run that, we would expect all those tests to pass.

We had fixed this one up here as well.

So, I'm going to run all the tests for the entire project, and we see they are all now passing.

So, in this video we've seen how we can right unit tests that anticipate exceptions, such that the test passes when an exception is thrown.

Unit testing for exceptions

About