wyngle-ripple 0.1.0

data/spec/generators/ripple/js_generator_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'rails/generators/ripple/js/js_generator'
+
+describe Ripple::Generators::JsGenerator do
+  before { run_generator }
+
+  it "should create an app/mapreduce directory" do
+    file('app/mapreduce').should exist
+  end
+
+  it "should copy all standard JS files into the mapreduce directory" do
+    Dir[file('app/mapreduce/*')].sort.map{|f| File.basename(f) }.should == %w{contrib.js iso8601.js ripple.js}
+  end
+end

data/spec/generators/ripple/model_generator_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'rails/generators/ripple/model/model_generator'
+
+shared_examples_for :model_generator do
+  it("should create the model file"){ model_file.should exist }
+  it { should contain(class_decl) }
+  it("should create the attribute declarations") do
+    attributes.each do |name, type|
+      should contain("property :#{name}, #{type}")
+    end
+  end
+end
+
+shared_examples_for :subclass_model_generator do
+  it_behaves_like :model_generator
+  it { should_not contain("include Ripple::Document") }
+  it { should_not contain("include Ripple::EmbeddedDocument") }
+end
+
+shared_examples_for :embedded_document_generator do
+  it_behaves_like :model_generator
+  it { should contain("include Ripple::EmbeddedDocument") }
+end
+
+shared_examples_for :document_generator do
+  it_behaves_like :model_generator
+  it { should contain("include Ripple::Document") }
+end
+
+describe Ripple::Generators::ModelGenerator do
+  let(:cli){ %w{general_model} }
+  let(:model_file){ file('app/models/general_model.rb') }
+  let(:class_decl){ "class GeneralModel" }
+  let(:attributes){ {} }
+  subject { model_file }
+  before { run_generator cli }
+
+  describe "generating a bare model" do
+    it_behaves_like :document_generator
+  end
+
+  describe "generating with attributes" do
+    let(:cli){ %w{general_model name:string shipped:datetime size:integer} }
+    let(:attributes) { {:name => String, :shipped => Time, :size => Integer } }
+    it_behaves_like :document_generator
+  end
+
+  describe "generating a model with a parent class" do
+    let(:cli){ %w{general_model --parent=widget} }
+    let(:class_decl){ "class GeneralModel < Widget" }
+    it_behaves_like :subclass_model_generator
+  end
+
+  describe "generating an embedded model" do
+    let(:cli){ %w{general_model --embedded} }
+    it_behaves_like :embedded_document_generator
+  end
+
+  describe "generating a model embedded in a parent document" do
+    let(:cli){ %w{general_model --embedded-in=widget} }
+    it_behaves_like :embedded_document_generator
+    it { should contain("embedded_in :widget") }
+  end
+end

data/spec/generators/ripple/observer_generator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'rails/generators/ripple/observer/observer_generator'
+
+describe Ripple::Generators::ObserverGenerator do
+  context "in the top-level scope" do
+    before { run_generator %w{person} }
+    subject{ file('app/models/person_observer.rb') }
+
+    it { should exist }
+    it { should contain("class PersonObserver < ActiveModel::Observer") }
+  end
+
+  context "in a nested scope" do
+    before { run_generator %w{profiles/social} }
+    subject { file('app/models/profiles/social_observer.rb') }
+
+    it { should exist }
+    it { should contain("class Profiles::SocialObserver < ActiveModel::Observer") }
+  end
+end

