[? music ?] [treehouse workshops]

Hello and welcome to this Treehouse Workshop.

I'm Andrew, and today we're going to talk about Cucumber,

a BDD, or behavior-driven development, testing framework.

Sometimes in client meetings you come out on the same page with your client.

Hopefully you are every time.

But as the development progresses in your application development

and the client sees the app, sometimes there's a miscommunication

on what needs to be done.

So Dan North came up with this idea of behavior-driven development.

There's 3 main principles in behavior-driven development,

and you can check those out on behaviour-driven.org.

The first principle is business and technology

should refer to the same system in the same way.

Basically, the words that you use as the developer

and as the business owner or the project owner should be the same language.

There shouldn't be anything really technical.

Everyone should understand what's going on in the software.

Principle number 2 is that

any system should have an identified, verifiable value to the business.

This idea is that you shouldn't be developing anything

that doesn't add value to the business.

And once you've identified it, it's got to be verifiable

that this actually does produce value for the business

because you're in the business to stay in business and to make money.

So if you're wasting time on stuff that isn't valuable to your consumer

and therefore you as a business, you should really scrap that idea.

And then the third principle is that the up-front analysis, design and planning

all have diminishing return.

So the idea there is that you can't really predict

everything that's going to happen in the future.

You can't predict all possible futures.

So just really focus on the minimum viable product

and get it out there for real users to test.

In short, BDD relies on the use of a very specific (and small) vocabulary

to minimize miscommunication and ensures that everyone understands,

whether that's the business owners, the developers, testers, analysts and managers,

so that they're not only on the same page but use the same words.

And Cucumber is a framework that enables you to just do that.

If you go to cukes.info, there is the Cucumber home page.

On here it shows you the basic overview of what Cucumber is.

So you define a feature and then scenarios,

and each scenario has sets of steps, and you implement the step_definition

and then you start running these steps as you would in a testing framework.

BDD doesn't supersede any testing framework per se;

it's really the best practices of testing just manifest in plain English.

So today we're going to create an anonymous blog

where users can comment and post their own posts

for a business owner or site operator to monetize

and make money from all the lovely people

coming to read these interesting anonymous articles.

What I'm going to do is jump into my console

and make sure I'm using the right version of Ruby, 1.9.3.

And let's just do gem install rails

just to make sure we've got the right version of Rails installed, all up to date.

Now I'm going to type rails new anoneeblog to create my new application.

And whilst it's doing its thing,

I'm going to jump over to the Cucumber-Rails gems documentation.

Cucumber can also be used in other languages like Java, Dot Net,

and it's been translated into other languages as well, not just English.

But we're going to use a specific gem called Cucumber-Rails.

For installation in Rails 3 projects, we need to include the Cucumber-Rails gem

and the database cleaner.

So I'm just going to copy that.

Actually, I'm going to open up Sublime, the anoneeblog.

So if we jump into our Gemfile and then paste in the test group gems

and jump back to our terminal and cd into our anoneeblog folder

and then bundle install, we've installed Cucumber.

So if we jump back to the documentation

it says to run rails generate cucumber:install,

so that's what we'll do next.

As you can see, it's created a features folder.

This is where we'll be writing our plain text features

and a bunch of other files too.

So let's go back to Sublime and jump into our features folder.

In here I'm going to create a new file called blogging.feature.

At the top of the feature file you need to specify a feature,

and you do that by saying Feature: and then what the feature is, a general description,

so Blogging, and then I'm going to say the value

In order to monetize content

As a site operator

I want people to be able to create a blog post.

These features could be anyone in the business or a user on the system

from their perspective.

So as the site operator, I want people to be able to generate content for me

so I can add word(?) all over the place so I can generate money.

The feature is a non-executed step.

It's just for a little bit of background.

The next thing we're going to define is a scenario which is executed.

Scenario: and then we'll call this Creating a blog post.

Under each scenario there's a step, and they all have these special keywords.

The first special keyword is Given, which is to talk about the assumptions of the test.

