Okay, so let's start on a new line and still keep our first expectation so

that if anything breaks along the way we'll know why.

And you can also go ahead and

remove the simple test expectation we wrote in the previous video.

Also go ahead and get rid of the comments.

So now I'll write a new expectation by typing expect titleCase,

the great mouse detective.

Now we don't just want the same string back, right?

We want the function to give us a different string.

So in our example, the return string should be

the great mouse detective with correct capitalization.

So let's start there.

This time I'll write .to.equal The Great Mouse Detective.

Notice how each word begins with a capital letter.

Now if we save our file and

run this in the console by typing node textUtilities.js.

We see that we get an assertion error.

It says, expected the great mouse detective to equal

The Great Mouse Detective capitalized.

Of course, because right now our title case function

just returns the same string we put in.

So to make this test pass, we basically need to make our whole function work.

Now that's a little bit too big and it's not very helpful for

this test to just tell us make it work like it's doing now.

So we should break this up into smaller expectations that we know how to tackle.

Usually, when writing tests the most comprehensive expectations should be

written last, that way the function passes all the simpler tests first.

So we'll keep this to.equal expectation at the bottom of all tests, so

that we know when we finished.

Then right above it we'll write a new test.

So now we should think about the smallest piece of the problem we know how to solve.

So what if we passed in just one letter?

That shouldn't be hard, right?.

The function would just return the same letter capitalized.

So our expectation should be something that captures that.

So we'll say expect lowercase

a to equal capital A.

So now when we save the file, go over to the console and run our test again.

We can see that it doesn't work yet.

We get the AssertionError expected lower case a to equal capital A.

Okay, we can definitely do this because it's built into JavaScript.

So back in the textUtilities file, I can call the toUpperCase method on our title.

So now if I save and run the test again,

we see that we passed our new smaller tests.

And we still failed the final test but for a different reason.

So now we're seeing the AssertionError,

expected THE GREAT MOUSE DETECTIVE to equal The Great Mouse Detective.

So all caps versus the correct capitalization.

Well, this is good progress.

But now we're capitalizing too much instead of not enough.

So now let's add another expectation with a bit more complexity.

So right below the expectation, the stroke say expect titleCase.

To.equal.

And this time let's use a single word title but more than one letter.

So first, I'll type the title vertigo in all lower case letter,

then I'll type Vertigo with a capital V.

Running the tests gives us the same problem as before but

it helps to keep the problem small and

comprehensible by confining our expectation to only one word.

So instead of uppercasing the entire title,

let's target just the first character in the title.

This time, when we run the tests we get,

expected capital V to equal Vertigo, right?

Because we're only returning the first letter.

So back in our function,

let's add the rest of the title in, skipping over the first letter.

So right after toUpperCase, we'll say + title.substring and we'll pass one.

So I'll run the test again in the console and great.

It looks like we passed our Vertigo test.

So now our final test says, AssertionError expected,

The great mouse detective to equal The Great Mouse Detective.

So the first letter capitalized vs the correct title casing.

So we're getting closer.

We know how to capitalize the first letter of a string, we know how to

add strings together, we just need to do this for each word in the title.

I think we're ready to try making it work.

We have a pretty thorough understanding of the problem at this point and

several tests to keep us on track if we misstep.

Okay so we know what to do with one word.

If we keep our final test case to mind, we know we need to break the string apart

into several pieces so that we can do our one word part on each word in the title.

And the title case function, we can start by splitting the title up at the spaces.

I'll type of var words = title.split.

And I'll leave a space inside the quotes.

So now we have an array of individual words from our title.

Now before we even get stuck figuring out the middle, I like to write the return

statement because I already pretty much know what it will look like.

We know we have to give back a string that's been title cased.

We know that somewhere in this function we have to put all the words we

just separated back together so we may as well do that in the return statement.

So I'll write return, titleCasedWords.join.

I know I have to join them back together with a space because that's how

I took them apart.

So right now I'm going to just guess that'll make an array called

titleCasedWords, because I know I have to transform

all the individual words from my words array somehow.

All right, so now that I have the start and end of my function,

a lot is already done for me.

I know I need to make this array titleCasedWords and

its value will be derived from the words array.

So I can at least type var

titleCaseWords = words.

Now here's the logic part, I need to loop through all the words,

do my title case logic on them and then store them in titleCaseWords.

So let's see, do you already know a function that will do something to each

member of an array and to give me back an array of the same length?

Yup, that's right, the map function can do that for us.

In fact we used this for the gather names of function in the first video.

So back in my titleCasedWords variable I'll add the map function right

after words.

Next I'll move all my titleCase logic for one word into the map callback.

And now I'll get every word title case to my title.

So in the map callback, I'll pass word and in the return statement,

I'll change title to word.

So now when I save my JavaScript file and run the test again in the console, great.

It looks like everything passes.

This function isn't quite finished.

I'll talk more about covering edge cases in the next stage.

So far, we've made a lot of assumptions about the input for this function.

For example, we've always started with a completely lowercase string,

with no punctuation or weird characters.

But what happens if we get a title that isn't nicely formatted already?

Like this type, we might need to expand our function to account for these things.

For now try and imagine a simple expectation for

the title case function, that would fail.

Remember titles don't really capitalize the first letter of every word,

they skip less important words.

So you can try fixing the title case function to practice your BDD strategy and

get more comfortable writing expectations with Chai.

Even if he had been overwhelmed or

confused about where to start with our title case function,

BDD helped us break the problem down into smaller and easier pieces.

As we work towards passing tests we got a better and better function.

Not only did red green refactor help us write or code but

now we actually have some simple tests for our function too.

It might seem strange at first to just think about these tiny examples and

expectations but the secret is that this is one of the easiest ways to program.

Once you get used to writing unit tests your code will also be better

because you'll have thought about it much more carefully.

You'll even have tests for your functions that you can show other people

to explain what your code does or get extra help.

That's pretty cool.