ripple 0.9.5 → 1.0.0.beta

data/spec/integration/ripple/nested_attributes_spec.rb

@@ -1,14 +1,13 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 require 'active_support/core_ext/array'
 
-describe Ripple::NestedAttributes do
-  require 'support/models/car'
-  require 'support/models/driver'
-  require 'support/models/passenger'
-  require 'support/models/engine'
-  require 'support/models/seat'
-  require 'support/models/wheel'
-  require 'support/test_server'
+describe Ripple::NestedAttributes, :integration => true do
+  # require 'support/models/car'
+  # require 'support/models/driver'
+  # require 'support/models/passenger'
+  # require 'support/models/engine'
+  # require 'support/models/seat'
+  # require 'support/models/wheel'
 
   context "one :driver (link)" do
     subject { Car.new }
@@ -93,10 +92,9 @@ describe Ripple::NestedAttributes do
       end
 
       it "should save the children when saving the parent" do
-        subject.passengers.each do |passenger|
-          passenger.should_receive(:save)
-        end
         subject.save
+        found_subject = Car.find(subject.key)
+        found_subject.passengers.map(&:name).should =~ %w[ Joe Sue Pat ]
       end
     end
 
@@ -134,12 +132,16 @@ describe Ripple::NestedAttributes do
 
       it "should save the child when saving the parent" do
         subject.passengers_attributes = [ { :key => passenger1.key, :name => 'UPDATED One' },
-                                          { :key => passenger1.key, :name => 'UPDATED Two' },
-                                          { :key => passenger1.key, :name => 'UPDATED Three' } ]
-        subject.passengers.each do |passenger|
-          passenger.should_receive(:save)
-        end
+                                          { :key => passenger2.key, :name => 'UPDATED Two' },
+                                          { :key => passenger3.key, :name => 'UPDATED Three' } ]
         subject.save
+
+        found_subject = Car.find(subject.key)
+        found_subject.passengers.map(&:name).should =~ [
+          'UPDATED One',
+          'UPDATED Two',
+          'UPDATED Three'
+        ]
       end
     end
   end
@@ -255,7 +257,5 @@ describe Ripple::NestedAttributes do
       subject.save
       subject.wheels.should == []
     end
-
   end
-
 end

data/spec/integration/ripple/persistence_spec.rb

@@ -1,41 +1,16 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../../../spec_helper", __FILE__)
+require 'spec_helper'
 
 describe "Ripple Persistence" do
-  require 'support/test_server'
-
-  before :all do    
-    Object.module_eval do
-      class Widget
-        include Ripple::Document
-        property :name, String
-        property :size, Integer
-      end
-    end
-  end
-  
   before :each do
     @widget = Widget.new
   end
-  
+
   it "should save an object to the riak database" do
     @widget.save
     @found = Widget.find(@widget.key)
     @found.should be_a(Widget)
   end
-  
+
   it "should save attributes properly to riak" do
     @widget.attributes = {:name => 'Sprocket', :size => 10}
     @widget.save
@@ -43,13 +18,19 @@ describe "Ripple Persistence" do
     @found.name.should == 'Sprocket'
     @found.size.should == 10
   end
-  
-  after :each do
-    Widget.destroy_all
+end
+
+describe Ripple::Document do
+  let(:custom_data)        { Subscription::MyCustomType.new('bar') }
+  let(:days_of_month)      { Set.new([1, 7, 15, 23]) }
+  let(:subscription)       { Subscription.create!(:custom_data => custom_data, :days_of_month => days_of_month) }
+  let(:found_subscription) { Subscription.find(subscription.key) }
+
+  it 'allows properties with custom types to be saved and restored from riak' do
+    found_subscription.custom_data.should == custom_data
   end
 
-  after :all do
-    Object.send(:remove_const, :Widget)
+  it 'allows Set properties to be saved and restored from riak' do
+    found_subscription.days_of_month.should == days_of_month
   end
-  
 end

