seomoz-ripple 1.0.0.pre

data/spec/fixtures/config.yml

@@ -0,0 +1,8 @@
+ripple:
+  http_port: 9000
+  host: localhost
+  
+ripple_rails:
+  development:
+    http_port: 9001
+    host: 127.0.0.1

data/spec/integration/ripple/associations_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe "Ripple Associations" do
+  require 'support/test_server'
+
+  before :all do
+    Object.module_eval do
+      class User
+        include Ripple::Document
+        one  :profile
+        many :addresses
+        property :email, String, :presence => true
+        many :friends, :class_name => "User"
+        one :emergency_contact, :class_name => "User"
+        one :credit_card, :using => :key
+      end
+      class Profile
+        include Ripple::EmbeddedDocument
+        property :name, String, :presence => true
+        embedded_in :user
+      end
+      class Address
+        include Ripple::EmbeddedDocument
+        property :street, String, :presence => true
+        property :kind,   String, :presence => true
+        embedded_in :user
+      end
+      class CreditCard
+        include Ripple::Document
+        one :user, :using => :key
+        property :number, Integer
+      end
+      class Post
+        include Ripple::Document
+        one :user, :using => :stored_key
+        many :comments, :using => :stored_key
+        property :comment_keys, Array
+        property :user_key, String
+        property :title, String
+      end
+      class Comment
+        include Ripple::Document
+      end
+    end
+  end
+
+  before :each do
+    @user        = User.new(:email => 'riak@ripple.com')
+    @profile     = Profile.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.profile = @profile
+    @user.save
+    @found = User.find(@user.key)
+    @found.profile.name.should == 'Ripple'
+    @found.profile.should be_a(Profile)
+    @found.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.map(&:key).should include(@friend1.key)
+    @found.friends.map(&:key).should include(@friend2.key)
+  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.key.should == @friend1.key
+  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
+
+  after :each do
+    User.destroy_all
+  end
+
+  after :all do
+    Object.send(:remove_const, :User)
+    Object.send(:remove_const, :Profile)
+    Object.send(:remove_const, :Address)
+    Object.send(:remove_const, :CreditCard)
+    Object.send(:remove_const, :Post)
+  end
+
+end

data/spec/integration/ripple/conflict_resolution_spec.rb

@@ -0,0 +1,293 @@
+require 'spec_helper'
+
+describe "Ripple conflict resolution" 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'
+
+    bucket.allow_mult = true
+  end
+
+  class ConflictedAddress
+    include Ripple::EmbeddedDocument
+    property :city, String
+  end
+
+  class ConflictedJob
+    include Ripple::EmbeddedDocument
+    property :title, String
+  end
+
+
+  before(:each) do
+    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 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
+
+    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