pickle 0.5.0 → 0.5.1

data/lib/pickle/path.rb

@@ -21,7 +21,7 @@ module Pickle
         pickle_path_for_resources_action_segment(resources, options[:action], options[:segment])
       end or raise "Could not figure out a path for #{pickle_names.inspect} #{options.inspect}"
     end
-    
+
   protected
     def find_pickle_path_using_action_segment_combinations(resources, parts)
       path = nil
@@ -32,7 +32,7 @@ module Pickle
       end
       path
     end
-    
+
     def pickle_path_for_resources_action_segment(resources, action, segment)
       action.blank? or action = action.downcase.gsub(' ','_')
       segment.blank? or segment = segment.downcase.gsub(' ','_')
@@ -42,4 +42,4 @@ module Pickle
       send("#{parts.join('_')}_path", *models) rescue nil
     end
   end
-end
+end

data/lib/pickle/session.rb

@@ -2,29 +2,29 @@ module Pickle
   module Session
     class ModelNotKnownError < RuntimeError
       attr_reader :name
-      
+
       def initialize(name, message = nil)
         @name = name
         @message = message.presence || "The model: '#{name}' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario."
       end
-      
+
       def to_s
         @message
       end
     end
-    
+
     class ModelNotFoundError < RuntimeError
     end
-    
+
     class << self
       def included(world_class)
         proxy_to_pickle_parser(world_class)
       end
-      
+
       def extended(world_object)
         proxy_to_pickle_parser(class << world_object; self; end) # metaclass is not 2.1 compatible
       end
-      
+
     protected
       def proxy_to_pickle_parser(world_class)
         world_class.class_eval do
@@ -35,16 +35,23 @@ module Pickle
         end
       end
     end
-    
+
     def create_model(pickle_ref, fields = nil)
-      factory, label = *parse_model(pickle_ref)
-      raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
-      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
-      record = pickle_config.factories[factory].create(fields)
-      store_model(factory, label, record)
-      record
+      create_or_build_model(:create, 1, pickle_ref, fields)
     end
-    
+
+    def create_models(count, pickle_ref, fields = nil)
+      create_or_build_model(:create, count, pickle_ref, fields)
+    end
+
+    def build_model(pickle_ref, fields = nil)
+      create_or_build_model(:build, 1, pickle_ref, fields)
+    end
+
+    def build_models(count, pickle_ref, fields = nil)
+      create_or_build_model(:build, count, pickle_ref, fields)
+    end
+
     # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
     def create_models_from_table(plural_factory, table)
       factory = plural_factory.singularize
@@ -68,14 +75,14 @@ module Pickle
 
       record
     end
-    
+
     def find_model!(name, fields = nil)
       find_model(name, fields) or raise ModelNotFoundError, "Can't find #{name}#{" with #{fields}" if fields.present?} from the orm in this scenario"
     end
-    
+
     def find_models(factory, fields = nil)
       factory = pickle_parser.canonical(factory)
-      
+
       models_by_index(factory).clear
 
       model_class = pickle_config.factories[factory].klass
@@ -84,7 +91,7 @@ module Pickle
 
       records.each {|record| store_model(factory, nil, record)}
     end
-    
+
     # if a column exists in the table which matches the singular factory name, this is used as the pickle ref
     def find_models_from_table(plural_factory, table)
       factory = plural_factory.singularize
@@ -93,11 +100,11 @@ module Pickle
         find_model(pickle_ref, hash)
       end
     end
-    
+
     # return the original model stored by create_model or find_model
     def created_model(name)
       factory, name_or_index = *parse_model(name)
-      
+
       if name_or_index.blank?
         models_by_index(factory).last
       elsif name_or_index.is_a?(Integer)
@@ -111,46 +118,59 @@ module Pickle
     def created_model?(name)
       (created_model(name) rescue nil) ? true : false
     end
-    
+
     # return a newly selected model
     def model(name)
       model = created_model(name)
       return nil unless model
       Pickle::Adapter.get_model(model.class, model.id)
     end