So Given I am on the home page.

If you've noticed, we haven't even developed any Ruby on Rails code at all.

We're just writing the tests, the actual scenarios,

that we want to have in the system.

So we're not committing to anything right now other than this is what we want it to do.

And instead of writing Given again, you can use the keyword And,

which can be used in combination with these other keywords

that I'm going to show you later.

Given I am on the home page

And I follow "New Post".

Imagine that on this home page there's a New Post button or a link.

When I click on it, it will take me through to a form that I need to fill in.

So I can do When.

This is the test case, so when I perform a certain action.

When I fill in "Title" with "Hello World!"

And—so I'm using And again, but it's When and then And rather than Given and And—

And I fill in "Body" with "This is my first post!"

And I press "Publish"

Then I should see "Hello World!"

And I should see "This is my first post!"

So this is saying when we press the Publish button,

I should be able to see Hello World! and This is my first post!

So as a business owner or site operator, I understand this language here,

and most people would understand this language who are dealing with websites.

So we're using very similar expressions as we're going through this scenario.

I forgot to mention that I used a Then keyword, which is also a special keyword,

to test these assumptions when I've performed a particular action,

and then I have used the combination And again there.

So what do we need to do?

We go back to our terminal, and when we installed Cucumber

it's created a rake task called cucumber.

So when I type rake cucumber,

it says the database doesn't exist yet, so rake db:migrate

and let's do rake cucumber.

And as you can see, all of these steps are yellow,

and that's because these steps are undefined.

As you noticed, at the bottom here

Cucumber has given us some examples of steps and how to implement them.

So let's copy and paste these

and then jump into our step_definitions and create a new file.

Let's call these general_steps.rb.

I'm just going to post those in there,

and I'm just going to grab this one step here where it says, "I am on the home page,"

and I am going to create a new step_definition file called path_steps.rb

and then paste that in there and save.

As you can see, we've got a block with Given, When, and Then

and a regular expression here

which captures special keywords that are in the step.

So for example, Given I follow something,

instead of calling it arg1 because Cucumber doesn't know what it's going to be,

I'm going to call this (link_name).

And there's a special keyword pending.

Here when I fill in, I'm going to put field and then with value,

and then When I press (button_name)

and Then I should see (content).

So instead of just having those arg1s and arg2s,

I've just made it a little bit clearer.

And here I don't need to do anything

because I'm not looking for a particular phrase.

So if you're not familiar with regular expressions,

I encourage you to go and look into those in greater detail.

But just imagine I'm repeating myself—"I follow" when I click on several links

or "I fill in" several forms.

These are regular expressions, they are regular sentences,

and we can get the program to grab the specific values in these quotes

and then we can test for those things.

When I run that test again, rake cucumber,

you can see that instead of suggesting now, it just says that I need to implement this

'Given I am on the home page'.

Cucumber uses something called Capybara,

which is a way for moving around a web page in code.

If we look at the documentation here, we can see that there are special keywords

called fill_in, click_link, visit, and that's the one that we really want to use right now.

We want to visit the home page.

So if we copy visit and then jump into our code,

go into our paths and then type visit and then "/", which is the home page URL.

So when we run this test now, when I do rake cucumber, it passes.

Next it says when I follow "New Post".

It says this needs to be implemented.

So if we go back to the Capybara website, there's a thing called click_link,

and it takes a string, which is the link_name.

So let's copy click_link, jump into our general_steps, and implement our step.

So click_link link_name.

And then let's run that again and see what happens.

And it's red. It says Unable to find link "New Post".

We haven't written any code yet, so that's what we need to do now.

In our home page we need to create a link with "New Post".

If we take a look in our public folder, delete the index.html

which Rails by default puts in there.

But in Rails 4 that's not going to be there at all, so you don't have to worry about it.

I've deleted that, and let's go to our routes config file.

We'll do root 2 and we'll call it posts

because we want the index of our PostsController to list the posts.