data/spec/integration/ripple/search_associations_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Ripple Search Associations", :integration => true, :search => true do
+  class SearchTransaction
+    include Ripple::Document
+    property :search_account_key, String
+    property :name, String
+  end
+
+  class SearchAccount
+    include Ripple::Document
+    many :search_transactions, :using => :reference
+    property :email, String
+  end
+
+  before :each do
+    @account      = SearchAccount.new(:email => 'riak@ripple.com')
+    @transaction1 = SearchTransaction.new(:name => 'One')
+    @transaction2 = SearchTransaction.new(:name => 'Two')
+  end
+
+  it "should save a many referenced association" do
+    @account.save!
+    @account.search_transactions << @transaction1 << @transaction2
+    @transaction1.save!
+    @transaction2.save!
+    @found = SearchAccount.find(@account.key)
+    @found.search_transactions.map(&:key).should include(@transaction1.key)
+    @found.search_transactions.map(&:key).should include(@transaction2.key)
+  end
+end

data/spec/ripple/associations/many_embedded_proxy_spec.rb

@@ -1,81 +1,68 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../../../spec_helper", __FILE__)
+require 'spec_helper'
 
 describe Ripple::Associations::ManyEmbeddedProxy do
-  require 'support/models/user'
-  require 'support/models/address'
-  require 'support/models/note'
-    
+  # require 'support/models/user'
+  # require 'support/models/address'
+  # require 'support/models/note'
+
   before :each do
-    @user    = User.new
+    @user    = User.new(:email => "riak@ripple.com")
     @address = Address.new
     @addr    = Address.new(:street => '123 Somewhere')
     @note    = Note.new
   end
-  
+
   it "should not have children before any are set" do
     @user.addresses.should == []
   end
-  
+
   it "should be able to set and get its children" do
     Address.stub!(:instantiate).and_return(@address)
     @user.addresses = [@address]
     @user.addresses.should == [@address]
   end
-  
+
   it "should set the parent document on the children when assigning" do
     @user.addresses = [@address]
     @address._parent_document.should == @user
   end
-  
+
   it "should return the assignment when assigning" do
     rtn = @user.addresses = [@address]
     rtn.should == [@address]
   end
-  
+
   it "should set the parent document on the children when accessing" do
     @user.addresses = [@address]
     @user.addresses.first._parent_document.should == @user
   end
-  
+
   it "should be able to replace its children with different children" do
     @user.addresses = [@address]
     @user.addresses.first.street.should be_blank
     @user.addresses = [@addr]
     @user.addresses.first.street.should == '123 Somewhere'
   end
-  
+
   it "should be able to add to its children" do
     Address.stub!(:instantiate).and_return(@address)
     @user.addresses = [@address]
     @user.addresses << @address
     @user.addresses.should == [@address, @address]
   end
-  
+
   it "should be able to chain calls to adding children" do
     Address.stub!(:instantiate).and_return(@address)
     @user.addresses = [@address]
     @user.addresses << @address << @address << @address
     @user.addresses.should == [@address, @address, @address, @address]
   end
-  
+
   it "should set the parent document when adding to its children" do
     @user.addresses << @address
     @user.addresses.first._parent_document.should == @user
   end
-  
+
   it "should be able to count its children" do
     @user.addresses = [@address, @address]
     @user.addresses.count.should == 2
@@ -85,37 +72,37 @@ describe Ripple::Associations::ManyEmbeddedProxy do
     Address.stub!(:new).and_return(@address)
     @user.addresses.build.should == @address
   end
-  
+
   it "should assign a parent to the children created with instantiate_target" do
     Address.stub!(:new).and_return(@address)
     @address._parent_document.should be_nil
     @user.addresses.build._parent_document.should == @user
   end
-  
+
   it "should validate the children when saving the parent" do
     @user.valid?.should be_true
     @user.addresses << @address
     @address.valid?.should be_false
     @user.valid?.should be_false
   end
-  
+
   it "should not save the root document when a child is invalid" do
     @user.addresses << @address
     @user.save.should be_false
   end
-  
+
   it "should allow embedding documents in embedded documents" do
     @user.addresses << @address
     @address.notes << @note
     @note._root_document.should   == @user
     @note._parent_document.should == @address
   end
-  
+
   it "should allow assiging child documents as an array of hashes" do
     @user.attributes = {'addresses' => [{'street' => '123 Somewhere'}]}
     @user.addresses.first.street.should == '123 Somewhere'
   end