data/spec/generators/ripple/test_generator_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'rails/generators/ripple/test/test_generator'
+
+describe Ripple::Generators::TestGenerator do
+  context "when Cucumber is present" do
+    before { mkdir_p file('features/support') }
+    before { run_generator }
+
+    it "should create a support file for the test server" do
+      file('features/support/ripple.rb').should exist
+    end
+  end
+
+  context "when RSpec is present" do
+    let(:original_contents) do
+      [
+       "require 'rspec'",
+       "RSpec.configure do |config|",
+       "  config.mock_with :rspec",
+       "end"
+      ]
+    end
+    let(:helper) { file('spec/spec_helper.rb') }
+    let(:contents) { File.read(helper) }
+    before do
+      mkdir_p file('spec')
+      File.open(helper,'w') do |f|
+        f.write original_contents.join("\n")
+      end
+      run_generator
+    end
+
+    it "should insert the test server require" do
+      contents.should include("require 'ripple/test_server'")
+    end
+
+    it "should insert the test server setup" do
+      contents.should include("  config.before(:suite) { Ripple::TestServer.setup }")
+      contents.should include("  config.after(:each) { Ripple::TestServer.clear }")
+      contents.should include("  config.after(:suite) { Ripple::TestServer.instance.stop }")
+    end
+
+    context "when the configuration block is indented" do
+      let(:original_contents) do
+        [
+         "require 'rspec'",
+         "require 'spork'",
+         "Spork.prefork do",
+         "  RSpec.configure do |config|",
+         "    config.mock_with :rspec",
+         "  end",
+         "end"
+        ]
+      end
+
+      it "should insert the test server require with additional indentation" do
+        contents.should include("  require 'ripple/test_server'")
+      end
+
+      it "should insert the test server setup with additional indentation" do
+        contents.should include("    config.before(:suite) { Ripple::TestServer.setup }")
+        contents.should include("    config.after(:each) { Ripple::TestServer.clear }")
+        contents.should include("    config.after(:suite) { Ripple::TestServer.instance.stop }")
+      end
+    end
+  end
+
+  context "when Test::Unit is present" do
+    let(:original_contents) do
+      [
+       "require 'active_support/test_case'",
+       "class ActiveSupport::TestCase",
+       "  setup :load_fixtures",
+       "end"
+      ]
+    end
+    let(:helper) { file('test/test_helper.rb') }
+    let(:contents) { File.read(helper) }
+    before do
+      mkdir_p file('test')
+      File.open(helper,'w') do |f|
+        f.write original_contents.join("\n")
+      end
+      run_generator
+    end
+
+    it "should insert the test server require" do
+      contents.should include("require 'ripple/test_server'")
+    end
+
+    it "should insert the test server setup and teardown" do
+      contents.should include("  setup { Ripple::TestServer.setup }")
+      contents.should include("  teardown { Ripple::TestServer.clear }")
+    end
+
+    context "when the test case class is indented" do
+      let(:original_contents) do
+        [
+         "require 'active_support/test_case'",
+         "module MyApp",
+         "  class ActiveSupport::TestCase",
+         "    setup :load_fixtures",
+         "  end",
+         "end"
+        ]
+      end
+
+      it "should insert the test server require with additional indentation" do
+        contents.should include("  require 'ripple/test_server'")
+      end
+
+      it "should insert the test server setup and teardown with additional indentation" do
+        contents.should include("    setup { Ripple::TestServer.setup }")
+        contents.should include("    teardown { Ripple::TestServer.clear }")
+      end
+    end
+  end
+end

data/spec/generators/ripple_generator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'rails/generators/ripple_generator'
+
+describe RippleGenerator do
+  it "should invoke the sub-generators" do
+    %w{configuration js test}.each do |gen|
+      generator.should_receive(:invoke).with("ripple:#{gen}")
+    end
+    run_generator
+  end
+end

