Historical errata for The RSpec Book

Asklak’s name is not displaying properly

— Aslak HellesÃÿy set out

More UTF errors

— his fiancÃl’e,

In the third alinea the last name of Aslak is not correct. It now sais HellesÃÿy.

When describing which gems you need to unpack into the rails project you say:

> gem unpack cucumber
> gem unpack rspec
> gem unpack rspec-rails
> gem unpack webrat

However on the line above you have

> sudo gem install cucumber rspec-rails webrat

I know that it’s obvious but you might want to add rspec by itself into that list so that people who aren’t paying attention will try to unpack a gem that they don’t have installed. Therefore it would become

> sudo gem install cucumber rspec rspec-rails webrat

If they were following the book that won’t happen since we install it earlier, but it might for people jumping around.

Thanks

Kent

in the sidebar Aslak’s last name prints as Helles[capital A bar][lowercase y umlaut]y. And later fiance has a typographic error as well. I’m on os x leopard, all updates.

In the spring of 2008, Aslak HellesÃÿy set out to rewrite RSpec’s Story Runner with a real grammar defined with Nathan Sobo’s Treetop library. Aslak dubbed it Cucumber at the suggestion of
his fiancÃl’e, Patricia Carrier, thinking it would be a short-lived
working title until it was merged back into RSpec. Little did either
of them know that Cucumber would develop a life of its own.

Could use a more complete description of how you set up the tutorial project and why in that manner.
Or a link to docs that outline why it is a good idea to do it that way & describe what all the component files are for.

before used instead of after in the following snippet:

set aside
the global state in an instance variable in before(:each) and then restore
it in after(:each), like this:
before(:each) do
original_global_value = $some_global_value $some_global_value = temporary_value end before(:each) do $some_global_value = original_global_value
end

this is a quibble, but the -colour option in the following snippet makes it seem like a command line arg with the dash as opposed to an option for —format

you can also add the –colour option to see passing examples
in green and failing examples in red.

Misspeeling. :)

And viola!

missing a t on consistent:

A good guideline to follow is to keep things consisent

Helper module included doesn’t match name of the module

Spec::Runner.configure do |config|
config.include(UserExampleHelperMethods)
end

module is actually UserExampleHelpers

We declare a shared example grouip

A couple of words got duped here

etc, etc declared in the in the
outer group are available in the inner group.

another before/after mixup - step 5:

1. outer before
2. inner before
3. example
4. inner after
5. outer before

In the Cucumber example, the word “for” has been syntax highlighted, which I presume is not needed. Of course, I’m just learning Cucumber so I could be completely wrong…

My head still spins after looking at the BDD cycle diagram. Perhaps turning it into a flowchart-y diagram makes it easier.

Before describing which files are responsible for what, a short introduction to installing the gems would be nice. Perhaps in an appendix or sidebar, but definately before page 18.

More syntax highlighting in the plain text scenarios.

I got sidetracked by the fact that cucumber was run in the examples with -n. IMHO it doesn’t add much value at first, so perhaps run the examples without -n, and introduce that specific command line flag later on in the book?

Missing the word ‘in’

‘But what about when the state we’re interested is …’ should be ‘But what about when the state we’re interested in is …’

‘the’ Should be ‘that’ in the sidebar.

BDD is about writing software that< matters

The word “that” is repeated twice in “stores a Registration in a Registry’s registrations collection, and that that collection…”

In the example: “on line” should be changed to on-line or online.

It looks like the root needs a bin directory to match example batch file on page 28.
project_root would then have top level directories bin, features, lib and spec.

The missing include( ) method is an RSpec expectation matcher method,
so we need to require the rspec exectations library

Should say “[…]rspec exPectations library”

It talks about the bin made in the last chapter, but with in the end that bin should be:

#!/usr/bin/env ruby -w
$LOAD_PATH.push File.join(File.dirname(FILE), “/../lib”)
require ‘mastermind’

game = Mastermind::Game.new(STDOUT)
game.start

2nd to last paragraph:
“you can go to to learn more of the detail and philosophy behind each feature”
(duplicate ‘to’)

Last paragraph: “its time” should be “it’s time”

3rd paragraph: I’m wondering about the “parallel structure below lib/mastermind and spec/mastermind”. That sounds like the kind of 1:1 relationship between units of code and tests that the first chapter talked about getting away from.

In figure 2.2, I am wondering why the lib/mastermind and spec /mastermind directories are not shown, and why step_definitions/mastermind.rb isn’t shown.

I’m also wondering why the top three directories appear to be in bold while the rest do not. It’s hard to tell if this is an artifact of the rendering or a meaningful part of the picture, though.

The first paragraph that starts on page 20 says “stories” three times, and then switches to the word “scenarios”. It’s hard to tell if these terms are meant to be interchangeable here, or, if not, what the relationship between them is.

Top:
“and enter that snippet to it.”

How about:
“and add that snippet to it.”
or
“and enter that snippet into it.”

3rd paragraph:
“It is common to write the code you wish we had doing TDD.”

This sounds a little odd after using “the code you wish YOU had” a couple times just before this.

I’m not sure if this is an error or not.

End of 1st paragraph of page 26:

“This is RSpec’s way of setting expectations about equality.”

I thought we were dealing with Cucumber in this chapter? The outer of the two cycles? Should this say RSpec or Cucumber? If ‘RSpec’ is correct, some explanation might help.

On the matter of -n, I got curious enough to look it up. There didn’t seem to be anything in the documentation wiki yet, but going to the source in Github I got my answer: long form “—no-source”, “Don’t print the file and line of the step definition with the steps.”

A brief mention of this might be enough to tie up that loose end for the reader.

First paragraph:
“Now we see file and line numbers”

How about:
“Now we see file names and line numbers”

Start of section 2.5:
“At this point we’ve made our way through to the first step in the concentric cycles”

This doesn’t seem quite right. How about eliminating “to”:
“At this point we’ve made our way through the first step in the concentric cycles”

From the diagram, it actually looks like we’ve finished step two and are now about to work on step three.

Start of section 2.5:
“the concentric cycles described at the beginning of this chapter”

The concentric cycles are introduced in the previous chapter (1), not the current one (2).

a few of the examples use the option colour yet there is a section on -color, it might make sense to standardize on one and/or mention the two are synonymous

9 No mutants survived. Cool!
Line 2 indicates that heckle found four opportunities to mutate the code
in the #start method. Line 9 tells us that at least one code example
failed after modifying the code in each of those four ways.

— Not in this example

In the final para on the page, “Now one of the two Thens are passing” should read “Now one of the two Thens is passing” (number agreement).

Second para on page: “… and is supported by RSpec’s mock framework with a the as_null_object() method:” should read “… and is supported by RSpec’s mock framework with the as_null_object() method:”

Section 15.1, “Traditional Rails Development” - second para, penultimate sentence: “… revisit what you’ve already built or make due.” should read “… revisit what you’ve already built or make do.”

Much better! Go ahead and copy that code into bin/mastermind.bat if
you’re on Windows. Otherwise, use bin/mastermind (and don’t forget to
chmod 755 bin/mastermind so you’ll be able to execute it later).

There was no “bin/mastermind” in the game original drawing on p 19

Section 8.1, para after the code example - instead of
“We use the describe() to define…”

How about either:

“We use the describe() method to define…”

Or:

“We use describe() to define…”

The first fits better, given that the following para talks about “The it() method…”

In section “Sharing Examples in a Module”, first sentence has “share_examples_for()”. Should be “shared_examples_for()”

Under “Emergent Design” subtitle, at the end of the second paragraph, a period (.) is missing.

…are responsible for testing pratices

Penultimate sentence on page: “This can to help reduce…” should read “This can help reduce…”

Last sentence in para after first code example: “RSpec let’s you express…” should be “RSpec lets you express…”

Last sentence on page: “Now you could, of course, express this like this:” seems stilted.

How about, slightly more verbose, but I think a little more fluent, “Now you could, of course, express the same thing like this:”

Last text on page: “… a second argument that is either String message…” should be “… a second argument that is either a String message…”

Last sentence on page: “RSpec let’s us use…” should read “RSpec lets us use…”

Section 12.3, final para: “… it’s code examples in …” should read “… its code examples in …”

Last sentence of last complete para on page: “… have them validate its working …” should read “… have them validate it’s working …”

I’m with you till about page 26 then you start getting into making Ruby bin files and a few other things, and i get lost.

Last paragraph:
“the Game needs a to handle the messenger argument to the initialize method.”

How about:
“the Game needs to handle the messenger argument to the initialize method.”

Last paragraph:
“half way” looks odd as two words. Should it say “halfway”?

One thing, I’m sure will be in the final version, but just wanted to confirm, normally these types of titles, have started out with some initial conditions of the software. For example, written with version X.Y.Z, assumes the following are installed, and may also include pointers for the installations. It seems like that could create problems down the road if people se variations in how things behave because their setup is different.

3rd paragraph of section 3.3:
“we prefer to refactor in the green than in the red.”

Should “than” be replaced with “rather than”?

Minor style issue: in the top code example, the first two examples are not separated by a blank line. Everywhere else, they are.

2nd paragraph:
“It just builds, gradually on what we’ve already developed.”

The comma looks funny there.

3rd paragraph:
“Go ahead and fire up a shell and run the script and you see the following output:”

How about changing “you” to “you’ll”

You interchangeably use Test Driven Development (TDD) and BDD was that intentional I thought they were different although this is also new to me. It may just need to be clearer that you are describing two different aspects of testing.

In “Joe asks…”: “[…] introduce you to the other styles of step defintions […]” should be “[…] definitions […]”

In the example on page 64, you have before(:each) twice when the 2nd one should be after(:each).

“In addition to share_examples_for” should be “In addition to shared_examples_for”.

:working_to_hard should be :working_too_hard

The authors use two different formats to write up features:

The “in order to” format on page 12 that places the business reason first.

Feature: pay bill on line
In order to reduce the time I spend paying bills
As a bank customer with a checking account
I want to pay my bills on line

And the Mike Cohn’s “so that” format on Page 20 that places the business value last:

Feature: code-breaker starts game
As a code-breaker
I want to start a game
So that I can break the code

While the authors do mention that the narrative is free format, they fail to mention that they used different structured formats in their examples, which could cause some confusion.

To avoid possible confusion after the prior code on page 20 you could say:

“Note the narrative structure in this example and the one on page 12 are different. We could have just as easily written the feature as:

Feature: code-breaker starts game
In order to break the code
As a code-breaker
I want to start a game”

Also while the features narrative is supposedly free format, some tools used with the test tools are dependent on the format. Maybe the authors mention that later.

The project structure discussed on page 18 and shown graphically in Figure 2.2 on page 19 is confusing. Where does this structure come from? Is the reader supposed to set it up from scratch? Is there some sort of command or tool the read is supposed to run like Rails scaffolding? (I created them manually – was there an alternative?)

Which mastermind.rb file is which? What’s in each? Why are the file names identical?

Where is the reader supposed to put the codebreaker_starts_game.feature file? Should it have an .rb extension? (It wasn’t too hard to figure out this last one by trial and error, but some advice would have been nice.)

There is further project structure confusion on page 27. Unlike Unix, Windows itself does not commonly have a bin directory, although Ruby does have a bin directory. Perhaps the authors are assuming that the student created the mastermind directory under the Ruby directory? Is so, suggesting it, because the project tree diagram in figure 2.2 doesn’t imply a bin anywhere. Also while Unix uses forward slashes at the command line, Windows uses back slashes, so the correct Windows format might be:

C:\\ruby\\bin\\mastermind.bat

assuming that is what the authors intended.

The file contents

#!/usr/bin/env ruby -w
$LOAD_PATH.push File.join(File.dirname(FILE), “/../lib” )
require ‘mastermind’
game = Mastermind::Game.new(STDOUT)
game.start

Does not work on Windows as a BAT file, so copying the above into mastermind.bat makes no sense. The authors need a Windows specific BAT file or some additional instructions that are missing.

Running the above as a BAT file gives the following results:
C:\\RubyPrograms\\TheRSpecBook\\mastermind>mastermind

C:\\RubyPrograms\\TheRSpecBook\\mastermind>#!/usr/bin/env ruby -w
‘#!’ is not recognized as an internal or external command,
operable program or batch file.