-    
+
     # predicate version which raises no errors
     def model?(name)
       (model(name) rescue nil) ? true : false
     end
-    
+
     # like model, but raise an error if it can't be found
     def model!(name)
       model(name) or raise ModelNotKnownError, name
     end
-    
+
     # like created_model, but raise an error if it can't be found
     def created_model!(name)
       created_model(name) or raise ModelNotKnownError, name
     end
-    
+
     # return all original models of specified type
     def created_models(factory)
       models_by_index(factory)
     end
-      
+
     # return all models of specified type (freshly selected from the database)
     def models(factory)
       created_models(factory).map do |model|
         Pickle::Adapter.get_model(model.class, model.id)
       end
     end
-    
+
     def respond_to_with_pickle_parser?(method, include_private = false)
       respond_to_without_pickle_parser?(method, include_private) || pickle_parser.respond_to?(method, include_private)
     end
-    
+
   protected
+    def create_or_build_model(method, count, pickle_ref, fields = nil)
+      factory, label = *parse_model(pickle_ref)
+      raise ArgumentError, "Can't #{method} with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
+      fields = fields.is_a?(Hash) ? parse_hash(fields) : parse_fields(fields)
+
+      count.to_i.times.map do
+        record = pickle_config.factories[factory].send(method, fields)
+        store_model(factory, label, record)
+        return record if count == 1
+        record
+      end
+    end
+
     def method_missing_with_pickle_parser(method, *args, &block)
       if pickle_parser.respond_to?(method)
         pickle_parser.send(method, *args, &block)
@@ -158,12 +178,12 @@ module Pickle
         method_missing_without_pickle_parser(method, *args, &block)
       end
     end
-    
+
     def pickle_parser=(parser)
       parser.session = self
       @pickle_parser = parser
     end
-    
+
     def pickle_parser
       @pickle_parser or self.pickle_parser = Pickle.parser
     end
@@ -172,37 +192,50 @@ module Pickle
       pickle_parser.config
     end
 
-    def convert_models_to_attributes(ar_class, attrs)
+    def convert_models_to_attributes(klass, attrs)
+      columns = nil
       conditions = {}
+
       attrs.each do |key, val|
-        if ((defined?(ActiveRecord::Base) && val.is_a?(ActiveRecord::Base)) ||
-          (defined?(DataMapper::Model) && val.is_a?(DataMapper::Model))) &&
-          Pickle::Adapter.column_names(ar_class).include?("#{key}_id")
+        if supported = supported_association_model_type?(val) or val.nil?
+          columns ||= Pickle::Adapter.column_names(klass)
+        end
+
+        if supported && columns.include?("#{key}_id")
           conditions["#{key}_id"] = val.id
-          conditions["#{key}_type"] = val.class.base_class.name if ar_class.column_names.include?("#{key}_type")
+          conditions["#{key}_type"] = val.class.base_class.name if columns.include?("#{key}_type")
+        elsif val.nil? && columns.include?("#{key}_id") && !columns.include?("#{key}")
+          # NOOP
         else
           conditions[key] = val
         end
       end
+
       conditions
     end
-    
+
+    def supported_association_model_type?(associated_model)
+      (defined?(ActiveRecord::Base) && associated_model.is_a?(ActiveRecord::Base)) ||
+        (defined?(DataMapper::Model) && associated_model.is_a?(DataMapper::Model)) ||
+        (defined?(Mongoid::Document) && associated_model.is_a?(Mongoid::Document))
+    end
+
     def models_by_name(factory)
       @models_by_name ||= {}
       @models_by_name[pickle_parser.canonical(factory)] ||= {}
     end
-    
+
     def models_by_index(factory)
       @models_by_index ||= {}
       @models_by_index[pickle_parser.canonical(factory)] ||= []
     end
-    
+
     # if the factory name != the model name, store under both names
     def store_model(factory, name, record)
       store_record(record.class.name, name, record) unless pickle_parser.canonical(factory) == pickle_parser.canonical(record.class.name)
       store_record(factory, name, record)
     end