data/spec/integration/ripple/associations_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe "Ripple Associations" do
+  before :each do
+    @user        = User.new(:email => 'riak@ripple.com')
+    @profile     = UserProfile.new(:name => 'Ripple')
+    @billing     = Address.new(:street => '123 Somewhere Dr', :kind => 'billing')
+    @shipping    = Address.new(:street => '321 Anywhere Pl', :kind => 'shipping')
+    @friend1     = User.create(:email => "friend@ripple.com")
+    @friend2     = User.create(:email => "friend2@ripple.com")
+    @cc          = CreditCard.new(:number => '12345')
+    @post        = Post.new(:title => "Hello, world!")
+    @comment_one = Comment.new.tap{|c| c.key = "one"; c.save! }
+    @comment_two = Comment.new.tap{|c| c.key = "two"; c.save! }
+  end
+
+  it "should save and restore a many stored key association" do
+    @post.comments << @comment_one << @comment_two
+    @post.save!
+
+    post = Post.find(@post.key)
+    post.comment_keys.should == [ 'one', 'two' ]
+    post.comments.keys.should == [ 'one', 'two' ]
+    post.comments.should == [ @comment_one, @comment_two ]
+  end
+
+  it "should remove a document from a many stored key association" do
+    @post.comments << @comment_one
+    @post.comments << @comment_two
+    @post.save!
+    @post.comments.delete(@comment_one)
+    @post.save!
+
+    @post = Post.find(@post.key)
+    @post.comment_keys.should == [ @comment_two.key ]
+    @post.comments.should == [ @comment_two ]
+  end
+
+  it "should save one embedded associations" do
+    @user.user_profile = @profile
+    @user.save
+    @found = User.find(@user.key)
+    @found.user_profile.name.should == 'Ripple'
+    @found.user_profile.should be_a(UserProfile)
+    @found.user_profile.user.should == @found
+  end
+
+  it "should not raise an error when a one linked associated record has been deleted" do
+    @user.emergency_contact = @friend1
+    @user.save
+
+    @friend1.destroy
+    @found = User.find(@user.key)
+    @found.emergency_contact.should be_nil
+  end
+
+  it "should allow a many linked record to be deleted from the association but kept in the datastore" do
+    @user.friends << @friend1
+    @user.save!
+
+    @user.friends.delete(@friend1)
+    @user.save!
+
+    found_user = User.find(@user.key)
+    found_user.friends.should be_empty
+    User.find(@friend1.key).should be
+  end
+
+  it "should allow a many embedded record to be deleted from the association" do
+    @user.addresses << @billing << @shipping
+    @user.save!
+
+    @user.addresses.delete(@billing)
+    @user.save!
+    User.find(@user.key).addresses.should == [@shipping]
+  end
+
+  it "should save many embedded associations" do
+    @user.addresses << @billing << @shipping
+    @user.save
+    @found = User.find(@user.key)
+    @found.addresses.count.should == 2
+    @bill = @found.addresses.detect {|a| a.kind == 'billing'}
+    @ship = @found.addresses.detect {|a| a.kind == 'shipping'}
+    @bill.street.should == '123 Somewhere Dr'
+    @ship.street.should == '321 Anywhere Pl'
+    @bill.user.should == @found
+    @ship.user.should == @found
+    @bill.should be_a(Address)
+    @ship.should be_a(Address)
+  end
+
+  it "should save a many linked association" do
+    @user.friends << @friend1 << @friend2
+    @user.save
+    @user.should_not be_new_record
+    @found = User.find(@user.key)
+    @found.friends.should include(@friend1)
+    @found.friends.should include(@friend2)
+  end
+
+  it "should save a one linked association" do
+    @user.emergency_contact = @friend1
+    @user.save
+    @user.should_not be_new_record
+    @found = User.find(@user.key)
+    @found.emergency_contact.should == @friend1
+  end
+
+  it "should reload associations" do
+    @user.friends << @friend1
+    @user.save!
+
+    friend1_new_instance = User.find(@friend1.key)
+    friend1_new_instance.email = 'new-address@ripple.com'
+    friend1_new_instance.save!
+
+    @user.reload
+    @user.friends.map(&:email).should == ['new-address@ripple.com']
+  end
+
+  it "allows and autosaves transitive linked associations" do
+    friend = User.new(:email => 'user-friend@example.com')
+    friend.key = 'main-user-friend'
+    @user.key = 'main-user'
+    @user.friends << friend
+    friend.friends << @user
+
+    @user.save! # should save both since friend is new
+
+    found_user = User.find!(@user.key)
+    found_friend = User.find!(friend.key)
+
+    found_user.friends.should == [found_friend]
+    found_friend.friends.should == [found_user]
+  end
+
+  it "should find the object associated by key after saving" do
+    @user.key = 'paying-user'
+    @user.credit_card = @cc
+    @user.save && @cc.save
+    @found = User.find(@user.key)
+    @found.reload
+    @found.credit_card.should eq(@cc)
+  end
+
+  it "should assign the generated riak key to the associated object using key" do
+    @user.key.should be_nil
+    @user.credit_card = @cc
+    @user.save
+    @cc.key.should_not be_blank
+    @cc.key.should eq(@user.key)
+  end
+
+  it "should save one association by storing key" do
+    @user.save!
+    @post.user = @user
+    @post.save!
+    @post.user_key.should == @user.key
+    @found = Post.find(@post.key)
+    @found.user.email.should == 'riak@ripple.com'
+    @found.user.should be_a(User)
+  end
+end