C:\\RubyPrograms\\TheRSpecBook\\mastermind>$LOAD_PATH.push File.join(File.dirname(FILE), "/../lib
‘$LOAD_PATH.push’ is not recognized as an internal or external command,
operable program or batch file.

C:\\RubyPrograms\\TheRSpecBook\\mastermind>require ‘mastermind’
‘require’ is not recognized as an internal or external command,
operable program or batch file.

C:\\RubyPrograms\\TheRSpecBook\\mastermind>game = Mastermind::Game.new(STDOUT)
‘game’ is not recognized as an internal or external command,
operable program or batch file.

C:\\RubyPrograms\\TheRSpecBook\\mastermind>game.start
‘game.start’ is not recognized as an internal or external command,
operable program or batch file.

OK, I was wrong, the mastermind.bat does work, but only when run from Cucumber and not as a standard BAT file. So it isn’t really a Windows script in the normal sense, it is a Ruby script that Cucumber finds and runs. If the reader has used Ruby for scripting, maybe this is obvious, but for a reader to uses Ruby primarily from within Rails it is less obvious.

The trick to get it to work is to place the mastermind.bat file at the top of the mastermind directory tree, the same place that the reader is using to run Cucumber.

Anyway, I think this could use a little clarification.

Heckle 1.4.1 was released in 2007, not 2006.

In the code example, how about adding (:capacity => 10) to the calls to Stack.new (as you do on pages 71 and 72) to show that you’re using a stack with a capacity of 10.

Top of page:
“in general, we want to have each example run in complete isolation from the other.”

How about “others” instead of “other”

Start of 1st paragraph:

The quoted phrases “should taste really good” and “should be available by the slice,” have ending quotation marks that face the wrong direction (so they look like opening quotation marks).

Also, the comma inside “should be available by the slice,” looks wrong - in the first line, for instance, “Any Pizza” has a comma after it that lies outside the closing quotation mark.

I’m not fluent in RSpec terminology yet, but this sentence in the first paragraph reads a little confusing:

“For example, let’s say you want to express a given in the outer group, an event, or when in the inner group, and the expected outcome in the examples them selves.”

It might be mostly a matter of the commas seeming to carry equal weight in the sentence, so it’s hard to tell where one list item in the sentence ends and the next begins.

top of page:

“Building from the models out to the views means writing code based on
assumptions of what ### ‘you’ ### think you’ll need”

“showtime_time.strftime(”%l:%M%p" ).strip.downcase" should have an upper “i” instead of a lower “L” as argument to strftime => “showtime_time.strftime(”%I:%M%p“).strip.downcase”

Again (see p.143): “showtime_time.min.zero? ? ”%l%p" : “%l:%M%p”" should have upper “i” instead of lower “L” => “showtime_time.min.zero? ? ”%L%p" : “%L:%M%p”"

Maybe it is easier to keep focused on cucumber if the required commands for creating the movie model and migrating the database are given:

- ruby script/generate model movie showtime_date:date showtime_time:time

- rake db:migrate
- rake db:test:prepare

Sorry for the entries #37641 and #37642 about strftime with option “%l”. I learned in the meantime that it’s used to get single digits - exactly what we want here :-).
Nevertheless it doesn’t work for me - I just get no digits back (“:15pm” instead of “2:15pm”) and I couldn’t find this option in the ruby or rails documentation, so I thought it’s a typo…

It seemed to me that chapter 1 could use a bit more discussion of the differences between RSpec and Cucumber… specifically regarding the differing strengths and why it is worth taking the time to learn and use two different tools. I only began to feel like I had a handle on it after reading the more detailed sections.

At least for me the option %l for strftime doesn’t work on windows (no problems with it on my linux machine). A very simple workaround is to convert the time to a datestring first:

showtime_time.to_datetime.strftime(“%l:%M%p”).strip.downcase

If it was not only me who encounters this problem it would be helpful to add a footnote on that.

So you can remove/ignore my previous entries #37641, #37642 and #37645 (I promise this is my last one on this topic :-)

maybe on : describe Stack, “when almost full (with one element less than capacity)”
(1..stack.capacity - 1).each { |n| stack.push n }

and : describe Stack, “when full”
(1..stack.capacity).each { |n| stack.push n }

End of 1st paragraph of section 9.1:
“An Expression Matcher is an object that does exactly what it’s name tells you: it matches an expression.”

Two things:

1. “it’s” should be “its”

2. How about “implies” or “says” instead of “tells you”

2nd to last paragraph on page:
“RSpec’s built in matchers.”

“built in” looks wrong, since the next section name and the first sentence in that next section use the hyphenated “built-in”.

Last paragraph: “to access them” sounds redundant here.

Top line:
“key_value_pairs_methods()” should be “key_value_pairs() methods”

(methods being part of the surrounding text rather than formatted as code)

This construction shows up three times on this page:

lambda {
team.working_too_hard.should throw_symbol(:working_to_hard)
}

I’m expecting it to look more like this:

lambda {
team.working_too_hard
}.should throw_symbol(:working_too_hard)

Am I off base here?

Right above “How They Work” heading:

This will pass as long as user.in_role?(“admin”).

How about:

This will pass as long as user.in_role?(“admin”) returns true.

Last paragraph before section 9.4:
“Well, we wouldn’t want to have to say anything quite so ridiculous, and so RSpec includes a means of assigning your own Explicit Predicate Matchers.”

How about changing “and so” to just “so”

2nd to last paragraph:
“using in implicit subject” should be “using an implicit subject”

The list on this page goes in roughly the order the topics were discussed, except the last two. Explicit came before implicit.

Last paragraph:
“mean time” looks odd (I’m used to “meantime”) but I’m not sure what the rules say

2nd paragraph:
“straight forward” -> “straightforward”

In code sample for person_test.rb (bottom):

require ’ test/unit’

(extra space before ‘test’)

Last paragraph:
“transforming” -> “transforming”

2nd paragraph of section 11.2:
“as shown on line in the code that follows”

How about:
“as shown on line 6 in the code that follows”

In the code sample on line 6:

describe(‘A Person’) # <label id=“code.lone_describe”

I don’t understand what the “<label” comment is doing. It looks kinda like a malformed xml tag…

2nd paragraph:
“We can take this a step further and just use the describe() to generate RSpec’s counterpart to a TestCase”

How about:
“We can take this a step further and just use the describe() call to generate RSpec’s counterpart to a TestCase”

Last sentence:
“If you run rake spec you should see the same output generated when we added describe() to the TestCase.”

How about:
“If you run rake spec you should see the same output generated AS when we added describe() to the TestCase.”

2nd paragraph:
“replace the the tests” (duplicate ‘the’)

Middle of page:
“So the next step is to simply replace the setup() and teardown() with before() and after():”

How about removing ‘the’:
“So the next step is to simply replace setup() and teardown() with before() and after():”

3rd paragraph:
“converstion” -> “conversion”

When running Cucumber to test after adding the model I get a complaint that the movies table does not exist:

cucumber features/showtime_descriptions.feature:7
Feature: Showtime Descriptions # features/showtime_descriptions.feature

So that I can find movies that fit my schedule
As a movie goer
I want to see accurate and concise showtimes
Scenario: Show minutes for times not ending with 00 # features/showtime_descriptions.feature:7
Given a movie # features/step_definitions/showtime_steps.rb:1
Could not find table ‘movies’ (ActiveRecord::StatementInvalid)

I am running Rails 2.2.2 and Cucumber 0.1.16.

Sidebar, 1st paragraph:
“It scanned Java source code with JUnit tests in them”

How about:
“It scanned Java source files with JUnit tests in them”
or
“It scanned Java source code with JUnit tests”

Wondering how/whether this “—format colour” option is related to the “-color” option on the next page.

Also, why does the spelling seem to alternate between ‘color’ and ‘colour’? Are they interchangeable?

The example at the top of this page, and the section heading on the previous page (115) show “-color” with one dash. The next example shows “—colour” with two dashes (and a different spelling). Farther down, an example shows it as “—color”

Are the one-dash versions and two-dash versions interchangeable? Are the spellings interchangeable? If so, it would be helpful to say that.

3rd paragraph:
“if you prefer to stick with rspec releases, the TextMate repository is a simple and clean option”

how about:
“if you prefer to stick with rspec releases, the official TextMate repository is a simple and clean option”

(to distinguish the official repository (as it is called in the preceding paragraph) from the development (github) one.

4th paragraph:
> ending with “_test.rb” rather than starting with “test.”

How about:
> ending with “_test.rb” rather than starting with “test_”.

3rd paragraph:
“Line 9 tells us that at least one code example failed”

Doesn’t look like it from the above example. It looks like it tells us that they all failed (“No mutants survived”).

Last complete paragraph has three occurrences of “move onto”. Should that be “move on to”?

Top of page (sentence starts on previous page):
“you don’t have to worry about installing every single gem required—it’s included with the app.”

How about:
“you don’t have to worry about installing every single gem required—THEY’RE included with the app.”

In the “Using Rails config.gem” section, I’m confused by the part (3rd paragraph) that says, “you’ll need to setup your test environment to load the gems.”

I thought the first paragraph of this sections said that by using this method you’ll have the gem loaded in all environments. So is it loaded in all environments or just the test environment? And, why can’t it be done for just the test environment?

4th paragraph:
“confidence to refactor your code and evolve the application code”

2nd ‘code’ sounds redundant

End of 4th paragraph: “specify it’s behavior” should be “specify its behavior”

Last paragraph: “it’s support for piggy-backing” should be “its support for piggy-backing”

3rd paragraph: “added valued” should be “added value”

2nd-to-last paragraph:
“created in the Given() and available to all subsequent steps”

How about:
“created in Given() and available to all subsequent steps”
or
“created in the Given() method and available to all subsequent steps”

End of page:

Since the last paragraph introduces the —scenario option, how about showing the command using that option in the example that follows

Footnote 3:
“The —scenario was introduced in cucumber-0.1.9”

How about:
“The —scenario option was introduced in cucumber-0.1.9”
or
“—scenario was introduced in cucumber-0.1.9”

… and heckle 1.4.2 was released in 2009. My erratum is moot!

s/software the matters/software that matters/

I think the line “Assuming that your monitor has more colors than this book, you can also add the –colour option…” should instead use a double hyphen…“—colour”

In the Arrays and Hashes paragraph on pg81, the first and second example looks to me to be incorrect. Should the two arrays in the second example be different or am I misunderstanding the intention?

[1,2,3].should [1,2,3] [1,2,3].should_not [1,2,3]
{’this’ => ‘hash’ }.should {'this' => 'hash' } {'this' => 'hash' }.should_not {’that’ => ‘hash’ }

Thanks, Iain Watt.

It seems the code example is aliasing the object predicate ‘can_drive_at_night?’ with :drive_at_night so just say that. As it is now the point you’re trying to make is not very clear.

The very last example on the page shows storing a value in the before and resetting it in the after. However the code shows two “before” functions - the second should be after.

Ie.

before(:each) do
original_global_value = $some_global_value $some_global_value = temporary_value end before(:each) do $some_global_value = original_global_value
end

should be

before(:each) do
original_global_value = $some_global_value $some_global_value = temporary_value end after(:each) do $some_global_value = original_global_value
end

There’s an existing example written:

movie_list.empty?.should be_true

A more idiomatic way of representing this would be:

movie_list.should be_empty

I don’t like the example because it makes more sense to the implementors of rspec than to its users. A better example might be:

it “should result in 3.325 < val < 3.335” do
val = 10.0 / 3.0
val.should be_close(3.33, 0.005)
end

Your first version of the spec file is:

require File.join(File.dirname(FILE), “/../spec_helper”)

module Mastermind
describe Game do
end
end

It’s good practice to include a stub for a test you know you’re going to need by making the example:

require File.join(File.dirname(FILE), “/../spec_helper”)

module Mastermind
describe Game do
it “should send a welcome message”
end
end

The line:

expected #has_key?(:id) to return true, got false

doesn’t format correctly (the syntax highlighter is confused)

The formatting of the output is using the wrong syntax highlighter (it shouldn’t treat the ‘#’ as a comment.

You should drop ‘RAILS_ROOT/’ from the directories - it’s what’s going to be naturally assumed by the reader and it’s inconsistent with other directory references.

Minor formatting problem - the first line of showtime_descriptions.feature is orphaned from the rest.

To be more consistent, replace (line #8)
“ruby spec/mastermind/game_spec.rb —format specdoc”
with
“spec —format specdoc spec/mastermind/game_spec.rb”

By doing so, you can also remove the “require ‘rubygems’” from your code.

The text reads “Steps are defined by calling any of three methods provided by
Cucumber: Given( ), When( ), or Then( )”. You mentioned And and But as similar to Then but continuing. Are they the defined the same as Then()? I am sure I’ll figure this out later, but so far this leaves me asking.

Text says " example grouip with theshared_examples_for“. Spelling error with ”group".

On the numbered list, showing the order the blocks run, item five should be outer after, not outer before

“[1,2,3].should_not [1,2,3]" this test will actually fail. I would assume you meant something like "[1,2,3].should_not [3,2,1]”.

What’s with the underscores in the number for the commission example? 250_000 and 7_500??

The text shown for the cucumber features/scenarios is using ruby syntax highlighting. So words like “for” and “break” in plain-text phrases like “So that I can break the code” are highlighted when they shouldn’t be.

I suggest using a different syntax highlighting.

“only moments a way” should be “only moments away”

In first paragraph at top of page, command for running the newly created codebreaker_submits_guess feature shows the file name as “codebreaker_submits_guess.rb” instead of “codebreaker_submits_guess.feature”.

In the feature narrative, it says:
“For each additional peg in the guess that matches the color but not the position of a color in the guess, a white peg is added to the mark.”

This should say:
“For each additional peg in the guess that matches the color but not the position of a color in the SECRET CODE, a white peg is added to the mark.”

This same error is repeated on page 53, when this same narrative is shown again.

3rd paragraph of ‘FIT’ sidebar:
I think ‘repetative’ should be ‘repetitive’

In 2nd paragraph of feature narrative, same error as on pg 50 (‘guess’ in last sentence should be ‘secred code’)

4th paragraph:
“modify if as follows” (if -> it)

3rd paragraph has three errors (that I noticed):

actaully -> actually
becasue -> because

“complex enough where this brute force approach…”
how about:
“complex enough THAT this brute force approach…”

3rd paragraph, 1st line:
How about ‘RSpec’ instead of ‘rspec’ (as you have it in other places in the book)

In lambda examples, :working_to_hard should be :working_too_hard

Start of section 4.3:
“we’ll build a code example around first one that is failing”

How about:
“well build a code example around THE first one that is failing”

2nd paragraph:
“the example on line .”

Should this be “the example on line 10.”?

2nd paragraph:
“But there there are two sides to every story.” (duplicate ‘there’)

2nd paragraph:
“its a good idea”

How about:
“it’s a good idea”

2nd paragraph:
“we’ve not only got all the examples to pass”

How about:
“we’ve not only gotten all the examples to pass”

2nd to last paragraph:
“Windows users use same script”

How about:
“Windows users use THE same script”

alogrithm -> algorithm

naive -> naïve

“either revisit what you’ve already built or make due.” s.b. “either revisit what you’ve already built or make do.”

In game.rb:

the expression
@code = code
is missing in the start-method.

[sudo] gem install aslakhellesoy-cucumber —version “>= 1.1.99.21”
does not work
it should be
[sudo] gem install aslakhellesoy-cucumber —version “>= 0.1.99.21”

The first example should read:

current_url.should =~ /vacation-photos/

The first line should read:

Let’s break down the spec:

(breakdown is not a verb)

“with a couple reusable” should read “with a couple of reusable”

Should the below code work?

ruby spec/mastermind/game_spec.rb —format specdoc

It returns, no output for me.

spec spec/mastermind/game_spec.rb —format specdoc
does work for me.

great book, so, far.

thanks

Need to describe the file naming conventions between the .feature file and the step definition files.

cucumber —require features features/codebreaker_submits_guess.rb

Shouldnt’t that filename be codebreaker_submits_guess.feature ?

End of 2nd paragraph:
“our applications provides” should be “our application provides”

Last paragraph:
“it’s own” should be “its own”

2nd paragraph: “it’s genres” should be “its genres”

Looks like the example at the end of this page is failing when it shouldn’t be

3rd paragraph:
“takes a little bit of a time” should be “takes a little bit of time”

4th paragraph:
“test between the tags” should be “text between the tags”

Looks like the last code sample should say “click_link” instead of “clicks_link”

2nd to last paragraph:
Should “it stores a ActionController::TestUploadedFile” say ‘an’ instead of ‘a’?

Top: “text/plainMIME” should be “text/plain MIME”

2nd paragraph:
“Webrat provides the submit_form()”

How about:
“Webrat provides submit_form()”
or
“Webrat provides the submit_form() method”

2nd to last paragraph:
“include” should be “including”

Last paragraph:
Out of place line break after “pseudo-class,”

3rd example regex:
“I the Messages tab should be active”

How about:
“The Messages tab should be active”

4th paragraph:
should “a interesting rule” say “an interesting rule”?

3rd paragraph:
“which include accessors”

How about:
“including accessors”

3rd paragraph:
“accessors for their value state”

How about:
“accessors for its value state”

3rd paragraph:
“RESTAPI” should be “REST API”

“cd to the mastermind directory” where? So far the book does not suggest downloading the code or creating a directory.

“Figure 2.2, on the next page shows” — you need a comma after “page”, or no comma before “on”.

“By convention, we’ll build” doesn’t make sense. By convention, people build… so we will too. Or: Following convention, we’ll build…

It’s not clear what file the steps should be typed in.

Add “a” before “*nix user”

Doing split(/n/) only works because the first message includes “\
”. If it were other way around (“Enter name: ” first, and then “Welcome!\
”, or whatever), then splitting on \
would not isolate the two messages. Assuming I’m right about this, it seems very fragile.

cucumber installation version is wrong

Given:
[sudo] gem install aslakhellesoy-cucumber —version “>= 1.1.99.21”

Should be: 0.1.99.21 otherwise gem is not found

“Fowler talks about changing the behavior of systems…” This sentence is kind of red herring. He really talks about not changing it, and in any case, there’s no need to recap this. You’ve already summarized what refactoring is, so you can just go and ahead and do it.

Make up your mind about how to spell behavio(u)r. I know the Prag enterprise has a foot in both camps, but still :-)

“criteria” in the “FIT” sidebar should be “criterion” (or “is” should be “are”).

absolute line #12 reads

with a the as_null_object( ) method:

perhaps should read

with an as_null_object( ) method:

“At this point all of the examples pass: ”

I could be mistaken, but I don’t think there was ever an iteration where game#start actually saved the parameter “code” into code. My tests didn't pass, i read backwards, and didn't see any code that set code.

“it’s support for piggy-backing” should be “its support for piggy-backing”

Clarify a bit why the Webrat version is less coupled with the code. It still embeds form element names. It really doesn’t seem that the use of movies_path is the sole remaining implementation detail left.

The code example at the bottom of the page should not have a page break after the first line, especially since it masks the required indentation of the next line.

TRUNC at end of line instead of: do |form|

(in code block on bottom half of page)

3rd paragraph of “A Big Misconception”:
“they’d completely make changing some of the views painful”

How about:
“they’d make completely changing some of the views painful”

First line:
‘things which lead that “Ah-ha!” moment’

How about:
‘things which lead TO that “Ah-ha!” moment’

4th paragraph:
“stub out text() method on the stub message”

How about:
“stub out THE text() method on the stub message”

3rd paragraph: duplicate ‘to’

Last line:
“should a render a form to create a message”

How about:
“should render a form to create a message”

Paragraph after 2nd code sample:
“Mock models that act as_null_object”

We didn’t use a token “as_null_object” (or any variation on “acts as”) in the code. We just had “:null_object => true”

First line:
“and we’re going to add a sidebar component”

How about:
“and NOW we’re going to add a sidebar component”

6th paragraph:
“let’s move it out into it’s own partial”

How about:
“let’s move it out into its own partial”

7th paragraph:
“rely on an local variable”

How about:
“rely on a local variable”

I don’t understand why the responses here (and again on the next page) would contain the string “rendered form partial”

2nd paragraph:
“If you run new.html.erb_spec.rb now, you’ll see four failing examples”

Why would they be failing now? We just refactored the form to a partial. Shouldn’t they still be passing, because the form is still rendered when the view is rendered?

2nd to last paragraph:
“this one spec and the form, itself.”

How about:
“this one spec and the form itself.”

2nd paragraph: duplicate “in”

4th bullet point:
shouldn’t “lib/path/to/view.html.erb” be something like “app/path/to/view.html.erb” instead?

“choose between the lesser of three evils” should be “choose among three evils” or “choose the least of three evils”.

9 No mutants survived. Cool!
…
Line 9 tells us that at least one code example failed — no failures

sidebar:
software the matters s/b software that matters

In Duck Typing subsection,
Passes if… and Passes unless …:
“m.respond_to?(m)” -> “actual.respond_to?(m)”

In 1.3 RSpec first code example mixed up “describe” and “context”.
My understanding is describe/context are for backword compatibility.
(see also. changelogs on 0.9.1)

They are still first class spec’ing vocabularies? Did I miss someting?

“This example uses the specify( ) method instead of it( ) because specify
is more readable when there is no docstring. ” <- I have a question. My understanding is context/specify is for backword compatibility now(s.a. 0.9.1 changes).
Is it a first class spec’ing DSL still now?

Using ActiveSupport’s test class, you can write:

test “a > b” do

etc.

By far the most disconcerting magical object is whatever “should” returns. It would be good to explain that. What is the return value of should, and how is that object engineered?

I’d urge you not to perpetuate the idea that duck typing is about calling respond_to? It really, really isn’t, and that interpretation of it has haunted it for years.

Cucumber Seeds: JBehave libary => library

cucumber —require features feature/codebreaker_submits_guess.rb should be .feature

Was page 15 in B1.0:
“its time” should be “it’s time”

team.working_too_hard.should throw_symbol(:working_to_hard)

Should the symbol be :working_too_hard (two oh’s)? Occurs twice on this page.

Next-to-last sentence in 2nd paragraph of section 15.1 should read “… revisit what you’ve already built or make do” (not “make due”).

Second paragraph under section 16.1 begins, “Like a good set of IntegrationTests…”. Need to de-wikify that.

Creating the model, movie.rb, without creating the migration as well might confuse new-to-rails readers. A gentle suggestion to the reader to script/generate the model, edit the migration, run db:migrate and db:test:clone (or at least a gentle reminder the first time) might help.

[Cut from the last para of 170 to the middle of 172]

Reasoning: Skip the example of “what Rails provides out of the box.” You’re trying to make the case for webrat, so lead with that. It’s a bit jarring to read 2 pages of “what I don’t want to use.”

On the last paragraph is a word missing:

.. second, the Game needs a [???] to handle the messenger argument ..

One comma too much be before the closing and
… other than the prescribed r, g, y, c, b[,] and w?

BDD is about writing software the matters

Ruby keywords are highlighted in this cucumber output (the next page, 25, has similar output without this problem)

Cucumber output shows snippets without anything in the bodies of the methods. In my output each has ‘pending’ in the body. Also, they are described in the output as “undefined steps”, not “steps pending”. I am using cucumber version 0.1.99.21

2nd line: “enter that snippet to it”
How about: “enter that snippet into it”

The feature file in the sample code has #START and #END comments, which also show up in cucumber’s output

“Now we see file and line numbers”
How about “Now we see file NAMES and line numbers”

“Now we see file [names] and line numbers for the feature and scenario”

I only see this for the scenario when I run cucumber — not the feature.

Wondering what the “require ‘rubygems’” line is doing here. It wasn’t in the example folder at 01/01, it’s not mentioned in the surrounding text, and my spec seems to run just fine without it.

Middle of page:
“but we prefer to refactor in the green than in the red”

How about:
“but we prefer to refactor in the green rather than in the red”

Omit: “You know, the ones who know about CTRL-C, but don’t know about cat.” Keep it collegial.

Leads into “experiencing that gnawing feeling” with haste as a lot of readers are still puzzling over “should_receive()” before “guess()”. The paragraph about “the first three lines in the example” could be made softer and clearer. It’s the first significant break point. It should be softer and clearer.

Last paragraph of 16.2:
“Then we’ll explore using Webrat for both the Simulated Browser and Automated Browser styles in Chapter 17, Simulating the Browser with Webrat”

The ‘automated’ part appears slated for the (as yet unwritten) chapter 18, not 17

Missing line number:
“[…]as shown on line in the code that follows”
Maybe a typo here:
describe(‘A Person’) # <label id=“code.lone_describe”

Running Ruby 1.9.1

The following error is returned when sending puts() to the mock messenger:

jon@bunt:~/Code/mastermind(master)$ spec -c spec/mastermind/game_spec.rb
F

1)
NoMethodError in ‘Mastermind::Game starting up should send a welcome message’
private method `puts’ called for messenger
/home/jon/Code/mastermind/lib/mastermind/game.rb:8:in `start’
/home/jon/Code/mastermind/spec/mastermind/game_spec.rb:10:in `block (3 levels) in ’

Finished in 0.021702199 seconds

1 example, 1 failure

Disregard my previous tech error. It was due to passing a string rather than the mock.

Top: “The step passes because the Genre model and table already exist.”

(because we said they do, just now?)

The step definition file we’re writing is called “genre_steps.rb” in the example at the bottom of this page. But on pages (at least including 170 and 172) it is called “movie_steps.rb”

Building from the models out to the views means writing code based on
>> assumptions of what <<>> think you’ll need <<.
of what <> think …
Being a smart ass I would further say that
that what you think you’ll need IS an assumption. So maybe it would be better to say:
“… based on assumptions.” or " … based on what you think you’ll need."

The first paragraph in “Finding the Way Home” is a vague mess.

Please be more specific when refering to the “destination”, the “example” or “this refactoring”.

The first paragraph in “Finding the Way Home” is vague because the reader is never explicitly told to add the code argument to the “should prompt for first guess” example. This isn’t an issue for people downloading the code examples, but can be for those whom choose to type the examples.

For the save_and_open_page description you should probably say that the .html is saved to RAILS_ROOT/tmp/ and is only opened automatically on OS X.

Assuming there is an automatically running script that produces the sample outputs in the book, the one on 174-175 fails because rake db:migrate hasn’t been run on the ‘03’ project in the ‘simulated browser’ section of the code samples.

It would be nice to know who talks here: “I once worked on an application …”
(Like here: beta2.0p193: “by Zach Dennis”)

TRUNC at the end of the line instead of
:value => “the title”
(in code example “should render a text field for the message title”)

First paragraph of “Semantics vs Syntax” -> “The spec also references elements with the IDs recent_messages and message,[…]” -> recent_messages and message are classes, not IDs.

…To put this into perpsective, perhaps a brief exploration… In third paragraph.

I agree with suggestion #38294. I am typing the examples as opposed to downloading the code samples, and I don’t know what the “destination” you refer to is. Which example don’t I need to copy?

If you’re reading the book sequentially and you’re not familiar with BDD terminology, it’s difficult to understand the relationships between features, scenarios, examples, and step definitions when working your way through Part 1. Could there be a chapter beforehand that explains these things in detail?

I’m not only new to RSpec and Cucumber, but also to BDD in general. A framework-agnostic explanation of BDD and its terminology, would go much further in helping me understand what RSpec and Cucumber are doing.

This page states “Running features/codebreaker_starts_game.feature gives us a different error now:”

The error that is actually received is “undefined method `start’ for # (NoMethodError)”

not
“wrong number of arguments (1 for 0) (ArgumentError)”

the command “cucumber —require features features/codebreaker_submits_guess.rb” should instead be “cucumber —require features features/codebreaker_submits_guess.feature”

When I try to run the codebreaker_submits_guess.feature

using this command:
cucumber —require features features/codebreaker_submits_guess.rb

I get the following output:
/Users/jp/.gem/ruby/1.8/gems/cucumber-0.1.16/bin/../lib/cucumber/treetop_parser/feature_parser.rb:27:in `parse_feature’: features/codebreaker_submits_guess.feature:20:5: Parse error, expected one of “\\r”, “\
”, “#”, “GivenScenario”, “Given”, “When”, “Then”, “And”, “But”, “Scenario Outline”, “Scenario”, “More Examples”. After “”. Found: “|” (Cucumber::TreetopParser::Feature::SyntaxError)

I copied the code for the codebreaker_sumbits_guess.feature directly from the code provided in the PDF.

The Null Object Pattern was mentioned and given the GOF book reference. The GOF book does not mention this pattern directly (I can’t find it). But other books that I have like Refactoring by Fowler or Refactoring to Patterns by Kerievsky does.

s/repetative/repetitive/

At the end of the first paragraph inside the “Cucumber Seeds” outset, “library” is misspelled as “libary”.

Rails.root.join(“spec”, “fixtures”, “vacation.jpg”)

cause problem w/ Rails 2.3.
Since Rails2.3, Rails.root returns Pathname and TestUploadedFile can’t handle path as Pathname correctly.

So, use File.expand_path(“vacation.jpg”, “#{Rails.root}/spec/fixtures”) or other method returns String or fix Rails( #2264 on rails.lighthouseapp.com)

“Although the narrative is free-form, we generally follow a variation of the Connextra format described in the (as yet) unwritten sec.narrative.”

Describing, or defining what the Connextra format is might be helpful to some readers. While familiar with user stories, using this term to describe the format was new to me. A little Googling solved that, but I’m still not clear on what sec.narrative refers to.

“Scenarios: all colors correct …” The current version of cucumber does not support this syntax, I had to replace Scenarios with Examples and remove the “all colors correct” part to get it to work.

“… To get this step passing we’ll need a MoviesController” …

It would help you describe the step to take to create this controller.

Before trying the samples, I did a clean rails install. This installed 2.3 . And some of the samples (don’t exactly remember) don’t work with 2.3 (possibly due to the in progress of the git versions of cucumber, and rspec). Maybe it is best to specify the rails version when creating the rails project.

In the description of attach_file, there is all of a sudden the mention of “Photo”. I took me a while to figure out how it relates to the form field. An example form would be nice here.

./script/cucumber features/showtime_descriptions.feature:7 Doesn’t work, most probably because I use Postgres and didn’t migrate to the db!? Is the migration of the movie model missing?

In the phrase, “and self is the result object.”, “result” should be styled like code.

The big gray block divides up the code example. This makes it difficult to read the code.

“The example will still be failing, but you should see another familiar error message: MissingTemplate. Go ahead and implement the new.html.erb template.”

But we just added the template file at the end of the last page (198). Since I have that template already, but it’s blank, the error I’m seeing now is:

1)
ArgumentError in ‘messages/new.html.erb should render a form to create a message’
wrong number of arguments (2 for 1)
./spec/views/messages/new.html.erb_spec.rb:11:in `have_selector’
./spec/views/messages/new.html.erb_spec.rb:11:
script/spec:4:

Finished in 0.082394 seconds

1 example, 1 failure

This line from the code example is causing a failure for me:

response.should have_selector(“form[method=post]”, :action => messages_path) do |form|

…

1)
ArgumentError in ‘messages/new.html.erb should render a form to create a message’
wrong number of arguments (2 for 1)
./spec/views/messages/new.html.erb_spec.rb:11:in `have_selector’
./spec/views/messages/new.html.erb_spec.rb:11:
script/spec:4:

Finished in 0.088844 seconds

1 example, 1 failure

When I remove the second argument, it passes (after making the other fixes mentioned this in the section) but still warnes about using a deprecated feature:

response.should have_selector(“form[method=post]” +
“[action=‘#{messages_path}’]”) do |form|
form.should have_selector(“input[type=submit]”)
end

…

Nokogiri::CSS::Parser.parse is deprecated, call Nokogiri::CSS.parse()
.

Finished in 0.087327 seconds

1 example, 0 failures

The new “should render a text field for the message title” example passes when it should fail. I’m guessing this change to Nokogiri probably has something to do with that:

(http)github.com/tenderlove/nokogiri/commit/13db61b3a028bf64ea94f957b4fc05bd0ecb9337

In the “” example I had to turn a line into this to get it to pass:

response.should have_selector(“form[method=post]” +
“[action=‘#{messages_path(@message.id)}’]”)

(among other things, message_path became messages_path)

“Now that we’re done refactoring, we can go back into spec-driving mode and add an example to edit.html.erb_spec.rb that expects the edit template to render the form partial”

This seems to imply that this file already exists at this point, but I’m pretty sure it doesn’t.

“Run that spec, watch it fail, and update edit.html.erb to render the partial”

I don’t think edit.html.erb exists yet either…

“With the shared example working let’s remove the original examples which ensured the for m partial was being endered. The new.html.erb_spec.rb should look like:”

but we already removed these back on page 208:

“If you run new.html.erb_spec.rb now, you’ll see four failing examples. These are the four that got copied over to _form.html.erb_spec.rb. Because those same examples are passing in the _form spec, we can safely remove them from the new spec.”

(and I think there were only three, not four)

In the ViewMatches example, it isn’t apparent until the very end that we’re supposed to be doing any following along in the views_example application:

“First, let’s add a line to require every ruby file in the spec/spec_helpers/ directory. This goes before the Spec::Runner.configure block:”

By this point we’re a couple sentences from the end of the chapter.

‘script/spec’ requires spec/autorun with latest rspec 1.2, use ‘rake spec’ instead

In Joe Asks: “…provided by the spec-rails library”: change “spec-rails” to “rspec-rails”

Change “Cucumbers’s” to “Cucumber’s” in the first paragraph of Completing the Feature.

In “The cost of going Agile”, “..project delivery We’ve managed..” should not have a capital W.

“..to understand what that means first. so we work with the core..”

Needs capital S in “so”, or a comma.

“..in response to being interacted with . This is useful for..”

Extra space.

“Part of the rational for using mocks..” should be rationale, minus the extra space.

Duplicated code snippets; it looks like the second one is complete, but the first is partial.

after adding the codebreaker_submits_guess.feature feature were told to run the command:

cucumber —require features features/codebreaker_submits_guess.rb

but the file is .feature not .rb so the command should be:

cucumber —require features features/codebreaker_submits_guess.feature

Download link doesn’t exist.

There is a discussion of running the RSpec examples and having all (4 at that point) pass, but with the code that is viewable in the book, they will not pass. The linked code shows @code = code inside lib/mastermind/game.rb#start

The book states that webrat’s fill_in supports referencing form fields by id=, name= and text. However in Rails 2.3, this seems to only be working with the name.

Under Floating Point Comparisons
“actual < (expected + delta) or > (expected - delta)”
the “or” should be “and actual”

“within the contest of a single object” s/contest/context/
and
“specify ordering off expectations” s/off/of/
and
“for multiple object in” s/object/objects/

Broken link to code download

You kind of jump right into things, without first suggesting that the reader does ‘rails mastermind’ ‘script/generate cucumber’ etc., maybe consider slowing it down in the beginning.

This story feels kind of out of place, I mean, it’s right in the middle of a code example. Perhaps move it so it’s not interfering with anything.

shouldn’t the lower game.rb example be expecting arguments?

e.g. start(code)

The link of the code to bin/mastermind is broken. And is it suppose to be mastermind.rb?

I don’t understand why we don’t want to use STDOUT or what it is. I started feeling a little lost on page 32. I’m not making the connection of what STDOUT has to do with cucumber.

A bit of clarification needed on mock(“messenger”). I’m not sure if the object mocks a object of the class messenger or creates a mock object and gives it a class name of messenger or something else. I’m new so maybe my question is dumb but it’s unclear to me.

I think it’s a better idea to use a curly energy-saver bulb instead of an incandescent bulb on the cover, if possible :)

This sentence in the last paragraph could use some love:
“The reason we can move this quickly that the green bar tells us that we’re safe after every change we make.”

In the mm/43 code example:

@messenger.puts temp.sort.join

should that line actually be(?):

@messenger.puts temp.compact.sort.join

First line of “A brief history of Agile”:

projcets

Link in the footnote isn’t active.

In the epub book on iPhone, it displays as “Peanut butter & jelly” instead of "Peanut butter & jelly. So, it reads as

to ensure “Peanut butter & jelly” is on the page, you’d type just that in the string, not “Peanut butter & jelly”.

I’m getting this error when run:
$ rake gems:unpack:dependencies RAILS_ENV=test

> no such file to load — nokogiri/native

“spec/spec_helper.rb: This file is used load…”

should be

“spec/spec_helper.rb: This file is used to load…”

When I run the feature on page 196, I get the error below. The problem is that there is no table for movies. Did you want me to scaffold a model and rake the migration? I’m trying to following along step by step and it misses this.

1. ERROR:

$ cucumber features/showtime_descriptions.feature:7
Feature: Showtime Descriptions

So that I can find movies that fit my schedule
As a movie goer
I want to see accurate and concise showtimes

Scenario: Show minutes for times not ending with 00 # features/showtime_descriptions.feature:7
Given a movie # features/step_definitions/showtime_steps.rb:1
Could not find table ‘movies’ (ActiveRecord::StatementInvalid)
features/showtime_descriptions.feature:9:in `Given a movie’
When I set the showtime to 2007-10-10 at 2:15pm # features/step_definitions/showtime_steps.rb:5
Then the showtime description should be “October 10, 2007 (2:15pm)” # features/step_definitions/showtime_steps.rb:10

1 scenario
1 failed step
2 skipped steps

The link provided to the code-breaker script is “Forbidden”.

“There is no application code yet, so we’re getting a NameError on Mastermind. Take a look at the backtrace.” What is a backtrace?

Wondering how the page numbers in this errata submission form should be handled when using formats like epub and mobi

It’s hard to follow the provided code examples, in the sequence of numbered folders.

How about a git repo for each of the main projects that book takes the reader through. Each step could have its own commit, and the reader could view it on github or clone it to their local machine and use tools like gitx to view it or play with it.

“This isn’t a very complex a problem compared to many …”
should be
“This isn’t a very complex problem compared to many …”

I think the last code snippet:
Download mm/27/lib/mastermind/game.rb
def start
messenger.puts "Welcome to Mastermind!" messenger.puts “Enter guess:”
end

should have been:
def start(code)
…

I found a couple of things in Chapter 10 tha kinda jumped off the screen at me.

132: The examples shown don’t match the text—Hash with 17 key/value pairs… hash.keys.length.should == 42.

Next paragraph, they do match:
hash.should.have(17).key_value_pairs.

Maybe I’m just being grumpy, but it bothered me as I read it.

136: In the paragraph

Since there are plenty of other examples that specify specifics about the error messages raised by message expectation failures, this example only cares that a MockExpectationError is raised.

“specify specifics” seems awkward.

The code links are broken. Example:

mm/04/features/step_definitions/mastermind.rb

Kind regards,

Ralf Waldvogel

Bottom of page:

The nested contexts produce a confusing description: “with duplicates in the guess that match a peg in the code by color and position”

Duplicate pegs in the guess can match a peg in the code by color, but by position?

Sidebar, 3rd paragraph:
“launched into an theoretical algorithm problem-solving session.”

How about:
“launched into a theoretical algorithm problem-solving session.”

Last paragraph:
“The reason we can move this quickly that”

How about:
“The reason we can move this quickly is that”

Near bottom:
“we’ve used to the Cucumber scenarios”

How about:
“we’ve used the Cucumber scenarios”

Near top:
I think “irreverance” should be “irreverence”

Last paragraph:
“behavour” should be “behaviour” (or “behavior”, not sure if the american/british thing matters much)

In the “Continual regression testing” subsection:
“depending on the kinds of feature we are implementing”

How about “kind of feature” or “kinds of features” here

First:
Running ruby 1.9.1 (2008-12-01 revision 20438) [i686-linux] and current rspec and cucumber I get only
Given /^I am not yet playing$/ do
pending
end

When /^I start a new game$/ do
pending
end

Then /^the game should say “([^\\”]*)"$/ do |arg1|
pending
end

The lines
Then /^the game should say “Welcome to Mastermind!”$/ do
pending
end
left.

Does the name of the as_null_object( ) method come from the internal implementation? Or does it describe the external behavior? I would expect something like: ignore_additional_parts().

To set up HTTP headers in Webrat, the text suggests the following:

Given /^I’m browsing the site using Safari$/ do
header “User-Agent” , “Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us)”
end

On its own, this is not enough; you must also explicitly call headers in your request, e.g.:

get ‘/’, nil, headers

Then, all is well.

Cheers,
- Brad Heintz
brad.heintz@gmail.com

In @game.start game is a local variable, so game.start will be correct.

Footnote about installation of packages should be moved to a ‘Preparing your ruby environment". I agree with other comments all this should be concentrated in one place. Ideally a ’rspec-book’ gem that always delivers the versions that related to the book no matter how the base gems evolve. Ideally this gem can be installed/uninstalled at will - without hosing your system as some dependency update/upgrade breaks your ‘dearest-project’.

Box: /subject-file with CTL+SHIFT+DOWN/feature-file with CTL+SHIFT+DOWN/

subject-file is a new notion.

End of sentence beneath box:
“Stories In, Features Out.”

This seems ambiguous to me. Did you mean “Stories went ‘out’, Features came ‘in’.”
Or did you mean something else by in/out?

Top of the page, code:

Then the game should say “Welcome to Mastermind!”
And the game should say “Enter guess:”

I think this could be more useful:

Then the game should emit “Welcome to Mastermind!”
And the game should prompt “Enter guess:”

The benefit is you save about 2 pages+ of convolutions trying to handle a shared step. This revealed nothing to me about Cucumber. In fact this shows the benefit of using Cucumber: It makes flaws patently obvious; 1) This game doesn’t ‘say’ anything (some do of course). 2) The two lines are fundamentally different.