-    
+
     def store_record(factory, name, record)
       models_by_name(factory)[name] = record
       models_by_index(factory) << record

data/lib/pickle/session/parser.rb

@@ -18,8 +18,8 @@ module Pickle
         else
           parse_field_without_model(field)
         end
-      end    
-      
+      end
+
       def parse_hash(hash)
         hash.inject({}) do |parsed, (key, val)|
           if session && val =~ /^#{capture_model}$/
@@ -31,4 +31,4 @@ module Pickle
       end
     end
   end
-end
+end

data/lib/pickle/version.rb

@@ -1,3 +1,3 @@
 module Pickle
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/pickle.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |s|
   s.version = Pickle::VERSION.dup
   s.platform = Gem::Platform::RUBY
   s.licenses = ["MIT"]
-  s.authors = ["Ian White", "James Le Cuirot", "Niklas Hofer"]
+  s.authors = ["Ian White", "James Le Cuirot"]
   s.description = "Easy model creation and reference in your cucumber features"
   s.summary = "Easy model creation and reference in your cucumber features."
-  s.email = ["ian.w.white@gmail.com", "chewi@aura-online.co.uk", "niklas+dev@lanpartei.de"]
+  s.email = ["ian.w.white@gmail.com", "chewi@aura-online.co.uk"]
   s.homepage = "https://github.com/ianwhite/pickle"
 
   s.rubyforge_project = "pickle"
@@ -34,5 +34,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "machinist", "~>2.0"
   s.add_development_dependency "database_cleaner"
   s.add_development_dependency "capybara"
-  s.add_development_dependency "sqlite3-ruby"
+  s.add_development_dependency "sqlite3"
 end

data/rails_generators/pickle/templates/email_steps.rb

@@ -27,37 +27,39 @@ When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
 end
 
 Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
-  expect(emails("to: \"#{email_for(to)}\"").size).to eq(count.to_i)
+  actual = emails("to: \"#{email_for(to)}\"").size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} delivered to #{to}"
 end
 
 Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
-  expect(emails(fields).size).to eq(count.to_i)
+  actual = emails(fields).size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} to be delivered with #{fields}"
 end
 
 Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
-  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil, "Failed to find #{email_ref} delivered to: #{to}"
 end
 
 Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
-  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil, "Unexpectedly found #{email_ref} delivered to: #{to}"
 end
 
 Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
-  expect(email(email_ref, fields)).not_to be_nil
+  expect(email(email_ref, fields)).not_to be_nil, "Failed to find #{fields} in #{email_ref}"
 end
 
 Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
