WorkUnitGroup - Blog

Crafting Rspec Steps with step_eval and DRYing them with a Helper Part 3

2008-04-23T20:03:00Z

Part 3 integrates the functionality that has gone to the helper back into the steps. <-->
<-->

Green light. Let's integrate the helper.


  steps_for :model do

     Given "$count $models" do |count, model|
       count.to_i.times { class_from_string(model).create }
     end

     When "I destroy all $models" do |model|
       class_from_string(model).destroy_all
     end

   end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end


# Here is the DRYing Helper

module Helper
  def class_from_string(name)
    eval "#{name.singularize.camelize}"
  end
end

# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     count.to_i.times { class_from_string(model).create }
   end
   
   When "I destroy all $models" do |model|
     class_from_string(model).destroy_all
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

describe Helper do
  describe "#class_from_string" do
    it "'article' -> Article" do
      class_from_string("article").should == Article
    end
  end
end

Run it:

Whoops! We have to extend our step implementations with the new functionality:


   steps_for :model do

      Given "$count $models" do |count, model|
        extend Helper
        count.to_i.times { class_from_string(model).create }
      end

      When "I destroy all $models" do |model|
        extend Helper
        class_from_string(model).destroy_all
      end

    end

Executable:


  require 'rubygems'
  require 'active_support'
  require 'spec'
  require 'spec/matchers'
  require 'spec/story'
  require 'spec/story/step'

  # This is the function that performs the step.

  def step_eval(stepname, stepgroupname)
    type = stepname.split(/\s+/).first.to_s.downcase.to_sym
    stepname = stepname.split(/\s+/)[1,100].join(" ")
    stepgroup = steps_for stepgroupname
    step = stepgroup.find(type, stepname)
    if step == nil
      raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
    end
    args = step.parse_args(stepname)
    step.perform self, *args
  end


  # Here is the DRYing Helper

  module Helper
    def class_from_string(name)
      eval "#{name.singularize.camelize}"
    end
  end

  # Here are the step implementations

  steps_for :model do

     Given "$count $models" do |count, model|
       extend Helper
       count.to_i.times { class_from_string(model).create }
     end

     When "I destroy all $models" do |model|
       extend Helper
       class_from_string(model).destroy_all
     end

   end



  # Here is the spec

  describe "Given $count $models" do
    it "should create 1 article" do
      class Article
      end
      Article.should_receive(:create).once
      step_eval "Given 1 article", :model
    end

    it "should create 17 lists" do
      class List
      end
      List.should_receive(:create).exactly(17).times
      step_eval "Given 17 lists", :model
    end
  end

  describe "When I destroy all $models" do
    it "should destroy all Articles" do
      class Article
      end
      Article.should_receive(:destroy_all)
      step_eval "When I destroy all articles", :model
    end
  end

  describe Helper do
    describe "#class_from_string" do
      it "'article' -> Article" do
        class_from_string("article").should == Article
      end
    end
  end

Run it:

Green Light!

Extending every single step with the Helper module is only necessary in this script. If you use the step with the real story runner you can mix the Helper into the Spec::Story::World: (eg. in stories/helper.rb)


 module Helper
    def class_from_string(name)
      eval "#{name.singularize.camelize}"
    end
 end

 Spec::Story::World.module_eval { include Helper }

Now we have two carefully crafted steps that are dryed up with a helper and everything gets automatically tested so you can rely on them and reuse them. That's it for today.

Crafting Rspec Steps with step_eval and DRYing them with a Helper Part 2

2008-04-23T19:51:00Z

Speccing steps with step_eval, implementing them and finally drying up with a helper

<-->

Write an Example for another step

What if we get rid of all those articles and lists?
We'll need another step:

When I destroy all $models

Start by writing the example:


  describe "When I destroy all $models" do
    it "should destroy all Articles" do
      class Article
      end
      Article.should_receive(:destroy_all)
      step_eval "When I destroy all articles", :model
    end
  end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end



# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     klass = eval "#{model.singularize.camelize}"
     count.to_i.times { klass.create }
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

Run:

Implement the second step

We have to declare the step in the stepgroup:


  steps_for :model do

     Given "$count $models" do |count, model|
       klass = eval "#{model.singularize.camelize}"
       count.to_i.times { klass.create }
     end

     When "I destroy all $models" do |model|
     end

   end

Again the executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end



# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     klass = eval "#{model.singularize.camelize}"
     count.to_i.times { klass.create }
   end
   
   When "I destroy all $models" do |model|
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

Run it:

This is obvious again. We need to call List.destroy_all in the step implementation. But this time we know that we will need a more flexible solution and we should reuse the class_from_string_thing from the first step.

DRYing up Steps and speccing a Helper

In our second step we'll need exactly the same first line of code as in the first step. We will only temporary copy and paste it but then write a helper method: (Remember that a step implementation is not an example and thus the clarity-degree may be 20% lower.)

