In some ways being a programmer is more like being a writer

than being an engineer.

It requires a lot of creativity and you can get stuck a lot waiting for

inspiration to strike.

A nice feature of Mocha is that we can outline tests

that need to be written still before we're ready to write them.

So when you have an idea for a test but you don't have time to figure it out, or

you aren't yet sure what it will look like,

you can still communicate your idea to other people and get started.

Let me show you an example.

In order to play a game, it would be nice to have a function

that checks whether the game is over after each turn.

That way, every time I make a guess, the game engine will check and

see whether I've struck the last ship in one or

whether the next player should start their turn.

I know I need that, but I'm not ready to think about how it works yet,

not even to write the tests.

So I can write a pending test spec to keep track of those tests I have to

write later.

Inside the test folder I'll create a new test suite file called gametest.js

since this suite will focus on functions pertaining to the flow of the game.

So first I'll import chai at the top of the new file so

that we can use it here as an expectation.

And now I'll set up the fundamental describe block for the suite.

And as the first argument I'll write, GAME INSTANCE FUNCTIONS in all caps.

This is only here to make the output nicer for me.

I'll call the function I'm testing here, checkGameStatus.

So I'll create a new test suite for it.

Now, a test spec that I know I should write for

this function confirms that it should tell me when the game is over.

So I'll create a new spec that says, it should tell me when the game is over.

This is a pending test, so in order to mark this test as pending,

I do not add a function as the second argument.

The it block is only written with the first argument describing the test.

And it doesn't contain any expectations yet.

So now if I go over to the console and run npm test,

It showed me that I now have 15 tests passing and one pending.

Notice the pending test is in a different color so they're easier to see.

In my console the test is light blue.

This is really useful as a reminder to myself and

others that some tests need to be written still.

It's like having an outline for my outline.

It communicates some information for getting started.

I can also mark tests as pending by typing an x in front of the pending block.

Like, xdescribe,

or, xit.

For example, if I add a regular test spec to my current suite,

even though I've added a function as a second argument,

I can add x in front of the describe block, and

all of the specs inside will be marked as pending.

I prefer leaving out a callback to using xdescribe,

because I don't have to delete anything later.

I just have to continue writing the test spec as I normally would.

You might see this done both ways, so

feel free to use whichever method you like better.