pickle-has_many_support 0.3.1 → 0.4.2

data/lib/pickle/adapters/active_record.rb

@@ -18,7 +18,13 @@ class ActiveRecord::Base
 
     # Gets a list of the available models for this adapter
     def self.model_classes
-      ::ActiveRecord::Base.__send__(:subclasses).select do |klass|
+      begin
+        klasses = ::ActiveRecord::Base.__send__(:descendants) # Rails 3
+      rescue
+        klasses = ::ActiveRecord::Base.__send__(:subclasses) # Rails 2
+      end
+
+      klasses.select do |klass|
         !klass.abstract_class? && klass.table_exists? && !except_classes.include?(klass.name)
       end
     end
@@ -42,5 +48,10 @@ class ActiveRecord::Base
     def self.find_all_models(klass, conditions)
       klass.find(:all, :conditions => conditions)
     end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create!(attributes)
+    end
   end
 end

data/lib/pickle/adapters/data_mapper.rb

@@ -33,5 +33,10 @@ module DataMapper::Resource
     def self.find_all_models(klass, conditions)
       klass.all(conditions)
     end
+    
+    # Create a model using attributes
+    def self.create_model(klass, attributes)
+      klass.create(attributes)
+    end
   end
 end

data/lib/pickle/adapters/mongoid.rb

@@ -0,0 +1,44 @@
+require 'mongoid'
+
+module Mongoid
+  module Document
+    module PickleAdapter
+      include Pickle::Adapter::Base
+
+      # Do not consider these to be part of the class list
+      def self.except_classes
+        @@except_classes ||= []
+      end
+
+      # Gets a list of the available models for this adapter
+      def self.model_classes
+        ObjectSpace.each_object(Class).to_a.select {|klass| klass.ancestors.include? Mongoid::Document}
+      end
+
+      # get a list of column names for a given class
+      def self.column_names(klass)
+        klass.fields.keys
+      end
+
+      # Get an instance by id of the model
+      def self.get_model(klass, id)
+        klass.find(id)
+      end
+
+      # Find the first instance matching conditions
+      def self.find_first_model(klass, conditions)
+        klass.first(:conditions => conditions)
+      end
+
+      # Find all models matching conditions
+      def self.find_all_models(klass, conditions)
+        klass.all(:conditions => conditions)
+      end
+
+      # Create a model with given attributes
+      def self.create_model(klass, attributes)
+        klass.create!(attributes)
+      end
+    end
+  end
+end

data/lib/pickle/config.rb

@@ -1,5 +1,3 @@
-require 'ostruct'
-
 module Pickle
   class Config
     attr_writer :adapters, :factories, :mappings, :predicates
@@ -13,7 +11,7 @@ module Pickle
     end
     
     def adapters
-      @adapters ||= [:machinist, :factory_girl, :active_record]
+      @adapters ||= [:machinist, :factory_girl, :orm]
     end
     
     def adapter_classes
@@ -31,6 +29,9 @@ module Pickle
         k.public_instance_methods.select {|m| m =~ /\?$/} + Pickle::Adapter.column_names(k)
       end.flatten.uniq
     end
+
+    class Mapping < Struct.new(:search, :replacement)
+    end
     
     def mappings
       @mappings ||= []
@@ -41,7 +42,7 @@ module Pickle
       options = args.extract_options!
       raise ArgumentError, "Usage: map 'search' [, 'search2', ...] :to => 'replace'" unless args.any? && options[:to].is_a?(String)
       args.each do |search|
-        self.mappings << OpenStruct.new(:search => search, :replacement => options[:to])
+        self.mappings << Mapping.new(search, options[:to])
       end
     end
   end

data/lib/pickle/email.rb

@@ -25,8 +25,7 @@ module Pickle
 
     def click_first_link_in_email(email)
       link = links_in_email(email).first
-      request_uri = URI::parse(link).request_uri
-      visit request_uri
+      visit link
     end
 
   protected
@@ -60,19 +59,18 @@ module Pickle
     # e.g. confirm in http://confirm
     def parse_email_for_explicit_link(email, regex)
       regex = /#{Regexp.escape(regex)}/ unless regex.is_a?(Regexp)
-      url = links_in_email(email).detect { |link| link =~ regex }
-      URI::parse(url).request_uri if url
+      links_in_email(email).detect { |link| link =~ regex }
     end
 
     # e.g. Click here in  <a href="http://confirm">Click here</a>
     def parse_email_for_anchor_text_link(email, link_text)
-      email.body =~ %r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>}
-      URI.split($~[1])[5..-1].compact!.join("?").gsub("&amp;", "&")
-      # sub correct ampersand after rails switches it (http://dev.rubyonrails.org/ticket/4002)
+      if match_data = email.body.match(%r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>})
+        match_data[1]
+      end
     end
 
     def links_in_email(email, protos=['http', 'https'])