On the last point, would people be comfortable bundling a programs splash screen with a GUI dialog requesting user interaction? Or in the audible case, bundling as shared behavior/features the startup music with audible prompts requesting input?

I was hoping this ‘straw man’ would reveal some Cucumber gold but at the end of a couple of pages….

You have given a directory tree for the RSpec tutorial.

It is <> clear where this goes. The “project root directory” is mentioned. But NOT the “Rails project root”.

Example: I am using NetBeans 6.5. It will create a standard Rails project with all the associated Rails directories.

I created a Rails MasterMind project.

Do these new directories go in the Rails Project root? E.g.,
MasterMind/bin/mastermind
MasterMind/features/step_definitions
Mastermind/features/support
MasterMind/features/support/env.rb
MasterMind/lib/mastermind
MasterMind/lib/mastermind.rb
MasterMind/spec/mastermind
MasterMind/spec/mastermind.rb
MasterMind/spec/spec_helper.rb

Or do these directories go in their own << NON-RAILS >> project root directory where << NONE >> of the normally Rails’ associated directories are:

Controllers,
Helpers,
Models,
View,
Configuration,
Database Migrations,
Libs,
Logs,
Public,
Rspec (I have installed the Rails gem ‘rspec’),
Unit Tests,
Functional Tests,
Test Fixtures,
Integration Tests,
Scripts
Documentation,
test/performance,
Vendor

go?

Can this Rspec/Cucumber system be installed in NetBeans? Or is this a recipe for complexity? Disaster? Not relevant to this book?

Struggling with all the concepts and yearning for the best way to may Rails Really Sing!!

Using NetBean 6.5 with Rails 2.3, Rspec and Cucumber gems installed. OS = Windoze Vizta.

Thanks,

Ken

Make it clear if this directory tree is << everything >> in the tree or is it a sub-tree in the RAILS project root directory with all those other RAILS dir’s.

Maybe set it up completely separately from RAILS? (I suspect this will defeat the coding/compliance cycle)

(See prior message for context.)

Ken

You may wish to describe how this works in the common IDEs.

NetBeans has great Project directory tree with the RAILS dir’s. Also a complete Files Tree showing ALL dir’s and files.

I used e-textmate before. It also has good layouts. But is not as good a integrating gems, plugins and tools.

Eclipse (Aptana) is similar.

How about some details on how the IDEs handle Rspec/Cucumber.

In NetBeans 6.l5 there already are a Unit Testing, RSpec set of directories and files.

Do we keep using the RSpec NB tools? How to incorporate Cucumber into the NB gui?

Thanks,

Ken Wagner

Running the examples should result in two failures not one. The example “should prompt for the first guess” should also be in error since the code is not passed to the start method in this example yet. The first time we see the code passed to the start method of this example is mm/27/spec/mastermind/game_spec.rb.

Have you thought about the issue of whether you’ll get flak from Pressman Toy for using the trademark Mastermind? Looks like the issue got raised in discussions about gnome-mastermind, too, but never went anywhere.

" In Cucumber, you get notification of a pending step, which you can think of as an undefined step. "

actually, it seems (from both Cucumber 0.2.2 output and the book’s output) that you get notification of an undefined step, which you can certainly think of as an undefined step…

“and Cucumber gave us this snippet to get that started:”

Actually, the snippet Cucumber gave us had “pending” in it; reading this, you might think you could just cut and paste the snippet from Cucumber, but you can’t.

"Here we store the return value of game.start": actually, it's game.start, not game.start.

@message is hyphenated. Not sure if there’s a rule about hyphenating code, but it feels wrong…

Immediately before Sec 4.5 you say it is not a good time to do exploratory testing. Then you go ahead and do it, concluding on p73 with a suggesting that exploratory testing was beneficial… “An interactive session with working software is worth a thousand meetings.”
Yours Confused

Looks like Cucumber 0.2.2 is smart enough to know that “Then the game should say ‘.*’” will cover both of the last two steps! (neat.)

RAILS_ENV=test rake gems
should be something like this
For Windows:
set RAILS_EV=test
For Linux and MacOS
export RAILS_ENV=test

rake gems
rake gems:install
rake gems:unpack:dependencies

The first paragraph of “Responding to Change” could be more explicit - perhaps add something like:

Our new Cucumber step-matcher needs Game.start() to accept an argument: the secret code. But our RSpec example assumes that start() doesn’t take any arguments. We don’t want to change two things at once, but we can’t fix one without breaking the other… can we?

“…and multiple failed attempts at decyphering the instructions in the release notes.”

The preferred spelling is “decipher”.

At this point, the RSpec stories pass fine but the Cucumber feature “code-breaker starts game” fails because it does not pass a code to Mastermind::Game::start. Is this intentional?

As Jesse posits above, I’m confused as to why “should_receive()” comes before the second “guess()”. Although, I just reread the paragraph about that code and it makes sense now, I missed it the first time. Maybe it could be made clearer? I can imagine why a mock object needs to know about the expectation before the call, but I also think it would help if this paragraph was expanded just a litte.

Isn’t a full page for a screenshot of the rails project tree a bit generous? Couldn’t be represented as a diagram, and to keep it consistent with the tree shown for the Mastermind game at the beginning of the book?

Perhaps remind the reader that they still need to create and run in the migration for the movies table to support the Movie class.

Is chapter 6 really necessary? Up until now it’s been a great tutorial/technical work on BDD using RSpec and friends and now it turns into a fluffy management book. If anything, this might make a good introductory chapter but I’d rather see more time given to BDD! The audience (developers) reading this book would already be sold on agile, otherwise they wouldn’t even be investigating BDD or TDD!

For example, in this chapter we’ll describe the behaviour of Game in spec/mastermind/game_spec.rb and we’ll put its
class definition in lib/mastermind/game.rb.

This sentence is in Chapter 2. States this will happen in Chapter 2.

Error: Doesn’t happen until Chapter 3.

Running “cucumber features” yields summary lines of:
1 scenario
1 failed step
1 skipped step
2 undefined steps

The book says it should be:

1 scenario
1 failed step
2 skipped steps
1 passed step

“1 passed step” vs "2 undefined steps.

Here is total STDOUT from “cucumber features”

Feature: code-breaker starts game
As a code-breaker
I want to start a game
So that I can break the code

Scenario: start game # features/codebreaker_starts_game.feature:6
Given I am not yet playing # features/step_definitions/mastermind.rb:5
uninitialized constant Mastermind (NameError)
./features/step_definitions/mastermind.rb:6:in `/^I am not yet playing$/’
features/codebreaker_starts_game.feature:7:in `Given I am not yet playing’
When I start a new game # features/step_definitions/mastermind.rb:9
Then the game should say “Welcome to Mastermind!” # features/codebreaker_starts_game.feature:9
And the game should say “Enter guess:” # features/codebreaker_starts_game.feature:10

1 scenario
1 failed step
1 skipped step
2 undefined steps

You can implement step definitions for missing steps with these snippets:

Then /^the game should say “([^\\”]*)"$/ do |arg1|
pending
end

Wording on the flow chart is awkward. “Repeat #2 - #7 until Scenario is passing” perhaps should mention “and the code is as simple and expressive as it can be” or something similar. “Repeat #1 - #7 when Scenario is all passing” perhaps should say “for each scenario in the current story” or something like that.

