[MUSIC]

All testing libraries work on the idea of assertions.

Some call them behaviors, or descriptions,

and assertions test a condition in your code that must be met.

For example,

when creating a car object, you could test that the new object has a model name.

If it doesn't, the assertion fails and we found an error in our code.

In Python's unit test framework, we have quite a few assertions that let you

test different conditions, like if two values are equal, an object is

an instance of a certain class, or if a certain exception is raised by some code.

I'll link to the full list of assertions in the teacher's notes but

we'll look at the most important ones in this video and the next couple.

So, let's get started.

So, we've already looked at the assert keyword.

But the unit test framework,

unit test module, gives us a bunch of other assertions that we can use.

We don't just have to assert that a statement is true.

So, let's test the four methods in our move class using these assertions.

So, the first one probably the easiest one is the equality test.

So we wanna test the dunder eq and

the dunder ne, which is for equal and not equal methods.

But like I said we don't wanna test them directly.

So let's say test equal.

And your methods do have to start with test.

If your methods don't start with test they won't be run as tests.

So we're gonna say rock1 is equal to rock, oops, sorry,

we need to make that moves.Rock.

And rock2 is equal to moves.rock.

And we're gonna say self.assertequal rock1 and rock2.

And then let's test the not equal.

Test_not_equal and self and we'll say rock1 or

rock is equal to moves.Rock and

we'll say paper is equal to moves.Paper, and

then self.assertNotEqual, and rock and paper,

because rock and paper should not be equal to each other.

But rock and rock, should be.

This should handle this testing.

We, we're making the two rock instances.

We make sure they're equal to each other and then make a rock instance and

a paper instance and make sure that they are not equal to each other.

We're repeating ourselves a little bit with making all of these rocks,

but we'll clean that up later.

So let's try running these tests.

So, python tests.py, and, oop, let's make this a little taller.

There we go.

Let's just run it again.

There we go.

So, it ran four tests.

One, two, three, four.

And they all passed.

So, great. Four tests, four passes.

So now, let's dry up our test a little bit.

We can add a method to our test case, and

I'll leave this up at the top that is named setUp.

And this is one of the fun cases where a library predates PEP 8.

So setUp has camel case, PEP 8 says we should be lowercase with underscores but

it's old, so it stays just like it is.

Okay, so this function, this method will get called,

will get run before each of our tests.

So, any code we put in here will always have like, kinda a fresh state.

So what we're gonna do is say, self.rock is equal to

moves.Rock, self.paper is equal to moves.Paper,

and self.scissors is equal to moves.Scissors.

And now I wish I had written something about Jagger,

because then I would have had moves.Jagger.

Okay.

Now Python has to do a little bit more work here.

Python has to instantiate these variables every time.

But we get to write less code and really that's what's important, right?

Our workload?

Okay.

So we have these three attributes.

We have self.rock, self.paper, self.scissors.

Let's use them.

So here we're gonna do rock one.

We don't need rock one, we don't need rock one at all.

And we don't even need rock two.

So we're gonna take those out.

And we're gonna assert that self.rock is equal to a new rock instance.

And then here we can take these two out completely and

just assert that self.rock is not equal to self.paper, 'kay?

So, we've dried the stuff up a whole lot.

Now, we have to make the new rock instance here,

because we don't want to just test that the object is equal to itself.

We know the object is equal to itself.

We wanna make sure the object is equal to another instance of the same class,

because two rocks with the same, this should be tied.

So we save all that, we run our tests again, and

oh, I have a typo, this should be moves.Rock.

All right, one more time?

And we're all good.

All the tests are still passing.

Okay, to complete the testing of all of our moves,

we should test our greater than, or the dunder vt, and

our less than, or the dunder le methods.

So, let's test that rock is better than scissors, because it should be.

So, self.assertGreater,

self.rock, and self.scissors.

And let's also test that paper is worse than scissors.

So, self.assertLess,

self.paper, and self.scissors.

Okay.

So, we're trying to write these in a, a fairly human readable way.

So let's, let's test this.

All of our tests pass, and that's great.

Now, there are a lot more search engines that are available.

We're gonna cover a few more in the course, and

the rest I'm gonna make sure and link to in the teacher's notes.

So, be able to read those and you'll be able to test all sorts of things.

Assertions that deal with quantitative values like assertEqual or

assertGreater are really handy when you're dealing with numbers.

I know that I use them quite a bit, both in regular scripts and for

testing web apps.

Or I wanna make sure that a status code is 200, 304, 404, or something else.

Remember, you have the full power of Python too, so feel free to use len and

other functions in your assertions.