In our layouts file, which is in app, views, layouts, application,

let's create another element here

being all HTML5 and that and do a link_to new_post_path

and "New Post" and save that.

And then let's run our test again.

As you can see, it says uninitialized constant PostsController.

So this is really holding our hand, telling us what we need to do next.

So let's do rails g controller posts.

This is generating our PostsController for us,

so let's rake cucumber again.

And it says it can't find the index action on PostsController.

So let's jump into our PostsController,

hit Save and then rake cucumber again.

So it's missing a template index.

So let's jump into our views, posts, New File, save it, index.html.erb.

You'll be starting to think now and starting to see

how this development process is working out.

It's like I'm not having to think because we've already specified what we need to do.

It's just going through each step and it's telling me what to do every single time.

It's developing by itself, which is awesome.

So let's run this test again.

And when we get past all this stack trace, it says local variable or method undefined.

And this is a route, so when we do rake routes, we've only got the root path.

So let's go to our routes config file.

As you can see, we've only defined the root URL.

So let's do resources :posts.

And then when we do rake routes now,

you can see we've got all the various routes there.

When I do rake cucumber now, it's given us a different error,

saying that the 'new' action hasn't been defined yet.

So let's jump back into our PostsController and we'll do def new

and then we know what's going to happen next

is it says it can't find the template for new_html.erb.

And then let's run rake cucumber again.

Now we're starting to do a couple of steps in a row

because we're anticipating what the test is going to do.

But the idea is that you don't write any code that you don't have to do,

what doesn't bring value to the business.

So there's this step here where I fill in.

Let's jump into our general_steps and let's implement this.

Capybara, if we jump back to their documentation,

you can see there's a fill_in and then the label name with the value.

So let's copy that and then let's jump back to our steps file.

So when we fill in field with the value, it should populate those fields for us.

Let's run it again.

Now it says Unable to find the field "Title".

That's because we haven't done a form yet.

We're going to use something called SimpleForm,

which is a gem for Rails to create simple forms.

If we jump into our Gemfile and do gem 'simple_form'

and then do bundle install, boom, and then go to our new form,

let's just do

New Post

and then we'll call the variable for the form f and that,

and let's do f.input, which is the special keyword for SimpleForm.

And we'll do :title.

We're not going to do any more than it's asked us to yet.

Let's do rake cucumber.

If we scroll up past all that stack trace, it goes a 'model_name' for NilClass.

So this is nil because any form helper

looks for the model name on an active model class.

So let's jump into our PostsController and let's do post = Post.new.

Click on Save, hit Return, and it says uninitialized constant Post.

That's because we don't have the Post model created.

So let's do rails g for generate model Post where the title is a string

and the body is a text.

If we hit Enter, rake db:migrate and then rake cucumber, let's see what happens.

As you can see, the title is now filled in.

Next, the body. It can't find the body.

And define f.input :body.

Let's run our test again.

Now it's asking us to implement the I press step,

so let's jump into our general_steps and then we need to implement that step here.

We need to click the button name, so let's do button_name and see what happens.

Oh, undefined method 'click'.

Let's jump back to the Capybara documentation.

So button. Is there a button? Click_button. So it's actually click_button.

Let's jump back to our test, replace click with click_button button_name,

and then run again.

It says Unable to find button "Publish".

That's because we haven't done the button Publish.

Let's jump back into our new and then do f.button :submit

and then let's call it "Publish" and then run the test again.

And it says we don't have a 'create' action, so let's implement that now.

Let's go to PostsController and then def create

and then we'll do @post = Post.new(params[:post])

and then @post.save and then let's redirect to the post as well.

Run the test.

Oh, 'redirect' is an invalid method because it is.

redirect_to

Not sudo reboot. Where did that come from?

rake cucumber—there we go.

So we don't have a 'show' action. Let's implement that.

def show

Let's do @post = Post.find(params[:id]).

And then let's go to our posts and create show.html.erb.

And because we know that the next test