Cucumber does not check the correspondence of the
“Given /^I am not yet playing$/ do
end”

sequences in “features/codebreaker_starts_game.feature”

and

“features/step_definitions/mastermind.rb”

so that if one file has “../^I am not yet playing$/..”
and the other has “../^I am not playing$/..”

the result of cucumber remains

“1 scenario
4 undefined steps”

after adding the mistyped entry in “features/mastermind.rb”

Would it not be better if cucumber flagged the mis-correspondence? Or flag the “Given …” in the mastermind.rb file as either an orphan (not found in the “.feature” file) or not matching the “step_definition” file.

I found this oddity while experimenting with the “Given” entries.

in the

my output to the first step added (page 26) indicates 1 pending step and not 1 passed step as the PDF book says on page 27

have a way for us to indicate what our environment is at this stage as we are submitting a suggestion/error… and save it so that we do not have to update but can update it if it changes.

first full paragraph, change “hard understand” to “hard to understand”

the last sentence on pdf p.251 mentions a familiar error and instructs reader to create new.html.erb. On the next page, it instructs the reader to add a route, then goes into a more detailed version of creating the new.html.erb MissingTemplate error. Methinks the first reference should be removed.

Last sentence of the page: " We’ll go over the the
protocol in a bit,[…]" -> double “the”

In the second paragraph, you mentioned an error message, but what follows is the code for defining a custom matcher with custom failure messages (which is introduced in the next paragraph).

"In the event of a failure using should_not( ), the generated message would read like this:

Spec::Matchers.define :report_to do |boss|
match do |employee|
employee.reports_to?(boss)
end
[…]
end"

First sentence of chapter 15.4: “Custom matchers can help us to build up domain-specific DSLs for
specifying our code,[…]” -> you should remove “domain-specific”, domain-specific domain-specific language sounds not very well.

“The spec should now be at 2 examples, 0 failures, 1 pending.” -> not if you are using Rails 2.3.2, it will fail with the following error message: “Missing template messages/create.erb in view path app/views”

You pasted the wrong code example on the bottom of the page (the same as on page 288 -> “rails_controllers/messages/14/spec/controllers/application_controller5_spec.rb”).

I note that the rspec-1.2.2 docs recommend using “failure_message_for_should” rather than “failure_message”, and “failure_message_for_should_not” rather than “negative_failure_message” … see preamble for module Spec::Matchers

Procs referring to method working_too_hard? need a question mark at the end to match the actual name of the method. Currently written as lambda{team.working_too_hard} but should be lambda{team.working_too_hard?}

“Instead of getting bbbw, we get bbw.”

Shouldn’t this be “Instead of getting bbb, we get bbw”? The pending example which was just unpendinged expects ‘bbb’. Unless I’ve made a mistake?

In the second sentence of 23.2, there ist a duplicated “to”.
“… and help us to to remove duplication …”

There seem to be some missing steps in getting to green with the ApplicationController spec. The code from the tgz download shows that the ApplicationController needs to ‘rescue_from AccessDenied, :with=>:access_denied’ and define an access_denied method on ApplicationController in order for the “redirect to 401.html” example to pass. This step does not appear in the body of the book. As given in the book, the example continues to fail with an uncaught AccessDenied exception.

Not sure if a note about this is worth including in the book, but while doing the Mastermind demo I twice made the same mistake: I accidentally left off the ‘w’ in the w[] constructions in the specs. This resulted in confusing errors, since[r g y c] == ‘r g y c’.

This doesn’t really matter since the point is just to demonstrate the throw_symbol matcher, but doesn’t the first implementation of working_too_hard? already short circuit? The method returns as soon as it finds anyone who worked for more than 50 hours. How is this a “perfect case for using throw/catch”?

Looks like there’s an extra paragraph break at the bottom of the page between “:nth-child pseudo-class,” and “giving it lots of flexibility.”

When following along with the steps in this chapter, creating the movie.rb file as listed on this page doesn’t immediately make the Cucumber scenario pass, as shown on the next page. The reason for this is that there isn’t a movies table in the database yet. Cucumber reports the following:

Feature: Showtime Descriptions
So that I can find movies that fit my schedule
As a moviegoer
I want to see accurate and concise showtimes

Scenario: Show minutes for times not ending in 00
Given a movie
Could not find table ‘movies’ (ActiveRecord::StatementInvalid)
features/showtime_descriptions.feature:7:in `Given a movie’
When I set the showtime to 2007-10-10 at 2:15pm
Then the showtime description should be “October 10, 2007 (2:15pm)”

1 scenario
1 failed step
2 skipped steps
—-

In order to get this working, there needs to be another step to create and run a database migration that will make the movies table and give it showtime_date and showtime_time columns. Running the model generator (script/generate model Movie showtime_date:date showtime_time:time) would suffice for creating the migration, and as an added bonus, also creates an empty movie.rb file for the model definition. Run the migration (rake db:migrate), clone the production database to the test database (rake db:test:clone), fill in the details in movie.rb, and then Cucumber reports a passing scenario.

Of course, adding all this migration and database stuff detracts from the simplicity of the example. The credo as I’ve understood it so far in the book is to implement as little as possible to get a scenario to pass, and generating and running a migration seems like a larger chunk of work than I’m used to seeing in the code found earlier in the book. Then again, Rails has more complicated dependencies than a bare-bones Ruby app, so it might be necessary here to bite off a larger chunk.

Code example 5 for application controller failing with:
AccessDenied in ‘ApplicationController handling AccessDenied exceptions should redirect to the /401.html (access denied) page’
AccessDenied

Sorry if this is something I’ve done — I’ve tried to see if it’s my fault & not spotted it.

The code listing for ‘simulated_browser/03/out/01.all_passing’ isn’t a passing scenario at all. It has a failing step with the following error:

Could not find table ‘genres’ (ActiveRecord::StatementInvalid)

For the 3rd example you neglected to mention that you have to update the form to include <%= f.test_area :text %>. Of course running the spec told be it was missing, but you should be consistent.

It would be nice if the book would be Ruby 1.9 safe. the code in the guess method is the first instance I’ve seen which isn’t. It iterates over the guess string with each_with_index, but in 1.9 Strings are no longer enumerable.

So something like guess.split(“”).each_with_index … might be in order.

First ignore my earlier erratum #39008 I’d lost track of what was being passed to guess.

Than said, in order to getht app to work, I had to change it to:

#!/usr/bin/env ruby
$LOAD_PATH.push File.join(File.dirname(FILE), “/../lib” )
require ‘mastermind’
game = Mastermind::Game.new(STDOUT)
game.start(%w[r g y c])
while guess = gets.chomp
game.guess guess.split(“”)
end

without the chomp the newline is part of the guess

without the “” argument to split, with a guess of “cyyg” it passes
[“cyyg”] NOT the expected [“c”, “y”, “y”, “g”]

In the list of of built-in expectations, the definition of be_close is incorrect.

actual < (expected + delta) or > (expected - delta)

The OR should be an AND.

actual.be_close(3, 0.5)

actual < 3.5 OR actual > 2.5 passes for any numeric value.

what you really want is: 2.5 < a < 3.5

I’m not sure why the ‘Bundling in vendor/plugins’ section splits the two vendor/gem sections. I would consider merging the ‘Bundling in vendor/gems’ section with the ‘Using Rails config.gem’ section and introducing the

[sudo] rake gems:unpack:dependencies RAILS_ENV=test

command earlier - as it is a powerful and elegant way to manage and freeze an applications gems.

Unpacking webrat (and nokogiri) breaks cucumber.

“Because webrat (and nokogiri) are native gems, that is, they are built locally on your machine based on its architecture, we won’t unpack those.”

share_examples_for should be shared_examples_for (also on p.122)

The spec output in the middle of the page only appears that way if using —format nested, which has not been described.

—nested should be —format nested (at least in rspec 1.2.2)

The example at the top of the page (beginning with “agent.commission.should == 0”) is actually testing more than the prior example (which ends “should change{agent.commission}.by(7_500)”) because it is testing the starting value of 0, where the rspec example is only testing the difference between the starting and ending values.

Yet the text claims the two examples “express the same thing”.

field.players.collect — shouldn’t that be .select?

142 says that “home_team.should have(9).players_on(field)” will call home_team.players_on(field). (At least, that’s how I read it.) But back on p.136 it says players_on_the_field() and key_value_pairs() are sugar and not even evaluated. How are these different? Why isn’t team.players_on_the_field called?

class ReportTo is missing its ‘end’

Is does_not_match? (if implemented) called instead of matches? for should_not? Or in addition to matches?, somehow? The text isn’t clear.

set_hidden_field() could be used to simulate hack attempts, to make sure the app is resistant to such attacks.

reload — if, after a form submission, the response is a redirect, will webrat really resubmit the form? Because I don’t think that is normal browser behavior. It will simply reload the target of the redirect.

Is contain() sophisticated enough to distinguish between content that will be displayed vs html comments, tag attributes, javascripts, and the like? Seems like, generally, matching invisible content is not what is desired here.

I’m on windows XP sp3, rails -v 2.3.2, cucumber 0.3.1, rspec(-rails) 1.2.5 and after I make the DB and run the tests I stiil get this error
Scenario: Show minutes for times not ending with 00 # features/showtime_descriptions.feature:7
Given a movie # features/step_definitions/showtime_steps.rb:1
When I set the showtime to 2007-10-10 at 2:15pm # features/step_definitions/showtime_steps.rb:5
Then the showtime description should be “October 10, 2007 (2:15pm)” # features/step_definitions/showtime_steps.rb:10
expected: “October 10, 2007 (2:15pm)”,
got: “October 10, 2007 (:15pm)” (using ==)
Diff:
@@ –1,2 +1,2 @@
-October 10, 2007 (2:15pm)
+October 10, 2007 (:15pm)
(Spec::Expectations::ExpectationNotMetError)
./features/step_definitions/showtime_steps.rb:11:in `/^the showtime description should be “October 10, 2007 \\(2:15pm\\)”$/’
features/showtime_descriptions.feature:11:in `Then the showtime description should be “October 10, 2007 (2:15pm)”’

What I found out is
showtime_time.strftime(“%l:%M%p”).strip.downcase
doesn’t work on my machine for some reason. If I change it to
showtime_time.strftime(“%I:%M%p”).strip.downcase
and add leading zeros (0) to the Scenarios it will pass.

login_require() -> login_required() (last paragraph)

The description of adding after(:each) to reload routes appears after the code listing that already shows that code.

Is it really necessary to repeat every matcher for the “should_not” version? I think it just clutters up the chapter.

The macros section says how to write macros, but doesn’t discuss using existing macros. Is it suggested to install shoulda? rspec_on_rails_on_crack? Will there be examples in the final book?

The book says “Go ahead and create that class in app/controllers/messages_controller.rb”. Contrary to other cases in the book, just create a empty class does not work, it leads to failed examples with the message “Controller specs need to know what controller is being specified”.

Instead of “Go ahead and create that class in app/controllers/messages_controller.rb” it should invite to create a real controller class.

it “should render a form to create a message” do
render “messages/new.html.erb”
response.should have_selector(“form[method=post]” , :action => messages_path) do
|form|
form.should have_selector(“input[type=submit]” )
end
end
——
This don’t work. After some checking, (in webrat specs) I discovered this:

describe “specifying nested elements” do
it “should be able to loop over all the matched elements” do
@body.should have_selector(“div”) do |node|
node.first.name.should == “div”
end
end
Here, they take the node as yielded to the block, and add .first.
I don’t know where this bug belongs, perhaps way down in ‘nokogiri’
But I have to but a .first or .to_s to get it to run.

There are still other scenarios that do not pass. If you add these to your Scenarios, you will see the problem.

Scenarios: dups in code and guess
| r r g g | g g r r | wwww |
| r r g y | g g r r | www |
| g r r g | r g g r | wwww |

You may want to note that there are additional failing scenarios (at least refer back to the “Exploratory Testing” section). Perhaps suggest it as an exercise for the user to find additional failing cases and fix them in the same manner prescribed.

Ignore previous posting - the suggestions are addressed in the book. Reading more carefully would be helpful.

Text says: “Here we store the return value of game.start in a variable named message in the When step definition.”
Text should say: “Here we store the return value of game.start in a variable named @message in the When step definition.”

(Loosing the @ from game.start.)

The text says: “Open up a shell and cd to the mastermind directory and run the game_spec.rb file with the spec command, like this: spec spec/mastermind/game_spec.rb”

This is ambiguous, if “cd to the mastermind directory” means “cd to /spec/mastermind/” then that part should be dropped from the code following the spec command.

This page needs to explain each of the steps it takes. Why each file is requiring the other. Why each file is located where it is. The purpose of each file. The syntax of each line.

The text says “the Game needs to handle the messenger argument to the initialize method”. In this phrase, “handle” should be “hand”.

At the bottom of the page, I tried to copy the Feature:… and following three lines that spanned the page boundary but it ended up copying the footer and header as well. Might consider keeping the code together on one page?

The error given by the spec at this point, using rails 2.3.2, is not consistent with the text. The actual error reported is: ‘No action responded to index. Actions:’

Duplicate word “the” in “We’ll go over the the
protocol in a bit”

“To run the feature and see the result, cd to the mastermind directory in a command shell and run cucumber features -n.”

I ran this in my own project.

cucumber features -n
produces an error

cucumber -n features
produces a summary

cucumber features
produces output similar to your text

ganesh:~ zim$ gem list

* LOCAL GEMS*

actionmailer (2.2.2, 2.2.0, 2.1.2, 2.1.1)
actionpack (2.2.2, 2.2.0, 2.1.2, 2.1.1)
activerecord (2.2.2, 2.2.0, 2.1.2, 2.1.1)
activeresource (2.2.2, 2.2.0, 2.1.2, 2.1.1)
activesupport (2.2.2, 2.2.0, 2.1.2, 2.1.1)
aptana_cloud (1.0.6)
archive-tar-minitar (0.5.2)
builder (2.1.2)
capistrano (2.5.5, 2.5.0, 2.4.3)
cgi_multipart_eof_fix (2.5.0)
cheat (1.2.1)
cucumber (0.3.4)
daemons (1.0.10)
diff-lcs (1.1.2)
ec2onrails (0.9.9.1, 0.9.9)
fastthread (1.0.1)
gem_plugin (0.2.3)
highline (1.5.0, 1.4.0)
linecache (0.43)
mongrel (1.1.5)
mysql (2.7)
net-scp (1.0.2, 1.0.1)
net-sftp (2.0.2, 2.0.1)
net-ssh (2.0.11, 2.0.4)
net-ssh-gateway (1.0.1, 1.0.0)
optiflag (0.6.5)
polyglot (0.2.5)
rails (2.2.2, 2.1.2)
rake (0.8.4, 0.8.3)
rcov (0.8.1.2.0)
rest-client (0.9)
rmagick (2.9.1)
rspec (1.1.12, 1.1.11)
rspec-rails (1.1.12, 1.1.11)
ruby-debug-base (0.10.3)
ruby-debug-ide (0.4.5, 0.4.3)
ruby-nxt (0.8.1)
ruby-serialport (0.7.0)
rubygems-update (1.3.3, 1.3.1)
rubyzip (0.9.1)
sources (0.0.1)
term-ansicolor (1.0.3)
termios (0.9.4)
treetop (1.2.5)
ganesh:~ zim$ ruby -v
ruby 1.8.5 (2006-12-25 patchlevel 12) [i686-darwin8.8.1]
ganesh:~ zim$

Shouldn’t the code samples at the top of the page be “fill_in …” instead of “fills_in …”

I think the example you use at the start of the book is two complex form a business case point of view i can’t relate to it and im a massive fan of cucumber.

The stubs in the example for the WidgetsController are reversed. it “finds the widget” stubs update_attributes msg, and it “updates the widget’s attributes” stubs the find msg.

There is no Cucumber “—scenario” option (V 0.3.6) as mentioned on second last line and in footnote 3.

To run a single scenario just specifiy the line number of it - as on page 242.

“enough is” Line 3

The text has a space but none appear due to the emphasis of “enough”

The code for testing the application controller is not working. I get this error:

1)
AccessDenied in ‘ApplicationController handling AccessDenied exceptions should redirect to the /401.html (access denied) page’
AccessDenied

Statment.new should be Statement.new
Same on p. 126

You have the user download (or type in) a model file, but don’t show the script/generate to generate the empty model file, migration file and test files. Since Movie is derived from ActiveRecord::Base, the tests fail because the table cannot be found. It would be good to generate the new model with “script/generate rspec_model Movie” or even “script/generate rspec_model Movie showtime_date:date showtime_time:time” followed by “rake db:migrate” and “rake db:test:clone”.

In the “Joe Asks…” dialogue, you’re already supposing the reader knows what you mean by red/green. Maybe a couple of paragraphs and some screenshots to let the readers see what the process looks like

regarding #38350, I was having the same problem (getting undefined error vs. wrong number of arguments error). I went back through the book and the problem was that back on page 33, I didn’t actually copy the code for the mastermind script. I think I was a little thrown off by the line just before the code snippet “If we did that, the mastermind script might look like this instead:”. I think the word ‘might’ made me assume that this wasn’t the actual code and was just an example. I probably wouldn’t have posted this but it looks like at least one other person made the same mistake, so hopefully he sees this.

The book suggests to use

Then /^the game should say “(.*)” $/ do |message|
@messenger.string.split(“\
” ).should include(message)
end

for the step definition for the last two acceptance criteria in the start game scenario. When I run cucumber features though it says that the definitions for those two criteria are undefined.

What I had to do to get this working was to use cucumber’s suggested implementation, and insert the body of the book’s definition into it. So it ended up looking like this:

Then /^the game should say “([^\\”]*)“$/ do |message|
@messenger.string.split(”\
" ).should include(message)
end

This seems to work. For some reason cucumber isn’t matching the regex provided in the book. I am using the 0.3.9 gem.

You say that we should not be refactoring in the red, and you provide a method (pending) to make this possible. But we are still in the red on the cucumber scenario. Is this something that should be addressed here?

It might be worth mentioning somewhere not to “require ‘model_name’” (or any other rails classes) in your rails spec’s as this can cause classes to be loaded multiple times when more than 1 spec is run.
I only mention it because I had the require statement at the top (working of off the original non-rails mastermind examples) and this gave me a bunch of problems with callbacks firing multiple times (because the class would end up being required automatically beforehand and then again for the spec itself). I know this is a general pieces of rails knowledge but it might be worth making it explicit to people just starting with rails so they don’t run into bizarre issues running their specs.

“For each peg in the guess that matches color”

…should read…

“For each peg in the guess that matches the color”

Remember some of us try BDD early in our journey to Railsdom as we figure “if we’re gonna learn Rails, we might as well learn best practice”.

For this reason, p33 needs to explain:

1. The function of the $LOAD_PATH line
2. Why bin/mastermind is the appropriate location for this code
3. Why “new(STDOUT)” tells the game object it can hand output to STDOUT (it’s not clear from the only Rails API documentation)

Following up on suggestion #37454, I think the directory structure and require statements are pretty mysterious and inscrutable from p. 25 forward. To some degree this hinges on how much you want to assume on the part of your readers, which is probably going to be explained in the not-yet-written preface. I realize that you’re not writing a textbook for rank beginners, but I do think you want to consider how much Ruby experience you’re assuming.

I’m envisioning including this book/material in my Software Design and Development course that I’ll be teaching in the Spring, and for students transitioning from a Java-based Data Structures to a (potentially) Ruby-based Software Design and Development course, this sort of “magic directory structure” material is going to make my life more difficult.

Consider, for example, p. 37-38 (PDF). In less than a page, we insert a whole bunch of require statements without any real sense of what we’re doing or why. In some cases, those requires are the only thing in the files, which seems super magical; why in the world does that accomplish anything? Sure, we can play along and type in the code and run it, but if we’re not pretty experienced with Ruby, it’s mostly voodoo rather than knowledge. (It’s like a “cool hack” with no comment or test code. It may “work”, but it doesn’t add much value to the project.)

I understand that this is “How real Ruby is written”, but I’m concerned that this will really put off interested people that approach this with a sincere desire to better understand BDD, Ruby, RSpec, and Cucumber, but find themselves bogged down in smoke and strange incantations.

with rspec 1.2.6 and cucumber 0.3.9 freshly installed, I don’t get the ‘undefined method ’include’’ problem - it appears that this is handled automatically.

my version of cucumber emits the snippet suggestion:

Then /^the test_runner should say “([^\\”]*)"$/ do |arg1|
pending
end

rather than the snippet suggestions

Then /^the game should say “Welcome to Mastermind!”$/ do
pending
end

Then /^the game should say “Enter guess:”$/ do
pending
end

perhaps this is intended to teach the refactoring process on a granular level, and was nice when I read through on my first pass. When I went back to go though and play with the examples, this became confusing, because my features and specs were failing (and passing) at different times, with different messages that the ones listed in the book.

my version of cucumber (0.3.9) emits the snippet suggestion:

Then /^the test_runner should say “([^\\”]*)"$/ do |arg1|
pending
end

rather than the snippet suggestions

Then /^the game should say “Welcome to Mastermind!”$/ do
pending
end

Then /^the game should say “Enter guess:”$/ do
pending
end

perhaps this is intended to teach the refactoring process on a granular level, and was nice when I read through on my first pass. When I went back to go though and play with the examples, this became confusing, because my features and specs were failing (and passing) at different times, with different messages that the ones listed in the book.

As you’ll see a bit later in this chapter (the word “in” is missing)

Running the command “cucumber features -n” results in a missing argument error. Running “cucumber features” does seem to work.

I found the discussion of the two different approaches to the design of the mastermind script distracting. I was concentrating on learning how Cucumber scripts are defined and then I got sidetracked into evaluating how the first version of the mastermind script violated the Single Responsibility Principle. Now because of design decision to pass STDOUT to Game.new() this affects the step definitions. At this point I haven’t even fully grasped the architecture of the mastermind program and how Cucumber interacts with it. It seems to me that any program that is to be tested with Cucumber must be designed as a API and a thin script which calls that API. Then the step definitions can call the API as well. This isn’t explained at the beginning of ch.2 so all that follows confuses me since I’m new to this testing game.

From the page:
" When /^I start a new game$/ do
game = Mastermind::Game.new
messages = game.start end Then /^the game should say "(.*)"$/ do |message| messages.should include(message)
end

That could work, but let’s take a step back for a second. How are we going to invoke this?"

There are two things being discussed here: 1) the emerging design of the application code and the step definition. It seems you are asking how we are going to invoke the step definition but that doesn’t make sense.

You should explicitly specify that spec be used to run the examples specified on the page. I mistakenly tried cucumber and was confused that my results didn’t match those of the book.

Need to add a line like this in the before block:

assigns[:recent_messages] = []

The first line of env.rb in B5.0 has an incorrect number of ../ in it. It reads “$: << File.join(File.dirname(FILE), ”/../../lib“)” but should read “$: << File.join(File.dirname(FILE), ”/../lib“)” to execute `cucumber features` succesfully.

Prior to Chapter 5, we had been using the code ‘r g y c’ as the secret code. In Chapter 5, it’s all of the sudden ‘r y g c’. Is that intentional?

“We just compact the array before sorting…” Might be helpful to add a few words, “We just compact the array before sorting and joining, which removes all nil’s from the array.” so those unfamiliar with compact know what it’s doing. Then again documentation is your friend.

“Planning phase: how many people, how long for…” Consider, “how many people, for how long,…” instead of “how long for”.

Perhaps this is a config error my end. But I’m new to Cucumber so I’m not sure.
If I execute
cucumber features -n
I get
missing argument: -n (OptionParser::MissingArgument)
/usr/local/lib/ruby/gems/1.9.1/gems/cucumber-0.3.11/lib/cucumber/cli/configuration.rb:40:in `parse!’
/usr/local/lib/ruby/gems/1.9.1/gems/cucumber-0.3.11/lib/cucumber/cli/main.rb:84:in `configuration’
/usr/local/lib/ruby/gems/1.9.1/gems/cucumber-0.3.11/lib/cucumber/cli/main.rb:36:in `execute!’
/usr/local/lib/ruby/gems/1.9.1/gems/cucumber-0.3.11/lib/cucumber/cli/main.rb:25:in `execute’
/usr/local/lib/ruby/gems/1.9.1/gems/cucumber-0.3.11/bin/cucumber:9:in `<top (required)>’
/usr/local/bin/cucumber:19:in `load’
/usr/local/bin/cucumber:19:in `

