To show you how BDD and the red green refactor cycle helps us, let's imagine we

have an application pulling movie titles from different sites on the Internet.

Because the information comes from multiple websites

we can't be sure that the titles coming in have the style we want.

We want the titles in our database to be nicely title cased.

Which means that the first letter of every word is capitalized except for

certain less important words like the, and, of and so on.

I've linked to some examples of title case in the teacher's notes as well.

So, let's try writing a function that can handle this title casing for

us using BDD principles.

First, let's install a testing tool called cahi.

Chai is what's called an expectation library.

Chai include special functions that throw an error when an expectation is not met.

For now we can use chai functions to write our BDD outline for a small function.

You can follow along in workspaces or

in your own command line terminal on your computer.

Okay, so, first we need to install chai for our project.

So in my workspace console I'll type, npm install chai,

followed by --save -dev.

So I'm using the --save-dev flag here for my npm installation instead

of just save because chai won't be a dependency for our working code.

We don't actually need chai or

any of our testing tools in order to run our application.

We just need to for our development process.

Now if you forget how to set this up, be sure to check the teacher's notes for

a link to chai's documentation and installation instructions.

Next, I'll create a new JavaScript file by going over to the console and

typing touchtextutilities.js.

I'm calling my JavaScript file text utilities.js because the title case

function that we're going to write is just a tool for manipulating text.

Once again, you can refresh your sidebar to see the new textutilities.js file.

So, when I open our textutilities file,

the first thing I'm gonna do is import the stuff we want from the cai library.

We specifically want to use the expect method.

Check the teacher’s notes to read about other methods you might prefer, but

I’m just going to use expect for the rest of the course.

So, to import expect from the chai library,

I'll type var expect = .expect;.

Remember, to import stuff,

we write require followed by the name of our library as a string.

So, inside the quotes, I'll type, chai.

And now Node will know to go look for

a package with that name in our node_modules directory.

Now you might not have seen this style of require statement before.

But don't worry, since I don't want to use everything in chai,

I'm just saving the expect method to a variable and throwing the rest away.

So, writing it this way is a more efficient way of writing it like this.

So var chai = require('chai') followed by var expect = chai.expect.

Now that we have the expect function in our file,

we can use it to write some expectations as our outline.

To use it, we write expect and pass in a value we want to use for comparison.

Then we chain some special child chai methods to tell chai

what we expect that value to be.

So for example, we can say expect(true).to.be.false.

So, expect(true).to.be.false.

Now this is obviously going to fail because true does not equal false.

So, if I save this and run our test file in the console using node,

followed by the name or a file, which is textUtilities.js.

Once I hit Enter we see that I get an error.

It says, AssertionError: expected true to be false.

Cool, so now I can go back to our code and fix this example so

that it's passing by switching false with true.

And now if I run node textUtilities.js again, we don't see any output at all.

So, there were no errors.

We're going to see a lot more useful output when we combine chai

with our unit testing framework Mocha in the next stage.

But for now, this will be our green.

All right, so now let's write our first expectation for the titleCase function.

So I'll start by writing expect(titleCase.

And then pass in an example of a movie title or

application might be sent from the Internet.

So I'm going to type, the great mouse detective.

Notice the title has no capital letters.

I'm just making this up as an example for me to test against.

I could put anything I want to in here.

This is just acting as a guide for me as I write this function.

So, what do I expect the output of our titleCase function

with the great mouse detective to be?

Well, I definitely know that I should get a string back, right?

A string goes in and a string comes out.

So, let's start with that.

So I'll say,

.to.be.a('string').

So, expect titleCase('the great mouse detective') to be a string.

With my first expectation written I could go run our

file again in the console with our command node textutilities.js.

And, this gives me an error now.

It says, ReferenceError: titleCase is not defined.

And that's right because I haven't written the titleCase function yet.

Now, we should fix just one error at a time.

So, let's make this go away.

Back in my textutilities.j sfile, right above the test we just wrote,

I'll write a new function named titleCase.

It'll say function tittleCase.

So now, when I save the file and run the file again in the console,

I see that I stop getting a reference error.

Instead, I get an error that says,

AssertionError: expected undefined to be a string.

Perfect, it looks like we're making progress.

Now, at this point I know that titleCase is going to accept

a string as an argument.

And it's going to do some stuff to it and give me back a new string.

So, I can get our current test to pass by doing just that much.

So, if I let the titleCase function accept a title and

then spit it back out by typing, return title.

Once I save my JavaScript file and run the test again in the console.

Great, we can see that it meets our expectations,

but our expectations aren't really accurate yet, right?

And this is an important lesson about testing.

We can pass all our tests even if nothing works correctly if our test code doesn't

really test what we want it to.

So, in the next video let's add some more expectations to flush out our outline.

We'll be talking a lot about how to do this during the course.

For now, I've linked to an article in the teacher's notes about

ways we can make our expectations really informative.