Getting green before we do the next thing

Let's get the example to pass:


  steps_for :model do

     Given "$count $models" do |count, model|
       klass = eval "#{model.singularize.camelize}"
       count.to_i.times { klass.create }
     end

     When "I destroy all $models" do |model|
       klass = eval "#{model.singularize.camelize}"
       klass.destroy_all
     end

   end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end



# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     klass = eval "#{model.singularize.camelize}"
     count.to_i.times { klass.create }
   end
   
   When "I destroy all $models" do |model|
     klass = eval "#{model.singularize.camelize}"
     klass.destroy_all
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

Run it:

Green! Let's spec this helper.

We will call our helper module Helper and the method 'class_from_string' and add this infrastructure upfront:


 module Helper
   def class_from_string(name)
   end
 end

Writing a first example for the helper:


describe Helper do
  describe "#class_from_string" do
    it "'article' -> Article" do
      class_from_string("article").should == Article
    end
  end
end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end


# Here is the DRYing Helper

module Helper
  def class_from_string(name)
    
  end
end

# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     klass = eval "#{model.singularize.camelize}"
     count.to_i.times { klass.create }
   end
   
   When "I destroy all $models" do |model|
     klass = eval "#{model.singularize.camelize}"
     klass.destroy_all
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

describe Helper do
  describe "#class_from_string" do
    it "'article' -> Article" do
      class_from_string("article").should == Article
    end
  end
end

Run it:

We already have done the implementation in the steps:


module Helper
  def class_from_string(name)
    eval "#{name.singularize.camelize}"
  end
end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end


# Here is the DRYing Helper

module Helper
  def class_from_string(name)
    eval "#{name.singularize.camelize}"
  end
end

# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     klass = eval "#{model.singularize.camelize}"
     count.to_i.times { klass.create }
   end
   
   When "I destroy all $models" do |model|
     klass = eval "#{model.singularize.camelize}"
     klass.destroy_all
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
  
  it "should create 17 lists" do
    class List
    end
    List.should_receive(:create).exactly(17).times
    step_eval "Given 17 lists", :model
  end
end

describe "When I destroy all $models" do
  it "should destroy all Articles" do
    class Article
    end
    Article.should_receive(:destroy_all)
    step_eval "When I destroy all articles", :model
  end
end

describe Helper do
  describe "#class_from_string" do
    it "'article' -> Article" do
      class_from_string("article").should == Article
    end
  end
end

Run it:

Green light. Let's integrate this in Part 3.

--> Part 3

Crafting Rspec Steps with step_eval and DRYing them with a Helper: Part 1

2008-04-23T19:47:00Z

Speccing steps with step_eval and implementing them.

Speccing steps with step_eval, implementing them and finally DRYing up.

StepSpecr wraps the step performing functionality in a single method. Through calling step_eval in an example the specified step will be evaluated in the context of the example. So you can do this:


  describe "Given a step that sets @number to 7" do
    it "should set number to 7" do
      @number = 1
      step_eval "Given a step that sets @number to 7", :spec
      @number.should == 7
    end
  end

Getting started

The script snippets that follows are executable rspec examples. You'll need to have installed rspec and rails as gems.

One trivial passing example to verify the functionality.

  
  require 'rubygems'
  require 'active_support'
  require 'spec'
  require 'spec/matchers'
  require 'spec/story'
  require 'spec/story/step'

  # This is the function that performs the step.

  def step_eval(stepname, stepgroupname)
    type = stepname.split(/\s+/).first.to_s.downcase.to_sym
    stepname = stepname.split(/\s+/)[1,100].join(" ")
    stepgroup = steps_for stepgroupname
    step = stepgroup.find(type, stepname)
    if step == nil
      raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
    end
    args = step.parse_args(stepname)
    step.perform self, *args
  end



  # Here are the step implementations

  steps_for :model do
  end



  # Here is the spec

  describe "description" do
    it "should description" do

    end
  end

Run it from TextMate:

Writing a first example

We want to have a step that takes a number and a name and that will create so much models (specified by name) as specified by number. Like this:

Given $count $models

Let's write an example: Given 1 article


  describe "Given $count $models" do
   it "should create 1 article" do
     class Article
     end
     Article.should_receive(:create).once
     step_eval "Given 1 article", :model
   end
 end

Here is the executable version:


 require 'rubygems'
 require 'active_support'
 require 'spec'
 require 'spec/matchers'
 require 'spec/story'
 require 'spec/story/step'

 # This is the function that performs the step.

 def step_eval(stepname, stepgroupname)
   type = stepname.split(/\s+/).first.to_s.downcase.to_sym
   stepname = stepname.split(/\s+/)[1,100].join(" ")
   stepgroup = steps_for stepgroupname
   step = stepgroup.find(type, stepname)
   if step == nil
     raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
   end
   args = step.parse_args(stepname)
   step.perform self, *args
 end



 # Here are the step implementations

 steps_for :model do
 end



 # Here is the spec

 describe "Given $count $models" do
   it "should create 1 article" do
     class Article
     end
     Article.should_receive(:create).once
     step_eval "Given 1 article", :model
   end
 end