The text says:

“The messenger( ) and game( ) methods use a common Ruby idiom of initializing an instance variable if it does not exist, and returning the value of that variable like a standard accessor.”

The text should explain why the messenger( ) and game( ) methods execute within each step definition even though there’s no code inside each definition to call them.

Also the test should explain what idiom you’re referring to in particular.

The text says:

“We moved the before(each) block to line 5, inside the outer -most describe( ) block. This makes it available to all of the nested groups, and therefore every example in this file.”

This includes making it available to nested groups that didn’t previously use them, like “should send a welcome message” and “should prompt for the first guess”.

The should explain whether:

(1) The block is available to nested groups like “should send…” etc after refactoring, but “should send…” don’t use them, and if so why
(2) The block is used by nested groups like “should send…” etc after refactoring, but this change in “should send…” doesn’t matter, and if so why
(3) The block is not in fact available to nested groups like “should send…” etc after refactoring, and if so why

It says:

“On line 4, we assign the value of returned by”.

It should say:

“On line 4, we assign the value returned by”

The text says:

“so require it file from lib/mastermind.rb”

It should say:

“so require the file from lib/mastermind.rb”

customer should be custom in “You can extract duplication and common patter ns in your model specs into customer macros…”

In first para at top of page. The font and layout for ‘gem install cucumber’ and ‘cucumber —help’ don’t follow your data-entry convention.

Between hello/1/spec/greeter_spec.rb and hello/2/spec/greeter_spec.rb the name of the variable holding the string has changed without explanation from greeting to message.

Section 2.3, first para. “Inside the hello directly, ”
Should that be ‘directory’?

Pull-out box, ‘Downloadable Files’

“..rather than just see it’s ultimate output”

Apostrophe not needed - this is a possesive, not a contraction. Should be “see its ultimate output”

In “code example” paragraph:

… reminds us that the writing them is a design and documentation practice …

I think you mean … the writing of them is a design …

On pages 274-275 there is output listed from running “./script/cucumber features/browse_movies.feature” which indicates a failing step, but the text immediately after this on page 275 claims that the scenario is passing.

…it let’s us express… should read …it lets us express…

…This code is certainlly naive,… should read …This code is certainly naive,…

In the code example that starts on PDF page 235 there is a definition of a should_assign method:

def should_assign(hash)
variable_name = hash.keys.first
model, method = hash[variable_name]
model_access_method = [model, method].join(‘.’ )

it “should assign @#{variable_name} => #{model_access_method}” do
expected = “the value returned by #{model_access_method}”
model.should_receive(method).and_return(expected)
do_request
assigns[variable_name].should == expected
end
end

Notice the definition of the local variable “expected”. At the bottom you specify that you expect assigns[variable_name] to be equal to the local variable “expected” which has been assigned a string just saying:

“the value returned by #{model_access_method}”

That means, if you use the should_assign macro like this:

get :index do
should_assign :projects => [Project, :all]
end

it will expect assigns[:projects] to be equal to “the value returned by Project.all”

I believe this is one of the “weirdnesses” that is mentioned in the beta warning in the beginning of the book. :)

“If the code-breaker indicates no, the
system and shuts down.” (Note the extraneous “and”.)

Should this be: “If the code-breaker indicates no, the
system shuts down.”?

“an interation planning meeting” -> iteration?

“Let’s go ahead and store this feature in file.” -> “in a file”?

(All my previous submissions referenced the wrong page, sorry. I just realized the page #s are at top and not bottom)

The words “The step passes because the Genre model and table already exist” are misleading.

“Create the Genre model and table already exist so the step will pass” would be more accurate.

Instructions for creating the Genre model and table, even if in an appendix, wouldn’t go amiss.

I think the hello example is a fantastic example but speaking as someone who has onboarded a number of teams to BDD via nbehave i still think your book is to fast paced and complex and i think you need some real simple web examples. I like the book i love cucumber but i just think your book is aimed to high and the learnign curve it introduces is to steep.

the-rspec-book_b7_0.pdf >> top of p29 says:
3 steps (1 failed, 2 skipped)

No explanation provided why 2 skipped. Does it stop upon first fail?

“corresponding likelihood” over “companion likelihood”

“challenging edge cases” over “sinister edge cases”

“don’t mark against the same peg more than once in the code. Moreover,” over “don’t mark against the same peg in the code twice. And to make things even more complex,”

“don’t mark against the same peg more than once in the code. Moreover,” over “don’t mark against the same peg in the code twice. And to make things even more complex,”

“We’re now interacting with the desired internal structure” over “We’re now interacting with the structure we want internally”

“before reading the next paragraph…” over “before reading the next paragraph.\\\
\\\
No. Seriously.” —at this point the reader is probably committed.

omit (repetitive) “Before we move on though, were there any other defects in the marking algorithm that you found in your own exploratory testing? If so, add some new scenarios to reflect them. If they fail, drive out the changes on your own, trying to stay in the green as much as possible.”

omit (juvenile) “(It’s nice to do this from time to time anyway—it helps
their self-esteem.)” —we already know we have a heightened sense for cheap irony

“Whether this is due to real understanding and value of Agile principles, or simply a marketing ruse, only time will tell.” over “Whether this is due to them understanding and valuing the underlying principles of Agile or simply a marketing ruse to dress up the same old tired processes is left as an exercise for the reader.”

behaviour (from behavour) in Changing Existing Code

“your application [and it] has any potentially tricky integration points”

“significant impact [on] the way that we drive out code”

use singular ‘return’ in “method can take an arbitrary number of arguments and a block, and returns a subclass”

“A little bit cryptic, yes?” over “A little bit cryptic, no?”

‘What we want to say is that “the result should equal five,” which is how we say it in English.’ over ‘What we want to say is that “the result should equal five.” Here’s how we say it in English: \\\
\\\
the result should equal 5’

“due to inconsequential formatting changes” is more readable than “due to some inconsequential changes to formatting,” no?

“While that does express our intention” over “While that does express what we’re trying to express”

The second sentence of the last paragraph on the page begins, “The seems…”. I believe the authors probably intended, “This seems…”.

When I run “cucumber features -s” at this point in the tutorial, both feature files are run, so I get much more output than the text describes (both “Feature: code-breaker starts game” and “Feature: code-breaker submits guess”).

“cucumber features -s” should be “cucumber features/codebreaker_starts_game.feature -s” to get the output described on this page.

The start method in the callout should have a code parameter.

The When /^I start a new game$/ do step got broken when the start method of Codebreaker::Game got a parameter, but it was never fixed in the tutorial and magically shows up on this page as already fixed!

“When something goes wrong it must be corrected” over “If something goes wrong it’s gotta get fixed”

“Please pay momentously” over “Please pay imminently”

repetative ceremony

The second code listing, after ‘so go ahead and create that class in app/controllers/messages_controller.rb: [Download rails_controllers/messages/015/spec/controllers/messages_controller_spec.rb]’ at the end of the page shows the spec instead of controller code.

The text doesn’t match the code example: “We stub the save method…”, but the update_attributes method was stubbed.

Please clarify as to `set RAILS_ENV=test` and `export RAILS_ENV=test`. I don’t understand how they are useful, or why I should specify these lines in config/environments/test.rb. Actually it now seems like it’s intended for the command line. Follows fast upon the config settings. Maybe another sentence or two should help.

“They are also unlikely to catch bugs that a good set of model specs might have missed.\\\
\\\
It’s not half bad, though.” over “They are also unlikely to catch bugs that a good set of model specs wouldn’t have already caught.\\\
\\\
It’s not all bad, however.” Unclear.

In the code listing for cucumber_rails/01/features/showtime_descriptions.feature, it says

So that I can find movies that fit my schedule
As a movie goer

Shouldn’t those lines be swapped?

In Figure 20.1, the RSpec loop back notation says “Repeat #3 - #5 for discovered, models, etc. until step is passing”

This doesn’t really make sense - perhaps it should say “Repeat #3 - #5 for discovered controllers, controller actions, models, etc. until step is passing”

This will then match more closely to the last bullet point on page 247.

Broken link in footnote to Github resource.

rspec-rails ActiveRecord::Error mocking

For outside-in view specs it would be useful to see how to mock ActiveRecord errors, for example I want to implement

it “should render an error message if errors are present”

as part of my view spec, which I am amending after finding in a feature that I had no validation error messages showing up on the page to tell the user what they did wrong.

Some general advice on mocking these complex objects (where you could just stub the action you know your view uses, error_messages_for() in this case, but that would be fragile if, for example, the view were changed to use error_message_for several times instead).

At the end of the page, you specify to “create the new.html.erb template” - however, you don’t indicate that any code needs to be added to that file (i.e. <% form_for …%>) before running the test again.

For the “show.html.erb” sample (starting on page 297), you create an empty file, run the test, see it fail, and then fix that error.

A user following along might think the same approach is being followed for this example. However, if you don’t add the code to new.html.erb, you won’t get the same errors shown in the book. (Specifically, you won’t get the “undefined method ‘spec_mocks_mock_path’…” error.)

Is “Internets” in the diagram meant to be serious or humorous?

I know it’s only an example, but I’m not sure if I’m following your working_too_hard? example.

Doesn’t the first version of the method finish running once any person has been working more than 50 hours in any week, and therefore not need short-circuiting? (It may be worth mentioning that using .any? would be more idiomatic ruby, unless .each is unavailable)

Second sentence of section 11.3 should begin “Ask a stakeholder how…” instead of “As a stakeholder how…”

bbbw should be bbb

The definition of the start method should have the code parameter. I believe this is what Ed Ruder was taking about.

the line:
def start

should be changed to:
def start(code)

Just under “A Small Change Goes a Long Way” we are instructed to run the feature again with:
cucumber -r features features/codebreaker_submits_guess.feature

I get “no such file to load” error using the cucumber -r option here, but it runs fine with -s or no option.

I am not sure if this is a typo, or if I am doing something else wrong. I did at least find it odd that the book begins using the -r option with no explanation of why we are doing so.

“set_hidden_field ”user_id“, :to => @bob.id” is correct

In the box on Matchers is the following text:

Given Dan’s penchant for “Getting The words Right”,…

words has been written in lowercase, while the rest of the phrase is in Title Case.

In the sidebar, second paragraph

“or other forms of visual aide”

should be “or other forms of visual aid”
or at least “or other visual aides”

Visual aid is the standard spelling. An aide is a person, so to say “forms of aide” is incorrect.

we gets -> we get

The last sentence in the page 354 “Not changing the controller…” is confusing to me and seems contradictory.

First full paragraph, missing space between text/plain and MIME

Given text:
text/plainMIME
should be:
text/plain MIME

Last paragraph under the contain() heading.

Reads:

contain() will match against the HTML decoded text of the document, so if you want to ensure “Peanut butter & jelly” is on the page, you’d type just that in the string, not “Peanut butter & jelly”.

Should say (I believe):

contain() will match against the HTML decoded text of the document, so if you want to ensure “Peanut butter & jelly” is on the page, you’d type just that in the string, not “Peanut butter & jelly”.

Also, the last double quotation mark is straight and not curly. Typesetting issue?

It says that the “xhr” method has one additional argument at the front, but in the example the action is missing. In the book you have

xhr :get
when it should be: xhr :get, :create

First paragraph under the heading “Fixing what we broke”

POSTS should be POSTs

It says, “Run that file with script/cucumber features and you’ll see that all of the steps are undefined, and that Cucumber has provided us with code snippets for all of the missing step definitions:”. However, the output says “uninitialized constant Movie (NameError)”. That means you’ve already created the step definitions, but you haven’t yet shown us the code.

This chapter is lacking an official “What we’ve learned” section like the others.

“to keep this example focused on the Simulated Browser style, we’ll leave the development of this code as an exercise for you.”

Cheater! ;)

“In the above example, if we renamed the Movie class to Film, we’d have to change line 8 which uses the field id and line 13 which uses the field name, but line 3 would continue to work just fine.”

Those line numbers aren’t visible in the text.

“Wrapping Up”: The other chapters used a phrase like “What We Have Learned” or something like that.

Third full paragraph on page 52:
“After loading the Ruby files, Cucumber then then loads and starts pars-
ing all the .feature files, matching all of the steps in scenarios against
the stored step definitions.”

Note the “then then” typo.

features/environments/cucumber.rb should be config/environments/cucumber.rb

The ruby on the cover next to “The facets of ruby series” is extraordinarily pixelated in stark contrast with the rest of the otherwise high resolution cover.

“the stub( ) method in the (as yet) unwritten chp.mockFramework”

chp.mockFramework is written as chapter 12.

“act as_null_object”

should be :null_object => true - or is there a .as_null_object method?

and again on page 305

rake -T | grep “rake spec”

rake -T spec is equivalent but shorter.

“BDUF means desiging an application in significant detail before writing the first line
of code.” I don’t know if it is totally wrong, but I think it should be “designing”.

I’m getting:

./script/spec spec/views/messages/new.html.erb_spec.rb
F

1)
NameError in ‘messages/new.html.erb should render a form to create a message’
undefined local variable or method `messages_path’ for #
./spec/views/messages/new.html.erb_spec.rb:12:
./script/spec:10:

Finished in 0.045964 seconds

1 example, 1 failure

I don’t see where you changed routes.rb. I think you may have rearranged the code, and it doesn’t match the text.

It says “Update the before block to do that and re-run the spec. You should now have one example, zero failures.”

That can’t be true. We haven’t put anything in the template yet. I think the code was rearranged, and the text is out of date.

It says, “Run the spec. The example we just wrote should be the only failure. Go ahead and implement the view to resolve that failure:”

I think that’s wrong too because the template is still empty.

“Run that, watch it fail, and implement the code in the view to make it pass.”

It’s probably a bad idea to assume the reader will guess the code correctly. It’s probably better to always show the right code that he should enter.

“Once again we’ll build on the messages example we started with earlier in this chapter. We’ll start where we left off in Section 24.2, Mock Example, on page 324. We had just produced a new page”

I don’t think you need to say that since it was just the previous section. Perhaps in an older revision, that section was further away.

“If you run new.html.erb_spec.rb now, you’ll see four passing examples, including the three we just copied to the _form spec.”

Following along, I have 5 at this point:

“should render a form to create a message”
“should render a text field for the message title”
“should render a text area for the message text”
“should render recent messages”
“should render the messages/form”

“Run that and you should see 3 examples, 0 failures.”

I’m getting:

1)
‘messages/_form.html.erb should render a form to create a message’ FAILED…

Finished in 0.107088 seconds

4 examples, 1 failure

It’s because you haven’t asked me to update the form yet. On the previous page, you said, “Getting back to the _form partial, for it to be usable for both the new and edit templates it’s going to have to get a bit smarter. It’s going to need to render the for m’s action attribute to point to the messages_path( ) for a new record and the message_path(@message) for an existing record.” However, you didn’t show any changes to the template.

“Run that and you should see 3 examples, 0 failures.”

Ah, I see the problem now. You never told me to delete “should render a form to create a message”.

“Now that we’re done refactoring, we can go back into spec-driving mode and add an example that expects the edit template to render the form partial. Go ahead and create a spec for edit with the following example:”

You forgot to put all the require, describe, etc. stuff in the first code example for this new file.

Last sentence on the page reads: “If that happpened…” Too much P.

The last sentence of this page says to “go ahead and create the template” but it doesn’t specify how to create it. If I create an entirely blank template was done for the show template earlier in the chapter - I get the same error Shannon jj Behrens talks about in erratum #40051. If I use “script/generate scaffold messages message:string” to create it my error message matches what the book says.

If you want folks to create the template differently than what was done earlier in the chapter I think you should be explicit as to how it should be created.

You say Now run cucumber features/codebreaker_starts_game -s from the project root, and you’ll see the following output:

But the command requires the .feature extension for the codebreaker_starts_game feature to properly run…

cucumber features/codebreaker_starts_game.feature -s

Instead of calling the step file just codebreaker.rb (which will make Textmate apply a ruby or ruby on rails template to the file… instead perhaps call it codebreaker_steps.rb so that Textmate will properly classify the file as a Cucumber steps file. This assumes of course that you’re on OS X, running Textmate and using the Cucumber textmate bundle… but still, allowing for that scenerio doens’t hurt anyone not using this setup, and it only helps those of us who are. I know you can switch the .rb to be whatever you want, including Cucumber steps… but that is a global setting and then all your normal ruby or ruby on rails files will be rendered in Textmate as Cucumber steps files too. The way the bundles interpret the language requires ‘steps.rb’ to be in the file name to automatically use Cucumber Steps as the template. At least that is how it works by default, you can of course change it with the bundle editor as I’m sure you’re aware.

when you run the 3rd context “with all 4 colors correct and 1 in the correct place” it fails because it’s expecting “bwww” but with how the code is setup so far it gets “wwwb” since the c char at the end is the only one that matches in place. The others are out of place so they generate the www first.

The BD Rails: Rails Views chapter would benefit from describing how to mock/stub/place expectations on ActionView helpers, for example when using textile you may want to
@controller.template.stub!(:textilize).and_return(‘textiled text’)

then
controller.template.should_receive(:textilize).with(service.teaser)
controller.tepmlate.should_not_receive(:textilize).with(service.name)

It took me a few hours to find this, I think it is worth adding to the chapter as these view helpers are an external dependency and their behaviour (i.e. is the textile actually converted correctly for display) seems better suited to the Cucumber level. Speccing textilize’s behaviour should be done in RedCloth’s own tests, not the application tests.

The minimum I would have found helpful is being told what to stub, it wasn’t clear whether it was @controller, the helper module, or as it turned out another object which makes MVC sense but isn’t mentioned in the literature.

It seems that testing the “validates_uniqueness_of” model validation is a bit tricky. Blogs and forums I’ve found have a number of suggestions, but they all seem to be “workarounds” to me. This topic doesn’t appear to be covered in the RSpec book (yet). I’d really like to see this topic covered.

Line numbers are getting selected when trying to copy and paste code example from PDF book page# 25.

This is the block (with #s copied over):

describe “RSpec Greeter” do
2 it “should say ‘Hello RSpec!’ when it receives the greet() message” do
3 greeter = RSpecGreeter.new
4 greeting = greeter.greet
5 greeting.should == “Hello RSpec!”
6 end
7 end

There’s an earlier example on book page# 20 with the same problem but it’s not something you are asked to enter into a text file.

Currently written:
$: << File.join(File.dirname(FILE), “/../lib”)

Suggestion:
$: << File.join(File.dirname(FILE), ‘..’, ‘lib’)

Reason:
File.join joins the strings with File::SEPARTOR. File::SEPARTOR may be different on other systems.

The code has a extra space character
Then /^it should say “([^\\”]*)" $/ do |greeting|

it should be
Then /^it should say “([^\\”]*)"$/ do |greeting|

(It is not visible in the pdf, I discovered it after copy&paste)

Wrong line number (minor problem!)

uninitialized constant Codebreaker (NameError)
./06/features/step_definitions/codebreaker.rb:7:in
`/^I start a new game$/’

