cucumber_factory 1.7.4 → 1.8.0

data/Gemfile

@@ -1,7 +1,7 @@
 source 'http://rubygems.org'
 
 gem 'rails', '=2.3.8'
-gem 'rspec', '=1.2.9'
-gem 'rspec-rails', '=1.2.9'
+gem 'rspec', '=1.3.2'
+gem 'rspec-rails', '=1.3.2'
 gem 'cucumber', '=0.9.3'
 gem 'jeweler'

data/Gemfile.lock

@@ -39,10 +39,10 @@ GEM
       activesupport (= 2.3.8)
       rake (>= 0.8.3)
     rake (0.8.7)
-    rspec (1.2.9)
-    rspec-rails (1.2.9)
+    rspec (1.3.2)
+    rspec-rails (1.3.2)
       rack (>= 1.0.0)
-      rspec (>= 1.2.9)
+      rspec (>= 1.3.0)
     rubyforge (2.0.4)
       json_pure (>= 1.1.7)
     term-ansicolor (1.0.5)
@@ -54,5 +54,5 @@ DEPENDENCIES
   cucumber (= 0.9.3)
   jeweler
   rails (= 2.3.8)
-  rspec (= 1.2.9)
-  rspec-rails (= 1.2.9)
+  rspec (= 1.3.2)
+  rspec-rails (= 1.3.2)

data/README.rdoc