-      URI.extract(email.body, protos)
+      URI.extract(email.body.to_s, protos)
     end
 
   end

data/lib/pickle/session/parser.rb

@@ -14,7 +14,7 @@ module Pickle
 
       def parse_field_with_model(field)
         if session && field =~ /^(\w+): #{capture_model}$/
-          {$1 => session.model($2)}
+          {$1 => session.model!($2)}
         else
           parse_field_without_model(field)
         end

data/lib/pickle/session.rb

@@ -1,6 +1,19 @@
 # -*- coding: utf-8 -*-
 module Pickle
   module Session
+    class ModelNotKnownError < RuntimeError
+      attr_reader :name
+      
+      def initialize(name, message = nil)
+        @name = name
+        @message = message || "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 << self
       def included(world_class)
         proxy_to_pickle_parser(world_class)
@@ -58,11 +71,13 @@ module Pickle
       record
     end
 
-    def find_model!(a_model_name, fields = nil)
-      find_model(a_model_name, fields) or raise "Can't find pickle model: '#{a_model_name}' in this scenario"
+    def find_model!(name, fields = nil)
+      find_model(name, fields) or raise ModelNotKnownError, name
     end
 
     def find_models(factory, fields = nil)
+      factory = pickle_parser.canonical(factory)
+      
       models_by_index(factory).clear
 
       model_class = pickle_config.factories[factory].klass
@@ -90,7 +105,7 @@ module Pickle
       elsif name_or_index.is_a?(Integer)
         models_by_index(factory)[name_or_index]
       else
-        models_by_name(factory)[name_or_index] or raise "Can't find pickle model: '#{name}' in this scenario"
+        models_by_name(factory)[name_or_index] or raise ModelNotKnownError, name
       end
     end
 
@@ -113,12 +128,12 @@ module Pickle
 
     # like model, but raise an error if it can't be found
     def model!(name)
-      model(name) or raise "Can't find pickle model: '#{name}' in this scenario"
+      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 "Can't find pickle model: '#{name}' in this scenario"
+      created_model(name) or raise ModelNotKnownError, name
     end
 
     # return all original models of specified type

data/lib/pickle/world.rb

@@ -1,8 +1,9 @@
 require 'pickle'
 
-# auto require for active record and datamapper
+# auto require for active record, datamapper and mongoid
 require 'pickle/adapters/active_record' if defined?(ActiveRecord::Base)
 require 'pickle/adapters/data_mapper'   if defined?(DataMapper::Resource)
+require 'pickle/adapters/mongoid'       if defined?(Mongoid::Document)
 
 # make cucumber world pickle aware
 World(Pickle::Session)

data/pickle.gemspec