/IF/ you use the code providerd (cb/06), the line should be 15. The difference is due to the 8 comment lines.

Duplicated

Perhaps you’ve you’ve heard that a 1-to-1 mapping between

This whole chapter on RSpec in Rails Views seems outdated, only the very fist basic example works. Also, as I did not get any further with the examples as they no longer match the API and there are even missing steps in the description. Finally, I used the spec_scaffold generator - which anyways created most of the “steps” discussed in this chapter, but in much better detail and with better code, too. Maybe it would be more usefull to start with the generator (scaffold, controller or model), explaining what we get there, and then work into some more pracitically relevant example?

both code examples are for the spec, not for the controller described in the second part:

class MessagesController < ApplicationController
end

Now the message text field is called “body”, while in views it was called “text”. Not important, but yet another point that makes the RoR chapters very inconsistent compared to the Codebreaker chapters.

The #new controller specs are fine, but the instructions for adding the controller’s method accordingly are missing:

def new
@message = Message.new params[:message]
end

“what the WidgetsControllerdoes”, missing space between words.

The first example in here does not work ‘out of the box’, because in the former chapter, the model was implemented ‘quick and dirty’ without adding the correct inheritance schema to it. Therefore, before running the first spec (“”should be valid with valid attributes"), app/models/message.rb needs to be extended like so:

class Message < ActiveRecord::Base
end

After adding the 3rd spec, you write (again):

Run the spec—4 examples, 0 failures, 2 pending. Wait a minute. We were
expecting it to fail, but it’s passing.

Should be: …1 pending…

Adding the User.new to the before method isn’t good enough, because we never created the user table in the first place, and this time just adding the correct inheritance to the unfinished implementation isn’t doing the trick, either:

with ActiveRecord:
should be valid with valid attributes
Could not find table ‘users’

only “Class User\
end”:
should be valid with valid attributes
undefined method `new_record?’ for #

I.e., first we need a migration for Users or, better, mock (not stub) the User:

before(:each) do
@message = Message.new(
:title => “foo”,
:text => “foo”,
:recipient => mock_model(User)
)
end

Just another point about keeping these three chapters on Rails MVC consistent:
In the Rails controller section, the method’s if clause was implemented exactly reverse:

def create
message = Message.new params[:message] if message.save
flash[:notice] = “The message was saved successfully.”
redirect_to messages_path
else
render :action => “new”
end
end

Before we get started we need to add a migration for the User model
that was added in the controllers chapter. Go ahead and generate a
migration to create the users table with a login attribute. User models
usually need more attributes, like passwords, but we’re not concer ned
with those aspects of a user right now. The only reason we’re jumping
ahead here with the user is that we’re not focusing on the behaviour
that drives a user into existence.
With the migration in place and the test database prepared let’s drive
some business rules into existence!
1) The User model again needs to be extended with the ActiveRecord class (or, if this chapter always relies on this in place, why not simply add this inheritance schema to all Models created in the Controller section to begin with)

2) This should actually suggest to add a :name attribute as ID, to be consistent with what was suggested before in the Message model:

class Message < ActiveRecord::Base
belongs_to :recipient, :class_name => User.name
validates_presence_of :title, :text, :recipient
end

Up until now you use ‘context’ nested in ‘describe’ blocks. Now on this page, you nest a ‘describe’ block inside another ‘describe’ block. Then in chapter 13, Spec::Examples, you show more code examples that have ‘describe’ blocks nested within other ‘describe’ blocks and none that show ‘context’ blocks within ‘describe’ blocks. It is not until chapter 17 (p238), ‘Tools and Integration’, that you show another code snippet with a ‘context’ block within a ‘describe’ block. All this with out mentioning that ‘context’ is an alias for ‘describe’. This inconsistency may be confusing for the reader. My suggestion is either maintain the ‘context’ within ‘describe’ blocks throughout the book or explain earlier that they are interchangeable.

Top of the page, “The game will need generate a secret code” should be “will need to generate”

2nd paragraph, 1st sentence. “At this stage you could be forgiven for be thinking” remove 2nd instance of ‘be’

I can’t seem to get my specs scripts to execute in my preferred order. Within each script, execution flows as expected, but the order the scripts are themselves run seems to be outside my control. I’ve tried renaming my RSpec scripts with a numerical prefix so they sort in my preferred order, but this seems to have no effect on the execution order. If there is a convenient way to influence the execution sequence, I’d like to see that mentioned in the book.

but they have the wisdom to recognize quickly whether those changes are heading them in the right direction. Once they do, they typically back up to the last known good state

This should read “in the wrong direction” otherwise it does not make sense.

The term “DRY” is not explained where it is first used.

Text:

Fortunately, Cucumber of fers a few dif ferent tools for DRY’ing things up
without sacrificing expressiveness and localization.

(There’s something odd with the ff pairing and it’s coming across with that extra space when copied with Preview on Mac OS X. I left the space in there in case you want to take a look at that formatting too.)

“Iteration” not explained

The term “iteration” is used very early on (first reference is p31 in b8_0) but not explained. There’s even an entire section titled “Planning the First Iteration” slightly later on but there’s still no explanation what this means in that section. Much later (p145) there’s a very brief reference to an iteration being an one or two week “mini-project” but no detailed explanation.

I think it would help to explain up front, at least briefly, what an iteration (and other Agile terms used in the book) is for those not familiar with Agile development methodologies rather than waiting till later like in Chap 10.

Diagram of directory structure for codebreaker somewhat ambiguous what is a file and what is a directory.

It’s a little confusing cause you don’t have a legend stating which “color” is a directory and which is a file. You can mostly figure it out just by the names and the structure except you have a grey “codebreaker” box in lib and a white “codebreaker” box in bin so for those two you might have to think: is the white one actually a file (but it doesn’t have an .rb extension like the other Ruby files) or is that just a “typo” and it’s supposed to be a directory to match what’s in the lib directory?

You might want to put slashes “/” after the directory names or use some other method to better distinguish between directories and files.

Page break in between code block at end of page 50.

This code is split:

Given /^I am not yet playing$/ do

end

Makes it impossible to cut and paste and the entire thing in one go (yes I know it’s not hard to type “end” manually…)

Suggestion: change “$:” in spec_helper.rb code to $LOAD_PATH

Using $: makes it look a little too “Perlish” :)

You are using $LOAD_PATH in bin/codebreaker earlier on page 55 so you should probably at least make things consistent.

cucumber -r used for the first time but inconsistent with previous usage.

In the previous usages of cucumber and features/codebreaker_submits_guess.feature the command line was just:

cucumber features/codebreaker_submits_guess.feature

but on the bottom of page 78 this changes to:

cucumber -r features features/codebreaker_submits_guess.feature

even though the output is the same (at least on my system). It also says “Now run again” when this is actually the first time we’ve used the -r switch.

There are a few other places where the -r is used (pgs 82, 110, 111, 115) but I haven’t gotten that far yet to know if it’s actually necessary or if the “short” version works as well.

I should say the reason I want to execute my scripts in a particular order is as a convenience for tracking down the source of a problem, not because of code dependencies or bad design. I just want the lowest-level problems to be reported first, so if there’s broken code it’ll be most likely found at the first or second red line. One bad line of production code can cascade through all the specs, causing a bunch of red lines. I like that. I just don’t like having the culprit shuffled in with the victims.

If there’s a way to randomize the spec execution sequence, but specify a reporting sequence, that would be ideal. But absent that solution, forcing a preferred execution order would suffice.

If anything like this is possible, I’d like to see it covered.

We are instructed to run:
cucumber features/codebreaker_starts_game -s
but it should be
cucumber features/codebreaker_starts_game.feature -s

The xhr example omits the action:

1. no params or session data
   xhr :get
2. with params
   xhr :get, :id => 2
3. with params and session data
   xhr :get, { :id => 2 }, { :user_id => 99 }

should be

1. no params or session data
   xhr :get, :index
2. with params
   xhr :get, :show, :id => 2
3. with params and session data
   xhr :get, :show, { :id => 2 }, { :user_id => 99 }

I couldn’t figure out how to do something like
Spec::Matchers.define :have_image do |src|
in my matchers.rb file (using the suggested file, module & spec_helper layout)

when using simple matcher it handled should but didn’t handle should_not

It’s role is to collect secret codes and provide statistical infor mation about which colors show up how often in which position.

Wrong its.

An object’s internal state is an implementation detail, and not part of it’s observable behaviour.

Wrong its.

Section 12.4’s opening paragraph talks about the “common pitfalls of mocking and stubbing.” However the section only mentions mocks. I was trying to figure out if “stubbing” got in there by accident or perhaps all the references to mocks really meant “test doubles.” Either way, I was confused, lol.

“See how the Given and When steps in this scenario both use the first
person… Given x, when I y, then I should see a message”

The *’ed phrase puts the then in the first person, but the actual scenario definition is:
Then the game should say “Welcome to Codebreaker!”
And the game should say “Enter guess:”

Would the “Thens” be better in the first person, or better to remove the *’ed phrase? Either way, it would align the two snippets and make them consistent.

s. love the book, can’t wait for it to be done :)

Briefly mention that you will be using the Direct Model Access technique to drive the Acceptance tests, mention the other two options, and refer readers the “Behavior Driven Rails” chapter (probably best in a sidebar).

Reasoning: When I first read this section to use in a program I was starting, I misunderstood that this was the only way to implement features, so I used Direct Model Access in my desktop app and was confused and turned off because a fair chunk of my code was not being exercised. Often, I am looking for a specific technique to implement immediately, so I’ll jump back and forth a lot and read a book in non-sequential pieces.

It would be nice to have a chapter or section for rails plugins and plugins engines like ‘engines’ and ‘desert’, explaining how to maintain tests on such part of rails applications that are not in the core.

“occurences” must be “occurrences” I suppose.
Missing “r” like HTTP’s REFERER.

Section: Bootstrapping an app with RSpec and Cucumber

On Windows when trying to run: script/generate rspec

I receive this error: Malformed version number string mswin32 (ArgumentError)

Workaround is to change commented out line to the line below it in file vendor_gem_source_index.rb

def version_for_dir(d)
#matches = /-([^-]+)$/.match(d)
matches = /-(\\d\\.\\d\\.\\d+)/.match(d)
Gem::Version.new(matches[1]) if matches
end

there is a discussion in nabble forum about n this.

I’m not sure if the Rails Controller chapter is the best place for this (or even if this is the best mechanism to suggest) but I feel that some information on using RSpec for spec’ing routes would be useful to the reader. If nothing else, it’d definitely be useful to me.

“… so if you want to ensure “Peanut butter & jelly” is on the page, you’d type just that in the string, not “Peanut butter & jelly”."

This is a little confusing since the two strings are the same. Is one of them intended to use & (the HTML entity for &) instead of a plain &?

I am using cucumber 0.3.98 with Ubuntu 8.10. When I run the example on p.27, the section where the snippets are expected following “You can implement step definitions for undefined steps with these snippets:” is empty.

See:
$ cucumber ./features
Feature: greeter says hello

In order to start learning RSpec and Cucumber
As a reader of a The RSpec Book
I want a greeter to say Hello

Scenario: greeter says hello # ./features/greeter_says_hello.feature:7
Given a greeter # ./features/greeter_says_hello.feature:8
When I send it the greet message # ./features/greeter_says_hello.feature:9
Then it should say “Hello Cucumber!” # ./features/greeter_says_hello.feature:10

1 scenario (1 undefined)
3 steps (3 undefined)
0m0.002s

You can implement step definitions for undefined steps with these snippets:

$

as_null_object does not ignore the other messages, it uses an array for some odd reason

this is my result:
spec spec/codebreaker/game_spec.rb —color
.F

1)
Spec::Mocks::MockExpectationError in ‘Codebreaker::Game starting up should prompt for the first guess’
Mock ‘messenger’ expected :puts with (“Enter guess:”) but received it with ([“Welcome to Codebreaker!”], [“Enter Guess:”])
/Users/Innovia/Sites/cukes/spec/codebreaker/game_spec.rb:15:in `block (3 levels) in ’

Finished in 0.004188 seconds

2 examples, 1 failure

Supply download link for:
cb/49/features/game_generates_secret_code.feature

The need for the start method parameter breaks the feature “codebreaker_starts_game”. Maybe it should be left as task for the reader to complete the test cycle.

one “be” too many

“At this stage you could be forgiven for be thinking this looks a lot like traditional top-down decomposition.”

Following the instructions leading up to the first cucumber command—“cucumber features”—results in correct output up to and including “You can implement step definitions for undefined steps with these snippets:”, but no snippets are provided. The step_definitions folder and at least an empty greeter_steps.rb need to be present before “cucumber features” will spit out the snippet templates.

Simply including instructions to create a placeholder directory and file would help avert confusion and wasted time spent troubleshooting when the output is not as expected. (I’m on Ubuntu 9.04 though I would think the problem is not system specific. Cucumber version is 0.3.98.)

The code switches from “r g y c” to “r y g c” here. Why not keep consistency through all examples?

In generator_spec.rb an instance variable @generator is set in the before method, but not used in any of the following tests.

First word on page: “inadvertantly” should be “inadvertently”.

5th paragraph, starting ‘When the Statement executes the generate( ) method,’ contains use of contraction-as-possessive “it’s name() method” … this should be “its name() method”

In third paragraph, starting ‘Now we have three participants in the example:’, at the end of the paragraph, the sans-serif text contains the word ‘when’ by accident. It should read ‘Statement logs a message on generate()’

In first paragraph of section “Counts”, at the end, I believe it should read “We can set this expectation explicitly…” rather than “We can make set this expectation explicitly…”

misspelling of “message” (as “mesage”) in second paragraph under heading “Negative Expectation”

heading “anything()” seems to appear too early. The last paragraph of the previous section appears after that heading, and has the first paragraph of the “anything()” section as its last couple of sentences.

Example output appears to be incorrect in section “Custom Argument Matchers”. “BiggerThanThreeMatcher” should be “GreaterThanThreeMatcher”

The method call double() causes an error with RSpec 1.2.8:
undefined method `double’ for #

For clarity, shouldn’t the code example contain a mock object instead of a “stub object”?

customer = stub(‘customer’)
customer.stub(:name).and_return(‘Aslak’)

…looks a bit weird.

I tried to run ‘autospec’ as suggested on this page, but I found that, while raising no errors, it also did nothing at all. After a little digging, I discovered that I needed to ‘[sudo] gem install ZenTest’ (with caps) in order to have the appropriate foo installed for ‘autospec’ to function. This is under MacOS 10.5.8 (uname -a == Darwin hypercycle.local 9.8.0 Darwin Kernel Version 9.8.0: Wed Jul 15 16:55:01 PDT 2009; root:xnu-1228.15.4~1/RELEASE_I386 i386)

Perhaps not reasonably w/i the purview of the text, but after installing the ‘heckle’ gem, the example command given in the text results in an error message. According to stackoverflow.com questions 1144906 error-running-heckle-currentcode-undefined-method-translate-for-ruby2ruby
the problem is because of a silent change in API between ruby2ruby v1.2.2 and v1.2.3. Since 1.2.4 was installed by the Gem subsystem, and also failed as shown in the webpage I referenced, it looks like the problem persists. Thought you might like to know.

at the top, “the line on which the feature is declared” should be “the line on which the scenario is declared”

When I try to add the custom failure message:
——————
count.should be_between(min.to_i,max.to_i),
“expected #{count} to be between #{min} and #{max}”
——————

ruby complains about wrong number of arguments:
——————

1. features/step-definitions/codebreaker.rb:69
   wrong number of arguments (2 for 1) (ArgumentError)
   ./features/step-definitions/codebreaker.rb:75:in `should’
   ——————

I have version 1.2.8 of rspec installed.

Any idea?

This, I believe, is technically incorrect: “How many times do we invoke Then the game should say: ….? Twice in this scenario!”
“the game should say” is invoked twice, once following “Then”, once following “And”, but “Then the game should say”, per se, only appears once. I don’t bring this up to be priggish but because it caused me genuine confusion. Unless I’m missing something and “Then the game should say” was in fact invoked twice.

this:
The next question is how to express this design decision in the step definition?
is not a questions, so should have a period, not a question mark.
just sayin’

“Run the spec—4 examples, 0 failures, 2 pending. Wait a minute. We were expecting it to fail, but it’s passing.”

should say:
“4 examples, 0 failures, 1 pending”

The paragraph beginning with:

“Before we get started we need to add a migration for the User model that was added in the controllers chapter. Go ahead and generate a migration to create the users table with a login attribute.”

Seems to be leftover from a previous iteration of this chapter. The code examples and the remainder of the chapter does not reference this at all.

When showing the example of moving the declaration of messenger to the before(:each) method, you have only updated the it “should send a welcome message” action to the new instance variable, though with the intention of removing duplication, we want to update the “should prompt for the first guess” action as well. You may want to reflect this in your example.

In first code example, line 4
“As a reader of a The RSpec Book”
should be
“As a reader of The RSpec Book”

(Same for all subsequent uses of that line of code.)

In last paragraph, “how to use in the context of” should be “how to use them in the context of”

Last paragraph on the page says to invoke cucumber as:
cucumber features/codebreaker_starts_game -s
This does not work, and generates a ‘missing file or dir’ error. You have to add the .feature extension like so:
cucumber features/codebreaker_starts_game.feature -s

One thing that I noticed is that the method snippets only appear if you have a step_definitions file. It could be empty, but it must exist to methods snippets to appear.

Missed and & in Peanut butter & jelly?

I think the code listing between pages 357 and 358 is incorrect - I was expecting the code for messages_controller.rb rather than a repeat of the code for messages_controller_spec.rb.

Page 60 (implicitly) describes the directory structure as spec/codebreaker, but the chart on page 49 shows codebreaker/spec. So I’m thinking the code on page 60 is wrong…?

Downloads of code on this page have #START, #END in them ie:

#START:title_and_narrative
Feature: code-breaker starts game

As a code-breaker
I want to start a game
So that I can break the code
#END:title_and_narrative

#START:scenario_only
Scenario: start game
Given I am not yet playing
When I start a new game
Then the game should say “Welcome to Codebreaker!”
And the game should say “Enter guess:”
#END:scenario_only

The first code example in section 14.2 Method Stubs has misleading code highlighting.

On line 6 of the code example:
statement.generate.should =~ /^Statement for Aslak/

The word “for” is highlighted as a ruby keyword, and led me to some head scratching.

Code being truncated at right margin on pages 88, 89 and 91

“The MissingTemplate error is gone, but the spec still fails with a new error:
undefined method `spec_mocks_mock_path’ for #
What’s happening here is that the form_for( ) method used in the view expects the message to be a model, but it’s a simple stub.”
The error I get is “undefined local variable or method `messages_path’ for” ect… which makes sense since just creating new.html.erb doesn’t populate the template with a form… Steps should include adding form_for which would take care of the previous failing step..

I think it would be clearer if you put the code at the very top of this page inside the class definition, that is start the code block with “class ActiveSupport::TestCase” and include the additional “end” statement. It is shown this way on page 334, but here when you tell the reader to add it to the code it’s not shown.

this is the first time I’m seeing “mock” object introduced. There should be a footnote or short blurb explaining that should_receive sets up an expectation but is satisfied only after game.start is executed. I was so confused by what was going on because I thought that the messenger (STDOUT or StringIO) was receiving a puts message BEFORE game.start. It isn’t until the chapter on Spec::Mocks that the order is explained.

My cucumber output does not match the error-free output in the beta book p83: “13 scenarios, 26 undefined steps, 13 passed steps”. I get: When I start a new game # features/step_definitions/codebreaker_steps.rb:12
wrong number of arguments (0 for 1) (ArgumentError)
./features/step_definitions/codebreaker_steps.rb:15:in `/^I start a new game$/’
features/codebreaker_starts_game.feature:9:in `When I start a new game’.

This is due to the fact that in the features/codebreaker_steps.rb, start() is still called with no arguments, while in the game_spec.rb and game.rb the start() method now requires an argument but this is never addressed in the features/codebreaker_steps.rb file.

We could, of course, just think about how we want this to work and just write the code for it, but we want write the simplest thing that could

should be “want TO write”

Under “Message Expectations,” you use “it’s” instead of “its”:

“In this example, if the generate( ) method fails to ask the customer double for it’s name,”

This page introduces the “as_null_object”, supposedly as a strategy for allowing the messenger mock object to expect not ONLY the argument in should_receive, but POSSIBLY other stuff too.

It doesn’t seem to work this way. When I run spec spec/codebreaker/game_spec.rb I get the following logical error message:

Mock ‘messenger’ expected :puts with (“Enter guess:”) but received it with ([“Welcome to Codebreaker!”], [“Enter guess:’”])


It seems the as_null_object modifier allows the mock to bypass the unexpected message, but instead it seems to be expecting a specific SET of messages.

Hope that made sense.

midway down the page,

def start

should be def start(code)

The text in the middle of the page says this: “Can’t get much more concise that this.” I believe it should say: “Can’t get much more concise than this.” The word “that” should be changed to “than”.

the second describe() and all it() calls do not have a “do” to start the blocks in the WidgetsController example

Just a small suggestion on the general writing. The phrase “go ahead and X” is used very frequently. You can simplify this and make it a little less repetitive by just writing “X”.

It might help to include " (DSL)" directly after using it fully spelled out once. And maybe spelling it all out again later on through-out.

Almost a touch silly, but i ran across the term DSL later on in the book and didn’t know what it meant, so i searched for it. The line below the full spelling out matched, but when i went to that instance, it was the top line on my screen, so i didn’t see the line above it spelling it out.

In the “greeter says hello” feature example, the feature description says “As a reader of a The Rspec Book”

It seems the intent is to convey that we are ‘a [user] of a [something]’ - however, it reads akwardly. It might read more clearly if it were changed to “As a reader of The Rspec Book”

After the user is instructed to type ‘cucumber features’ it says “You should see output like this:” and shows snippets for the pending step definitions. These snippets are only displayed if a file with a .rb extension exists in the features/step_definitions/ directory.

I tested this by running ‘cucumber features’ with the following:

1. features/step_definitions does not exist - no snippets were displayed

2. features/step_definitions exists, but contains no files - no snippets were displayed

3. features/step_definitions exists, and contains the file ‘foo.txt’ - no snippets were displayed

4. features/step_definitions exists, and contains the file ‘foo.rb’ - Joy! got snippets

5. features/step_definitions exists, and contains the file ‘greeter_steps.rb’ - got snippets

While setting up Selenium for use with Cucumber, adding the line “config.selenium_wait_timeout = 10” as indicated in the example env.rb causes a NoMethodError to be thrown when ‘rake features’ is run.

undefined method `selenium_wait_timeout=’ for # (NoMethodError)
./features/support/env.rb:22
/usr/lib/ruby/gems/1.8/gems/webrat-0.5.3/lib/webrat/core/configuration.rb:8:in `configure’
./features/support/env.rb:20

in the features section, “reponsible” should be “responsible”

“In the default configuration, it will also runs each scenario in an isolated DB transaction.”

“addiitonal” should be “additional”

There is still a logic error in the Codebreaker::Game::guess method, even after the last correction.

Similar to the last correction (where a ‘b’ can be overwritten by a ‘w’), the code still suffers from the problem where a ‘w’ can be overwritten by a ‘b’.

If the code is ‘r g g c’ and the guess is ‘g g c r’, then the logic works as follows:
1) the first ‘g’ gets a ‘w’ marked in the second position
2) the second ‘g’ gets a ‘b’ overwriting the ‘w’ in the second position. The fact that the first ‘g’ still should be marked as a ‘w’ in the third position is lost.
3) the ‘r’ and ‘c’ each properly get marked as ‘w’
4) the mark returned is ‘bww’ but should be ‘bwww’