-  
+
   it "should return an array from to_ary" do
     Address.stub!(:instantiate).and_return(@address)
     @user.addresses << @address
@@ -127,7 +114,7 @@ describe Ripple::Associations::ManyEmbeddedProxy do
     lambda { @user.addresses = @address }.should raise_error
     lambda { @user.addresses = [@note] }.should raise_error
   end
-  
+
   it "should not add the associated validator multiple times" do
     #$stderr.puts User.validators.collect(&:inspect)
     User.validators_on(:addresses).count.should eq(1)

data/spec/ripple/associations/many_linked_proxy_spec.rb

@@ -1,25 +1,13 @@
-# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-require File.expand_path("../../../spec_helper", __FILE__)
+require 'spec_helper'
 
 describe Ripple::Associations::ManyLinkedProxy do
-  require 'support/models/tasks'
+  # require 'support/models/tasks'
 
   before :each do
     @person = Person.new {|p| p.key = "riak-user" }
     @task = Task.new {|t| t.key = "one" }
     @other_task = Task.new {|t| t.key = "two" }
+    @third_task = Task.new {|t| t.key = "three" }
     [@person, @task, @other_task].each do |doc|
       doc.stub!(:new?).and_return(false)
     end
@@ -35,7 +23,13 @@ describe Ripple::Associations::ManyLinkedProxy do
 
   it "should set the links on the RObject when assigning" do
     @person.tasks = [@task]
-    @person.robject.links.should include(@task.robject.to_link("tasks"))
+    @person.robject.links.should include(@task.to_link("tasks"))
+  end
+
+  it "should be able to replace the entire collection of documents (even appended ones)" do
+    @person.tasks << @task
+    @person.tasks = [@other_task]
+    @person.tasks.should == [@other_task]
   end
 
   it "should return the assigned documents when assigning" do
@@ -43,47 +37,39 @@ describe Ripple::Associations::ManyLinkedProxy do
     t.should == [@task]
   end
 
-  it "should save unsaved documents when assigning" do
-    @task.should_receive(:new?).and_return(true)
-    @task.should_receive(:save).and_return(true)
-    @person.tasks = [@task]
-  end
-
   it "should link-walk to the associated documents when accessing" do
-    @person.robject.links << @task.robject.to_link("tasks")
+    @person.robject.links << @task.to_link("tasks")
     @person.robject.should_receive(:walk).with(Riak::WalkSpec.new(:bucket => "tasks", :tag => "tasks")).and_return([])
     @person.tasks.should == []
   end
 
-  it "should replace associated documents with a new set" do
-    @person.tasks = [@task]
-    @person.tasks = [@other_task]
-    @person.tasks.should == [@other_task]
-  end
+  it "handles conflict appropriately by selecting the linked-walk robjects that match the links" do
+    @person.robject.links << @task.to_link("tasks") << @other_task.to_link("tasks")
+    @person.robject.
+      should_receive(:walk).
+      with(Riak::WalkSpec.new(:bucket => "tasks", :tag => "tasks")).
+      and_return([[@task.robject, @other_task.robject, @third_task.robject]])
 
-  it "should be able to append documents to the associated set" do
-    @person.tasks << @task
-    @person.tasks << @other_task
-    @person.should have(2).tasks
+    @person.tasks.should == [@task, @other_task]
   end
 
-  it "should be able to chain calls to adding documents" do
-    @person.tasks << @task << @other_task
-    @person.should have(2).tasks
+  it "allows the links to be replaced directly" do
+    @person.tasks = [@task]
+    @person.tasks.__send__(:should_receive, :reset)
+    @person.tasks.__send__(:links).should == [@task.robject.to_link("tasks")]
+    @person.tasks.replace_links([@other_task, @third_task].map { |t| t.robject.to_link("tasks") })
+    @person.tasks.__send__(:links).should == [@other_task, @third_task].map { |t| t.robject.to_link("tasks") }
   end
 
-  it "should set the links on the RObject when appending" do
-    @person.tasks << @task << @other_task
-    [@task, @other_task].each do |t|
-      @person.robject.links.should include(t.robject.to_link("tasks"))
-    end
+  it "should replace associated documents with a new set" do
+    @person.tasks = [@task]
+    @person.tasks = [@other_task]
+    @person.tasks.should == [@other_task]
   end
 