@@ -2,41 +2,61 @@
 
 Cucumber Factory allows you to create ActiveRecord objects directly from your {Cucumber}[http://cukes.info/] features. No step definitions required.
 
+
 == Examples
 
 The following will call {Movie.make}[http://github.com/notahat/machinist], {Factory.create(:movie)}[http://github.com/thoughtbot/factory_girl], Movie.create! or Movie.new, depending on what's available:
+
     Given there is a movie
 
 To create a new record with attributes set, you can say:
-    Given there is a movie with the title "Sunshine" and the year "2007"
-
-The following will also store the created record in <tt>@sunshine</tt>:
-    Given "Sunshine" is a movie with the title "Sunshine" and the year "2007"
 
-To set associations you can refer to other records by name:
-    Given "Before Sunrise" is a movie
-    And "Before Sunset" is a movie with the prequel "Before Sunrise"
-
-You can also refer to the last created object of a kind by saying "above":
-    Given there is a movie with the title "Before Sunrise"
-    And "Before Sunset" is a movie with the prequel above
+    Given there is a movie with the title "Sunshine" and the year "2007"
 
 Boolean attributes can be set by appending "which", "that" or "who" at the end:
+
     Given there is a movie which is awesome
     And there is a movie with the name "Sunshine" that is not a comedy
     And there is a director who is popular
 
 Instead of "and" you can also use "but" and commas to join sentences:
+
     Given there is a movie which is awesome, popular and successful but not science fiction
     And there is a director with the income "500000" but with the account balance "-30000"
 
-== Factory support
+
+== Setting associations
+
+You can set <tt>belongs_to</tt> associations by referring to the last created record of a kind by saying "above":
+
+    Given there is a movie with the title "Before Sunrise"
+    And there is a movie with the prequel above
+
+The example above also shows how to set <tt>has_many</tt> associations - you simply set the <tt>belongs_to</tt> association on the other side.
+
+You can also set associations by referring to any string attribute used previously:
+
+    Given there is a movie with the title "Before Sunrise"
+    And there is a movie with the title "Limitless"
+    And there is a movie with the prequel "Before Sunrise"
+
+You can also explicitly give a record a name and use it to set a <tt>belongs_to</tt> association below:
+
+    Given "Before Sunrise" is a movie
+    And there is a movie with the title "Limitless"
+    And there is a movie with the prequel "Before Sunrise"
+
+Note that in the example above, "Before Sunrise" is only a name you can use to refer to the record. The name is not actually used for the movie title, or any other attribute value.
+
+
+== Fixture factory support
 
 {Machinist blueprints}[http://github.com/notahat/machinist] and {factory_girl factories}[http://github.com/thoughtbot/factory_girl] will be used when available.
 
 You can use named Machinist blueprint such as <tt>Movie.blueprint(:comedy)</tt> like this:
 
-    Given a movie (comedy) with the title "Groundhog Day"
+    Given there is a movie (comedy) with the title "Groundhog Day"
+
 
 == Overriding factory steps
 
@@ -50,18 +70,23 @@ If you want to override a factory step with your own version, just do so:
 
 Custom steps will always be preferred over factory steps. Also Cucumber will not raise a warning about ambiguous steps if the only other matching step is a factory step.
 
+
 == Installation and setup
 
 Cucumber Factory is a gem, which you can install with
+
     sudo gem install cucumber_factory
 
 In Rails 2, add the following to your <tt>environment.rb</tt>:
+
     config.gem 'cucumber_factory'
 
 In Rails 3, add the following to your <tt>Gemfile</tt>:
+
     gem 'cucumber_factory'
 
 Finally, create a file <tt>features/step_definitions/factory_steps.rb</tt>, which just says
+
     Cucumber::Factory.add_steps(self)
 
 

data/VERSION

@@ -1 +1 @@
-1.7.4
+1.8.0

data/cucumber_factory.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cucumber_factory}
-  s.version = "1.7.4"
+  s.version = "1.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henning Koch"]
-  s.date = %q{2010-12-02}
+  s.date = %q{2011-06-12}
   s.description = %q{Cucumber Factory allows you to create ActiveRecord models from your Cucumber features without writing step definitions for each model.}
   s.email = %q{github@makandra.de}
   s.extra_rdoc_files = [
@@ -65,32 +65,32 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Create records from Cucumber features without writing step definitions.}
   s.test_files = [
-    "spec/app_root/app/controllers/application_controller.rb",
-     "spec/app_root/app/models/job_offer.rb",
-     "spec/app_root/app/models/machinist_model.rb",
+    "spec/runtime_ext_spec.rb",
+     "spec/steps_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/factory_spec.rb",
+     "spec/app_root/db/migrate/003_create_payments.rb",
+     "spec/app_root/db/migrate/001_create_movies.rb",
+     "spec/app_root/db/migrate/004_create_actors.rb",
+     "spec/app_root/db/migrate/002_create_users.rb",
      "spec/app_root/app/models/movie.rb",
+     "spec/app_root/app/models/machinist_model.rb",
      "spec/app_root/app/models/opera.rb",
-     "spec/app_root/app/models/payment.rb",
-     "spec/app_root/app/models/plain_ruby_class.rb",
+     "spec/app_root/app/models/job_offer.rb",
      "spec/app_root/app/models/user.rb",
      "spec/app_root/app/models/people/actor.rb",
+     "spec/app_root/app/models/payment.rb",
+     "spec/app_root/app/models/plain_ruby_class.rb",
+     "spec/app_root/app/controllers/application_controller.rb",
+     "spec/app_root/lib/console_with_fixtures.rb",
      "spec/app_root/config/boot.rb",
      "spec/app_root/config/environment.rb",
+     "spec/app_root/config/routes.rb",
      "spec/app_root/config/environments/in_memory.rb",
-     "spec/app_root/config/environments/mysql.rb",
-     "spec/app_root/config/environments/postgresql.rb",
      "spec/app_root/config/environments/sqlite.rb",
+     "spec/app_root/config/environments/postgresql.rb",
      "spec/app_root/config/environments/sqlite3.rb",
-     "spec/app_root/config/routes.rb",
-     "spec/app_root/db/migrate/001_create_movies.rb",
-     "spec/app_root/db/migrate/002_create_users.rb",
-     "spec/app_root/db/migrate/003_create_payments.rb",
-     "spec/app_root/db/migrate/004_create_actors.rb",
-     "spec/app_root/lib/console_with_fixtures.rb",
-     "spec/spec_helper.rb",
-     "spec/factory_spec.rb",
-     "spec/runtime_ext_spec.rb",
-     "spec/steps_spec.rb"
+     "spec/app_root/config/environments/mysql.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/cucumber/factory.rb

@@ -1,115 +1,139 @@
-module Cucumber
-  module Factory
-    class << self
-
-      ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?'
-
-      # List of Cucumber step definitions created by #add_steps
-      attr_reader :step_definitions
-
-      def add_steps(main)
-        @step_definitions = []
-        steps.each do |step|
-          @step_definitions << (main.instance_eval do
-            Given(step[:pattern], &step[:action])
-          end)
-        end
-      end
-
-      def steps
-        # we cannot use vararg blocks here in Ruby 1.8, as explained by Aslak: http://www.ruby-forum.com/topic/182927
-        [ { :pattern => /^"([^\"]*)" is an? (.+?)( \(.+?\))?#{ATTRIBUTES_PATTERN}?$/,
-            :action => lambda { |a1, a2, a3, a4, a5| Cucumber::Factory.parse_named_creation(self, a1, a2, a3, a4, a5) } },
-          { :pattern => /^there is an? (.+?)( \(.+?\))?#{ATTRIBUTES_PATTERN}$/,
-            :action => lambda { |a1, a2, a3, a4| Cucumber::Factory.parse_creation(self, a1, a2, a3, a4) } } ]
-      end
-  
-      def parse_named_creation(world, name, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
-        record = parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
-        variable = variable_name_from_prose(name)
-        world.instance_variable_set variable, record
-      end
-    
-      def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
-        model_class = model_class_from_prose(raw_model)
-        attributes = {}
-        if raw_attributes.try(:strip).present?
-          raw_attributes.scan(/(?:the|and|with|but|,| )+(.*?) ("([^\"]*)"|above)/).each do |fragment|
-            attribute = attribute_name_from_prose(fragment[0])
-            value_type = fragment[1] # 'above' or a quoted string
-            value = fragment[2] # the value string without quotes
-            attributes[attribute] = attribute_value(world, model_class, attribute, value_type, value)
-          end
-        end
-        if raw_boolean_attributes.try(:strip).present?
-          raw_boolean_attributes.scan(/(?:which|who|that|is| )*(not )?(.+?)(?: and | but |,|$)+/).each do |fragment|
-            flag = !fragment[0] # if not ain't there, this is true
-            attribute = attribute_name_from_prose(fragment[1])
-            attributes[attribute] = flag
-          end
-        end
-        variant = raw_variant.present? && /\((.*?)\)/.match(raw_variant)[1].downcase.gsub(" ", "_")
-        create_record(model_class, variant, attributes)
-      end
-
-      private
-
-      def attribute_value(world, model_class, attribute, value_type, value)
-        association = model_class.respond_to?(:reflect_on_association) ? model_class.reflect_on_association(attribute) : nil
-        if association.present?
-          if value_type == "above"
-            # Don't use class.last, in sqlite that is not always the last inserted element
-            value = association.klass.find(:last, :order => "id") or raise "There is no last #{attribute}"
-          else
-            value = world.instance_variable_get(variable_name_from_prose(value))
-          end
-        else
-          value = world.Transform(value)
-        end
-        value
-      end
-
-      def attribute_name_from_prose(prose)
-        prose.downcase.gsub(" ", "_").to_sym
-      end
-
-      def model_class_from_prose(prose)
-        # don't use \w which depends on the system locale
-        prose.gsub(/[^A-Za-z0-9_\/]+/, "_").camelize.constantize
-      end
-      
-      def variable_name_from_prose(prose)
-        # don't use \w which depends on the system locale
-        name = prose.downcase.gsub(/[^A-Za-z0-9_]+/, '_')
-        name = name.gsub(/^_+/, '').gsub(/_+$/, '')
-        name = "_#{name}" unless name.length >= 0 && name =~ /^[a-z]/
-        :"@#{name}"
-      end
-      
-      def factory_girl_factory_name(name)
-        name.to_s.underscore.to_sym
-      end
-      
-      def create_record(model_class, variant, attributes)
-        fg_factory_name = factory_girl_factory_name(variant || model_class)
-        if defined?(::Factory) && factory = ::Factory.factories[fg_factory_name]
-          ::Factory.create(fg_factory_name, attributes)
-        elsif model_class.respond_to?(:make) # Machinist blueprint
-          if variant.present?
-            model_class.make(variant.to_sym, attributes)
-          else
-            model_class.make(attributes)
-          end
-        elsif model_class.respond_to?(:create!) # Plain ActiveRecord
-          model = model_class.new
-          model.send(:attributes=, attributes, false) # ignore attr_accessible
-          model.save!
-          model
-        else
-          model_class.new(attributes)
-        end
-      end
-
-    end
-  end
-end
+module Cucumber
+  class Factory
+
+    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?'
+
+    NAMED_RECORDS_VARIABLE = :'@named_cucumber_factory_records'
+
+    CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR = {
+      :kind => :Before,
+      :block => lambda { instance_variable_set(NAMED_RECORDS_VARIABLE, {}) }
+    }
+
+    NAMED_CREATION_STEP_DESCRIPTOR = {
+      :kind => :Given,
+      :pattern => /^"([^\"]*)" is an? (.+?)( \(.+?\))?#{ATTRIBUTES_PATTERN}?$/,
+      # we cannot use vararg blocks here in Ruby 1.8, as explained by Aslak: http://www.ruby-forum.com/topic/182927
+      :block => lambda { |a1, a2, a3, a4, a5| Cucumber::Factory.send(:parse_named_creation, self, a1, a2, a3, a4, a5) }
+    }
+
+    CREATION_STEP_DESCRIPTOR = {
+      :kind => :Given,
+      :pattern => /^there is an? (.+?)( \(.+?\))?#{ATTRIBUTES_PATTERN}$/,
+       # we cannot use vararg blocks here in Ruby 1.8, as explained by Aslak: http://www.ruby-forum.com/topic/182927
+      :block => lambda { |a1, a2, a3, a4| Cucumber::Factory.send(:parse_creation, self, a1, a2, a3, a4) }
+    }
+
+    class << self
+
+      attr_reader :step_definitions
+
+      def add_steps(main)
+        add_step(main, CREATION_STEP_DESCRIPTOR)
+        add_step(main, NAMED_CREATION_STEP_DESCRIPTOR)
+        add_step(main, CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR)
+      end
+
+      private
+
+      def add_step(main, descriptor)
+        @step_definitions ||= []
+        step_definition = main.instance_eval { send(descriptor[:kind], *[descriptor[:pattern]].compact, &descriptor[:block]) }
+        @step_definitions << step_definition
+      end
+
+      def get_named_record(world, name)
+        world.instance_variable_get(NAMED_RECORDS_VARIABLE)[name]
+      end
+
+      def set_named_record(world, name, record)
+        world.instance_variable_get(NAMED_RECORDS_VARIABLE)[name] = record
+      end
+  
+      def parse_named_creation(world, name, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
+        record = parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
+        set_named_record(world, name, record)
+      end
+    
+      def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes)
+        model_class = model_class_from_prose(raw_model)
+        attributes = {}
+        if raw_attributes.try(:strip).present?
+          raw_attributes.scan(/(?:the|and|with|but|,| )+(.*?) ("([^\"]*)"|above)/).each do |fragment|
+            attribute = attribute_name_from_prose(fragment[0])
+            value_type = fragment[1] # 'above' or a quoted string
+            value = fragment[2] # the value string without quotes
+            attributes[attribute] = attribute_value(world, model_class, attribute, value_type, value)
+          end
+        end
+        if raw_boolean_attributes.try(:strip).present?
+          raw_boolean_attributes.scan(/(?:which|who|that|is| )*(not )?(.+?)(?: and | but |,|$)+/).each do |fragment|
+            flag = !fragment[0] # if the word 'not' didn't match above, this expression is true
+            attribute = attribute_name_from_prose(fragment[1])
+            attributes[attribute] = flag
+          end
+        end
+        variant = raw_variant.present? && /\((.*?)\)/.match(raw_variant)[1].downcase.gsub(" ", "_")
+        record = create_record(model_class, variant, attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def attribute_value(world, model_class, attribute, value_type, value)
+        association = model_class.respond_to?(:reflect_on_association) ? model_class.reflect_on_association(attribute) : nil
+        if association.present?
+          if value_type == "above"
+            # Don't use class.last, in sqlite that is not always the last inserted element
+            value = association.klass.find(:last, :order => "id") or raise "There is no last #{attribute}"
+          else
+            value = get_named_record(world, value)
+          end
+        else
+          value = world.Transform(value)
+        end
+        value
+      end
+
+      def attribute_name_from_prose(prose)
+        prose.downcase.gsub(" ", "_").to_sym
+      end
+
+      def model_class_from_prose(prose)
+        # don't use \w which depends on the system locale
+        prose.gsub(/[^A-Za-z0-9_\/]+/, "_").camelize.constantize
+      end
+
+      def factory_girl_factory_name(name)
+        name.to_s.underscore.to_sym
+      end
+      
+      def create_record(model_class, variant, attributes)
+        fg_factory_name = factory_girl_factory_name(variant || model_class)
+        if defined?(::Factory) && factory = ::Factory.factories[fg_factory_name]
+          ::Factory.create(fg_factory_name, attributes)
+        elsif model_class.respond_to?(:make) # Machinist blueprint
+          if variant.present?
+            model_class.make(variant.to_sym, attributes)
+          else
+            model_class.make(attributes)
+          end
+        elsif model_class.respond_to?(:create!) # Plain ActiveRecord
+          model = model_class.new
+          model.send(:attributes=, attributes, false) # ignore attr_accessible
+          model.save!
+          model
+        else
+          model_class.new(attributes)
+        end
+      end
+
+      def remember_record_names(world, record, attributes)
+        string_values = attributes.values.select { |v| v.is_a?(String) }
+        for string_value in string_values
+          set_named_record(world, string_value, record)
+        end
+      end
+
+    end
+  end
+end

data/spec/factory_spec.rb

@@ -2,41 +2,19 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe Cucumber::Factory do
 
-  describe 'add_steps' do
-  
-    it "should add Given rules to the world" do
-      world = mock('world').as_null_object
-      world.should_receive(:Given).exactly(2).times
-      Cucumber::Factory.add_steps(world)
-    end
-    
-  end
-  
+  subject { Cucumber::Factory }
+
   describe 'model_class_from_prose' do
 
     it "should return the class matching a natural language expression" do
-      Cucumber::Factory.send(:model_class_from_prose, "movie").should == Movie
-      Cucumber::Factory.send(:model_class_from_prose, "job offer").should == JobOffer
+      subject.send(:model_class_from_prose, "movie").should == Movie
+      subject.send(:model_class_from_prose, "job offer").should == JobOffer
     end
 
     it "should allow namespaced models" do
-      Cucumber::Factory.send(:model_class_from_prose, "people/actor").should == People::Actor
+      subject.send(:model_class_from_prose, "people/actor").should == People::Actor
     end
 
   end
 
-  describe 'variable_name_from_prose' do
-  
-    it "should translate natural language to instance variable names" do
-      Cucumber::Factory.send(:variable_name_from_prose, "movie").should == :'@movie'
-      Cucumber::Factory.send(:variable_name_from_prose, "Some Movie").should == :'@some_movie'
-    end
-    
-    it "should make sure the generated instance variable names are legal" do
-      Cucumber::Factory.send(:variable_name_from_prose, "1973").should == :'@_1973'
-      Cucumber::Factory.send(:variable_name_from_prose, "%$§").should == :'@_'
-    end
-    
-  end
-
 end

data/spec/spec_helper.rb

@@ -22,12 +22,13 @@ end
 def prepare_cucumber_example
   @runtime = Cucumber::Runtime.new
   language = @runtime.load_programming_language('rb')
-  scenario = stub('scenario', :language => 'en')
+  scenario = stub('scenario', :language => 'en', :accept_hook? => true)
   language.send(:begin_scenario, scenario)
   @world = language.current_world
   @main = Object.new
   @main.extend(Cucumber::RbSupport::RbDsl)
   Cucumber::Factory.add_steps(@main)
+  @runtime.before(scenario)
 end
 
 def invoke_cucumber_step(step)

data/spec/steps_spec.rb

@@ -79,36 +79,40 @@ describe 'steps provided by cucumber_factory' do
   it "should create records with attributes" do
     movie = Movie.new
     Movie.stub(:new => movie)
-    movie.should_receive(:"attributes=").with({ :title => "Sunshine", :year => "2007" }, false)
+    movie.should_receive(:attributes=).with({ :title => "Sunshine", :year => "2007" }, false)
     invoke_cucumber_step('there is a movie with the title "Sunshine" and the year "2007"')
   end
 
   it "should allow to join attribute lists with 'and's, commas and 'but's" do
     movie = Movie.new
     Movie.stub(:new => movie)
-    movie.should_receive(:"attributes=").with({ :title => "Sunshine", :year => "2007", :box_office_result => "32000000" }, false)
+    movie.should_receive(:attributes=).with({ :title => "Sunshine", :year => "2007", :box_office_result => "32000000" }, false)
     invoke_cucumber_step('there is a movie with the title "Sunshine", the year "2007" but with the box office result "32000000"')
   end
 
   it "should apply Cucumber transforms to attribute values" do
     movie = Movie.new
     Movie.stub(:new => movie)
-    @world.should_receive(:Transform).with("value").and_return("transformed value")
-    movie.should_receive(:"attributes=").with({ :title => "transformed value" }, false)
+    @main.instance_eval do
+      Transform /^(value)$/ do |value|
+        'transformed value'
+      end
+    end
+    movie.should_receive(:attributes=).with({ :title => "transformed value" }, false)
     invoke_cucumber_step('there is a movie with the title "value"')
   end
 
   it "should create records with attributes containing spaces" do
     movie = Movie.new
     Movie.stub(:new => movie)
-    movie.should_receive(:"attributes=").with({ :box_office_result => "99999999" }, false)
+    movie.should_receive(:attributes=).with({ :box_office_result => "99999999" }, false)
     invoke_cucumber_step('there is a movie with the box office result "99999999"')
   end
 
   it "should create records with attributes containing uppercase characters" do
     user = User.new
     User.stub(:new => user)
-    user.should_receive(:"attributes=").with({ :name => "Susanne" }, false)
+    user.should_receive(:attributes=).with({ :name => "Susanne" }, false)
     invoke_cucumber_step('there is a User with the Name "Susanne"')
   end
 
@@ -119,18 +123,23 @@ describe 'steps provided by cucumber_factory' do
     payment.comment.should == 'Thanks for lending'
   end
 
-  it "should set instance variables in the world" do
-    invoke_cucumber_step('"Sunshine" is a movie with the title "Sunshine" and the year "2007"')
-    @world.instance_variable_get(:'@sunshine').title.should == "Sunshine"
+  it "should allow to name records and set a belongs_to association to that record by refering to that name" do
+    invoke_cucumber_step('"Some Prequel" is a movie with the title "Before Sunrise"')
+    invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Some Prequel"')
+    movie = Movie.find_by_title!('Before Sunset')
+    prequel = Movie.find_by_title!('Before Sunrise')
+    movie.prequel.should == prequel
   end
 
-  it "should understand pointers to instance variables" do
-    invoke_cucumber_step('"Before Sunrise" is a movie with the title "Before Sunrise"')
-    invoke_cucumber_step('"Before Sunset" is a movie with the title "Before Sunset" and the prequel "Before Sunrise"')
-    @world.instance_variable_get(:'@before_sunset').prequel.title.should == "Before Sunrise"
+  it "should allow to set a belongs_to association to a previously created record by refering to any string attribute of that record" do
+    invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
+    invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Before Sunrise"')
+    movie = Movie.find_by_title!('Before Sunset')
+    prequel = Movie.find_by_title!('Before Sunrise')
+    movie.prequel.should == prequel
   end
 
-  it "should allow to point to a previously created record through 'above'" do
+  it "should allow to set a belongs_to association to a previously created record by saying 'above'" do
     invoke_cucumber_step('there is a user with the name "Jane"')
     invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
     invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above and the prequel above')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cucumber_factory
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 55
   prerelease: false
   segments: 
   - 1
-  - 7
-  - 4
-  version: 1.7.4
+  - 8
+  - 0
+  version: 1.8.0
 platform: ruby
 authors: 
 - Henning Koch
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-02 00:00:00 +01:00
+date: 2011-06-12 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -105,29 +105,29 @@ signing_key:
 specification_version: 3
 summary: Create records from Cucumber features without writing step definitions.
 test_files: 
-- spec/app_root/app/controllers/application_controller.rb
-- spec/app_root/app/models/job_offer.rb
-- spec/app_root/app/models/machinist_model.rb
+- spec/runtime_ext_spec.rb
+- spec/steps_spec.rb
+- spec/spec_helper.rb
+- spec/factory_spec.rb
+- spec/app_root/db/migrate/003_create_payments.rb
+- spec/app_root/db/migrate/001_create_movies.rb
+- spec/app_root/db/migrate/004_create_actors.rb
+- spec/app_root/db/migrate/002_create_users.rb
 - spec/app_root/app/models/movie.rb
+- spec/app_root/app/models/machinist_model.rb
 - spec/app_root/app/models/opera.rb
-- spec/app_root/app/models/payment.rb
-- spec/app_root/app/models/plain_ruby_class.rb
+- spec/app_root/app/models/job_offer.rb
 - spec/app_root/app/models/user.rb
 - spec/app_root/app/models/people/actor.rb
+- spec/app_root/app/models/payment.rb
+- spec/app_root/app/models/plain_ruby_class.rb
+- spec/app_root/app/controllers/application_controller.rb
+- spec/app_root/lib/console_with_fixtures.rb
 - spec/app_root/config/boot.rb
 - spec/app_root/config/environment.rb
+- spec/app_root/config/routes.rb
 - spec/app_root/config/environments/in_memory.rb
-- spec/app_root/config/environments/mysql.rb
-- spec/app_root/config/environments/postgresql.rb
 - spec/app_root/config/environments/sqlite.rb
+- spec/app_root/config/environments/postgresql.rb
 - spec/app_root/config/environments/sqlite3.rb
-- spec/app_root/config/routes.rb
-- spec/app_root/db/migrate/001_create_movies.rb
-- spec/app_root/db/migrate/002_create_users.rb
-- spec/app_root/db/migrate/003_create_payments.rb
-- spec/app_root/db/migrate/004_create_actors.rb
-- spec/app_root/lib/console_with_fixtures.rb
-- spec/spec_helper.rb
-- spec/factory_spec.rb
-- spec/runtime_ext_spec.rb
-- spec/steps_spec.rb
+- spec/app_root/config/environments/mysql.rb