cucumber_factory 2.0.0 → 2.2.0

data/lib/cucumber_factory/factory.rb

@@ -2,11 +2,14 @@ module CucumberFactory
   module Factory
     class Error < StandardError; end
 
-    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?'
+    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?' # ... with the year 1979 which is science fiction
     TEXT_ATTRIBUTES_PATTERN = ' (?:with|and) these attributes:'
+    UPDATE_ATTR_PATTERN = '(?: (?:has|belongs to)( the .+?))?(?:(?: and| but|,)*( is .+?))?' # ... belongs to the collection "Fantasy" and is trending
+    TEXT_UPDATE_ATTR_PATTERN = '(?: and|,)* has these attributes:'
 
-    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?'
-    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?'
+    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?' # Given there is a movie (comedy)
+    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?' # Given "LotR" is a movie
+    RECORD_UPDATE_PATTERN = 'the (.+?) (above|".+?"|\'.+?\')' # Given the movie "LotR" ...
 
     NAMED_RECORDS_VARIABLE = :'@named_cucumber_factory_records'
 
@@ -39,9 +42,15 @@ module CucumberFactory
       :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_creation, self, a1, a2, a3, a4) }
     }
 
+    UPDATE_STEP_DESCRIPTOR = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}$/,
+      :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4) }
+    }
+
     NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
       :kind => :Given,
-      :pattern => /^"#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}?$/,
+      :pattern => /^#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}?$/,
       :block => lambda { |a1, a2, a3, a4, a5, a6, a7| CucumberFactory::Factory.send(:parse_named_creation, self, a1, a2, a3, a4, a5, a6, a7) },
       :priority => true
     }
@@ -53,6 +62,13 @@ module CucumberFactory
       :priority => true
     }
 
+    UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}#{TEXT_UPDATE_ATTR_PATTERN}$/,
+      :block => lambda { |a1, a2, a3, a4, a5| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4, a5) },
+      :priority => true
+    }
+
     class << self
 
       def add_steps(main)
