The kind of automated test we'll learn to write in this course

are called, Unit Tests.

Unit Testing involves Writing tests that confirm an individual function or

piece of code works the way we want it to.

We write Unit Test for code that has a clear specific purpose, for example,

we'll often write unit test for the individual functions in a program,

the unit tests can then call the function without needing to run our entire

application to make sure we know that the function behaves as we expect.

Unit Tests are kind of like a basketball drill.

As a basketball player, you need to master various skills like shooting,

passing, running, dribbling and so on.

Basketball players run specific drills to test

each of these skills outside of an actual game.

A basketball player might just practice free throws for a while and

then practice dribbling at a different time without worrying about shooting or

passing or what their teammates are doing.

A Unit Test is like one of these drills and

we can run unit tests constantly during our development process

to ensure that everything is working every time we make a change.

But being good at each single thing isn't enough to be

a really good basketball player.

They also have to be able to do them all together.

In addition to practicing each individual basketball skill,

players practice drills as a team.

They need to make sure that they can dribble, pass, and

shoot just as well when there are other people doing their part around them.

And that they can do them all together in the correct sequence.

In programming this kind of testing is called Integration Testing.

You use integration tests when you add new code to preexisting code

to make sure that not only do all of the pieces work individually as expected, but

also that they run together correctly without breaking.

Product managers or people who run open-source projects might also run

integration tests whenever others write code to contribute to their projects.

To make sure that the code others write doesn't break their existing project

that's useful.

On a basketball team it's not enough that your skills are up to par.

And that you work well together as a team.

You also have to play actual games.

Live games are very different even from practice games,

we play basketball on different courts.

With different crowds and against teams with different strategies.

So being a good basketball team requires a lot of team experience in this context.

In software, this kind of testing is called End-To-End Testing.

We fire up the application and

run it from start to finish for all the user stories we can think of.

This ensures that the program is ready to go live.

And that the special details of deployment don't screw up the stuff that we

carefully tested on our local machines with Unit Test and integration tests.

We conduct end to end test very occasionally.

Maybe only a few times during a product's life cycle.

As a very time consuming and expensive.

You might conduct some or all of these kind of tests where you work or

in your personal projects.

We'll focus on Unit Testing in this course because that's what you'll spend most of

the time writing.

Unit Tests actually help us write better code and

grow as developers as soon as we start using them.