wyngle-ripple 0.1.0

data/spec/ripple/associations/many_linked_proxy_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Ripple::Associations::ManyLinkedProxy do
+  # 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
+  end
+
+  it "should be empty before any associated documents are set" do
+    @person.tasks.should be_empty
+  end
+
+  it "should accept an array of documents" do
+    @person.tasks = [@task]
+  end
+
+  it "should set the links on the RObject when assigning" do
+    @person.tasks = [@task]
+    @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
+    t = (@person.tasks = [@task])
+    t.should == [@task]
+  end
+
+  it "should link-walk to the associated documents when accessing" do
+    @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 "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]])
+
+    @person.tasks.should == [@task, @other_task]
+  end
+
+  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 replace associated documents with a new set" do
+    @person.tasks = [@task]
+    @person.tasks = [@other_task]
+    @person.tasks.should == [@other_task]
+  end
+
+  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
+  #   pending "Need unsaved document support"
+  # end
+
+  it "should return an array from to_ary" do
+    @person.tasks << @task
+    @person.tasks.to_ary.should == [@task]
+  end
+
+  it "should refuse assigning a collection of the wrong type" do
+    lambda { @person.tasks = nil }.should raise_error
+    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

data/spec/ripple/associations/many_reference_proxy_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe Ripple::Associations::ManyReferenceProxy do
+  # require 'support/models/transactions'
+
+  before :each do
+    @account = Account.new {|e| e.key = "accounty"}
+    @payment_method = PaymentMethod.new {|e| e.key = "paymadoo"}
+    @other_payment_method = PaymentMethod.new {|e| e.key = "otherpaym"}
+    Ripple.client.stub(:search => {"response" => {"docs" => []}})
+  end
+
+  it "should be empty before any associated documents are set" do
+    @account.payment_methods.should be_empty
+  end
+
+  it "should accept an array of documents" do
+    @account.payment_methods = [@payment_method]
+  end
+
+  it "should set the key on the sub object when assigning" do
+    @account.payment_methods = [@payment_method]
+    @payment_method.account_key.should == "accounty"
+  end
+
+  it "should be able to replace the entire collection of documents (even appended ones)" do
+    @account.payment_methods << @payment_method
+    @account.payment_methods = [@other_payment_method]
+    @account.payment_methods.should == [@other_payment_method]
+  end
+
+  it "should return the assigned documents when assigning" do
+    t = (@account.payment_methods = [@payment_method])
+    t.should == [@payment_method]
+  end
+
+  it "should find the associated documents when accessing" do
+    Ripple.client.should_receive(:search).with("payment_methods", "account_key: accounty").and_return({"response" => {"docs" => ["id" => "paymadoo"]}})
+    PaymentMethod.should_receive(:find).with(["paymadoo"]).and_return([@payment_method])
+    @account.payment_methods.should == [@payment_method]
+  end
+
+  it "should replace associated documents with a new set" do
+    @account.payment_methods = [@payment_method]
+    @account.payment_methods = [@other_payment_method]
+    @account.payment_methods.should == [@other_payment_method]
+  end
+
+  it "should return an array from to_ary" do
+    @account.payment_methods << @payment_method
+    @account.payment_methods.to_ary.should == [@payment_method]
+  end
+
+  it "should refuse assigning a collection of the wrong type" do
+    lambda { @account.payment_methods = nil }.should raise_error
+    lambda { @account.payment_methods = @payment_method }.should raise_error
+    lambda { @account.payment_methods = [@account] }.should raise_error
+  end
+
+  describe "#<< (when the target has not already been loaded)" do
+    it "avoids searching when adding a record to an unloaded association" do
+      PaymentMethod.should_not_receive(:search)
+      @account.payment_methods << @payment_method
+    end
+
+    it "should be able to count the associated documents" do
+      @account.payment_methods << @payment_method
+      @account.payment_methods.count.should == 1
+      @account.payment_methods << @other_payment_method
+      @account.payment_methods.count.should == 2
+    end
+
+    it "should be able to count without loading documents" do
+      Ripple.client.stub(:search => {"response" => {"docs" => [{"id" => @payment_method.key}, {"id" => @other_payment_method.key}]}})
+      PaymentMethod.should_not_receive(:find)
+      @account.payment_methods.count.should == 2
+    end
+
+    it "should be able to append documents to the associated set" do
+      @account.payment_methods << @payment_method
+      @account.payment_methods << @other_payment_method
+      @account.should have(2).payment_methods
+    end
+
+    it "should be able to chain calls to adding documents" do
+      @account.payment_methods << @payment_method << @other_payment_method
+      @account.should have(2).payment_methods
+    end
+
+    it "should assign the keys on the sub object when appending" do
+      @account.payment_methods << @payment_method << @other_payment_method
+      [@payment_method, @other_payment_method].each do |t|
+        t.account_key.should == "accounty"
+      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
+      @account.payment_methods.stub(:find_target => Set.new([@payment_method]))
+      @account.payment_methods.reset
+      @account.payment_methods << @payment_method
+      @account.payment_methods.should == [@payment_method]
+    end
+  end
+
+  describe "#reset" do
+    it "clears appended documents" do
+      @account.payment_methods << @payment_method
+      @account.payment_methods.reset
+      @account.payment_methods.should == []
+    end
+  end
+
+  describe "#keys" do
+    let(:ze_keys) { %w(1 2 3) }
+    let(:search_results) do
+      {"response" => {"docs" => ze_keys.map { |k| {"id" => k} }}}
+    end
+
+    before(:each) do
+      Ripple.client.stub(:search => search_results)
+      PaymentMethod.stub(:find => [@payment_method])
+    end
+
+    it "returns a set of keys" do
+      @account.payment_methods.keys.should be_a(Set)
+      @account.payment_methods.keys.to_a.should =~ ze_keys
+    end
+
+    it "is memoized between calls" do
+      @account.payment_methods.keys.should equal(@account.payment_methods.keys)
+    end
+
+    it "is cleared when the association is reset" do
+      orig_set = @account.payment_methods.keys
+      @account.payment_methods.reset
+      @account.payment_methods.keys.should_not equal(orig_set)
+    end
+
+    it "is cleared when the association is replaced" do
+      orig_set = @account.payment_methods.keys
+      @account.payment_methods.replace([@payment_method])
+      @account.payment_methods.keys.should_not equal(orig_set)
+    end
+
+    it "maintains the list of keys properly as new documents are appended" do
+      @account.payment_methods << @payment_method
+      @account.payment_methods.should have(1).key
+      @account.payment_methods << @other_payment_method
+      @account.payment_methods.should have(2).keys
+    end
+  end
+
+  describe "#include?" do
+    it "delegates to the set of keys so as not to unnecessarily load the associated documents" do
+      @account.payment_methods.keys.should_receive(:include?).with(@payment_method.key).and_return(true)
+      @account.payment_methods.include?(@payment_method).should be_true
+    end
+
+    it "short-circuits and returns false if the given object is not a ripple document" do
+      @account.payment_methods.keys.should_not_receive(:include?)
+      @account.payment_methods.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
+      @account.payment_methods << @payment_method
+      other_account = Account.new { |p| p.key = @payment_method.key }
+      @account.payment_methods.include?(other_account).should be_false
+    end
+  end
+end