@@ -61,6 +77,8 @@ module CucumberFactory
         add_step(main, CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
       end
 
       private
@@ -100,15 +118,31 @@ module CucumberFactory
       end
 
       def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
-        build_strategy = BuildStrategy.from_prose(raw_model, raw_variant)
+        build_strategy, transient_attributes = CucumberFactory::BuildStrategy.from_prose(raw_model, raw_variant)
         model_class = build_strategy.model_class
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes, transient_attributes)
+        record = build_strategy.create_record(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_update(world, raw_model, raw_name, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
+        model_class = CucumberFactory::BuildStrategy.parse_model_class(raw_model)
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes)
+        record = resolve_associated_value(world, model_class, model_class, model_class, raw_name)
+        CucumberFactory::UpdateStrategy.new(record).assign_attributes(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil, transient_attributes = [])
         attributes = {}
         if raw_attributes.try(:strip).present?
           raw_attribute_fragment_regex = /(?:the |and |with |but |,| )+(.*?) (#{VALUE_SCALAR}|#{VALUE_ARRAY}|#{VALUE_LAST_RECORD})/
           raw_attributes.scan(raw_attribute_fragment_regex).each do |fragment|
             attribute = attribute_name_from_prose(fragment[0])
             value = fragment[1]
-            attributes[attribute] = attribute_value(world, model_class, attribute, value)
+            attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
           end
           unused_raw_attributes = raw_attributes.gsub(raw_attribute_fragment_regex, '')
           if unused_raw_attributes.present?
@@ -129,46 +163,71 @@ module CucumberFactory
               raw_attribute, value = fragment.split(': ')
               attribute = attribute_name_from_prose(raw_attribute)
               value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
-              attributes[attribute] = attribute_value(world, model_class, attribute, value)
+              attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           # DataTable e.g. in raw [["first name", "Jane"], ["last name", "Jenny"]]
           else
             raw_multiline_attributes.raw.each do |raw_attribute, value|
               attribute = attribute_name_from_prose(raw_attribute)
               value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
-              attributes[attribute] = attribute_value(world, model_class, attribute, value)
+              attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           end
         end
-        record = build_strategy.create_record(attributes)
-        remember_record_names(world, record, attributes)
-        record
+        attributes
       end
 
-      def attribute_value(world, model_class, attribute, value)
-        association = model_class.respond_to?(:reflect_on_association) ? model_class.reflect_on_association(attribute) : nil
-
-        if matches_fully?(value, VALUE_ARRAY)
-          elements_str = unquote(value)
-          value = elements_str.scan(VALUE_SCALAR).map { |v| attribute_value(world, model_class, attribute, v) }
-        elsif association.present?
-          if matches_fully?(value, VALUE_LAST_RECORD)
-            value = CucumberFactory::Switcher.find_last(association.klass) or raise Error, "There is no last #{attribute}"
-          elsif matches_fully?(value, VALUE_STRING)
-            value = unquote(value)
-            value = get_named_record(world, value) || transform_value(world, value)
-          elsif matches_fully?(value, VALUE_INTEGER)
-            value = value.to_s
-            value = get_named_record(world, value) || transform_value(world, value)
-          else
-            raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
-          end
+      def attribute_value(world, model_class, transient_attributes, attribute, value)
+        associated, association_class = resolve_association(attribute, model_class, transient_attributes)
+
+        value = if matches_fully?(value, VALUE_ARRAY)
+          array_values = unquote(value).scan(VALUE_SCALAR)
+          array_values.map { |v| attribute_value(world, model_class, transient_attributes, attribute, v) }
+        elsif associated
+          resolve_associated_value(world, model_class, association_class, attribute, value)
         else
-          value = resolve_scalar_value(world, model_class, attribute, value)
+          resolve_scalar_value(world, model_class, attribute, value)
         end
         value
       end
 
+      def resolve_association(attribute, model_class, transient_attributes)
+        return unless model_class.respond_to?(:reflect_on_association)
+
+        association = model_class.reflect_on_association(attribute)
+        association_class = nil
+
+        if association
+          association_class = association.klass unless association.polymorphic?
+          associated = true
+        elsif transient_attributes.include?(attribute.to_sym)
+          klass_name = attribute.to_s.camelize
+          if Object.const_defined?(klass_name)
+            association_class = klass_name.constantize
+            associated = true
+          end
+        else
+          associated = false
+        end
+        [associated, association_class]
+      end
+
+      def resolve_associated_value(world, model_class, association_class, attribute, value)
+        if matches_fully?(value, VALUE_LAST_RECORD)
+          raise(Error, "Cannot set last #{model_class}##{attribute} for polymorphic associations") unless association_class.present?
+
+          CucumberFactory::Switcher.find_last(association_class) || raise(Error, "There is no last #{attribute}")
+        elsif matches_fully?(value, VALUE_STRING)
+          value = unquote(value)
+          get_named_record(world, value) || transform_value(world, value)
+        elsif matches_fully?(value, VALUE_INTEGER)
+          value = value.to_s
+          get_named_record(world, value) || transform_value(world, value)
+        else
+          raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
+        end
+      end
+
       def resolve_scalar_value(world, model_class, attribute, value)
         if matches_fully?(value, VALUE_STRING)
           value = unquote(value)

data/lib/cucumber_factory/update_strategy.rb

@@ -0,0 +1,30 @@
+module CucumberFactory
+
+  class UpdateStrategy
+
+    def initialize(record)
+      @record = record
+    end
+
+    def assign_attributes(attributes)
+      active_record_strategy(attributes) ||
+        ruby_object_strategy(attributes)
+    end
+
+    private
+
+    def active_record_strategy(attributes)
+      return unless @record.respond_to?(:save!)
+
+      CucumberFactory::Switcher.assign_attributes(@record, attributes)
+      @record.save!
+    end
+
+    def ruby_object_strategy(attributes)
+      attributes.each do |name, value|
+        @record.send("#{name}=".to_sym, value)
+      end
+    end
+
+  end
+end

data/lib/cucumber_factory/version.rb

@@ -1,3 +1,3 @@
 module CucumberFactory
-  VERSION = '2.0.0'
+  VERSION = '2.2.0'
 end

data/spec/cucumber_factory/factory/build_strategy_spec.rb

@@ -2,47 +2,45 @@ require 'spec_helper'
 
 describe CucumberFactory::BuildStrategy do
 
-  subject { CucumberFactory::BuildStrategy }
-
   # most of the behaviour is integration tested in steps_spec.rb
 
   describe '.from_prose' do
 
     context 'when describing a factory_bot factory' do
-
-      it 'returns a strategy corresponding to the factories model' do
-        FactoryBot.stub_factories :job_offer => JobOffer
-        strategy = subject.from_prose('job offer', nil)
+      it 'returns a strategy and transient attributes corresponding to the factories model' do
+        strategy, transient_attributes = described_class.from_prose('job offer', nil)
 
         strategy.should be_a(described_class)
         strategy.model_class.should == JobOffer
+        transient_attributes.should == [:my_transient_attribute]
       end
 
       it 'uses the variant for the factory name if present' do
-        FactoryBot.stub_factories :job_offer => JobOffer
-        strategy = subject.from_prose('foo', '(job offer)')
+        strategy, transient_attributes = described_class.from_prose('job offer', '(tempting_job_offer)')
 
         strategy.should be_a(described_class)
         strategy.model_class.should == JobOffer
+        transient_attributes.should == [:my_transient_attribute, :other_transient_attribute]
       end
-
     end
 
     context 'when describing a non factory_bot model' do
+      before do
+        hide_const("FactoryBot")
+      end
 
       it "should return a strategy for the class matching a natural language expression" do
-        subject.from_prose("movie", nil).model_class.should == Movie
-        subject.from_prose("job offer", nil).model_class.should == JobOffer
+        described_class.from_prose("movie", nil).first.model_class.should == Movie
+        described_class.from_prose("job offer", nil).first.model_class.should == JobOffer
       end
 
       it "should ignore variants for the class name" do
-        subject.from_prose("movie", "(job offer)").model_class.should == Movie
+        described_class.from_prose("movie", "(job offer)").first.model_class.should == Movie
       end
 
       it "should allow namespaced models" do
-        subject.from_prose("people/actor", nil).model_class.should == People::Actor
+        described_class.from_prose("people/actor", nil).first.model_class.should == People::Actor
       end
-
     end
 
   end

data/spec/cucumber_factory/steps_spec.rb

@@ -1,468 +1,608 @@
 require 'spec_helper'
 
-describe 'steps provided by cucumber_factory' do
+TRANSFORMS_SUPPORTED = Cucumber::VERSION < '3'
 
+describe 'steps provided by cucumber_factory' do
   before(:each) do
     prepare_cucumber_example
   end
 
-  TRANSFORMS_SUPPORTED = Cucumber::VERSION < '3'
+  context 'FactoryBot' do
+    it "should create ActiveRecord models by calling #new and #save!" do
+      movie = Movie.new
+      Movie.should_receive(:new).with(no_args).and_return(movie)
+      movie.should_receive(:save!)
+      invoke_cucumber_step("there is a movie")
+    end
 
-  it "should create ActiveRecord models by calling #new and #save!" do
-    movie = Movie.new
-    Movie.should_receive(:new).with(no_args).and_return(movie)
-    movie.should_receive(:save!)
-    invoke_cucumber_step("there is a movie")
-  end
+    it "should create models that have a factory_bot factory by calling #FactoryBot.create(:model_name)" do
+      FactoryBot.should_receive(:create).with(:job_offer, { :title => "Awesome job" })
+      invoke_cucumber_step('there is a job offer with the title "Awesome job"')
+    end
 
-  it "should create models that have a machinist blueprint by calling #make" do
-    MachinistModel.should_receive(:make).with({ :attribute => "foo"})
-    invoke_cucumber_step('there is a machinist model with the attribute "foo"')
-  end
+    it "should create model variants that have a factory_bot factory by calling #FactoryBot.create(:variant)" do
+      FactoryBot.should_receive(:create).with(:job_offer, :tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
+      invoke_cucumber_step('there is a job offer (tempting job offer) with the title "Awesomafiablyfantasmic job"')
+    end
 
-  it "should be able to step_match machinist blueprint variants" do
-    MachinistModel.should_receive(:make).with(:variant, { :attribute => "foo"})
-    invoke_cucumber_step('there is a machinist model (variant) with the attribute "foo"')
-  end
+    it "should create model variants that have a factory_bot trait by calling #FactoryBot.create(:factory, :trait1, :trait2)" do
+      FactoryBot.should_receive(:create).with(:job_offer, :risky, :lucrative, { :title => "Awesomafiablyfantasmic job" })
+      invoke_cucumber_step('there is a job offer (risky, lucrative) with the title "Awesomafiablyfantasmic job"')
+    end
 
-  it "should be able to step_match machinist blueprint variants containing spaces or uppercase characters in prose" do
-    MachinistModel.should_receive(:make).with(:variant_mark_two, { :attribute => "foo"})
-    invoke_cucumber_step('there is a machinist model (Variant Mark Two) with the attribute "foo"')
-  end
+    it "should create model variants that have a factory_bot factory by using the model name as a factory name" do
+      FactoryBot.should_receive(:create).with(:job_offer, { :title => "Awesomafiablyfantasmic job" })
+      invoke_cucumber_step('there is a job offer with the title "Awesomafiablyfantasmic job"')
+    end
 
-  it "should create models that have a factory_bot factory by calling #FactoryBot.create(:model_name)" do
-    FactoryBot.stub_factories :job_offer => JobOffer
-    FactoryBot.should_receive(:create).with(:job_offer, { :title => "Awesome job" })
-    invoke_cucumber_step('there is a job offer with the title "Awesome job"')
-  end
+    it "should instantiate classes with multiple words in their name" do
+      job_offer = JobOffer.new
+      JobOffer.should_receive(:new).with(no_args).and_return(job_offer)
+      invoke_cucumber_step("there is a job offer")
+    end
 
-  it "should create model variants that have a factory_bot factory by calling #FactoryBot.create(:variant)" do
-    FactoryBot.stub_factories :tempting_job_offer => JobOffer
-    FactoryBot.should_receive(:create).with(:tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
-    invoke_cucumber_step('there is a job offer (tempting job offer) with the title "Awesomafiablyfantasmic job"')
-  end
+    it "should instantiate classes with uppercase characters in their name" do
+      user = User.new
+      User.should_receive(:new).and_return(user)
+      invoke_cucumber_step("there is a User")
+    end
 
-  it "should create model variants that have a factory_bot trait by calling #FactoryBot.create(:factory, :trait1, :trait2)" do
-    FactoryBot.stub_factories :tempting_job_offer => JobOffer
-    FactoryBot.should_receive(:create).with(:tempting_job_offer, :risky, :lucrative, { :title => "Awesomafiablyfantasmic job" })
-    invoke_cucumber_step('there is a tempting job offer (risky, lucrative) with the title "Awesomafiablyfantasmic job"')
-  end
+    it "should allow either 'a' or 'an' for the article" do
+      opera = Opera.new
+      Opera.should_receive(:new).with(no_args).and_return(opera)
+      invoke_cucumber_step("there is an opera")
+    end
 
-  it "should create model variants that have a factory_bot factory by using the model name as a factory name" do
-    FactoryBot.stub_factories :tempting_job_offer => JobOffer
-    FactoryBot.should_receive(:create).with(:tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
-    invoke_cucumber_step('there is a tempting job offer with the title "Awesomafiablyfantasmic job"')
-  end
+    it "should create records with attributes" do
+      movie = Movie.new
+      Movie.stub(:new => movie)
+      invoke_cucumber_step('there is a movie with the title "Sunshine" and the year "2007"')
+      movie.title.should == "Sunshine"
+      movie.year.should == 2007
+    end
 
-  it "should instantiate plain ruby classes by calling #new" do
-    PlainRubyClass.should_receive(:new).with({})
-    invoke_cucumber_step("there is a plain ruby class")
-  end
+    it "should allow to join attribute lists with 'and's, commas and 'but's" do
+      movie = Movie.new
+      Movie.stub(:new => movie)
+      invoke_cucumber_step('there is a movie with the title "Sunshine", the year "2007" but with the box office result "32000000"')
+      movie.title.should == "Sunshine"
+      movie.year.should == 2007
+      movie.box_office_result.should == 32000000
+    end
 
-  it "should instantiate classes with multiple words in their name" do
-    JobOffer.should_receive(:new).with({})
-    invoke_cucumber_step("there is a job offer")
-  end
+    if TRANSFORMS_SUPPORTED
+      it "should apply Cucumber transforms to attribute values" do
+        movie = Movie.new
+        Movie.stub(:new => movie)
+        @main.instance_eval do
+          Transform /^(value)$/ do |value|
+            'transformed value'
+          end
+        end
+        invoke_cucumber_step('there is a movie with the title "value"')
+        movie.title.should == "transformed value"
+      end
+    end
 
-  it "should instantiate classes with uppercase characters in their name" do
-    user = User.new
-    User.should_receive(:new).and_return(user)
-    invoke_cucumber_step("there is a User")
-  end
+    it "should create records with attributes containing spaces" do
+      movie = Movie.new
+      Movie.stub(:new => movie)
+      invoke_cucumber_step('there is a movie with the box office result "99999999"')
+      movie.box_office_result.should == 99999999
+    end
 
-  it "should instantiate namespaced classes" do
-    actor = People::Actor.new
-    People::Actor.should_receive(:new).and_return(actor)
-    invoke_cucumber_step("there is a people/actor")
-  end
+    it "should create records with attributes containing uppercase characters" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a User with the Name "Susanne"')
+      user.name.should == "Susanne"
+    end
 
-  it "should allow either 'a' or 'an' for the article" do
-    Opera.should_receive(:new).with({})
-    invoke_cucumber_step("there is an opera")
-  end
+    it "should override attr_accessible protection" do
+      invoke_cucumber_step('there is a payment with the amount "120" and the comment "Thanks for lending"')
+      payment = Payment.last
+      payment.amount.should == 120
+      payment.comment.should == 'Thanks for lending'
+    end
 
-  it "should create records with attributes" do
-    movie = Movie.new
-    Movie.stub(:new => movie)
-    invoke_cucumber_step('there is a movie with the title "Sunshine" and the year "2007"')
-    movie.title.should == "Sunshine"
-    movie.year.should == 2007
-  end
+    it "should allow to set an explicit primary key" do
+      invoke_cucumber_step('there is a payment with the ID 2')
+      payment = Payment.last
+      payment.id.should == 2
+    end
 
-  it "should allow to join attribute lists with 'and's, commas and 'but's" do
-    movie = Movie.new
-    Movie.stub(:new => movie)
-    invoke_cucumber_step('there is a movie with the title "Sunshine", the year "2007" but with the box office result "32000000"')
-    movie.title.should == "Sunshine"
-    movie.year.should == 2007
-    movie.box_office_result.should == 32000000
-  end
+    it "should allow to name records and set a belongs_to association to that record by referring 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 "Limitless"')
+      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
 
-  if TRANSFORMS_SUPPORTED
-    it "should apply Cucumber transforms to attribute values" do
-      movie = Movie.new
-      Movie.stub(:new => movie)
-      @main.instance_eval do
-        Transform /^(value)$/ do |value|
-          'transformed value'
+    it "should allow to set a belongs_to association to a previously created record by referring 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 "Limitless"')
+      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 set a belongs_to association to a previously updated record by referring to any string attribute used when updating" do
+      invoke_cucumber_step('there is a movie')
+      invoke_cucumber_step('the movie above has the title "Before Sunrise"')
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      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 set a belongs_to association to a previously created record by referring to their explicitely set primary keys" do
+      invoke_cucumber_step('there is a movie with the ID 123')
+      invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel 123')
+      movie = Movie.find_by_title!('Before Sunset')
+      prequel = Movie.find(123)
+      movie.prequel.should == prequel
+    end
+
+    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 user with the name "John"')
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      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')
+      before_sunset = Movie.find_by_title!("Before Sunset")
+      before_sunset.prequel.title.should == "Before Sunrise"
+      before_sunset.reviewer.name.should == "John"
+    end
+
+    if TRANSFORMS_SUPPORTED
+      it "should fallback to using transforms when no named record is found" do
+        user = User.create!(:name => 'Me')
+        @main.instance_eval do
+          Transform(/^(me)$/) do |value|
+            user
+          end
         end
+        invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "me"')
+        before_sunset = Movie.find_by_title!("Before Sunset")
+        before_sunset.reviewer.should == user
       end
-      invoke_cucumber_step('there is a movie with the title "value"')
-      movie.title.should == "transformed value"
     end
-  end
 
-  it "should create records with attributes containing spaces" do
-    movie = Movie.new
-    Movie.stub(:new => movie)
-    invoke_cucumber_step('there is a movie with the box office result "99999999"')
-    movie.box_office_result.should == 99999999
-  end
+    it "should give created_at precedence over id when saying 'above' if the primary key is not numeric" do
+      invoke_cucumber_step('there is a uuid user with the name "Jane" and the id "jane"')
+      invoke_cucumber_step('there is a uuid user with the name "John" and the id "john"')
+      UuidUser.find_by_name("John").update_attributes!(:created_at => 1.day.ago)
+      invoke_cucumber_step('there is a movie with the title "Before Sunset" and the uuid reviewer above')
+      before_sunset = Movie.find_by_title!("Before Sunset")
+      before_sunset.uuid_reviewer.name.should == "Jane"
+    end
 
-  it "should create records with attributes containing uppercase characters" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a User with the Name "Susanne"')
-    user.name.should == "Susanne"
-  end
+    it "should ignore created_at if the primary key is numeric" do
+      invoke_cucumber_step('there is a user with the name "Jane"')
+      invoke_cucumber_step('there is a user with the name "John"')
+      User.find_by_name("John").update_attributes!(:created_at => 1.day.ago)
+      invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above')
+      before_sunset = Movie.find_by_title!("Before Sunset")
+      before_sunset.reviewer.name.should == "John"
+    end
 
-  it "should override attr_accessible protection" do
-    invoke_cucumber_step('there is a payment with the amount "120" and the comment "Thanks for lending"')
-    payment = Payment.last
-    payment.amount.should == 120
-    payment.comment.should == 'Thanks for lending'
-  end
+    it "should raise a proper error if there is no previous record when saying 'above'" do
+      lambda do
+        invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above and the prequel above')
+      end.should raise_error(/There is no last reviewer/i)
+    end
 
-  it "should allow to set an explicit primary key" do
-    invoke_cucumber_step('there is a payment with the ID 2')
-    payment = Payment.last
-    payment.id.should == 2
-  end
+    it "should reload an object assigned to a belongs_to before assigning" do
+      invoke_cucumber_step('"Jane" is a user who is deleted')
+      User.last.update_attributes(:deleted => false)
+      proc { invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "Jane"') }.should_not raise_error
+    end
 
-  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 "Limitless"')
-    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 allow to set positive boolean attributes with 'who' after the attribute list" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user with the name "Jane" who is deleted')
+      user.name.should == "Jane"
+      user.deleted.should == true
+    end
 
-  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 "Limitless"')
-    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 name records and set a belongs_to association to that record by referring 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 "Limitless"')
+      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 allow to set a belongs_to association to a previously created record by refering to their explicitely set primary keys" do
-    invoke_cucumber_step('there is a movie with the ID 123')
-    invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel 123')
-    movie = Movie.find_by_title!('Before Sunset')
-    prequel = Movie.find(123)
-    movie.prequel.should == prequel
-  end
+    it "should allow to set positive boolean attributes with 'which' after the attribute list" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user with the name "Jane" which is deleted')
+      user.name.should == "Jane"
+      user.deleted.should == true
+    end
 
-  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 user with the name "John"')
-    invoke_cucumber_step('there is a movie with the title "Limitless"')
-    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')
-    before_sunset = Movie.find_by_title!("Before Sunset")
-    before_sunset.prequel.title.should == "Before Sunrise"
-    before_sunset.reviewer.name.should == "John"
-  end
+    it "should allow to set positive boolean attributes with 'that' after the attribute list" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user with the name "Jane" that is deleted')
+      user.name.should == "Jane"
+      user.deleted.should == true
+    end
 
-  if TRANSFORMS_SUPPORTED
-    it "should fallback to using transforms when no named record is found" do
-      user = User.create!(:name => 'Me')
-      @main.instance_eval do
-        Transform(/^(me)$/) do |value|
-          user
-        end
-      end
-      invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "me"')
-      before_sunset = Movie.find_by_title!("Before Sunset")
-      before_sunset.reviewer.should == user
+    it "should allow to set boolean attributes without regular attributes preceding them" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user who is deleted')
+      user.deleted.should == true
     end
-  end
 
-  it "should give created_at precedence over id when saying 'above' if the primary key is not numeric" do
-    invoke_cucumber_step('there is a uuid user with the name "Jane" and the id "jane"')
-    invoke_cucumber_step('there is a uuid user with the name "John" and the id "john"')
-    UuidUser.find_by_name("John").update_attributes!(:created_at => 1.day.ago)
-    invoke_cucumber_step('there is a movie with the title "Before Sunset" and the uuid reviewer above')
-    before_sunset = Movie.find_by_title!("Before Sunset")
-    before_sunset.uuid_reviewer.name.should == "Jane"
-  end
+    it "should allow to set negative boolean attribute" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user who is not deleted')
+      user.deleted.should == false
+    end
 
-  it "should ignore created_at if the primary key is numeric" do
-    invoke_cucumber_step('there is a user with the name "Jane"')
-    invoke_cucumber_step('there is a user with the name "John"')
-    User.find_by_name("John").update_attributes!(:created_at => 1.day.ago)
-    invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above')
-    before_sunset = Movie.find_by_title!("Before Sunset")
-    before_sunset.reviewer.name.should == "John"
-  end
+    it "should allow to set multiple boolean attributes" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user who is locked and not deleted and subscribed')
+      user.locked.should == true
+      user.deleted.should == false
+      user.subscribed.should == true
+    end
 
-  it "should raise a proper error if there is no previous record when saying 'above'" do
-    lambda do
-      invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above and the prequel above')
-    end.should raise_error(/There is no last reviewer/i)
-  end
+    it "should allow to set boolean attributes that are named from multiple words" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user who is locked and not scared and scared by spiders and deleted')
+      user.locked.should == true
+      user.scared.should == false
+      user.scared_by_spiders.should == true
+      user.deleted.should == true
+    end
 
-  it "should reload an object assigned to a belongs_to before assigning" do
-    invoke_cucumber_step('"Jane" is a user who is deleted')
-    User.last.update_attributes(:deleted => false)
-    proc { invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "Jane"') }.should_not raise_error
-  end
+    it "should allow to join boolean attribute lists with 'and's, commas and 'but's" do
+      user = User.new
+      User.stub(:new => user)
+      invoke_cucumber_step('there is a user who is locked, scared, but scared by spiders and deleted')
+      user.locked.should == true
+      user.scared.should == true
+      user.scared_by_spiders.should == true
+      user.deleted.should == true
+    end
 
-  it "should allow to set positive boolean attributes with 'who' after the attribute list" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user with the name "Jane" who is deleted')
-    user.name.should == "Jane"
-    user.deleted.should == true
-  end
+    it "should allow to set a has_many association by referring to multiple named records in square brackets" do
+      invoke_cucumber_step('there is a movie with the title "Sunshine"')
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      invoke_cucumber_step('there is a user with the reviewed movies ["Sunshine" and "Limitless"]')
+      user = User.last
+      reviewed_movie_titles = user.reviewed_movies.map(&:title)
+      reviewed_movie_titles.should =~ ['Sunshine', 'Limitless']
+    end
 
-  it "should allow to set positive boolean attributes with 'which' after the attribute list" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user with the name "Jane" which is deleted')
-    user.name.should == "Jane"
-    user.deleted.should == true
-  end
+    it 'allow associations for transient attributes if they are named after the associated model' do
+      invoke_cucumber_step('there is a movie with the title "Sunshine"')
+      invoke_cucumber_step('there is a user with the movie "Sunshine"')
+      user = User.last
+      user.reviewed_movies.count.should == 1
+      user.reviewed_movies.first.title.should == 'Sunshine'
+    end
 
-  it "should allow to set positive boolean attributes with 'that' after the attribute list" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user with the name "Jane" that is deleted')
-    user.name.should == "Jane"
-    user.deleted.should == true
-  end
+    it "should allow to set attributes via doc string" do
+      user = User.new
+      User.stub(:new => user)
 
-  it "should allow to set boolean attributes without regular attributes preceding them" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user who is deleted')
-    user.deleted.should == true
-  end
+      invoke_cucumber_step('there is a user with these attributes:', <<-DOC_STRING)
+name: Jane
+locked: true
+      DOC_STRING
 
-  it "should allow to set negative boolean attribute" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user who is not deleted')
-    user.deleted.should == false
-  end
+      user.name.should == "Jane"
+      user.locked.should == true
+    end
 
-  it "should allow to set multiple boolean attributes" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user who is locked and not deleted and subscribed')
-    user.locked.should == true
-    user.deleted.should == false
-    user.subscribed.should == true
-  end
+    it "should allow to set attributes via additional doc string" do
+      user = User.new
+      User.stub(:new => user)
 
-  it "should allow to set boolean attributes that are named from multiple words" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user who is locked and not scared and scared by spiders and deleted')
-    user.locked.should == true
-    user.scared.should == false
-    user.scared_by_spiders.should == true
-    user.deleted.should == true
-  end
+      invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', <<-DOC_STRING)
+name: Jane
+      DOC_STRING
 
-  it "should allow to join boolean attribute lists with 'and's, commas and 'but's" do
-    user = User.new
-    User.stub(:new => user)
-    invoke_cucumber_step('there is a user who is locked, scared, but scared by spiders and deleted')
-    user.locked.should == true
-    user.scared.should == true
-    user.scared_by_spiders.should == true
-    user.deleted.should == true
-  end
+      user.name.should == "Jane"
+      user.email.should == "test@invalid.com"
+    end
 
-  it "should allow to set integer attributes without surrounding quotes" do
-    invoke_cucumber_step('there is a plain Ruby class with the amount 123 and the total 456')
-    obj = PlainRubyClass.last
-    obj.attributes[:amount].should == 123
-    obj.attributes[:total].should == 456
-  end
+    it 'should allow named records when setting attributes via doc string' do
+      invoke_cucumber_step('"Some Prequel" is a movie with these attributes:', <<-DOC_STRING)
+title: Before Sunrise
+      DOC_STRING
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      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 allow to set decimal attributes without surrounding quotes" do
-    invoke_cucumber_step('there is a plain Ruby class with the amount 1.23 and the total 45.6')
-    obj = PlainRubyClass.last
-    obj.attributes[:amount].should be_a(BigDecimal)
-    obj.attributes[:amount].to_s.should == "1.23"
-    obj.attributes[:total].should be_a(BigDecimal)
-    obj.attributes[:total].to_s.should == "45.6"
-  end
+    it "should allow to set attributes via data table" do
+      user = User.new
+      User.stub(:new => user)
 
-  it "should allow set an array of strings with square brackets" do
-    invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar"] and the list ["bam", "baz"]')
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == ['foo', 'bar']
-    obj.attributes[:list].should == ['bam', 'baz']
-  end
+      invoke_cucumber_step('there is a user with these attributes:', nil, <<-DATA_TABLE)
+| name   | Jane |
+| locked | true |
+      DATA_TABLE
 
-  it "should allow set an array of numbers with square brackets" do
-    invoke_cucumber_step('there is a plain Ruby class with the integers [1, 2] and the decimals [3.4, 4.5]')
-    obj = PlainRubyClass.last
-    obj.attributes[:integers].should == [1, 2]
-    obj.attributes[:decimals].should == [BigDecimal('3.4'), BigDecimal('4.5')]
-  end
+      user.name.should == "Jane"
+      user.locked.should == true
+    end
 
-  it 'should allow to set an empty array' do
-    invoke_cucumber_step('there is a plain Ruby class with the tags []')
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == []
-  end
+    it "should allow to set attributes via additional data table" do
+      user = User.new
+      User.stub(:new => user)
 
-  it 'should allow to separate array values with either a comma or "and"' do
-    invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar" and "baz"] and the list ["bam", "baz" and "qux"]')
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == ['foo', 'bar', 'baz']
-    obj.attributes[:list].should == ['bam', 'baz', 'qux']
-  end
+      invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', nil, <<-DATA_TABLE)
+| name | Jane |
+      DATA_TABLE
 
-  it 'should allow to separate array values with an Oxford comma' do
-    invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar", and "baz"] and the list ["bam", "baz", and "qux"]')
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == ['foo', 'bar', 'baz']
-    obj.attributes[:list].should == ['bam', 'baz', 'qux']
-  end
+      user.name.should == "Jane"
+      user.email.should == "test@invalid.com"
+    end
 
-  it "should allow to set a has_many association by refering to multiple named records in square brackets" do
-    invoke_cucumber_step('there is a movie with the title "Sunshine"')
-    invoke_cucumber_step('there is a movie with the title "Limitless"')
-    invoke_cucumber_step('there is a user with the reviewed movies ["Sunshine" and "Limitless"]')
-    user = User.last
-    reviewed_movie_titles = user.reviewed_movies.map(&:title)
-    reviewed_movie_titles.should =~ ['Sunshine', 'Limitless']
-  end
+    it 'should allow named records when setting attributes via data table' do
+      invoke_cucumber_step('"Some Prequel" is a movie with these attributes:', nil, <<-DATA_TABLE)
+| title | Before Sunrise |
+      DATA_TABLE
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      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 allow attribute names starting with 'the'" do
-    PlainRubyClass.should_receive(:new).with({:theme => 'Sci-fi'})
-    invoke_cucumber_step('there is a plain ruby class with the theme "Sci-fi"')
-  end
+    it "should allow mixed single quotes for model names" do
+      invoke_cucumber_step("'Some Prequel' is a movie with the title \"Before Sunrise\"")
+      invoke_cucumber_step('there is a movie with the title "Limitless"')
+      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 allow attribute names starting with 'and'" do
-    PlainRubyClass.should_receive(:new).with({:android => 'Paranoid'})
-    invoke_cucumber_step('there is a plain ruby class with the android "Paranoid"')
-  end
+    it 'supports named associations with polymorphic associations' do
+      invoke_cucumber_step('"my opera" is an opera')
+      invoke_cucumber_step('there is a movie with the premiere site "my opera"')
+    end
 
-  it "should allow attribute names starting with 'with'" do
-    PlainRubyClass.should_receive(:new).with({:withdrawal => 'bank_account'})
-    invoke_cucumber_step('there is a plain ruby class with the withdrawal "bank_account"')
-  end
+    it 'does not support last record references with polymorphic associations as the target class cannot be guessed' do
+      invoke_cucumber_step('there is an opera')
+      expect {
+        invoke_cucumber_step('there is a movie with the premiere site above')
+      }.to raise_error(CucumberFactory::Factory::Error, 'Cannot set last Movie#premiere_site for polymorphic associations')
+    end
 
-  it "should allow attribute names starting with 'but'" do
-    PlainRubyClass.should_receive(:new).with({:butt => 'pear-shaped'})
-    invoke_cucumber_step('there is a plain ruby class with the butt "pear-shaped"')
-  end
+    it 'works with nested factories (BUGFIX)' do
+      invoke_cucumber_step('there is a subgenre movie')
+    end
 
-  it "should allow to set attributes via doc string" do
-    user = User.new
-    User.stub(:new => user)
+    describe 'references to named records are tracked correctly' do
+      # CucumberFactory keeps track of all created records by their attributes.
+      # For example, if you create a user with the name "Peter" you can reference him later on as "Peter".
 
-    invoke_cucumber_step('there is a user with these attributes:', <<-DOC_STRING)
-name: Jane
-locked: true
-    DOC_STRING
+      it 'does not overwrite existing references when associating new records with another reference (BUGFIX)' do
+        invoke_cucumber_step('"reviewer" is a user with the id "1"')
+        movie1 = invoke_cucumber_step('there is a movie with the reviewer "reviewer" and the id "2"') # <- should not overwrite the 'reviewer' reference
+        movie2 = invoke_cucumber_step('there is a movie with the reviewer "reviewer" and the id "3"')
+
+        expect(movie1.reviewer_id).to eq(1)
+        expect(movie2.reviewer_id).to eq(1)
+      end
 
-    user.name.should == "Jane"
-    user.locked.should == true
+      it 'does not set new references when setting primary keys of an association (BUGFIX)' do
+        movie1 = invoke_cucumber_step('there is a movie with the id "123" and the user id "456"')  # <- should not set a '456' reference
+        movie2 = invoke_cucumber_step('there is a movie with the user id "456"')
+
+        expect(movie1.reviewer_id).to eq(456)
+        expect(movie2.reviewer_id).to eq(456)
+      end
+    end
   end
 
-  it "should allow to set attributes via additional doc string" do
-    user = User.new
-    User.stub(:new => user)
+  context 'without FactoryBot' do
+    before do
+      hide_const("FactoryBot")
+    end
 
-    invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', <<-DOC_STRING)
-name: Jane
-    DOC_STRING
+    it "should instantiate plain ruby classes by calling #new" do
+      PlainRubyClass.should_receive(:new).with({})
+      invoke_cucumber_step("there is a plain ruby class")
+    end
 
-    user.name.should == "Jane"
-    user.email.should == "test@invalid.com"
-  end
+    it "should instantiate namespaced classes" do
+      actor = People::Actor.new
+      People::Actor.should_receive(:new).and_return(actor)
+      invoke_cucumber_step("there is a people/actor")
+    end
 
-  it "should allow to set array attributes via doc string" do
-    invoke_cucumber_step('there is a plain Ruby class with these attributes:', <<-DOC_STRING)
-tags: ["foo", "bar"]
-    DOC_STRING
+    it "should allow to set integer attributes without surrounding quotes" do
+      invoke_cucumber_step('there is a plain Ruby class with the amount 123 and the total 456')
+      obj = PlainRubyClass.last
+      obj.attributes[:amount].should == 123
+      obj.attributes[:total].should == 456
+    end
 
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == ['foo', 'bar']
-  end
+    it "should allow to set decimal attributes without surrounding quotes" do
+      invoke_cucumber_step('there is a plain Ruby class with the amount 1.23 and the total 45.6')
+      obj = PlainRubyClass.last
+      obj.attributes[:amount].should be_a(BigDecimal)
+      obj.attributes[:amount].to_s.should == "1.23"
+      obj.attributes[:total].should be_a(BigDecimal)
+      obj.attributes[:total].to_s.should == "45.6"
+    end
 
-  it "should allow to set attributes via data table" do
-    user = User.new
-    User.stub(:new => user)
+    it "should allow set an array of strings with square brackets" do
+      invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar"] and the list ["bam", "baz"]')
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == ['foo', 'bar']
+      obj.attributes[:list].should == ['bam', 'baz']
+    end
 
-    invoke_cucumber_step('there is a user with these attributes:', nil, <<-DATA_TABLE)
-| name   | Jane |
-| locked | true |
-    DATA_TABLE
+    it "should allow set an array of numbers with square brackets" do
+      invoke_cucumber_step('there is a plain Ruby class with the integers [1, 2] and the decimals [3.4, 4.5]')
+      obj = PlainRubyClass.last
+      obj.attributes[:integers].should == [1, 2]
+      obj.attributes[:decimals].should == [BigDecimal('3.4'), BigDecimal('4.5')]
+    end
 
-    user.name.should == "Jane"
-    user.locked.should == true
-  end
+    it 'should allow to set an empty array' do
+      invoke_cucumber_step('there is a plain Ruby class with the tags []')
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == []
+    end
 
-  it "should allow to set attributes via additional data table" do
-    user = User.new
-    User.stub(:new => user)
+    it 'should allow to separate array values with either a comma or "and"' do
+      invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar" and "baz"] and the list ["bam", "baz" and "qux"]')
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == ['foo', 'bar', 'baz']
+      obj.attributes[:list].should == ['bam', 'baz', 'qux']
+    end
 
-    invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', nil, <<-DATA_TABLE)
-| name | Jane |
-    DATA_TABLE
+    it 'should allow to separate array values with an Oxford comma' do
+      invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar", and "baz"] and the list ["bam", "baz", and "qux"]')
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == ['foo', 'bar', 'baz']
+      obj.attributes[:list].should == ['bam', 'baz', 'qux']
+    end
 
-    user.name.should == "Jane"
-    user.email.should == "test@invalid.com"
-  end
+    it "should allow attribute names starting with 'the'" do
+      PlainRubyClass.should_receive(:new).with({:theme => 'Sci-fi'})
+      invoke_cucumber_step('there is a plain ruby class with the theme "Sci-fi"')
+    end
+
+    it "should allow attribute names starting with 'and'" do
+      PlainRubyClass.should_receive(:new).with({:android => 'Paranoid'})
+      invoke_cucumber_step('there is a plain ruby class with the android "Paranoid"')
+    end
+
+    it "should allow attribute names starting with 'with'" do
+      PlainRubyClass.should_receive(:new).with({:withdrawal => 'bank_account'})
+      invoke_cucumber_step('there is a plain ruby class with the withdrawal "bank_account"')
+    end
 
-  it "should allow to set array attributes via data table" do
-    invoke_cucumber_step('there is a plain Ruby class with these attributes:', nil, <<-DATA_TABLE)
+    it "should allow attribute names starting with 'but'" do
+      PlainRubyClass.should_receive(:new).with({:butt => 'pear-shaped'})
+      invoke_cucumber_step('there is a plain ruby class with the butt "pear-shaped"')
+    end
+
+    it "should allow to set array attributes via doc string" do
+      invoke_cucumber_step('there is a plain Ruby class with these attributes:', <<-DOC_STRING)
+tags: ["foo", "bar"]
+      DOC_STRING
+
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == ['foo', 'bar']
+    end
+
+    it "should allow to set array attributes via data table" do
+      invoke_cucumber_step('there is a plain Ruby class with these attributes:', nil, <<-DATA_TABLE)
 | tags | ["foo", "bar"] |
-    DATA_TABLE
+      DATA_TABLE
 
-    obj = PlainRubyClass.last
-    obj.attributes[:tags].should == ['foo', 'bar']
-  end
+      obj = PlainRubyClass.last
+      obj.attributes[:tags].should == ['foo', 'bar']
+    end
 
-  it "should allow single quote for attribute values" do
-    MachinistModel.should_receive(:make).with({ :attribute => "foo"})
-    invoke_cucumber_step("there is a machinist model with the attribute 'foo'")
-  end
+    it "should create models that have a machinist blueprint by calling #make" do
+      MachinistModel.should_receive(:make).with({ :attribute => "foo"})
+      invoke_cucumber_step('there is a machinist model with the attribute "foo"')
+    end
 
-  it "should allow mixed single and double quotes for different attribute values" do
-    MachinistModel.should_receive(:make).with({ :attribute => "foo", :other_attribute => "bar" })
-    invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the other attribute \"bar\"")
-  end
+    it "should be able to step_match machinist blueprint variants" do
+      MachinistModel.should_receive(:make).with(:variant, { :attribute => "foo"})
+      invoke_cucumber_step('there is a machinist model (variant) with the attribute "foo"')
+    end
 
-  it "should allow mixed single quotes for model names" do
-    invoke_cucumber_step("'Some Prequel' is a movie with the title \"Before Sunrise\"")
-    invoke_cucumber_step('there is a movie with the title "Limitless"')
-    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 be able to step_match machinist blueprint variants containing spaces or uppercase characters in prose" do
+      MachinistModel.should_receive(:make).with(:variant_mark_two, { :attribute => "foo"})
+      invoke_cucumber_step('there is a machinist model (Variant Mark Two) with the attribute "foo"')
+    end
 
-  it 'should not raise an error for a blank instance name' do
-    MachinistModel.should_receive(:make).with({ :attribute => 'foo' })
-    invoke_cucumber_step("'' is a machinist model with the attribute 'foo'")
-  end
+    it "should allow single quote for attribute values" do
+      MachinistModel.should_receive(:make).with({ :attribute => "foo"})
+      invoke_cucumber_step("there is a machinist model with the attribute 'foo'")
+    end
 
-  it 'should warn if there are unused fragments' do
-    MachinistModel.should_not_receive(:make)
-    lambda { invoke_cucumber_step("there is a machinist model with the attribute NOQUOTES") }.should raise_error(ArgumentError, 'Unable to parse attributes " with the attribute NOQUOTES".')
-    lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the ") }.should raise_error(ArgumentError, 'Unable to parse attributes " and the ".')
-    lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo'. the other_attribute 'bar' and the third attribute 'baz'") }.should raise_error(ArgumentError, 'Unable to parse attributes ".".')
-  end
+    it "should allow mixed single and double quotes for different attribute values" do
+      MachinistModel.should_receive(:make).with({ :attribute => "foo", :other_attribute => "bar" })
+      invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the other attribute \"bar\"")
+    end
+
+    it 'should not raise an error for a blank instance name' do
+      MachinistModel.should_receive(:make).with({ :attribute => 'foo' })
+      invoke_cucumber_step("'' is a machinist model with the attribute 'foo'")
+    end
+
+    it 'should warn if there are unused fragments' do
+      MachinistModel.should_not_receive(:make)
+      lambda { invoke_cucumber_step("there is a machinist model with the attribute NOQUOTES") }.should raise_error(ArgumentError, 'Unable to parse attributes " with the attribute NOQUOTES".')
+      lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the ") }.should raise_error(ArgumentError, 'Unable to parse attributes " and the ".')
+      lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo'. the other_attribute 'bar' and the third attribute 'baz'") }.should raise_error(ArgumentError, 'Unable to parse attributes ".".')
+    end
+
+    it "should allow to update the last record of a type" do
+      invoke_cucumber_step('there is a user with the name "Bar" and the email "foo@example.com" who is not subscribed')
+      invoke_cucumber_step('the user above has the name "Baz", the email "foobar@example.com", and is subscribed')
+      user = User.last
+      user.name.should == 'Baz'
+      user.email.should == 'foobar@example.com'
+      user.subscribed.should == true
+    end
 
+    it "should be able to update a record with a given name" do
+      invoke_cucumber_step('"Foo" is a user with the name "Bar"')
+      invoke_cucumber_step('the user "Foo" has the email "foo@example.com"')
+      invoke_cucumber_step("the user 'Foo' is subscribed")
+      user = User.last
+      user.name.should == 'Bar'
+      user.email.should == 'foo@example.com'
+      user.subscribed.should == true
+    end
+
+    it "should be able to update a record with a Cucumber table expression" do
+      invoke_cucumber_step('"Foo" is a user with the name "Bar"')
+      invoke_cucumber_step('the user above has these attributes:', nil, <<-DATA_TABLE)
+| name   | Jane |
+| locked | true |
+      DATA_TABLE
+      user = User.last
+      user.name.should == "Jane"
+      user.locked.should == true
+    end
+
+    it "should allow to update a record via additional data table" do
+      invoke_cucumber_step('"Foo" is a user with the name "Bar"')
+      invoke_cucumber_step('the user above has the email "test@invalid.com", is subscribed, and has these attributes:', nil, <<-DATA_TABLE)
+| name | Jane |
+      DATA_TABLE
+      user = User.last
+      user.name.should == "Jane"
+      user.email.should == "test@invalid.com"
+      user.subscribed.should == true
+    end
+
+    it "should allow to update an association" do
+      invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
+      invoke_cucumber_step('there is a user with the name "John"')
+      invoke_cucumber_step('the movie above has the reviewer above')
+      movie = Movie.last
+      movie.reviewer.name.should == "John"
+    end
+  end
 end