-  it "should be able to count the associated documents" do
-    @person.tasks << @task
-    @person.tasks.count.should == 1
-    @person.tasks << @other_task
-    @person.tasks.count.should == 2
+  it "asks the keys set for the count to avoid having to unnecessarily load all documents" do
+    @person.tasks.keys.stub(:size => 17)
+    @person.tasks.count.should == 17
   end
 
   # it "should be able to build a new associated document" do
@@ -100,4 +86,106 @@ describe Ripple::Associations::ManyLinkedProxy do
     lambda { @person.tasks = @task }.should raise_error
     lambda { @person.tasks = [@person] }.should raise_error
   end
+
+  describe "#<< (when the target has not already been loaded)" do
+    it "avoids link-walking when adding a record to an unloaded association" do
+      @person.robject.should_not_receive(:walk)
+      @person.tasks << @task
+    end
+
+    it "should be able to count the associated documents" do
+      @person.tasks << @task
+      @person.tasks.count.should == 1
+      @person.tasks << @other_task
+      @person.tasks.count.should == 2
+    end
+
+    it "maintains the list of keys properly as new documents are appended" do
+      @person.tasks << @task
+      @person.tasks.should have(1).key
+      @person.tasks << @other_task
+      @person.tasks.should have(2).keys
+    end
+
+    it "should be able to append documents to the associated set" do
+      @person.tasks << @task
+      @person.tasks << @other_task
+      @person.should have(2).tasks
+    end
+
+    it "should be able to chain calls to adding documents" do
+      @person.tasks << @task << @other_task
+      @person.should have(2).tasks
+    end
+
+    it "should set the links on the RObject when appending" do
+      @person.tasks << @task << @other_task
+      [@task, @other_task].each do |t|
+        @person.robject.links.should include(t.to_link("tasks"))
+      end
+    end
+
+    it "does not return duplicates (for when the object has been appended and it's robject is found while walking the links)" do
+      @person.tasks.stub(:robjects => [@task.robject])
+      @person.tasks.reset
+      @person.tasks << @task
+      @person.tasks.should == [@task]
+    end
+  end
+
+  describe "#reset" do
+    it "clears appended documents" do
+      @person.tasks << @task
+      @person.tasks.reset
+      @person.tasks.should == []
+    end
+  end
+
+  describe "#keys" do
+    let(:link_keys) { %w[ 1 2 3 ] }
+    let(:links) { link_keys.map { |k| Riak::Link.new('tasks', k, 'task') } }
+
+    before(:each) do
+      @person.tasks.stub(:links => links)
+    end
+
+    it "returns a set of keys" do
+      @person.tasks.keys.should be_a(Set)
+      @person.tasks.keys.to_a.should == link_keys
+    end
+
+    it "is memoized between calls" do
+      @person.tasks.keys.should equal(@person.tasks.keys)
+    end
+
+    it "is cleared when the association is reset" do
+      orig_set = @person.tasks.keys
+      @person.tasks.reset
+      @person.tasks.keys.should_not equal(orig_set)
+    end
+
+    it "is cleared when the association is replaced" do
+      orig_set = @person.tasks.keys
+      @person.tasks.replace([@task])
+      @person.tasks.keys.should_not equal(orig_set)
+    end
+  end
+
+  describe "#include?" do
+    it "delegates to the set of keys so as not to unnecessarily load the associated documents" do
+      @person.tasks.keys.should_receive(:include?).with(@task.key).and_return(true)
+      @person.tasks.include?(@task).should be_true
+    end
+
+    it "short-circuits and returns false if the given object is not a ripple document" do
+      @person.tasks.keys.should_not_receive(:include?)
+      @person.tasks.include?(Object.new).should be_false
+    end
+
+    it "returns false if the document's bucket is different from the associations bucket, even if the keys are the same" do
+      @person.tasks << @task
+      other_person = Person.new { |p| p.key = @task.key }
+      @person.tasks.include?(other_person).should be_false
+    end
+  end
 end