data/spec/ripple/associations/many_stored_key_proxy_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Ripple::Associations::ManyStoredKeyProxy do
+  # require 'support/models/transactions'
+
+  before :each do
+    @account = Account.new {|t| t.key = "accounty" }
+    @transaction_one = Transaction.new {|t| t.key = "one" }
+    @transaction_two = Transaction.new {|t| t.key = "two" }
+    @transaction_three = Transaction.new {|t| t.key = "three" }
+    @transaction_one.stub(:new_record?).and_return(false)
+    @transaction_two.stub(:new_record?).and_return(false)
+    @transaction_three.stub(:new_record?).and_return(false)
+  end
+
+  it "should be empty before any associated documents are set" do
+    @account.transactions.should be_empty
+  end
+
+  it "should allow appending" do
+    @account.transactions << @transaction_one
+    @account.transactions.should == [@transaction_one]
+    @account.transaction_keys.should == ["one"]
+  end
+
+  it "should be able to chain calls to adding documents" do
+    @account.transactions << @transaction_one << @transaction_two
+    @account.transactions.should == [@transaction_one, @transaction_two]
+  end
+
+  it "creates the right type of key collection" do
+    Object.module_eval do
+      class DifferentlyKeyedAccount
+        include Ripple::Document
+        property :transaction_keys, SortedSet
+        many :transactions, :using => :stored_key
+      end
+    end
+
+    account = DifferentlyKeyedAccount.new
+    account.transactions << @transaction_one
+    account.transaction_keys.should == SortedSet.new(["one"])
+  end
+
+  it "should accept an array of documents" do
+    @account.transactions = [@transaction_one]
+    @account.transactions.should == [@transaction_one]
+    @account.transaction_keys.should == %w(one)
+  end
+
+  it "should be able to replace the entire collection of documents (even appended ones)" do
+    @account.transactions << @transaction_one
+    @account.transactions = [@transaction_two]
+    @account.transactions.should == [@transaction_two]
+    @account.transaction_keys.should == %w(two)
+  end
+
+  it "should return the assigned documents when assigning" do
+    t = (@account.transactions = [@transaction_one])
+    t.should == [@transaction_one]
+  end
+
+  it "asks the keys set for the count to avoid having to unnecessarily load all documents" do
+    @account.transactions << @transaction_one
+    @account.transaction_keys.stub(:size => 17)
+    @account.transactions.count.should == 17
+  end
+
+  it "should return an array from to_ary" do
+    @account.transactions << @transaction_one
+    @account.transactions.to_ary.should == [@transaction_one]
+  end
+
+  it "should refuse assigning a collection of the wrong type" do
+    lambda { @account.transactions = nil }.should raise_error
+    lambda { @account.transactions = @transaction_one }.should raise_error
+    lambda { @account.transactions = [@account] }.should raise_error
+  end
+
+  it "should refuse appending a document of the wrong type" do
+    lambda { @account.transactions << Account.new }.should raise_error
+  end
+
+  describe "#reset" do
+    it "clears appended documents" do
+      @account.transactions << @transaction_one
+      @account.transactions.reset
+      @account.transactions.should == []
+    end
+
+    it "resets to the saved state of the proxy" do
+      Transaction.stub(:find).and_return([@transaction_one])
+      @account.transactions << @transaction_two
+      @account.transactions.reset
+      Transaction.stub(:find).and_return([@transaction_one])
+      @account.transactions.should == [ @transaction_one ]
+    end
+  end
+
+  describe "#include?" do
+    it "delegates to the set of keys so as not to unnecessarily load the associated documents" do
+      @account.transactions.keys.should_receive(:include?).with(@transaction_two.key).and_return(true)
+      @account.transactions.include?(@transaction_two).should be_true
+    end
+
+    it "short-circuits and returns false if the given object is not a ripple document" do
+      @account.transactions.keys.should_not_receive(:include?)
+      @account.transactions.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
+      @account.transactions << @transaction_one
+      other_account = Account.new { |p| p.key = @transaction_one.key }
+      @account.transactions.include?(other_account).should be_false
+    end
+  end
+
+  describe "#keys" do
+    before do
+      @account.transactions << @transaction_one << @transaction_two
+    end
+
+    it "returns a set of keys" do
+      @account.transactions.keys.should be_a(Array)
+      @account.transactions.keys.to_a.should == %w(one two)
+    end
+
+    it "is memoized between calls" do
+      @account.transactions.keys.should equal(@account.transactions.keys)
+    end
+
+    it "is cleared when the association is reset" do
+      orig_set = @account.transactions.keys
+      @account.transactions.reset
+      @account.transactions.keys.should_not equal(orig_set)
+      @account.transactions.keys.should == []
+    end
+
+    it "is cleared when the association is replaced" do
+      orig_set = @account.transactions.keys
+      @account.transactions.replace([@transaction_one])
+      @account.transactions.keys.should_not equal(orig_set)
+      @account.transactions.keys.to_a.should == %w(one)
+    end
+
+    it "maintains the list of keys properly as new documents are appended" do
+      @account.transactions.keys.size.should == 2
+      @account.transactions << @transaction_three
+      @account.transactions.keys.size.should == 3
+    end
+
+  end
+
+  it "temporarily bombs if the document you're appending isn't saved. This behavior shouldn't last long." do
+    lambda { @account.transactions << Transaction.new }.should raise_error
+  end
+
+end