A code example demonstrating this:

module Codebreaker
describe Game do
before(:each) do
messenger = mock("messenger").as_null_object game = Game.new(messenger) end ... context "with all 4 colors correct and 1 in the correct place, w before b" do it "should mark the guess with bwww" do game.start(stub(‘generator’, :code => %w[r g g c]))
messenger.should_receive(:puts).with("bwww") game.guess(%w[g g c r])
end
end
end
end

Another code example demonstrating another logic error:

module Codebreaker
describe Game do
before(:each) do
messenger = mock("messenger").as_null_object game = Game.new(messenger) end context "with all 4 colors correct and 2 in the correct place, w after b" do it "should mark the guess with bbww" do game.start(stub(‘generator’, :code => %w[r g c g]))
messenger.should_receive(:puts).with("bbww") game.guess(%w[r g g c])
end
end
end
end

Inconsistency: here “life cycle” is two words, whereas on page 140 it is one.

“developement” should be “development”

“the acceptance criteria is “owned” by the tester" should be “the acceptance criteria are “owned” by the tester"

Contradiction: here on page 158 in the context of describing the BDD process, you state that driving out the detail of a story (including the Acceptance Criteria) “doesn’t need to happen during the inception (and probably shouldn’t!) but it does need to happen before we start coding.”

But back on page 40, we were told that Acceptance Test Driven Planning is one of the three practices of BDD, and ATDP specifies that the acceptance tests are agreed on during or possibly before, but no later than, an iteration planning meeting.

So does BDD allow for acceptance tests to be defined any time prior to coding, or no later than iteration planning?

Furthermore, if BDD is to be more formally defined as consisting of the three specific practices referenced on page 40, then I would expect Chapter 11 to detail this.

Add some introductory/explanatory text to the example code in the “Yielding” subsection

I’m looking for a good bit more detail on how the BDD and Cucumber/RSpec tie in with the roles and processes of agile development.

For example, we are told that testers “own” the acceptance criteria. But how does that flow into the use of tools? It seems quite natural to me to have the testers own the free text part of Cucumber features, and have developers own the step definitions (perhaps after some negotiation with the testers and BAs to get the scenarios phrased in a way that is amenable to step definition automation). Then the coders create the code, specs and step definitions following the “BDD Cycle” described earlier. As the coders finish some subset of story functionality, they check in their work in progress into source control, and the cucumber reports resulting from the continuous integration build inform the testers of what scenarios in the story are ready for him to start manual/exploratory testing. Then this should flow in to product owner acceptance of the story when all acceptance criteria are demonstrated.

You’ve started the description of how we kick off use of BDD. Tie it in more tightly with all of the processes within an agile iteration.

Also, some discussion is warranted here regarding the applicability of BDD and Cucumber/RSpec to acceptance criteria in general. What types of acceptance criteria should be driven out by BDD? Everything, always, or are there times when other methods like prototyping of screens (without true end-to-end slices of functionality) should be used instead? Similarly, what types of acceptance criteria are appropriate to drive out using Cucumber and RSpec, vs. others which are more appropriate for other tools or manual processes? When different methods are more appropriate, what roles should own them?

Should there be a process step early in each story where the acceptance criteria are discussed, and the testers and coders decide how each one should be demonstrated, with some handled by coders using Cucumber/RSpec, and others demonstrated by testers using other processes/tools like manual testing or GUI automation tools like Selenium? Should there not be a division of responsibilities across roles so that the resulting automation test suite is complete and non-overlapping (DRY)? If so, what do you suggest for a proper division?

The Cucumber “World” concept has not been introduced to the reader yet at this point. Perhaps add a forward reference to the Cucumber chapter, or rephrase.

I don’t agree with this assertion in the text:
“On the other hand, if we pass it [the generator] to new( ), then we have to create a new Game every time we want to play a new game.”
Why? The Game::initialize() method can save a reference to the Generator, and Game::start() can invoke Generator::code() to create a new secret code each time a new game starts.

“Luckily, we have tools in both RSpec and Cucumber to keep things simultaneously readable and DRY.”

On the contrary, I find that the combination of both RSpec and Cucumber causes a decidedly non-DRY result. When the BDD Cycle process is followed, a redundant RSpec code example is created for every failing Cucumber scenario. The result is a lot of overlapping tests. In the final iteration of the Codebreaker, the resulting RSpec and Cucumber suites were about 80% redundant with one another.

While I recognize that the primary purpose of Cucumber scenarios and RSpec code examples is to drive out the design, an important secondary use for them is as a regression test suite. As a result of the overlap of the RSpec and Cucumber suites, the majority of features in the Codebreaker app had two tests which would fail if any of the functionality changed. Over time this would result in a significant drag on development extensions of the app.

Shouldn’t we be trying to have a DRY test suite with minimal redundancy? Specifically, I question the wisdom of creating a failing RSpec example for every failing Cucumber step definition. What is the harm in allowing the step definition to drive the application design directly?

Perhaps overlap of test suites is not such a big issue in a more serious application. In a toy app like Codebreaker, there is little behavior which is not directly externally visible to users. This may ultimately be the cause of why the two test suites overlap so drastically. Bigger apps with more hidden details would have more RSpec examples not duplicated as Cucumber scenarios, so the proportion of overlapping tests would be smaller.

Still, why should there need to be redundant test coverage even for externally facing behaviors? It seems like some guidance is in order regarding which tool is more appropriate for which kinds of behaviors. E.g., Cucumber should be used for externally visible behaviors which are important enough to be included in acceptance criteria for features, whereas RSpec should be used for lower-level behaviors. Or similarly Cucumber is a tool for black-box behavioral testing where RSpec is for white box.

If the authors truly believe that there is real value in creating the redundant RSpec tests in order to better drive out the design (and I’m not catching how the redundant RSpec example is any better than the step definition it matches), perhaps then the process should include a step to delete the redundant RSpec tests from the test suite following story acceptance (or feature release). If their value has played out, why pay the cost of dragging along the baggage of redundant tests?

Furthermore, I think there should be a clearer distinction between what behaviors should be demonstrated in Cucumber vs. RSpec acknowledging the target audience for the tools. RSpec is a developer-centric tool, where Cucumber bridges the gap to testers and BAs. I think a strong argument can be made that all non-trivial externally visible behaviors should be reflected in Cucumber scenarios. In the BDD cycle when creating RSpec tests, if the developer discovers a new behavior needed by the app, your description has him creating an RSpec code example for it. But should that behavior then be demonstrated by a Cucumber scenario which duplicates (or preferably replaces) the RSpec example? The advantage of moving the behavioral demonstration to Cucumber is that you have made it accessible to testers and BAs, which assures that they become aware of it and gives them a change to review it. Developers alone should not be the ones to decide important functionality of the app. In the Codebreaker app, an example of this is adding the ‘reveal’ feature to Game::guess(). While this was done to facilitate testing, it resulted in the addition of important externally accessible behavior, and the BAs should be aware of it. E.g., the BAs might object to adding a mechanism to the game which makes it so easy to cheat, because they might be targeting the app toward competition use. Leaving the demonstration of the behavior “buried” down in RSpec is unwise from an agile process perspective.

Throughout the book, I would expect to see more information regarding best practices for use of the tools and how they should fit into agile processes, not just a demonstration of how the tools work. Some of what I am asking for belongs more in Chapter 11, but I would also expect to see more about how to make appropriate use of the tools throughout the extended Codebreaker example in Part 1.

It says “To modify this feature file to run through Selenium, we must make.” It should say “we had to make”.

Just to make things 100% idiot-proof, maybe you should state that the file we have just written goes into the features subdirectory.

The last paragraph references creating the messages_controller.rb file and adding in the MessagesController class, but the following code is from the messages_controller_spec.rb displayed earlier in the page.

Does that sound like we’re putting the developer’s needs ahead of the
needs of the stakeholder’s needs?
=>
Does that sound like we’re putting the developer’s needs ahead of the
needs of the stakeholder(s)?

Has it been explicitly explained how to “run the script” before this point?
The description is verbose enough that a line or two on running the bin/codebreaker script would be helpful without being OTT.

“Can’t get much more concise that this.” should read: " Can’t get much more concise than this."

Between chapters, the code used in the scenarios seems to have swapped from “r g y c” to “r y g c,” causing the output to differ from that presented in the book.

We picked a game because we thought it be more

I think you meant -
We picked a game because we thought it would be more
^

The given block that starts on page 51 is interrupted by footnotes on that page, followed by a gray box explaining the download files, and then there’s the word “end” - code block should not be broken up if at all possible for clarity purposes

I’m getting errors after copying code from the pdf into gedit and then running cucumber - code that has a " followed by a $ is inserting a space when copied into the editor - this results in a step undefined error - this happens with all such code that I have copied, such as the following - (as a matter of fact, the space was added when pasting into this “description” box, so it must be there but not showing in the .pdf

Then /^I should see “([^\\”]*)" $/ do |message|
@message.should == message
end

Similar issue here as reported before - there’s a big “Joe Asks” box followed by the word “end”, which is the final bit of code from the previous page interrupted by footnotes and “Joe Asks”

Working the code along with the text was very intuitive up to this page - all of a sudden, it’s just “add code to this file a command”, add another command to another file, include this, include that - and voila everything will work. I take it you’re assuming everyone knows what $LOAD_PATH and File.join and File.dirname commands are doing. Obviously, one can figure it out but the intent of the book should be more tutorial and explanation, as previous pages were.

I’m getting lost at this point - on page 60 the chapter starts with “we’re going to use RSpec to describe behavior” then it’s three pages of adding code to various files, ending with running an RSpec command that really tells us nothing - then moving on to cucumber again? The book had a great pace and I knew exactly what was going on until Chapter 5.

Had to use , :null_object => true in declaring the mock as as_null_object blew up

Looking at the code, especially when doing refactors - the refactored lines should be highlighted in some way to immediately make obvious what is being changed

I really think this chapter needs some work - we end on page 72 with an spec command. Then we do a bunch of fairly clear refactorings, only to be told to “run the feature again” - well, the last thing we did was spec - now we’re back to features. This chapter really bounces back and forth and loses the reader along the way

def start
@messenger….

should be
def start(code)
@messsenger…

otherwise test breaks again

There are two “The”s in the second section of "render(), response(), and contain().

“Update the before block to use mock_model( )”

The before block was in beta 10.0 its no longer in beta 11.0

text from 348 to 351 needs breaking up with some headers. Its very easy to get lost in the example. I would suggest some sub headings like

Create Message Class
Mock As New Record
Add Input Field
Mock Title Attribute
Mock Null Object
Dry up with before(:each)

Perhaps these could be notes in the margin if titles are to unobtrusive

orphaned ‘end’ from code example at beginning of page - should be kept with rest of code example

“Open the new template and remove the form. ”
should be a bit more specific?
“Open the new template and remove the render of the form partial. ”

In the rspec_model generation snippet, the ‘rake db:migrate’ task is misspelled as ‘rake db:mgirate’

p369/370
We don’t need
.and_return(@message)
once we have refactored the “creates a new message” using a before block. Our before block ensures the message is returned for the save and our test is not concerned about the message

This should be part of the Subscription spec:

it “ignores messages from previous months” do
user.sent_messages << Message.create!( :title => "Book Update", :text => "Beta 11 includes great stuff!", :recipient => mock_model(User), :created_at => Time.now - 60*60*24*31 ) subscription.can_send_message?(@user).should == true
end

Also I can’t see why you’re passing the date into can_send_message. There is no obvious current need to do this. Shouldn’t we just spec it as it is used in user? i.e. subscription.can_send_message? self

This change of messages_controller break loads of the tests. It’s not at all obvious how to refactor the tests and controller in tandem to achieve this. Especially as I can’t see how to reference the current_user. This needs to be explained.

“Go ahead and run script/cucumber —tag focus from the project root” should be “Go ahead and run script/cucumber —tag @focus from the project root”, to work with cucumber 0.4.3

“Now run cucumber -t focus so we can see how we’re doing” should be “Now run cucumber -t @focus so we can see how we’re doing”, when using cucumber 0.4.3. Also, is it intentional to use ‘cucumber’, rather than ‘script/cucumber’? If so, you probably want to call out the difference and explain that it’s a shortcut and/or how it differs from ‘script/cucumber’.

Under “A Small Change Goes a Long Way”

I just don’t think it’s explained very well when you say “Run the feature again with cucumber” that you mean “cucumber features/codebreaker_submits_guess.feature” and not just “cucumber” which is why the former poster thought they had to send a code in codebreaker_steps.rb. I got confused, too, when I didn’t get the 13/26/13 thing. Then I realized what you meant by “Run the feature again with cucumber”… I would clarify this.

In section 4.2 Steps and Step Definitions, the code example is split, with the “end” being orphaned on page 52 and separated from the widow by a callout “Doanloadable Files.”

That is, on page 51 there is some code that should read:

Given /I am not yet playing/ do
pending
end

But this code is split by (a) the page break, (b) footers, © the “Downloadable Files” call-out.

So on page 51 you see:
Given /I am not yet playing/ do
pending

1. As we’ll review later in Chapter 18 …

then on page 52 you see:
| Downloadable Files
| blah blah blah
+———

end

which is a little odd.

after doing “script/generate rspec_model”
migrate is written wrong (rake db:mgirate<)

I got following error when I run “script/cucumber —tag focus”

Tag names must start with an @ sign. The following tag name didn’t: focus (RuntimeError)

The error disappear when run follwing,
run script/cucumber —tag @focus

I think you should spell out the fact that the computer is taking the Code Maker role.

“This looks a lot like the scenario declarations we wrote for the code- breaker starts game feature, with two subtle differences” - should refer to the code-breaker submits guess feature.

require ‘webrat/integrations/rspec-rails’

should be:

require ‘webrat/integration/rspec-rails’

“… outermost describe( ) block, “mes-
sages/show.html.erb”in this case. …"

It’s missing a space before “in this case.”

Maybe “messages/show.html.erb” should not break in two lines as it is a filename.
—lucas

on rails_models/beta2/03/app/models/user.rb snippet

“…
has_many :received_messages, :class_name => Message.name,
:foreign_key => ”recipient_id"
…"

Should be
“:class_name => Message”

and not
“:class_name => Message.name”

The second sentence in the first paragraph under render(), response() and contain() says: “The The rendered content[…]”

Hope that’s clear enough ;)

First full paragraph on the page starts with “The do,”. It should be “They do,”.

I would like more information on the higher-level project descriptions i.e. outcomes and feature sets, and how they fit in. Specifically, I want to know how they would fit in with the codebreaker example - what are the feature sets for it? Would there be outcomes?