@@ -5,11 +5,10 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pickle-has_many_support}
-  s.version = "0.3.1"
-
+  s.version = "0.4.2"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ian White"]
-  s.date = %q{2010-07-21}
+  s.date = %q{2010-08-23}
   s.description = %q{Easy model creation and reference in your cucumber features}
   s.email = %q{ian.w.white@gmail.com}
   s.extra_rdoc_files = [
@@ -17,12 +16,14 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     "Gemfile",
+     "Gemfile.lock",
      "History.txt",
      "License.txt",
      "README.rdoc",
      "Rakefile",
      "Rakefile.d/cucumber.rake",
-     "Rakefile.d/jeweller.rake",
+     "Rakefile.d/jeweler.rake",
      "Rakefile.d/rcov.rake",
      "Rakefile.d/rspec.rake",
      "Rakefile.d/yard.rake",
@@ -46,16 +47,19 @@ Gem::Specification.new do |s|
      "features/step_definitions/generator_steps.rb",
      "features/step_definitions/path_steps.rb",
      "features/step_definitions/pickle_steps.rb",
+     "features/step_definitions/raise_error_steps.rb",
      "features/support/email.rb",
      "features/support/env.rb",
      "features/support/paths.rb",
      "features/support/pickle.rb",
      "features/support/pickle_app.rb",
      "init.rb",
+     "lib/generators/pickle_generator.rb",
      "lib/pickle.rb",
      "lib/pickle/adapter.rb",
      "lib/pickle/adapters/active_record.rb",
      "lib/pickle/adapters/data_mapper.rb",
+     "lib/pickle/adapters/mongoid.rb",
      "lib/pickle/config.rb",
      "lib/pickle/email.rb",
      "lib/pickle/email/parser.rb",
@@ -109,9 +113,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 1.3"])
+      s.add_runtime_dependency(%q<cucumber>, [">= 0.8"])
+      s.add_runtime_dependency(%q<yard>, [">= 0"])
+      s.add_runtime_dependency(%q<rake>, [">= 0"])
     else
+      s.add_dependency(%q<rspec>, [">= 1.3"])
+      s.add_dependency(%q<cucumber>, [">= 0.8"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
     end
   else
+    s.add_dependency(%q<rspec>, [">= 1.3"])
+    s.add_dependency(%q<cucumber>, [">= 0.8"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
   end
 end
 

data/spec/pickle/adapter_spec.rb

@@ -7,11 +7,11 @@ require 'pickle/adapters/active_record'
 
 describe Pickle::Adapter do
   it ".factories should raise NotImplementedError" do
-    lambda{ Pickle::Adapter.factories }.should raise_error(NotImplementedError)
+    lambda { Pickle::Adapter.factories }.should raise_error(NotImplementedError)
   end
 
   it "#create should raise NotImplementedError" do
-    lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
+    lambda { Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
   end
 
   describe ".model_classes" do
@@ -26,7 +26,7 @@ describe Pickle::Adapter do
       klass4 = Class.new(ActiveRecord::Base)
       klass5 = Class.new(ActiveRecord::Base)
       klass6 = Class.new(ActiveRecord::Base)
-      [klass1, klass2,klass3,klass4, klass5, klass6].each{|k| k.stub!(:table_exists?).and_return(true)}
+      [klass1, klass2, klass3, klass4, klass5, klass6].each { |k| k.stub!(:table_exists?).and_return(true) }
 
       klass2.stub!(:name).and_return("CGI::Session::ActiveRecordStore::Session")
       klass3.stub!(:name).and_return("ActiveRecord::SessionStore::Session")
@@ -39,37 +39,60 @@ describe Pickle::Adapter do
 
   describe "adapters: " do
     before do
-      @klass1 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('One')}
-      @klass2 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('One::Two')}
-      @klass3 = returning(Class.new(ActiveRecord::Base)) {|k| k.stub!(:name).and_return('Three')}
+      @klass1 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('One') }
+      @klass2 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('One::Two') }
+      @klass3 = returning(Class.new(ActiveRecord::Base)) { |k| k.stub!(:name).and_return('Three') }
     end
 
     describe 'ActiveRecord' do
-      before do
-        ActiveRecord::Base::PickleAdapter.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
-      end
 
-      it ".factories should create one for each active record class" do
-        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass1).once
-        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass2).once
-        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass3).once
-        Pickle::Adapter::ActiveRecord.factories
+#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
+          ::ActiveRecord::Base.should_receive(:descendants).and_return([])
+          ::ActiveRecord::Base.should_not_receive(:subclasses).and_return([])
+
+          ActiveRecord::Base::PickleAdapter.model_classes
+        end
+
+        it "calls .subclasses when .descendants doesn't respond" do
+          ::ActiveRecord::Base.should_receive(:subclasses).and_return([])
+
+          ActiveRecord::Base::PickleAdapter.model_classes
+        end
+
       end
 
-      describe ".new(Class)" do
+      describe 'with class stubs' do
         before do
-          @factory = Pickle::Adapter::ActiveRecord.new(@klass2)
+          Pickle::Adapter::Orm.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
         end
 
-        it "should have underscored (s/_) name of Class as #name" do
-          @factory.name.should == 'one_two'
+        it ".factories should create one for each active record class" do
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass1).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass2).once
+          Pickle::Adapter::Orm.should_receive(:new).with(@klass3).once
+          Pickle::Adapter::Orm.factories.length.should == 3
         end
 
-        it "#create(attrs) should call Class.create!(attrs)" do
-          @klass2.should_receive(:create!).with({:key => "val"})
-          @factory.create(:key => "val")
+        describe ".new(Class)" do
+          before do
+            @factory = Pickle::Adapter::Orm.new(@klass2)
+          end
+
+          it "should have underscored (s/_) name of Class as #name" do
+            @factory.name.should == 'one_two'
+          end
+
+          it "#create(attrs) should call Class.create!(attrs)" do
+            @klass2.should_receive(:create!).with({:key => "val"})
+            @factory.create(:key => "val")
+          end
         end
       end
+
+
     end
 
     describe 'FactoryGirl' do

data/spec/pickle/config_spec.rb

@@ -5,12 +5,12 @@ describe Pickle::Config do
     @config = Pickle::Config.new
   end
 
-  it "#adapters should default to :machinist, :factory_girl, :active_record" do
-    @config.adapters.should == [:machinist, :factory_girl, :active_record]
+  it "#adapters should default to :machinist, :factory_girl, :orm" do
+    @config.adapters.should == [:machinist, :factory_girl, :orm]
   end
 
-  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::ActiveRecord" do
-    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::ActiveRecord]
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::Orm" do
+    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Orm]
   end
 
   describe "setting adapters to [:machinist, SomeAdapter]" do
@@ -29,22 +29,22 @@ describe Pickle::Config do
     it "should call adaptor.factories for each adaptor" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([])