will be expecting to find the Post.title and the body, let's just do that now.

simple_format @post.body

rake cucumber

Okay. It says Then I should see "Hello World!"

We haven't implemented that step yet.

So once we've implemented this step, we will have created a very simple

but effective way for testing our forms and testing for content.

Let's go back to the Capybara documentation and let's look for content.

So a page has content?

Let's copy that.

Because this returns a true or false value,

we need to assert whether this is true or false.

So if page has content, it would return true or false.

Let's do assert, which is what you'd use in a test framework.

Actually, it's using MiniTest under the hood here.

Let's do rake cucumber.

As you can see, all these steps are passing now.

We've started defining the language, defining the steps,

so that when we add more content to these features

we can reuse these steps over and over again.

So it can be quite painful initially, but once you get over the hump,

things start to look better.

I've got some more features here set up for blogging.

Open this in Sublime, copy and paste those, and paste them into the blogging_feature.

Here we have a few more steps to look at.

This is the scenario we want to check: Creating an invalid blog.

I want to go to the home page, follow "New Post" and don't enter a title

but I enter in a body and I click on Publish.

I should see "can't be blank".

This is an error message that SimpleForm shows.

So when I fill in the title and then empty the body and click on Publish,

it should say "can't be blank" on the body that time.

So when I fill in the body—that implies the title is still filled in—

and I click on Publish, I should see a published post.

I'm going to use a new annotation up here called work in progress.

When I run rake cucumber:wip, it will only run the scenarios that are work in progress.

So instead of running all those features over and over again,

we're just seeing this.

So what's happening here?

It's a bit obtuse at the moment, so let's introduce a new step

that we can use for debugging.

Just before the failing test happens, let's include a new step to show me the page.

Let's jump back into here and then say And then show me the page.

Maybe not Then because that's a keyword. And show me the page. Let's do that.

So rake cucumber:wip and let's copy that step_definition for us to general_steps

and let's have a look at Capybara.

Let's look at debugging.

Capybara provides save_and_open_page, so let's copy that

and jump back into our Sublime,

save and open the page, and let's run this test again.

As you can see, it says Please install the launchy gem.

Let's do that.

Jump into our Gemfile, and let's put it into our test group

and then bundle install

and then rake cucumber:wip

and it's opened the page.

As you can see, it's creating a post. That's not what we want.

We want it to validate the presence of the title and the body.

So let's jump back into our Sublime editor and go to Post

and let's do validates :title :presence => true.

Let's, while we're at it, because we know it's looking for the body as well, do that.

Save and then rake cucumber:wip.

What's going on here? PresenceValidator. Let's double check.

We can't see blank because it's not doing anything.

We're not actually showing the form.

So if we jump into our PostsController and do an if statement here,

so if @post.save will redirect to the post if it's valid,

else we will render the new form again.

So let's run that rake cucumber:wip again, and I've spelled render wrong, so it will fail.

Let's do it again.

There we have it.

It says can't be blank.

If we look at all these steps, they're passing. Great.

Sometimes when you're working like this, it can get a little bit confusing

because you're not actually clicking through the process yourself;

you're getting this system automated.

We don't want that page to load up every time, so let's get rid of that step.

Go to our feature and get rid of that step.

But now that's been implemented, we can use that again

if we need to debug in the future.

Now let's take a look at this next scenario called Listing Articles.

It says I have the following posts:

As you can see, this is new structure here and it's a table

with the title and bodies of 2 posts.

So given I've got my first post and my second post,

when I'm on the home page the second post should be listed first.

It should be going from the newest first down to the oldest.

When I follow the second post link, I should see the second post's post.

And when I follow the home page, I should be back on the home page.

Let's do rake cucumber:wip again.

And we've got some new things to implement here.

These 2 steps here are related to the post,

so let's just copy that and create a new step_definition file called post_steps

because we're going to keep our code nice and compartmentalized.

So post_steps, save that.

And then there was this last one here about a path.

So let's go to path_steps and post this in here.