-  expect(email(email_ref).body).to match(/#{text}/)
+  expect(email(email_ref).body).to match(/#{text}/), "Failed to find \"#{text}\" in #{email_ref}"
 end
 
 Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
-  expect(email(email_ref).body).not_to match(/#{text}/)
+  expect(email(email_ref).body).not_to match(/#{text}/), "Unexpectedly found \"#{text}\" in #{email_ref}"
 end
 
 Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
-  expect(email(email_ref).body).to match(/#{path_to(page)}/)
+  expect(email(email_ref).body).to match(/#{path_to(page)}/), "Failed to find link to #{page} in #{email_ref}"
 end
 
 Then(/^show me the emails?$/) do
-   save_and_open_emails
+  save_and_open_emails
 end

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -7,7 +7,7 @@ end
 
 # create n models
 Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  count.to_i.times { create_model(plural_factory.singularize, fields) }
+  create_models(count, plural_factory.singularize, fields)
 end
 
 # create models from a table
@@ -26,10 +26,15 @@ Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name
 end
 
 # find models with a table
-Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+Then(/^the following #{capture_plural_factory} should exist:?$/) do |plural_factory, table|
   expect(find_models_from_table(plural_factory, table)).not_to be_any(&:nil?)
 end
 
+# not find models with a table
+Then(/^the following #{capture_plural_factory} should not exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should be_all(&:nil?)
+end
+
 # find exactly n models
 Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
   expect(find_models(plural_factory.singularize, fields).size).to eq(count.to_i)
@@ -60,7 +65,7 @@ Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |targe
   expect(model!(owner).send(association)).not_to eq(model!(target))
 end
 
-# assert model.predicate? 
+# assert model.predicate?
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
     expect(model!(name)).to send("have_#{predicate.gsub(' ', '_')}")
@@ -83,7 +88,7 @@ end
 Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
   actual_value  = model(name).send(attribute)
   expectation   = expectation.gsub("should", "to").gsub(" ", "_")
-  
+
   case expected
   when 'nil', 'true', 'false'
     expect(actual_value).send(expectation, eq(eval(expected)))

data/spec/pickle/adapter_spec.rb

@@ -15,47 +15,35 @@ describe Pickle::Adapter do
     expect { Pickle::Adapter.new.create }.to raise_error(NotImplementedError)
   end
 
-  describe ".model_classes" do
-    before do
-      Pickle::Adapter.model_classes = nil
-    end
-  end
-
   describe "adapters: " do
-    before do
-      @klass1 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('One') }
-      @klass2 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('One::Two') }
-      @klass3 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('Three') }
+    around do |example|
+      begin
+        class One < ActiveRecord::Base; end
+        class One::Two < ActiveRecord::Base; end
+        class Three < ActiveRecord::Base; end
+        example.run
+      ensure
+        Object.send :remove_const, :One
+        Object.send :remove_const, :Three
+      end
     end
 
     describe 'ActiveRecord' do
-
-#DEPRECATION WARNING: subclasses is deprecated and will be removed from Rails 3.0 (use descendants instead). (called from __send__ at /Users/pivotal/workspace/factorylabs/protosite/vendor/cache/ruby/1.8/gems/pickle-0.3.1/lib/pickle/adapters/active_record.rb:21)
-
-      describe ".model_classes" do
-        it "calls .descendants" do
-          expect(::ActiveRecord::Base).to receive(:descendants).and_return([])
-          expect(::ActiveRecord::Base).not_to receive(:subclasses)
-
-          ActiveRecord::Base::PickleAdapter.model_classes
-        end
-      end
-
       describe 'with class stubs' do
         before do
-          allow(Pickle::Adapter::Orm).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
+          allow(Pickle::Adapter::Orm).to receive(:model_classes).and_return([One, One::Two, Three])
         end
 
         it ".factories should create one for each active record class" do
-          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass1).once
-          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass2).once
-          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass3).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(One).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(One::Two).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(Three).once
           expect(Pickle::Adapter::Orm.factories.length).to eq(3)
         end
 
         describe ".new(Class)" do
           before do
-            @factory = Pickle::Adapter::Orm.new(@klass2)
+            @factory = Pickle::Adapter::Orm.new(One::Two)
           end
 
           it "should have underscored (s/_) name of Class as #name" do
@@ -63,7 +51,7 @@ describe Pickle::Adapter do
           end
 
           it "#create(attrs) should call Class.create!(attrs)" do
-            expect(@klass2).to receive(:create!).with({:key => "val"})
+            expect(One::Two).to receive(:create!).with({:key => "val"})
             @factory.create(:key => "val")
           end
         end
@@ -72,19 +60,19 @@ describe Pickle::Adapter do
 
     describe 'FactoryGirl' do
       before do
-        allow(Pickle::Adapter::FactoryGirl).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
+        allow(Pickle::Adapter::FactoryGirl).to receive(:model_classes).and_return([One, One::Two, Three])
 
         if defined? ::FactoryGirl
           @orig_factories = ::FactoryGirl.factories.dup
           ::FactoryGirl.factories.clear
-          ::FactoryGirl::Syntax::Default::DSL.new.factory(:one, :class => @klass1) {}
-          ::FactoryGirl::Syntax::Default::DSL.new.factory(:two, :class => @klass2) {}
+          ::FactoryGirl::Syntax::Default::DSL.new.factory(:one, :class => One) {}
+          ::FactoryGirl::Syntax::Default::DSL.new.factory(:two, :class => One::Two) {}
           @factory1 = ::FactoryGirl.factories[:one]
           @factory2 = ::FactoryGirl.factories[:two]
         else
           @orig_factories, Factory.factories = Factory.factories, {}
-          Factory.define(:one, :class => @klass1) {}
-          Factory.define(:two, :class => @klass2) {}
+          Factory.define(:one, :class => One) {}
+          Factory.define(:two, :class => One::Two) {}
           @factory1 = Factory.factories[:one]
           @factory2 = Factory.factories[:two]
         end
@@ -100,14 +88,14 @@ describe Pickle::Adapter do
       end
 
       it ".factories should create one for each factory" do
-        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory1).once
-        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory2).once
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory1, @factory1.name).once
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory2, @factory2.name).once
         Pickle::Adapter::FactoryGirl.factories
       end
 