-      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([])
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([])
       @config.factories
     end
 
     it "should aggregate factories into a hash using factory name as key" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist = mock('machinist', :name => 'machinist')])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl = mock('factory_girl', :name => 'factory_girl')])
-      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record = mock('active_record', :name => 'active_record')])
-      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'active_record' => @active_record}
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm = mock('orm', :name => 'orm')])
+      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'orm' => @orm}
     end
 
     it "should give preference to adaptors first in the list" do
       Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist_one = mock('one', :name => 'one')])
       Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl_one = mock('one', :name => 'one'), @factory_girl_two = mock('two', :name => 'two')])
-      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record_two = mock('two', :name => 'two'), @active_record_three = mock('three', :name => 'three')])
-      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @active_record_three}
+      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm_two = mock('two', :name => 'two'), @orm_three = mock('three', :name => 'three')])
+      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @orm_three}
     end
   end
 
@@ -80,8 +80,12 @@ describe Pickle::Config do
       @config.map 'foo', :to => 'faz'
     end
 
-    it "should create OpenStruct(search: 'foo', replace: 'faz') mapping" do
-      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replacement => 'faz')
+    it "should create Mapping('foo', 'faz') mapping" do
+      @config.mappings.first.tap do |mapping|
+        mapping.should be_kind_of Pickle::Config::Mapping
+        mapping.search.should == 'foo'
+        mapping.replacement.should == 'faz'
+      end
     end
   end
 
@@ -91,8 +95,8 @@ describe Pickle::Config do
     end
 
     it "should create 2 mappings" do
-      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replacement => 'faz')
-      @config.mappings.last.should == OpenStruct.new(:search => 'bar', :replacement => 'faz')
+      @config.mappings.first.should == Pickle::Config::Mapping.new('foo', 'faz')
+      @config.mappings.last.should == Pickle::Config::Mapping.new('bar', 'faz')
     end
   end
 

data/spec/pickle/email_spec.rb

@@ -143,18 +143,24 @@ describe Pickle::Email do
     end
 
     it "should find a link for http://example.com/page" do
-      should_receive(:visit).with('/page')
+      should_receive(:visit).with('http://example.com/page')
       visit_in_email(@email1, 'http://example.com/page')
     end
 
     it "should find a link for \"example page\"" do
-      should_receive(:visit).with('/page')
+      should_receive(:visit).with('http://example.com/page')
       visit_in_email(@email1, 'example page')
     end
 
     it "should follow the first link in an email" do
-      should_receive(:visit).with('/page')
+      should_receive(:visit).with('http://example.com/page')
       click_first_link_in_email(@email1)
     end
+    
+    it "should not raise an error when the email body is not a string, but needs to_s [#26]" do
+      stub!(:visit)
+      @email1.stub!(:body).and_return(:a_string_body)
+      lambda { click_first_link_in_email(@email1) }.should_not raise_error
+    end
   end
 end

data/spec/pickle/session_spec.rb

@@ -23,7 +23,7 @@ describe Pickle::Session do
   end
 
   let :user_factory do
-    Pickle::Adapter::ActiveRecord.new(user_class)
+    Pickle::Adapter::Orm.new(user_class)
   end
 
   before do
@@ -280,7 +280,7 @@ describe Pickle::Session do
 
     it "should call raise error if find_model returns nil" do
       should_receive(:find_model).with('name', 'fields').and_return(nil)
-      lambda { find_model!('name', 'fields') }.should raise_error(RuntimeError, "Can't find pickle model: 'name' in this scenario")
+      lambda { find_model!('name', 'fields') }.should raise_error(Pickle::Session::ModelNotKnownError)
     end
   end
 
@@ -290,7 +290,7 @@ describe Pickle::Session do
     end
 
     it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
-      find_models('user', 'hair: "pink"')
+      find_models('user', 'hair: "pink"').should == [user]
     end
 
     describe "after find," do
@@ -298,6 +298,12 @@ describe Pickle::Session do
 
       it_should_behave_like "after storing a single user"
     end
+    
+    it "should cope with spaces in the factory name (ie. it should make it canonical)" do
+      pickle_parser.stub!(:canonical).and_return('user')
+      pickle_parser.should_receive(:canonical).with('u ser').and_return('user')
+      find_models('u ser', 'hair: "pink"').should == [user]
+    end
   end
 
   describe 'creating \'a super admin: "fred"\', then \'a user: "shirl"\', \'then 1 super_admin\' (super_admin is factory that returns users)' do
@@ -442,10 +448,10 @@ describe Pickle::Session do
   end
 
   it "#model!('unknown') should raise informative error message" do
-    lambda { model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
+    lambda { model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError, "The model: 'unknown' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario.")
   end
 
   it "#created_model!('unknown') should raise informative error message" do
-    lambda { created_model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
+    lambda { created_model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError)
   end
 end