Run it:

The runner didn't find the step. We have to declare it in the stepgroup:


 steps_for :model do
   
   Given "$count $models" do |count, model|
   end
   
 end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end



# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
end

Run it:

Implementing the step

The Mock (Article) expected to receive create. Let's call create on him:


  steps_for :model do

     Given "$count $models" do |count, model|
       Article.create
     end

   end

Executable:


require 'rubygems'
require 'active_support'
require 'spec'
require 'spec/matchers'
require 'spec/story'
require 'spec/story/step'

# This is the function that performs the step.

def step_eval(stepname, stepgroupname)
  type = stepname.split(/\s+/).first.to_s.downcase.to_sym
  stepname = stepname.split(/\s+/)[1,100].join(" ")
  stepgroup = steps_for stepgroupname
  step = stepgroup.find(type, stepname)
  if step == nil
    raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
  end
  args = step.parse_args(stepname)
  step.perform self, *args
end



# Here are the step implementations

steps_for :model do
   
   Given "$count $models" do |count, model|
     Article.create
   end
   
 end



# Here is the spec

describe "Given $count $models" do
  it "should create 1 article" do
    class Article
    end
    Article.should_receive(:create).once
    step_eval "Given 1 article", :model
  end
end

Run:

Green Light!

Writing a second example

Our 'Given $count $models' should not only create 1 article every time we perform it. It should also create 2 memberships, 3 assets or 17 lists. Let's write another example to specify this:

  
  describe "Given $count $models" do
    it "should create 1 article" do
      class Article
      end
      Article.should_receive(:create).once
      step_eval "Given 1 article", :model
    end

    it "should create 17 lists" do
      class List
      end
      List.should_receive(:create).exactly(17).times
      step_eval "Given 17 lists", :model
    end
  end

Executable:

  require 'rubygems'
  require 'active_support'
  require 'spec'
  require 'spec/matchers'
  require 'spec/story'
  require 'spec/story/step'

  # This is the function that performs the step.

  def step_eval(stepname, stepgroupname)
    type = stepname.split(/\s+/).first.to_s.downcase.to_sym
    stepname = stepname.split(/\s+/)[1,100].join(" ")
    stepgroup = steps_for stepgroupname
    step = stepgroup.find(type, stepname)
    if step == nil
      raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
    end
    args = step.parse_args(stepname)
    step.perform self, *args
  end



  # Here are the step implementations

  steps_for :model do

     Given "$count $models" do |count, model|
       Article.create
     end

   end



  # Here is the spec

  describe "Given $count $models" do
    it "should create 1 article" do
      class Article
      end
      Article.should_receive(:create).once
      step_eval "Given 1 article", :model
    end

    it "should create 17 lists" do
      class List
      end
      List.should_receive(:create).exactly(17).times
      step_eval "Given 17 lists", :model
    end
  end

Run the examples:

The failure message is 'undefined method `create' for Article:Class'. This is because in the second example the expectation is that the List class receives create but is the step implementation we are statically calling Article.create.

Implementing the step

We need to evaluate a constant that is specified by a string:


  steps_for :model do

     Given "$count $models" do |count, model|
       klass = eval "#{model.singularize.camelize}"
       klass.create
     end

   end

Let's try this. Heres the

Executable


  require 'rubygems'
  require 'active_support'
  require 'spec'
  require 'spec/matchers'
  require 'spec/story'
  require 'spec/story/step'

  # This is the function that performs the step.

  def step_eval(stepname, stepgroupname)
    type = stepname.split(/\s+/).first.to_s.downcase.to_sym
    stepname = stepname.split(/\s+/)[1,100].join(" ")
    stepgroup = steps_for stepgroupname
    step = stepgroup.find(type, stepname)
    if step == nil
      raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
    end
    args = step.parse_args(stepname)
    step.perform self, *args
  end



  # Here are the step implementations

  steps_for :model do

     Given "$count $models" do |count, model|
       klass = eval "#{model.singularize.camelize}"
       klass.create
     end

   end



  # Here is the spec

  describe "Given $count $models" do
    it "should create 1 article" do
      class Article
      end
      Article.should_receive(:create).once
      step_eval "Given 1 article", :model
    end

    it "should create 17 lists" do
      class List
      end
      List.should_receive(:create).exactly(17).times
      step_eval "Given 17 lists", :model
    end
  end

Run:

This is obvious: create has to be called 'count' times:


    steps_for :model do

       Given "$count $models" do |count, model|
         klass = eval "#{model.singularize.camelize}"
         count.to_i.times { klass.create }
       end

     end