-      describe ".new(factory)" do
+      describe ".new(factory, factory_name)" do
         before do
-          @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1, @factory1.name)
         end
 
         it "should have name of factory_name" do
@@ -115,7 +103,7 @@ describe Pickle::Adapter do
         end
 
         it "should have klass of build_class" do
-          expect(@factory.klass).to eq(@klass1)
+          expect(@factory.klass).to eq(One)
         end
 
         unless defined? ::FactoryGirl
@@ -129,8 +117,8 @@ describe Pickle::Adapter do
 
     describe 'Fabrication' do
       before do
-        @schematic1 = [:one, Fabrication::Schematic::Definition.new(@klass1)]
-        @schematic2 = [:two, Fabrication::Schematic::Definition.new(@klass2)]
+        @schematic1 = [:one, Fabrication::Schematic::Definition.new(One)]
+        @schematic2 = [:two, Fabrication::Schematic::Definition.new(One::Two)]
         allow(::Fabrication.manager).to receive(:schematics).and_return(Hash[[@schematic1, @schematic2]])
       end
 
@@ -151,7 +139,7 @@ describe Pickle::Adapter do
         end
 
         it "should have klass of build_class" do
-          expect(@factory.klass).to eq(@klass1)
+          expect(@factory.klass).to eq(One)
         end
       end
 
@@ -167,23 +155,23 @@ describe Pickle::Adapter do
 
     describe 'Machinist' do
       before do
-        allow(Pickle::Adapter::Machinist).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
+        allow(Pickle::Adapter::Machinist).to receive(:model_classes).and_return([One, One::Two, Three])
 
-        @klass1.blueprint {}
-        @klass3.blueprint {}
-        @klass3.blueprint(:special) {}
+        One.blueprint {}
+        Three.blueprint {}
+        Three.blueprint(:special) {}
       end
 
       it ".factories should create one for each master blueprint, and special case" do
-        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass1, :master).once
-        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass3, :master).once
-        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass3, :special).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(One, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(Three, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(Three, :special).once
         Pickle::Adapter::Machinist.factories
       end
 
       describe ".new(Class, :master)" do
         before do
-          @factory = Pickle::Adapter::Machinist.new(@klass1, :master)
+          @factory = Pickle::Adapter::Machinist.new(One, :master)
         end
 
         it "should have underscored (s/_) name of Class as #name" do
@@ -191,14 +179,14 @@ describe Pickle::Adapter do
         end
 
         it "#create(attrs) should call Class.make!(:master, attrs)" do
-          expect(@klass1).to receive(:make!).with(:master, {:key => "val"})
+          expect(One).to receive(:make!).with(:master, {:key => "val"})
           @factory.create(:key => "val")
         end
       end
 
       describe ".new(Class, :special)" do
         before do
-          @factory = Pickle::Adapter::Machinist.new(@klass3, :special)
+          @factory = Pickle::Adapter::Machinist.new(Three, :special)
         end
 
         it "should have 'special_<Class name>' as #name" do
@@ -206,7 +194,7 @@ describe Pickle::Adapter do
         end
 
         it "#create(attrs) should call Class.make!(:special, attrs)" do
-          expect(@klass3).to receive(:make!).with(:special, {:key => "val"})
+          expect(Three).to receive(:make!).with(:special, {:key => "val"})
           @factory.create(:key => "val")
         end
       end