Let's assert that the current path is the same as "/".

That's that step implemented.

Let's run cucumber:wip again.

This following posts step has not been implemented, so let's do that next.

When we jump into our post_steps, it says that this table here,

this table of data, is a Cucumber::AST::Table.

Let's check the documentation on that.

Pop that into Google, click on that here,

and you can see the methods that are on this particular object.

There's one thing called hashes here which shows that it returns an array of hashes

and we can use Active Record to pass in these hashes in order to create these posts.

So let's go to our posts definition and cycle over the table for hash in table.hashes

and then we can do Post.create and then (hash).

So that passes in the body and title for each one of those rows.

So there's 1 hash per row with the keys and values.

Let's save that and then do rake cucumber:wip again.

Then we need to implement this.

"My Second Post" should be listed first.

The regular expression is capturing the title here, so I'm going to do title.

But also notice that these 2 steps are very similar.

So I'm going to get rid of this last step

and then I'm going to use another similar regular expression here

to capture the position.

What we can do is we can look using Capybara

to find all the h1 elements on our listing page.

Let's do that now.

We can do all("h1").each h1 do and then we're going to pass in i as an index.

The index that's been passed in by Ruby is a zero-based index,

so we can do if position =="first", which is this captured expression here,

and i == 0, then we can assert_equals h1.text—so that's the text of the h1—

is equal to the title that's captured by the regular expression here.

We can do elseif position = "second" and i == 1, which is zero-based for the second

in the array of h1s, we can assert_equals h1.text is equal to the title as well.

Let's run that step again.

It says Unable to find the link to "My Second Post".

So let's jump into our index.html and let's do for post in @posts

and let's do h1 and let's do link_to post.title, post.

This should list all the posts as h1s.

As you can see, we've got something going on here.

Oh. It says 'each' on NilClass.

Let's jump back to our posts index and do @posts = Post.all and then do it again.

And it says it's Unable to find the "Home" link.

So let's go back to our layouts and then we can link_to "Home", root_path.

That's using the Rails special keyword. Let's run that again.

And then it should be on the home page. And it passes.

Let's take a look at our application as it stands using rails s.

Let's jump into our home page and let's create a new post.

This is my first post. Hello! And Publish.

Let's go back home. This is my first post.

Let's create a second post.

This is my second post.

Hello!

And let's go to the home page.

As you can see, there's something not quite right here.

There must be something wrong with our testing assumptions

because our first post is first and our second post is second.

Sometimes even when we're trying to do the best thing here, it doesn't add up.

So let's deconstruct what's going on here.

I can see that I've missed an equals sign there.

I wonder if that's anything to do with it.

Let's do rake cucumber:wip.

It's still passing, and we know it should fail

because the first post is listed first, not the second.

Let's try and log out some information here

Let's assert_equals that the title is—

We're hoping that the title of the first step should be—what was it?—

"My Second Post".

Let's do "My Second Post".

It says 'assert_equals' is undefined method, 'assert_equals'.

So we can see that this here is not even being triggered by this all.

So maybe this all method is incorrect here.

But I should be able to assert_equals.

Okay, so in MiniTest it's not assert_equals, it's actually assert_equal.

So let's assert_equal that all h1s should be—the length of it should be 2

just as a quick sanity check.

Let's rake cucumber:wip.

It's equaling 2 but for some reason it's not going in here correctly.

So let's assert_equal h1.text is equal to "Blah". It should fail.

Yeah, it expected "My First Post" but was "Blah".

That's okay.

Let's just go to our code in our PostsController

and let's just reverse the order.