data/spec/integration/ripple/conflict_resolution_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+
+describe "Ripple conflict resolution", :integration => true do
+  class ConflictedPerson
+    include Ripple::Document
+
+    property :name,   String
+    property :age,    Integer, :numericality => { :greater_than => 0, :allow_nil => true }
+    property :gender, String
+    property :favorite_colors, Set, :default => lambda { Set.new }
+    property :created_at, DateTime
+    property :updated_at, DateTime
+    property :coworker_keys, Array
+    property :mother_key, String
+    key_on   :name
+
+    # embedded
+    one :address, :class_name => 'ConflictedAddress'
+    many :jobs, :class_name => 'ConflictedJob'
+
+    # linked
+    one :spouse, :class_name => 'ConflictedPerson'
+    many :friends, :class_name => 'ConflictedPerson'
+
+    #stored_key
+    one :mother, :using => :stored_key, :class_name => 'ConflictedPerson'
+    many :coworkers, :using => :stored_key, :class_name => 'ConflictedPerson'
+  end
+
+  class ConflictedAddress
+    include Ripple::EmbeddedDocument
+    property :city, String
+  end
+
+  class ConflictedJob
+    include Ripple::EmbeddedDocument
+    property :title, String
+  end
+
+  before(:each) do
+    ConflictedPerson.bucket.allow_mult ||= true
+    ConflictedPerson.on_conflict { } # reset to no-op
+  end
+
+  context 'when there is no conflict' do
+    it 'does not invoke the on_conflict hook' do
+      ConflictedPerson.on_conflict { raise "This conflict hook should not be invoked" }
+
+      # no errors should be raised by the hook above
+      ConflictedPerson.find('Noone')
+      ConflictedPerson.create!(:name => 'John')
+      ConflictedPerson.find('John').should_not be_nil
+    end
+  end
+
+  let(:created_at) { DateTime.new(2011, 5, 12, 8, 30, 0) }
+  let(:updated_at) { DateTime.new(2011, 5, 12, 8, 30, 0) }
+
+  let(:original_person) do
+    ConflictedPerson.create!(
+                             :name            => 'John',
+                             :age             => 25,
+                             :gender          => 'male',
+                             :favorite_colors => ['green'],
+                             :address         => ConflictedAddress.new(:city => 'Seattle'),
+                             :jobs            => [ConflictedJob.new(:title => 'Engineer')],
+                             :spouse          => ConflictedPerson.create!(:name => 'Jill', :gender => 'female'),
+                             :friends         => [ConflictedPerson.create!(:name => 'Quinn', :gender => 'male')],
+                             :coworkers       => [ConflictedPerson.create!(:name => 'Horace', :gender => 'male')],
+                             :mother          => ConflictedPerson.create!(:name => 'Serena', :gender => 'female'),
+                             :created_at      => created_at,
+                             :updated_at      => updated_at
+                             )
+  end
+
+  context 'for a document that has a deleted sibling' do
+    before(:each) do
+      create_conflict original_person,
+        lambda { |p| p.destroy! },
+        lambda { |p| p.age = 20 },
+        lambda { |p| p.age = 30 }
+    end
+
+    it 'indicates that one of the siblings was deleted' do
+      siblings = nil
+      ConflictedPerson.on_conflict { |s, c| siblings = s }
+      ConflictedPerson.find('John')
+
+      siblings.should have(3).sibling_records
+      deleted, undeleted = siblings.partition(&:deleted?)
+      deleted.should have(1).record
+      undeleted.should have(2).records
+      deleted = deleted.first
+
+      # the deleted record should be totally blank except for the name (since it is the key)
+      deleted.attributes.reject { |k, v| v.blank? }.should == {"name" => "John"}
+    end
+
+    it 'does not consider the deleted sibling when trying basic resolution of attributes that siblings are in agreement about' do
+      record = conflicts = nil
+      ConflictedPerson.on_conflict { |s, c| conflicts = c; record = self }
+      ConflictedPerson.find('John')
+
+      conflicts.should == [:age]
+      record.gender.should == 'male'
+      record.favorite_colors.should == ['green'].to_set
+    end
+  end
+
+  context 'for a document that has conflicted attributes' do
+    let(:most_recent_updated_at) { DateTime.new(2011, 6, 4, 12, 30) }
+    let(:earliest_created_at)    { DateTime.new(2010, 5, 3, 12, 30) }
+
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.age = 20; p.created_at = earliest_created_at },
+      lambda { |p| p.age = 30; p.updated_at = most_recent_updated_at },
+      lambda { |p| p.favorite_colors << 'red' }
+    end
+
+    it 'raises a NotImplementedError when there is no on_conflict handler' do
+      ConflictedPerson.instance_variable_get(:@on_conflict_block).should_not be_nil
+      ConflictedPerson.instance_variable_set(:@on_conflict_block, nil)
+
+      expect {
+        ConflictedPerson.find('John')
+      }.to raise_error(NotImplementedError)
+    end
+
+    it 'invokes the on_conflict block with the siblings and the list of conflicted attributes' do
+      siblings = conflicts = nil
+      ConflictedPerson.on_conflict { |s, c| siblings = s; conflicts = c }
+      ConflictedPerson.find('John')
+
+      siblings.should have(3).sibling_records
+      siblings.map(&:class).uniq.should == [ConflictedPerson]
+      siblings.map(&:age).should =~ [20, 25, 30]
+
+      conflicts.should =~ [:age, :favorite_colors]
+    end
+
+    it 'automatically resolves any attributes that are in agreement among all siblings' do
+      record = nil
+      ConflictedPerson.on_conflict { record = self }
+      ConflictedPerson.find('John')
+      record.name.should == 'John'
+      record.gender.should == 'male'
+    end
+
+    it 'automatically resolves updated_at to the most recent timestamp' do
+      record = nil
+      ConflictedPerson.on_conflict { record = self }
+      ConflictedPerson.find('John')
+      record.updated_at.should == most_recent_updated_at
+    end
+
+    it 'automatically resolves created_at to the earliest timestamp' do
+      record = nil
+      ConflictedPerson.on_conflict { record = self }
+      ConflictedPerson.find('John')
+      record.created_at.should == earliest_created_at
+    end
+
+    it 'automatically sets conflicted attributes to their default values' do
+      record = nil
+      ConflictedPerson.on_conflict { record = self }
+      ConflictedPerson.find('John')
+      record.age.should be_nil
+      record.favorite_colors.should == Set.new
+    end
+
+    it 'returns the resolved record with the changes made by the on_conflict hook' do
+      ConflictedPerson.on_conflict do |siblings, _|
+        self.age = siblings.map(&:age).inject(&:+)
+      end
+
+      person = ConflictedPerson.find('John')
+      person.age.should == (20 + 25 + 30)
+    end
+
+    it "reloads a document with conflicts" do
+      record = original_person.reload
+      record.updated_at.should == most_recent_updated_at
+    end
+
+    context 'when .on_conflict is given a list of attributes' do
+      it 'raises an error if attributes not mentioned in the list are in conflict' do
+        ConflictedPerson.on_conflict(:age) { }
+        expect {
+          ConflictedPerson.find('John')
+        }.to raise_error(NotImplementedError) # since favorite_colors is also in conflict
+      end
+
+      it 'does not raise an error if all conflicted attributes are in the list' do
+        ConflictedPerson.on_conflict(:age, :favorite_colors) { }
+        ConflictedPerson.find('John')
+      end
+    end
+  end
+
+  context 'when there are conflicts on a one embedded association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.address.city = 'San Francisco' },
+      lambda { |p| p.address.city = 'Portland' }
+    end
+
+    it 'sets the association to nil and includes its name in the list of conflicts passed to the on_conflict block' do
+      siblings = conflicts = record = nil
+      ConflictedPerson.on_conflict { |*a| siblings, conflicts = *a; record = self }
+      ConflictedPerson.find('John')
+      record.address.should be_nil
+      conflicts.should == [:address]
+      siblings.map { |s| s.address.city }.should =~ ['Portland', 'San Francisco']
+    end
+  end
+
+  context 'when there are conflicts on a many embedded association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.jobs << ConflictedJob.new(:title => 'CEO') },
+      lambda { |p| p.jobs << ConflictedJob.new(:title => 'CTO') }
+    end
+
+    it 'sets the association to an empty array and includes its name in the list of conflicts passed to the on_conflict block' do
+      siblings = conflicts = record = nil
+      ConflictedPerson.on_conflict { |*a| siblings, conflicts = *a; record = self }
+      ConflictedPerson.find('John')
+      record.jobs.should == []
+      conflicts.should == [:jobs]
+      siblings.map { |s| s.jobs.map(&:title) }.should =~ [["Engineer", "CEO"], ["Engineer", "CTO"]]
+    end
+  end
+
+  context 'when there are conflicts on a one linked association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.spouse = ConflictedPerson.create!(:name => 'Renee', :gender => 'female') },
+      lambda { |p| p.spouse = ConflictedPerson.create!(:name => 'Sharon', :gender => 'female') }
+    end
+
+    it 'sets the association to nil and includes its name in the list of conflicts passed to the on_conflict block' do
+      record_spouse = conflicts = sibling_spouse_names = nil
+
+      ConflictedPerson.on_conflict do |siblings, c|
+        record_spouse = spouse
+        conflicts = c
+        sibling_spouse_names = siblings.map { |s| s.spouse.name }
+      end
+
+      ConflictedPerson.find('John')
+      record_spouse.should be_nil
+      conflicts.should == [:spouse]
+      sibling_spouse_names.should =~ %w[ Sharon Renee ]
+    end
+  end
+
+  context 'when there are conflicts on a many linked association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.friends << ConflictedPerson.new(:name => 'Luna', :gender => 'female') },
+      lambda { |p| p.friends << ConflictedPerson.new(:name => 'Molly', :gender => 'female') }
+    end
+
+    it 'sets the association to a blank array and includes its name in the list of conflicts passed to the on_conflict block' do
+      record_friends = conflicts = sibling_friend_names = nil
+
+      ConflictedPerson.on_conflict do |siblings, c|
+        record_friends = friends
+        conflicts = c
+        sibling_friend_names = siblings.map { |s| s.friends.map(&:name) }
+      end
+
+      ConflictedPerson.find('John')
+      record_friends.should == []
+      conflicts.should == [:friends]
+      sibling_friend_names.map(&:sort).should =~ [['Luna', 'Quinn'], ['Molly', 'Quinn']]
+    end
+  end
+
+  context 'when there are conflicts on a many stored_key association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.coworkers << ConflictedPerson.create!(:name => 'Colleen', :gender => 'female') },
+      lambda { |p| p.coworkers = [ ConflictedPerson.create!(:name => 'Russ', :gender => 'male'),
+                                   ConflictedPerson.create!(:name => 'Denise', :gender => 'female') ] }
+    end
+
+    it 'sets the association to a blank array and includes the owner_keys in the list of conflicts passed to the on_conflict block' do
+      record_coworkers = record_coworker_keys = conflicts = sibling_coworker_keys = nil
+
+      ConflictedPerson.on_conflict do |siblings, c|
+        record_coworkers = coworkers
+        record_coworker_keys = coworker_keys
+        conflicts = c
+        sibling_coworker_keys = siblings.map { |s| s.coworker_keys }
+      end
+
+      ConflictedPerson.find('John')
+      record_coworker_keys.should == []
+      record_coworkers.should == []
+      conflicts.should == [:coworker_keys]
+      sibling_coworker_keys.map(&:sort).should =~ [['Colleen', 'Horace'], ['Denise', 'Russ']]
+    end
+  end
+
+  context 'when there are conflicts on a one stored_key association' do
+    before(:each) do
+      create_conflict original_person,
+      lambda { |p| p.mother = ConflictedPerson.new(:name => 'Nancy', :gender => 'female') },
+      lambda { |p| p.mother = ConflictedPerson.new(:name => 'Sherry', :gender => 'male') }
+    end
+
+    it 'sets the association to nil and includes its name in the list of conflicts passed to the on_conflict block' do
+      record_mother = conflicts = sibling_mother_keys = nil
+
+      ConflictedPerson.on_conflict do |siblings, c|
+        record_mother = mother
+        conflicts = c
+        sibling_mother_keys = siblings.map { |s| s.mother_key }
+      end
+
+      ConflictedPerson.find('John')
+      record_mother.should be_nil
+      conflicts.should == [:mother_key]
+      sibling_mother_keys.sort.should == %w(Nancy Sherry)
+    end
+  end
+end