Executable:

   require 'rubygems'
   require 'active_support'
   require 'spec'
   require 'spec/matchers'
   require 'spec/story'
   require 'spec/story/step'

   # This is the function that performs the step.

   def step_eval(stepname, stepgroupname)
     type = stepname.split(/\s+/).first.to_s.downcase.to_sym
     stepname = stepname.split(/\s+/)[1,100].join(" ")
     stepgroup = steps_for stepgroupname
     step = stepgroup.find(type, stepname)
     if step == nil
       raise Spec::Expectations::ExpectationNotMetError.new("Didn't find step: '#{stepname}'") 
     end
     args = step.parse_args(stepname)
     step.perform self, *args
   end



   # Here are the step implementations

   steps_for :model do

      Given "$count $models" do |count, model|
        klass = eval "#{model.singularize.camelize}"
        count.to_i.times { klass.create }
      end

    end



   # Here is the spec

   describe "Given $count $models" do
     it "should create 1 article" do
       class Article
       end
       Article.should_receive(:create).once
       step_eval "Given 1 article", :model
     end

     it "should create 17 lists" do
       class List
       end
       List.should_receive(:create).exactly(17).times
       step_eval "Given 17 lists", :model
     end
   end

Run:

Green again!

-->Part 2

Introducing StepSpecr

2008-04-21T13:02:00Z

StepSpecr is a Rails plugin intended to be used with Rspec User Stories.

StepSpecr provides a ‘testing’ framework for speccing Given/When/Then steps within Rspec examples. This lets you implement GWT-steps the BDD way.

StepSpecr is a Rails plugin intended to be used with Rspec User Stories.

StepSpecr provides a ‘testing’ framework for speccing Given/When/Then steps within Rspec examples. This lets you implement GWT-steps the BDD way.

Getting started

StepSpecr is a Rails plugin, so…

$ rails greatapp

$ cd greatapp

It’s necessary to have edge rails in order to use the plugin script with github (where stepspecr is hosted).

$ rake rails:freeze:edge

StepSpecr depends on rspec:

$ script/plugin install git://github.com/dchelimsky/rspec.git

$ script/plugin install git://github.com/dchelimsky/rspec-rails.git

$ script/generate rspec

Install StepSpecr:

$ script/plugin install git://github.com/mhennemeyer/stepspecr.git

$ script/generate stepspecr

Run the example_step_spec

By bootstraping the project (script/generate stepspecr) a example_step_spec.rb was generated. Run it now to see if everything works.

$ script/spec—format -c specdoc spec/steps/example_step_spec.rb

( I'll work on performance :) )

Spec a great step

Create a new spec file:

$ mate greatapp/spec/steps/great_step_spec.rb

The spec needs to require its helper file:

require File.expand_path(File.dirname(FILE) + ”/stepspecr_helper.rb”)

(You can copy it from the example_step_spec.)

The greatapp must have a great model to work properly

so you’ll likely write the following step in your Rspec Story:

Given a great_model

Write an example for this step:

In PROJECT_HOME/spec/steps/great_steps_spec.rb:


  require File.expand_path(File.dirname(__FILE__) + "/stepspecr_helper.rb")

  describe "Given a great_model" do
    it "should create a great_model" do
      StepSpecr.spec "Given a great_model" do 
        step_group :great_models
        before do 
          class GreatModel 
          end
          GreatModel.should_receive(:create)
        end
      end
    end
  end

The code passed to the before method in the spec block will be evaluated before the ‘Given a great_model’ step gets run.
We only want to specify what the step will do and we don’t care about if there is a GreatModel class in the system. – so we can just ‘mock’ one.
The second statement in the before block is the actual expectation we have of the behavior of the step: It should try to create a GreatModel instance.
Run the example and watch it fail:

$ script/spec—format -c specdoc spec/steps/great_steps_spec.rb

Implementation.

Create the step file:

$ mate greatapp/stories/steps/great_steps.rb

The failure message was: ‘Didn’t find step’. Let’s write the step without implementation to get a more meaningful directive:


  steps_for :great_models do
    Given "a great_model" do
    end
  end

Run the example again:

$ script/spec—format specdoc spec/steps/great_step_spec.rb

Now the system tells us what to do: ‘Mock expected :create … ‘


  steps_for :great_models do
    Given "a great_model" do
      GreatModel.create
    end
  end

Run the example again:

$ script/spec—format specdoc spec/steps/great_step_spec.rb

That’s it for a very first introduction.

While this great_step thing is not too useful, it is (for me anyway) quite convenient to have a bdd tool at hand when it comes to implementing more involved GWT-Steps.

‘Real World’-like example coming soon …

Crafting Rspec Steps with step_eval and DRYing them with a Helper
Part 2
Part 3