Last sentence of last paragraph, file name should be movie.rb not movies.rb.

In the _form code at the bottom of the page, the line beginning with “describe” should have a triangle marker next to it denoting the line has changed.

The two code lines beginning with “@message.stub” should have triangle markers denoting these lines have changed.

In the code for _form.html.erb_spec.rb both the book and the download are missing the empty Message class definition (class Message; end). I get:
NameError in ‘messages/_form.html.erb renders a form to create a message’
uninitialized constant Message

when I don’t include the empty class definition in the code.

A cross reference is missing in the third bullet point:

You’re not using the Webrat API. If you’re using the technique
described in [CROSS REF],

“undefined method `message_path’”

should be

undefined method `messages_path’

with an extra s.

Same for:

“there is no message_path route”

In the inner line of the Then implementation, you can’t line-break before the . because Ruby will think it’s an end-of-statement.

secret_codes.count_for(color, position)
.should be_between etc

should be

secret_codes.count_for(color, position).
should be_between etc

Tested on MRI 1.8.7p174

If you created the app with “rails views_example” and have been following along, adding code as you read, you get an “uninitialized constant Message” error rather than the “No action responded to create”. As far as I can tell the book never says when to create the message.rb model file. I think the book would be improved if you mentioned at some point when to create message.rb. Seems like you expected this to happen sometime in the last chapter (see my comment #41571:).

3rd line up from the bottom of the page should say:
Now it fails with uninitialized constant FooController::AccessDenied

At least that is the error I got.

Last word, first paragraph missing an ‘a’ from behaviour.

The line:
“The do, however, facilitate conversation between the customer and devel-”

should be “They do…”

This page says: “Now all examples are passing…” but I’m still getting an error: “uninitialized constant Message::User (NameError)” Looking at the schema.rb from the downloadable code it looks like a User model got generated but I don’t see this mentioned in the book.

To get things working I did the following:
script/generate rspec_model user name:string email:string
rake db:migrate
rake db:test:prepare

In the footnote, is the word “smaller” supposed to be “larger” or “bigger”?

you use “the the” right before the start of the narrative paragraph: … which improves our ability to plan iterations, hence the the name Acceptance Test Driven Planning.

I noticed that on page 28, you use the “In order to… As a… I want” style, but on this page you are still using the older “As a… I want… So that…” Is this intentional, or did pg. 41 not get updated. You may have mentioned it, but it might be helpful to mention the theory behind keeping the “In order to” first (Liz Keogh has some great stuff on this).

“We’ll want to load game.rb and any other source files from a single location, so require the file from lib/codebreaker.rb”

Huh, lol?! Why would we want to do that? It’d be great if this was expanded on. When I read it, it seemed like needless complexity, but I’m sure there’s a really great reason/learning-experience there…

Thanks - love the book!!

env.rb file for simulated_browser/03 supplied with the code is incorrect. It referrs to selenium and throws errors when run as suggested in the book in the footnote 2. However, if you are following along (I am), the env.rb file that gets generated is fine and the code executes correctly. So, in a nutshell, the code supplied with the book is out of sync with the book.

Bharat

In the last sentence of the first paragraph, I believe it should say unobtrusive instead of obtrusive.

Last paragraph starts with The The.

On the last paragraph of this page you ask for a migration, but don’t mention doing “db:test:prepare” as you have done in other places in the book. Might be nice to make mention of that here too.

My cucumber returns:
13 scenarios (13 undefined)
39 steps (26 undefined, 13 passed)
I guess this is OK as none of the scenarios are finished with their definitions - but I spend a while trying to hunt for a return as it is quoted in the book - until I concluded the above guess.

new.html.erb_spec.rb file code has dropped the line:
class Message;end
inadvarently and therefore the all the tests fail.
Bharat

I don’t understand the footnote on this page: “Note that the code included when you require spec/stubs/cucumber does not verify message expectations.”

I’m guessing it means that you still have to require rspec in addition to “require ‘spec/stubs/cucumber’,” but I’d love some more info here.

Thanks!

The example code for cb/27/lib/codebreaker/game.rb should contain the argument “code” for the def start method (fixed below):

def start(code)
messenger.puts "Welcome to Codebreaker!" messenger.puts “Enter guess:”
end

I believe that it would be a lot better if the rails example was as integrated as the codebreaker.

In truth it defines a very different aproach from regular rails and it doesn’t make sense to use old rails approach to continue the example because the rspec way is only in latter chapters.

Its a great book and it would be great if you could make it more complete, as some issues are very fresh and aren’t easy to track down over the web.

Eliminate the the second instance of the word “be” from the sentence: “In order to control how many messages can be sent in a month, the subscription will need to be know how many messages have already been sent.”

On the very first line of this page.

feel for how to do go about it

Using the code linked to from pp 144-145, rspec is generating errors for the two summary tests:

Spec::Mocks::MockExpectationError in ‘Codebreaker::Game marking a guess with the text ’summary’ after one guess should print the summary’
Mock “messenger” received :send_summary with unexpected arguments
expected: ([#<Codebreaker::Guess:0x101807710 mark=["w", "w"], guess=[“b”, “w”, “y”, “r”]>])
got: ([[#<Codebreaker::Guess:0x101808390 mark=["w", "w"], guess=[“b”, “w”, “y”, “r”]>]])

and

Spec::Mocks::MockExpectationError in ‘Codebreaker::Game marking a guess with the text ’summary’ after three guesses should print the summary’
Mock “messenger” received :send_summary with unexpected arguments
expected: ([#<Codebreaker::Guess:0x1017fd968 mark=["w", "w"], guess=[“b”, “w”, “y”, “r”]>, #<Codebreaker::Guess:0x1017fd788 mark=["b", "b", "b"], guess=[“r”, “y”, “g”, “g”]>, #<Codebreaker::Guess:0x1017fd5a8 mark=["b", "b", "w"], guess=[“r”, “c”, “y”, “c”]>])
got: ([[#<Codebreaker::Guess:0x1017ff1a0 mark=["w", "w"], guess=[“b”, “w”, “y”, “r”]>, #<Codebreaker::Guess:0x1017febb0 mark=["b", "b", "b"], guess=[“r”, “y”, “g”, “g”]>, #<Codebreaker::Guess:0x1017fe5e8 mark=["b", "b", "w"], guess=[“r”, “c”, “y”, “c”]>]])

Changing code back to pass strings and matching the strings works.

rspec 1.2.9
ruby 1.8.7

The “gem install cucumber” should be on a seperate line in the blue “code” font. this would match the “gem install rspec” instruction on page 26 and make it easier to find.

spec spec/codebreaker/game_spec.rb —format nested
gives a false positive for the:
messenger.should_recieve(:puts).with(“bbbb”)
3 examples, 0 failures
(If it matters: My system is windows XP, Ruby 1.9.1p243, rspec 1.2.9). It cathes the missing ‘guess’, if I comment that out - so what could the problem be ?

current_user is not defined in the messages_controller context, thus the spec throwing an error.

Just above title “Narrative”:
" hence the the name Acceptance Test Driven
Planning."
should be
" hence the name Acceptance Test Driven
Planning."

Under Snow Leopard, Cucumber + Selenium + Firefox is teh fux0red. Either need to patch Selenium or use Safari.

Also, current Selenium changed transaction behavior, so scenarios need @no-txn to work.

Pages 144-145, related to #41707.

I was receiving the same Spec errors pertaining to :send_summary. The code in code/cb/73 had one additional fix that isn’t covered in the text of the chapter, which is the addition of the def ==(other) method in guess.rb

The game_spec.rb file will not pass until the def ==(other) method is added to guess.rb, but there’s no explanation as to what the method does or why it is needed.

The paragraph “Outcome-based planning” ends with “and that that’s ok” which might be correct but the two “that” sound very strange and could it be dropped anyways.

I find your diagrams such as in Figure 13.2 to be a bit confusing and generally not helpful in understanding the flow of how the example works. Maybe it’s just me, but it could be something to improve upon.

Very begining of section 9.3, Cucumber in the Outfield:
“If you run cucumber now, you’ll see some some failures […]”

I can read some “some” duplication in this sentence (not mine, the one of the book ;-)

psuedo-code -> pseudo-code in “With that in mind, your next refactoring exercise, and this is admittedly a doozy, is to convert the current mark algorithm to one that expresses this psuedo-code.”

Shouldn’t

Given /I am not yet playing/ do

be

Given /^I am not yet playing$/ do

?

Could you include a short section on testing rake tasks? I think that could be pretty helpful.

codes.uniq.length.should be >= 95

…

It fails with expected >= 95, got 1.

…

I think it should be: “It fails with expected <= 95, got 1.”

Typo around middle of the page at “Now that we’ve seen how we to configure Webrat, Cucumber, and Rails
to work with Selenium …”. You use “we to” and only one of those words should be present.

[CROSS REF] should reference sections 21.2 and 21.3

There is a code line ending with TRUNC, is this supposed to be truncated?

Line starts with “selenium.is_ordered …”

From your page: Google “exploratory testing” and you’ll find upwards of 785,000
results. Testing is a craft of its own, rich with literature, experience,
and community. But the details of exploratory testing are outside the
scope of this book, and simply “exploring the app” will suffice for our
needs.

Your point about testing is well-taken, but using Google counts is getting to be notoriously tricky. I think the huge counts are overly suggestive and maybe can’t even by counted on.

When I did it today (2009-12-11), I got about 653,000 results. Actually going through them — I clicked on page 10 and got page 8 — ends with “In order to show you the most relevant results, we have omitted some entries very similar to the 734 already displayed.
If you like, you can repeat the search with the omitted results included.”

When I searched with the term in quotes, I got about 61,500 results. Again, I clicked on page 10 and got page 8 with “In order to show you the most relevant results, we have omitted some entries very similar to the 715 already displayed.
If you like, you can repeat the search with the omitted results included.”

I frankly don’t know how to evaluate the huge count. I think the but bottoming out at less than 800 also certainly suggests something. But I can’t say I’m even clear about that.

This section indicates that a clarification will be made about the differences of using stub, mock and double to make a spec more clear, but I don’t think it is really addressed in the chapter. After finishing the chapter, I am still unsure of when to really use mock vs. double. The chapter alludes that mock presents a tighter connection to the subject of the spec than stub, but the double instance doesn’t seem to be addressed.

Should there be a green arrow next to the code line “<%= f.text_field :title %>” do denote that this is the new line to add in the file? (location at approx middle of page)

Last line before section 23.3 starts, “specs, the can be very helpful throughout the spec suite.”, the word “the” should be “they”.

left out the word “see” in the sentence: “If you run
that spec now you should it fail with:” in the paragraph below the first example on the page.

Is there any benefit to creating the Message class in the spec helper? Why not actually go ahead and create the model at this point? Is it just for simplicity?

The cucumber output in my terminal is colored and seems to be one of the major features of cucumber (run it till it’s green!). Have you thought about applying the same colors to the output in the book instead of everything being blue?

PORO = Plain old ruby object, yes? Is this abbreviation defined elsewhere, I had to google it.

Practicioner should be practitioner

When viewing the PDF using Adobe 9.2.0 on Windows XP the equals signs within the code sample appear instead as what look to be bolded dashes. When I copy and paste the code sample into emacs the code appears correctly with the equals sign:

describe MovieList do
context “when first created” do
it “should be empty” do
movie_list = MovieList.new
movie_list.should be_empty
end
end
end

Therefore this issue only appears when viewing sample code within the Adobe PDF viewer but copy and paste into another program renders the sample code correctly. This issue is not unique to page #21 of the PDF but it is the first instance I noted it.

I can provide a screenshot of the error if desired.

Asa
bourea@hotmail.com

“… run cucumber -s again and you should see
output like this: …”

I think you meant to write “cucumber features/codebreaker_starts_game.feature -s” instead of “cucumber -s” to get output quoted within book.

spec/codebreaker/ should be codebreaker/spec/

Might want to include spec command along the lines of:
spec spec/game_spec.rb…

game = Game.new - this line fails with wrong number of arguments (0 for 1) should it instead be game = Game.new(@messenger) ?

In “Scenario: Hide minutes for times ending with 00”, the When is: ‘When I set the showtime to “2007-10-10” at “2:15pm”’. Shouldn’t it be: ‘When I set the showtime to “2007-10-10” at “2:00pm”’?

This part of the chapter becomes VERY fuzzy. It’s the first time my code breaks and does not behave like the book as I go along. Maybe you should clarify a bit.

If this…

“The one that is failing is the only example left that is still calling start() with no code, and it’s a near duplicate of the passing example that says (passing the code to start). We can now safely remove the failing example, and remove the parenthetical context from the passing example, leaving us with this:”

… is true, why are we instructed to to this…

“def start
messenger.puts "Welcome to Codebreaker!" messenger.puts ”Enter guess:"
end"

??? - Should’nt it be instead…

“def start(code)
messenger.puts "Welcome to Codebreaker!" messenger.puts ”Enter guess:"
end"

… If one wants to insure that the code is required by the start method?

secret_codes.count_for(color, position). <- remove period

should be_between(min.to_i,max.to_i) <- add space after comma for consistency

Need to update:
[sudo] gem install cucumber rspec-rails webrat

to:
gem install cucumber-rails rspec-rails webrat

Starting with Cucumber 0.4.5 you will need the cucumber-rails gem

script/cucumber -tag @focus fails with:

Missing these required gems:
database_cleaner >=0.2.3

I ran rake gems:install to no avail but gem install database_cleaner worked.

cucumber -t focus should instead be cucumber -t @focus

webrat_steps.rb should be renamed web_steps.rb

Download rails_views/messages/15/spec/views/messages/edit.html.erb_spec.rb -> need to add class Message; end within download file

of of other components

remove redundant of

In “Designing Interfaces with Mock Objects”, we go through a section of refactoring, in particular the Game spec. There’s a part where we happen to end up comparing equality between objects:

@messenger.should_receive(:send_summary).with([Guess.new(%w[b w y r], %w[w w])])

The last two tests in the Game spec will fail even when it looks like everything should be fine, because there’s no equality defined in the Guess class yet. I looked through the code examples relating to that section (rev 73) and found this in the Guess class:

def (other) other.guess self.guess && other.mark == self.mark
end

There doesn’t seem to be any mention of this method before page 153, and if it’s left to be an exercise to the reader, it wasn’t an obvious one. I spent quite a long time trying to figure out what was going wrong. It was frustrating because I’d been following the examples and instructions and felt compelled reread that section several times before giving up and digging into the example code. Some clarity would be nice here :)

It’d be great if you could add a note as to how to handle errors that are raised in Webrat/Cucumber. On 395, the example of implementing an “access denied” feature in your ApplicationController is a good one, but it left me lost when I did the next logical step, which was to try and build it out using Cucumber.

Here’s what I tried, in the wild, with the application controller/spec implemented as suggested:

Scenario: Users cannot sign up when sign ups are disabled
Given sign ups are disabled
When I go to the sign up page
Then I should see “forbidden”

The second step (using the built-in when I go to…) causes an AccessDenied error to be thrown (as you’d expect). However, when Webrat encounters the exception, it reraises it and the test fails. I’m not sure how to handle this (maybe with lambda { visit … } ?), but some clarification would be fantastic here, seeing as it’s the next logical step someone might try.

Addendum to #41956: The solution was found in features/support/env.rb which specifies the @allow-rescue tag.

Installing the Cucumber gem installs 0.5.3. When I ran the ‘script/generate cucumber’ I got “Couldn’t find ‘cucumber’ generator”. When I dug around, I found that after Cucumber 0.4.5 you need to install the Cucumber-Rails gem. Either the old gem needs to be specified, or the instructions to install Cucumber-Rails gem needs to be added.

Should the phrase “breaking the guess” be “breaking the code”?

The sentence “it is very, very liberating, and results consistently in more usable APIs” should be written as “it is very, very liberating and results consistently in more usable APIs” or “it is very, very liberating, and it results consistently in more usable APIs”.

Now needs the gem ‘cucumber-rails’, in order to get script/generate cucumber to work.

You’ll also need to specify “—webrat” and “—rspec”, given the other gems listed.

script/generate cucumber - add the “—spork” unless on Windows?

Near the bottom of “Should I spec associations?” box. Pretty sure there is some kind of typo here:

“They’re just part of wiring up the association, and an that requires them won’t work correctly without them, so there is no need to spec them directly either.”

Simply commenting out “Cucumber::Rails.use_transactional_fixtures” caused the scenarios to fail. Setting it to false will make the scenarios pass again. (I’m using all the latest gems)

For an existing record, shouldn’t the method be “put”?

Running script/cucumber —tag @focus (on Win32) results in:

WARNING: C:/data/donp/NetBeansProjects/showtime/features/support/env.rb:18: cucumber/webrat/element_locator.rb is deprecated and will be removed in Cucumber 0.6.0.
Use cucumber/web/tableish instead.

Solution is to comment out line 18 in features/support/env.rb:
#require ‘cucumber/webrat/element_locator’ # Deprecated in favor of #tableish - remove this line if you don’t use #element_at or #table_at

There is a double “the” (“the the”) in the final of the third paragraph.

“hence the the name Acceptance Test Driven Planning.”

Regards.

the link to textmate bundle has a typo
should be svn.textmate.org/trunk/Bundles/Ruby%20RSpec.tmbundle

FYI, on MS Windows XP with ruby 1.8.6 (2008-08-11 patchlevel 287) [i386-mswin32], Time.now.strftime(“%l”) => “”. I notice that the %l isn’t documented in the Pickaxe. I used:
def formatted_time
hour = showtime_time.strftime(“%I”).to_i.to_s
hour + showtime_time.strftime(“:%M%p”).strip.downcase
end

Second para after “Bundling in vendor/gems” - “With that configration in place” should be “With that config*u*ration in place”

Second sentence - “…use together to begin driving development from the outside.” Thinking that should be “from the outside-in” since you say that everywhere else, including the preceding sentence. ;)

Maybe:

“So far we’ve explored the concepts of BDD in Rails at a high level, and set up a project with the recommended tools. In the next chapter we’ll take a look at how Cucumber and Rails and be used together to really begin the outside-in development of our application. Turn the page and let’s begin.”

Or something like that. ;)

When explaining the output of script/generate cucumber there is no description for config/cucumber.yml.

For the “Bundling in vendor/gems” and “Bundling in vendor/plugins” - what I forsee happening is someone relatively new to Rails reading the book and following it blindly, but being confused when they get here. Some more context as to /why/ one would pick one, the other, or neither might be helpful. Maybe a little callout section or something just before those two sections.

Dropped the end of the 4th paragraph - “A - indicates a number match: one of the numbers in the guess is the same as one of the numbers in the secret code, but in a”

Regarding the “Bundling in vendor/gems” section starting on p.303; Unpacking dependencies installs Nokogiri which will cause an error when running the first scenario on p.309. Shouldn’t the book instruct the reader to remove Nokogiri from vendor/gems as it contains native extensions? I think this was mentioned in passing on b12 but has not been included on b13.

In the “Focus on the Role” section, the “Coh04” link Is being displayed in bright green. This is incredibly hard to read on the gray background.

I’m viewing the PDF using Preview.app on a 13" Macbook Pro running Snow Leopard (10.6.2). I don’t think I have done any customization that would cause the color to be different on my system, but don’t remember for sure.

The same bright green link also appears in the body text on Page 35 (“JAH02”) and, while it’s easier to read on a white background, it is still somewhat painful.

I do see that this is the same in other PragPub books (e.g. Agile Web Development with Rails) so maybe it is something particular to my machine. At any rate, I thought I’d point it out in case it is something that could be configured in your PDF files.

In the fifth paragraph that begins “Inside the codebreaker directory”, the feature file name should be “codebreaker_starts_game.feature” as I’m pretty sure we’re breaking “codes”, not fish (“cods”). ;-)

#start (last but one line) is formatted green like a comment, but isn’t a comment.

Two lines with #start are formatted green like comments, but aren’t comments.

Second paragraph ends with “Here are the contents of the two files:” and there are no contents listed.

This is definitely nit-picking, but the feature’s explanation text is not parallel. I think it would read better as follows:

For each number in the guess that matches the number and position of a number in the secret code, the mark includes one +. For each number in the guess that matches the number but not the position of a number in the secret code, the mark includes one -.

The only change is the final phrase: “the mark includes one -.”

“documents it’s responsibility” s/b “documents its responsibility”