pickle-has_many_support 0.3.1

data/pickle.gemspec

@@ -0,0 +1,117 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{pickle-has_many_support}
+  s.version = "0.3.1"
+
+  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.description = %q{Easy model creation and reference in your cucumber features}
+  s.email = %q{ian.w.white@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "License.txt",
+     "README.rdoc",
+     "Rakefile",
+     "Rakefile.d/cucumber.rake",
+     "Rakefile.d/jeweller.rake",
+     "Rakefile.d/rcov.rake",
+     "Rakefile.d/rspec.rake",
+     "Rakefile.d/yard.rake",
+     "Todo.txt",
+     "VERSION",
+     "features/app/app.rb",
+     "features/app/blueprints.rb",
+     "features/app/factories.rb",
+     "features/app/views/notifier/email.erb",
+     "features/app/views/notifier/user_email.erb",
+     "features/email/email.feature",
+     "features/generator/generators.feature",
+     "features/path/models_page.feature",
+     "features/path/named_route_page.feature",
+     "features/pickle/create_from_active_record.feature",
+     "features/pickle/create_from_factory_girl.feature",
+     "features/pickle/create_from_machinist.feature",
+     "features/step_definitions/email_steps.rb",
+     "features/step_definitions/extra_email_steps.rb",
+     "features/step_definitions/fork_steps.rb",
+     "features/step_definitions/generator_steps.rb",
+     "features/step_definitions/path_steps.rb",
+     "features/step_definitions/pickle_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/pickle.rb",
+     "lib/pickle/adapter.rb",
+     "lib/pickle/adapters/active_record.rb",
+     "lib/pickle/adapters/data_mapper.rb",
+     "lib/pickle/config.rb",
+     "lib/pickle/email.rb",
+     "lib/pickle/email/parser.rb",
+     "lib/pickle/email/world.rb",
+     "lib/pickle/parser.rb",
+     "lib/pickle/parser/matchers.rb",
+     "lib/pickle/path.rb",
+     "lib/pickle/path/world.rb",
+     "lib/pickle/session.rb",
+     "lib/pickle/session/parser.rb",
+     "lib/pickle/version.rb",
+     "lib/pickle/world.rb",
+     "pickle.gemspec",
+     "rails_generators/pickle/pickle_generator.rb",
+     "rails_generators/pickle/templates/email.rb",
+     "rails_generators/pickle/templates/email_steps.rb",
+     "rails_generators/pickle/templates/paths.rb",
+     "rails_generators/pickle/templates/pickle.rb",
+     "rails_generators/pickle/templates/pickle_steps.rb",
+     "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/kb/pickle/tree}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Easy model creation and reference in your cucumber features}
+  s.test_files = [
+    "spec/pickle/adapter_spec.rb",
+     "spec/pickle/config_spec.rb",
+     "spec/pickle/email/parser_spec.rb",
+     "spec/pickle/email_spec.rb",
+     "spec/pickle/parser/matchers_spec.rb",
+     "spec/pickle/parser_spec.rb",
+     "spec/pickle/path_spec.rb",
+     "spec/pickle/session_spec.rb",
+     "spec/pickle_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,33 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(args, options)
+    super(args, options)
+    @generate_email_steps = args.include?('email')
+    if @generate_path_steps = args.include?('path') || args.include?('paths')
+      File.exists?('features/support/paths.rb') or raise "features/support/paths.rb not found, is your cucumber up to date?"
+    end
+  end
+  
+  def manifest
+    record do |m|
+      m.directory File.join('features/step_definitions')
+      m.directory File.join('features/support')
+      
+      current_pickle = File.exists?('features/support/pickle.rb') ? File.read('features/support/pickle.rb') : ''
+      pickle_assigns = {:pickle_path => false, :pickle_email => false}
+      
+      if @generate_path_steps
+        pickle_assigns[:pickle_path] = true
+        m.template 'paths.rb', File.join('features/support', 'paths.rb')
+      end
+      
+      if @generate_email_steps
+        pickle_assigns[:pickle_email] = true
+        m.template 'email_steps.rb', File.join('features/step_definitions', 'email_steps.rb')
+        m.template 'email.rb', File.join('features/support', 'email.rb')
+      end
+
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', 'pickle_steps.rb')      
+      m.template 'pickle.rb', File.join('features/support', 'pickle.rb'), :assigns => pickle_assigns
+    end
+  end
+end

data/rails_generators/pickle/templates/email.rb

@@ -0,0 +1,21 @@
+module EmailHelpers
+  # Maps a name to an email address. Used by email_steps
+
+  def email_for(to)
+    case to
+  
+    # add your own name => email address mappings here
+  
+    when /^#{capture_model}$/
+      model($1).email
+  
+    when /^"(.*)"$/
+      $1
+  
+    else
+      to
+    end
+  end
+end
+
+World(EmailHelpers)

data/rails_generators/pickle/templates/email_steps.rb

@@ -0,0 +1,63 @@
+# this file generated by script/generate pickle email
+#
+# add email mappings in features/support/email.rb
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+# Clear the deliveries array, useful if your background sends email that you want to ignore
+Given(/^all emails? (?:have|has) been delivered$/) do
+  ActionMailer::Base.deliveries.clear
+end
+
+Given(/^(\d)+ emails? should be delivered$/) do |count|
+  emails.size.should == count.to_i
+end
+
+When(/^(?:I|they) follow "([^"]*?)" in #{capture_email}$/) do |link, email_ref|
+  visit_in_email(email(email_ref), link)
+end
+
+When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
+  click_first_link_in_email(email(email_ref))
+end
+
+Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
+  emails("to: \"#{email_for(to)}\"").size.should == count.to_i
+end
+
+Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
+  emails(fields).size.should == count.to_i
+end
+
+Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
+  email(email_ref, "to: \"#{email_for(to)}\"").should_not be_nil
+end
+
+Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
+  email(email_ref, "to: \"#{email_for(to)}\"").should be_nil
+end
+
+Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
+  email(email_ref, fields).should_not be_nil
+end
+
+Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
+  email(email_ref).body.should =~ /#{text}/
+end
+
+Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
+  email(email_ref).body.should_not =~ /#{text}/
+end
+
+Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
+  email(email_ref).body.should =~ /#{path_to(page)}/
+end
+
+Then(/^show me the emails?$/) do
+   save_and_open_emails
+end

data/rails_generators/pickle/templates/paths.rb

@@ -0,0 +1,47 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+
+    # the following are examples using path_to_pickle
+
+    when /^#{capture_model}(?:'s)? page$/                           # eg. the forum's page
+      path_to_pickle $1
+
+    when /^#{capture_model}(?:'s)? #{capture_model}(?:'s)? page$/   # eg. the forum's post's page
+      path_to_pickle $1, $2
+
+    when /^#{capture_model}(?:'s)? #{capture_model}'s (.+?) page$/  # eg. the forum's post's comments page
+      path_to_pickle $1, $2, :extra => $3                           #  or the forum's post's edit page
+
+    when /^#{capture_model}(?:'s)? (.+?) page$/                     # eg. the forum's posts page
+      path_to_pickle $1, :extra => $2                               #  or the forum's edit page
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/rails_generators/pickle/templates/pickle.rb

@@ -0,0 +1,28 @@
+# this file generated by script/generate pickle [paths] [email]
+#
+# Make sure that you are loading your factory of choice in your cucumber environment
+#
+# For machinist add: features/support/machinist.rb
+#
+#    require 'machinist/active_record' # or your chosen adaptor
+#    require File.dirname(__FILE__) + '/../../spec/blueprints' # or wherever your blueprints are
+#    Before { Sham.reset } # to reset Sham's seed between scenarios so each run has same random sequences
+#
+# For FactoryGirl add: features/support/factory_girl.rb
+#
+#    require 'factory_girl'
+#    require File.dirname(__FILE__) + '/../../spec/factories' # or wherever your factories are
+#
+# You may also need to add gem dependencies on your factory of choice in <tt>config/environments/cucumber.rb</tt>
+
+require 'pickle/world'
+# Example of configuring pickle:
+#
+# Pickle.configure do |config|
+#   config.adapters = [:machinist]
+#   config.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
+# end
+<%- if pickle_path -%>require 'pickle/path/world'
+<%- end -%>
+<%- if pickle_email -%>require 'pickle/email/world'
+<%- end -%>

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -0,0 +1,100 @@
+# this file generated by script/generate pickle
+
+# create a model
+Given(/^#{capture_model} exists?(?: with #{capture_fields})?$/) do |name, fields|
+  create_model(name, fields)
+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) }
+end
+
+# create models from a table
+Given(/^the following #{capture_plural_factory} exists?:?$/) do |plural_factory, table|
+  create_models_from_table(plural_factory, table)
+end
+
+# find a model
+Then(/^#{capture_model} should exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model!(name, fields)
+end
+
+# not find a model
+Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name, fields|
+  find_model(name, fields).should be_nil
+end
+
+# find models with a table
+Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should_not be_any(&:nil?)
+end
+
+# find exactly n models
+Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
+  find_models(plural_factory.singularize, fields).size.should == count.to_i
+end
+
+# assert equality of models
+Then(/^#{capture_model} should be #{capture_model}$/) do |a, b|
+  model!(a).should == model!(b)
+end
+
+# assert model is in another model's has_many assoc
+Then(/^#{capture_model} should be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should include(model!(target))
+end
+
+# assert model is not in another model's has_many assoc
+Then(/^#{capture_model} should not be (?:in|one of|amongst) #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not include(model!(target))
+end
+
+# assert model is another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should == model!(target)
+end
+
+# assert model is not another model's has_one/belongs_to assoc
+Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |target, owner, association|
+  model!(owner).send(association).should_not == model!(target)
+end
+
+# assert model.predicate? 
+Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# assert not model.predicate?
+Then(/^#{capture_model} should not (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
+  if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
+    model!(name).should_not send("have_#{predicate.gsub(' ', '_')}")
+  else
+    model!(name).should_not send("be_#{predicate.gsub(' ', '_')}")
+  end
+end
+
+# model.attribute.should eql(value)
+# model.attribute.should_not eql(value)
+Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
+  actual_value  = model(name).send(attribute)
+  expectation   = expectation.gsub(' ', '_')
+  
+  case expected
+  when 'nil', 'true', 'false'
+    actual_value.send(expectation, send("be_#{expected}"))
+  when /^[+-]?[0-9_]+(\.\d+)?$/
+    actual_value.send(expectation, eql(expected.to_f))
+  else
+    actual_value.to_s.send(expectation, eql(eval(expected)))
+  end
+end
+
+# assert size of association
+Then /^#{capture_model} should have (\d+) (\w+)$/ do |name, size, association|
+  model!(name).send(association).size.should == size.to_i
+end

data/spec/pickle/adapter_spec.rb

@@ -0,0 +1,163 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'active_record'
+require 'factory_girl'
+require 'machinist/active_record'
+require 'pickle/adapters/active_record'
+
+describe Pickle::Adapter do
+  it ".factories should raise NotImplementedError" do
+    lambda{ Pickle::Adapter.factories }.should raise_error(NotImplementedError)
+  end
+
+  it "#create should raise NotImplementedError" do
+    lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
+  end
+
+  describe ".model_classes" do
+    before do
+      Pickle::Adapter.model_classes = nil
+    end
+
+    it "should only include #suitable_for_pickle classes" do
+      klass1 = Class.new(ActiveRecord::Base)
+      klass2 = Class.new(ActiveRecord::Base)
+      klass3 = Class.new(ActiveRecord::Base)
+      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)}
+
+      klass2.stub!(:name).and_return("CGI::Session::ActiveRecordStore::Session")
+      klass3.stub!(:name).and_return("ActiveRecord::SessionStore::Session")
+      klass4.stub!(:table_exists?).and_return(false)
+      klass5.stub!(:abstract_class?).and_return(true)
+      Pickle::Adapter.model_classes.should include(klass1, klass6)
+      Pickle::Adapter.model_classes.should_not include(klass2, klass3, klass4, klass5)
+    end
+  end
+
+  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')}
+    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
+      end
+
+      describe ".new(Class)" do
+        before do
+          @factory = Pickle::Adapter::ActiveRecord.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
+
+    describe 'FactoryGirl' do
+      before do
+        Pickle::Adapter::FactoryGirl.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        @orig_factories, Factory.factories = Factory.factories, {}
+
+        Factory.define(:one, :class => @klass1) {}
+        Factory.define(:two, :class => @klass2) {}
+        @factory1 = Factory.factories[:one]
+        @factory2 = Factory.factories[:two]
+      end
+
+      after do
+        Factory.factories = @orig_factories
+      end
+
+      it ".factories should create one for each factory" do
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory1).once
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory2).once
+        Pickle::Adapter::FactoryGirl.factories
+      end
+
+      describe ".new(factory)" do
+        before do
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
+        end
+
+        it "should have name of factory_name" do
+          @factory.name.should == 'one'
+        end
+
+        it "should have klass of build_class" do
+          @factory.klass.should == @klass1
+        end
+
+        it "#create(attrs) should call Factory(<:key>, attrs)" do
+          Factory.should_receive(:create).with("one", {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+
+    describe 'Machinist' do
+      before do
+        Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+
+        @klass1.blueprint {}
+        @klass3.blueprint {}
+        @klass3.blueprint(:special) {}
+      end
+
+      it ".factories should create one for each master blueprint, and special case" do
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, :master).once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :master).once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :special).once
+        Pickle::Adapter::Machinist.factories
+      end
+
+      describe ".new(Class, :master)" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(@klass1, :master)
+        end
+
+        it "should have underscored (s/_) name of Class as #name" do
+          @factory.name.should == 'one'
+        end
+
+        it "#create(attrs) should call Class.make(:master, attrs)" do
+          @klass1.should_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)
+        end
+
+        it "should have 'special_<Class name>' as #name" do
+          @factory.name.should == 'special_three'
+        end
+
+        it "#create(attrs) should call Class.make(:special, attrs)" do
+          @klass3.should_receive(:make).with(:special, {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+end

data/spec/pickle/config_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Pickle::Config do
+  before 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]
+  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]
+  end
+
+  describe "setting adapters to [:machinist, SomeAdapter]" do
+    class SomeAdapter; end
+
+    before do
+      @config.adapters = [:machinist, SomeAdapter]
+    end
+
+    it "#adapter_classes should be Adapter::Machinist, SomeAdapter" do
+      @config.adapter_classes.should == [Pickle::Adapter::Machinist, SomeAdapter]
+    end
+  end
+
+  describe "#factories" 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([])
+      @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}
+    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}
+    end
+  end
+
+  it "#mappings should default to []" do
+    @config.mappings.should == []
+  end
+
+  describe '#predicates' do
+    it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
+      class1 = mock('Class1',
+                    :public_instance_methods => ['nope', 'foo?', 'bar?'],
+                    :column_names => ['one', 'two'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      class2 = mock('Class2',
+                    :public_instance_methods => ['not', 'foo?', 'faz?'],
+                    :column_names => ['two', 'three'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
+
+      @config.predicates.to_set.should == ['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set
+    end
+
+    it "should be overridable" do
+      @config.predicates = %w(lame?)
+      @config.predicates.should == %w(lame?)
+    end
+  end
+
+  describe "#map 'foo', :to => 'faz'" do
+    before 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')
+    end
+  end
+
+  describe "#map 'foo', 'bar' :to => 'faz'" do
+    before do
+      @config.map 'foo', 'bar', :to => 'faz'
+    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')
+    end
+  end
+
+  it "#configure(&block) should execiute on self" do
+    @config.should_receive(:foo).with(:bar)
+    @config.configure do |c|
+      c.foo :bar
+    end
+  end
+end