So order("created_at—and we want it to descend.

So let's run rake cucumber:wip

because that's the code that we should be expecting, and it's passing.

Do rails s again, take a look at our localhost,

and the "My Second Post" is first; the first post is second.

So that's as it should be.

But we've got something wrong with our test,

and we need to make sure that our test—

It's almost like you need a test for your tests.

Let's take a look at this.

The issue here is that each should have each_with_index,

which is the Ruby method to pass in the thing that you're iterating over

with its index.

If we run this test now, rake cucumber:wip,

we can see that it was expecting the second post first, not the first post.

So if we jump into our PostsController and do order("created_at DESC").all,

do another rake cucumber:wip, and it's not passing.

Let's boot up the Rails server and see if what we're expecting is happening.

And it is. So there's something wrong with the logic somewhere.

Let's just run rake cucumber:wip again just to double check where we're at.

It was expecting the first post but was second post.

Let's double check.

If the position is first and is equal to 0—

Let's check what this all action is doing.

Let's do assert_equal 0, i

and assert_equal h1.text, and it should be "My Second Post".

This should pass on the first iteration.

Let's do rake cucumber:wip.

It's not. It's saying expected 0 but was 1.

So each_with_index. Let's double check the documentation for it.

Let's check if this is a zero-based index or not.

It doesn't say it's zero-based, so let's double check

by doing 1 and 2, rake cucumber:wip, and there we go.

So each_with_index doesn't seem to be a zero-based index. I thought it was.

Those are passing now.

So if we take out the wip from our blogging feature now,

like so, run rake cucumber:wip, we haven't got any with the wip annotation.

So when we run rake cucumber by itself, those 3 things pass.

What's a blog without comments?

Not a blog at all or Daring Fireball, which is a blog, so I don't know why I said that.

Let's create a Comments feature.

We'll copy those comments from this folder here.

We've got a feature for commenting.

It says In order to increase engagement on the site to monetize traffic

As an site operator I want people to be able to comment on blog posts.

And I have introduced a new thing called Background.

Background is something that gets run before every scenario.

This background would create 2 posts,

and it expects that I'm on the home page.

And when I follow the second post link,

I should be able to fill in some form somewhere on there saying

my name is Andrew and that the comment body is awesome.

And when I press Submit Comment,

I should be back on that "My Second Post" page.

with a "Comment by: Andrew" and "My Awesome comment".

And if I follow the home link and I go to "My First Post",

there shouldn't be a comment by me and you shouldn't see my awesome comment.

And then secondly, we've got this other scenario where we do an invalid comment

where if we don't fill in the name but we fill in the body it should say

I "can't be blank" and vice versa and with the assumption

that the form will be completely filled in on the error

and I only need to fill in the missing part.

And once I submit that, I should be able to see "Comment by: Andrew"

and "My Awesome comment".

I've just noticed we need to submit that comment,

and I should be able to see those.

Let's jump back to our console after we've just done wip on this creating comment.

So rake cucumber:wip.

As you can see, there's 2 steps that haven't been defined yet.

So let's copy those and let's jump first to our posts_step

because there's one for a particular post.

I should be on the title of that particular post page

and I should not see.

So this is a general step, so let's keep organized.

Let's call that content.

Let's do a similar thing to has_content, and we'll just put an exclamation mark

to say has not got that content.

In our posts_step we can do something similar to our paths

where we assert_equal current_path is the same as the post_path with the—

I'm going to start up here so it's a little bit more legible.

So post = Post.where.

The title is the title, and we're going to get the first one that matches that.

So we put post in there.

We're asserting that the current path of the page is the same as the post path.

So we've implemented those 2 steps now,

and when we do cucumber:wip we can address the first problem—

that there isn't a field with the name "Name" and I can't fill in the word "Andrew".

So let's jump to our show because it's expecting a form here.

We will do a simple_form_for.

And because it's supposed to be for a comment for a particular post,

we're going to pass in the array of post and a new comment.

Let's run rake cucumber:wip.

As you can see, it's saying 'model_name' is nil.

That's because comment is a NilClass again.

If we jump to our PostsController and go to our show,

what we can do here is just do @comment = Comment.new.

You should be guessing now that the comment class hasn't been created yet,

so there's an uninitialized constant, Comment.

So we can do rails g model Comment,

and because it's a nested belongs_to structure,

we're going to create a post_id of an integer,

we're going to create a name, which is a string,

and we're going to create a body, which is text.

Okay, so rake db:migrate.

Always remember to do that when you create a model.

When we do rake cucumber now, it will clone the development database

into the test database.

I did rake cucumber, so it's showing loads of stuff.

So let's do rake cucumber:wip

so we're not bogged down with all these tests not failing.

If we scroll up to the top, it says can't find 'post_comments_path'.

So let's jump into our routes

and then let's do a nested resource, so resources :comments.

When we do rake routes now, it will show the comments route.

We don't need to do that, so I'm just running rake cucumber:wip,

and it says Unable to find the field "Name".

So once again, jump back into our form for the comment

and do f.input :name.

And because I know there's going to be a body and that will be the next test,

we can start combining these together.

But don't get too carried away because you may end up

spending time on a feature that doesn't need implementing.

And then f.button :submit, and I can't remember the specific wording,

so let me just jump to the commenting feature.

It's called "Submit Comment".

"Submit Comment", "Submit Comment".

When I click on Submit Comment, I should be on the post page

and I should see the comment.

So let's see if we need to do anything.

It says uninitialized constant CommentsController. Okay.

We need to generate it, so rails g controller comments.

As you can see, this has been created now.

Let's run rake cucumber:wip.

The more and more you get used to this, you'll understand,

"Oh, create method." So let's create that.

Comments def create end.

Let's do @comment =

Let's do @post as well.

So @post = Post.find(params[:post_id])

and then we can do @comment = @post.comments.build(params[:comment]).

And because we haven't set up the belongs_to and has_many relationship,

we'll do that now.

So a post has_many :comments.

And a comment belongs_to :post.

Okay.

So if @comment.save redirect_to @post

because we want to be back on the post page.

And else if there's an error, we'll do something in a second.

Let's do rake cucumber:wip.

It says that I should be on the second post page, which I am,

but we're not displaying the comments yet.

So let's go to our show page and we will display the comments here.

Let's do for comment in @post.comments

and then we'll do a div_for(comment) as a nice little wrapper, do, end,

and then we'll have an h2 with the %= Comment by: comment.name,

end the h2 and then do a simple_format, which is a Rails helper,

with comment.body.

Save that and rake cucumber:wip.

As you can see, it goes home, goes to the first post,

and it can't see the "Comment by: Andrew" on that post.

As you can see, we've already been building up these steps,

and once you've written them out, they pass a lot quicker

as you're progressing through building your site.

Let's check the last scenario out

by just doing a wip over it and then rake cucumber:wip.

When I press Submit it says it can't be blank.

So let's jump into our Comment and let's do validates :name,

:presence—let's spell it right the first time this time—

and validates :body, :presence => true as well.

Let's run this again.

It's saying Missing template comments/create.

So let's take a look at our CommentsController.

That's because when it's valid it tries to render the create method.

But since we've already defined post and comment,

we can just render the same form from the posts in the show action.

Let's do rake cucumber:wip. And it passes.

Let's finally remove the wip and then test all of our features and scenarios.

And everything is passing.

The final test is to boot up our Rails server, go to localhost 3000.

Let's create a comment.

Andrew. Really cool post!

And as you can see, it said Comment by: Andrew.

And if I submit, it says it must be filled in.

So it's working as we expect it to.

I hope you've enjoyed watching me build a website

using Cucumber and behavior-driven development.

It just goes to show that after the initial pain of the setup building out the site,

it gets a little bit faster, and you can maybe take a few of those steps all in one go.

So whether you're building a project yourself

for you and your business partner or even for your client,

it really helps to minimize miscommunications

so that you're all on the same page using the same language

and hopefully be building the same product in the end.

My name is Andrew Chalkley, and you've been watching a Treehouse Workshop.

If you've enjoyed this workshop, you'll also enjoy the others that we have to offer

on TeamTreehouse.com.

[? music ?] [treehouse workshops]