massive_record 0.1.1 → 0.2.0.beta

data/spec/orm/models/test_class.rb

@@ -1,4 +1,7 @@
 class TestClass < MassiveRecord::ORM::Table
+  
+  references_one :attachable, :polymorphic => true, :store_in => :test_family
+
   column_family :test_family do
     field :foo, :string
   end

data/spec/orm/relations/interface_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+require 'orm/models/person'
+require 'orm/models/person_with_timestamp'
+
+describe MassiveRecord::ORM::Relations::Interface do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  describe "class methods" do
+    subject { Person }
+
+    describe "should include" do
+      %w(references_one).each do |relation|
+        it { should respond_to relation }
+      end
+    end
+
+    it "should not share relations" do
+      Person.relations.should_not == PersonWithTimestamp.relations
+    end
+  end
+
+
+  describe "references one" do
+    describe "relation's meta data" do
+      subject { Person.relations.detect { |relation| relation.name == "boss" } }
+
+      it "should have the reference one meta data stored in relations" do
+        Person.relations.detect { |relation| relation.name == "boss" }.should_not be_nil
+      end
+
+      it "should have type set to references_one" do
+        subject.relation_type.should == "references_one"
+      end
+
+      it "should raise an error if the same relaton is called for twice" do
+        lambda { Person.references_one :boss }.should raise_error MassiveRecord::ORM::RelationAlreadyDefined
+      end
+    end
+
+
+    describe "instance" do
+      subject { Person.new }
+      let(:boss) { PersonWithTimestamp.new }
+      let(:proxy) { subject.send(:relation_proxy, "boss") }
+
+      it { should respond_to :boss }
+      it { should respond_to :boss= }
+      it { should respond_to :boss_id }
+      it { should respond_to :boss_id= }
+
+
+      describe "record getter and setter" do
+        it "should return nil if foreign_key is nil" do
+          subject.boss.should be_nil 
+        end
+
+        it "should return the proxy's proxy_target if boss is set" do
+          subject.boss = boss
+          subject.boss.should == boss
+        end
+
+        it "should be able to reset the proxy" do
+          proxy.should_receive(:load_proxy_target).and_return(true)
+          proxy.should_receive(:reset) 
+          subject.boss.reset
+        end
+
+        it "should be able to reload the proxy" do
+          proxy.should_receive(:load_proxy_target).and_return(true)
+          proxy.should_receive(:reload)
+          subject.boss.reload
+        end
+
+        it "should set the foreign_key in proxy_owner when proxy_target is set" do
+          subject.boss = boss
+          subject.boss_id.should == boss.id
+        end
+
+        it "should load proxy_target object when read method is called" do
+          PersonWithTimestamp.should_receive(:find).and_return(boss)
+          subject.boss_id = boss.id
+          subject.boss.should == boss
+        end
+
+        it "should not load proxy_target twice" do
+          PersonWithTimestamp.should_receive(:find).once.and_return(boss)
+          subject.boss_id = boss.id
+          2.times { subject.boss }
+        end
+      end
+    end
+  end
+
+
+  describe "references one polymorphic" do
+    describe "relation's meta data" do
+      subject { TestClass.relations.detect { |relation| relation.name == "attachable" } }
+
+      it "should have the reference one polymorphic meta data stored in relations" do
+        TestClass.relations.detect { |relation| relation.name == "attachable" }.should_not be_nil
+      end
+
+      it "should have type set to correct type" do
+        subject.relation_type.should == "references_one_polymorphic"
+      end
+
+      it "should raise an error if the same relaton is called for twice" do
+        lambda { TestClass.references_one :attachable }.should raise_error MassiveRecord::ORM::RelationAlreadyDefined
+      end
+    end
+
+
+    describe "instance" do
+      subject { TestClass.new }
+      let(:attachable) { Person.new }
+
+      it { should respond_to :attachable }
+      it { should respond_to :attachable= }
+      it { should respond_to :attachable_id }
+      it { should respond_to :attachable_id= }
+      it { should respond_to :attachable_type }
+      it { should respond_to :attachable_type= }
+
+
+      describe "record getter and setter" do
+        it "should return nil if foreign_key is nil" do
+          subject.attachable.should be_nil 
+        end
+
+        it "should return the proxy's proxy_target if attachable is set" do
+          subject.attachable = attachable
+          subject.attachable.should == attachable
+        end
+
+        it "should set the foreign_key in proxy_owner when proxy_target is set" do
+          subject.attachable = attachable
+          subject.attachable_id.should == attachable.id
+        end
+
+        it "should set the type in proxy_owner when proxy_target is set" do
+          subject.attachable = attachable
+          subject.attachable_type.should == attachable.class.to_s.underscore
+        end
+
+
+
+        [Person, PersonWithTimestamp].each do |polymorphic_class|
+          describe "polymorphic association to class #{polymorphic_class}" do
+            let (:attachable) { polymorphic_class.new :id => "ID1" }
+
+            before do
+              subject.attachable_id = attachable.id
+              subject.attachable_type = polymorphic_class.to_s.underscore
+            end
+
+            it "should load proxy_target object when read method is called" do
+              polymorphic_class.should_receive(:find).and_return(attachable)
+              subject.attachable.should == attachable
+            end
+
+            it "should not load proxy_target twice" do
+              polymorphic_class.should_receive(:find).once.and_return(attachable)
+              2.times { subject.attachable }
+            end
+          end
+        end
+      end
+    end
+  end
+
+
+
+
+  describe "references many" do
+    describe "relation's meta data" do
+      subject { Person.relations.detect { |relation| relation.name == "test_classes" } }
+
+      it "should have the reference one meta data stored in relations" do
+        Person.relations.detect { |relation| relation.name == "test_classes" }.should_not be_nil
+      end
+
+      it "should have type set to references_many" do
+        subject.relation_type.should == "references_many"
+      end
+
+      it "should raise an error if the same relaton is called for twice" do
+        lambda { Person.references_one :test_classes }.should raise_error MassiveRecord::ORM::RelationAlreadyDefined
+      end
+    end
+
+
+    describe "instance" do
+      subject { Person.new }
+      let(:test_class) { TestClass.new }
+      let(:proxy) { subject.send(:relation_proxy, "test_classes") }
+
+      it { should respond_to :test_classes }
+      it { should respond_to :test_class_ids }
+      it { should respond_to :test_class_ids= }
+
+      it "should have an array as foreign_key attribute" do
+        subject.test_class_ids.should be_instance_of Array
+      end
+    end
+  end
+end

data/spec/orm/relations/metadata_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe MassiveRecord::ORM::Relations::Metadata do
+  subject { MassiveRecord::ORM::Relations::Metadata.new(nil) }
+
+  %w(name foreign_key class_name relation_type find_with polymorphic records_starts_from).each do |attr|
+    it { should respond_to attr }
+    it { should respond_to attr+"=" }
+  end
+
+
+  it "should be setting values by initializer" do
+    metadata = subject.class.new :car, :foreign_key => :my_car_id, :class_name => "Vehicle", :store_in => :info, :polymorphic => true, :records_starts_from => :records_starts_from
+    metadata.name.should == "car"
+    metadata.foreign_key.should == "my_car_id"
+    metadata.class_name.should == "Vehicle"
+    metadata.store_in.should == "info"
+    metadata.records_starts_from.should == :records_starts_from
+    metadata.should be_polymorphic
+  end
+
+  it "should not be possible to set relation type through initializer" do
+    metadata = subject.class.new :car, :relation_type => :foo
+    metadata.relation_type.should be_nil
+  end
+
+
+  its(:name) { should be_nil }
+
+  it "should return name as string" do
+    subject.name = :foo
+    subject.name.should == "foo"
+  end
+
+
+  describe "#class_name" do
+    it "should return whatever it's being set to" do
+      subject.class_name = "Person"
+      subject.class_name.should == "Person"
+    end
+
+    it "should return class name as a string" do
+      subject.class_name = Person
+      subject.class_name.should == "Person"
+    end
+
+    it "should calculate it from name" do
+      subject.name = :employee
+      subject.class_name.should == "Employee"
+    end
+
+    it "should calculate correct class name if represents a collection" do
+      subject.relation_type = "references_many"
+      subject.name = "persons"
+      subject.class_name.should == "Person"
+    end
+  end
+
+
+
+
+  describe "#foreign_key" do
+    it "should return whatever it's being set to" do
+      subject.foreign_key = "person_id"
+      subject.foreign_key.should == "person_id"
+    end
+
+    it "should return foreign key as string" do
+      subject.foreign_key = :person_id
+      subject.foreign_key.should == "person_id"
+    end
+
+    it "should try and calculate the foreign key from the name" do
+      subject.class_name = "PersonWithSomething"
+      subject.name = :person
+      subject.foreign_key.should == "person_id"
+    end
+
+    it "should return plural for if meta data is representing a many relation" do
+      subject.relation_type = :references_many
+      subject.name = :persons
+      subject.foreign_key.should == "person_ids"
+    end
+  end
+
+  describe "#foreign_key_setter" do
+    it "should return whatever the foreign_key is pluss =" do
+      subject.should_receive(:foreign_key).and_return("custom_key")
+      subject.foreign_key_setter.should == "custom_key="
+    end
+  end
+
+
+
+  describe "#store_in" do
+    its(:store_in) { should be_nil }
+
+    it "should be able to set column family to store foreign key in" do
+      subject.store_in = :info
+      subject.store_in.should == "info"
+    end
+  end
+
+  it "should know its persisting foreign key if foreign key stored in has been set" do
+    subject.store_in = :info
+    should be_persisting_foreign_key
+  end
+
+  it "should not be storing the foreign key if records_starts_from is defined" do
+    subject.store_in = :info
+    subject.records_starts_from = :method_which_returns_a_starting_point
+    should_not be_persisting_foreign_key
+  end
+
+
+
+  it "should compare two meta datas based on name" do
+    other = MassiveRecord::ORM::Relations::Metadata.new(subject.name)
+    other.should == subject
+  end
+
+  it "should have the same hash value for the same name" do
+    subject.hash == subject.name.hash
+  end
+
+
+
+  describe "#new_relation_proxy" do
+    let(:proxy_owner) { Person.new }
+    let(:proxy) { subject.relation_type = "references_one" and subject.new_relation_proxy(proxy_owner) }
+
+    it "should return a proxy where proxy_owner is assigned" do
+      proxy.proxy_owner.should == proxy_owner
+    end
+
+    it "should return a proxy where metadata is assigned" do
+      proxy.metadata.should == subject
+    end
+
+    it "should append _polymorphic to the proxy name if it is polymorphic" do
+      subject.polymorphic = true
+      subject.relation_type = "references_one"
+      subject.relation_type.should == "references_one_polymorphic"
+    end
+  end
+
+
+  describe "#polymorphic_type_column" do
+    before do
+      subject.polymorphic = true
+    end
+
+    it "should remove _id and add _type to foreign_key" do
+      subject.should_receive(:foreign_key).and_return("foo_id")
+      subject.polymorphic_type_column.should == "foo_type"
+    end
+
+    it "should simply add _type if foreign_key does not end on _id" do
+      subject.should_receive(:foreign_key).and_return("foo_id_b")
+      subject.polymorphic_type_column.should == "foo_id_b_type"
+    end
+
+    it "should return setter method" do
+      subject.should_receive(:polymorphic_type_column).and_return("yey")
+      subject.polymorphic_type_column_setter.should == "yey="
+    end
+  end
+
+
+  describe "records_starts_from" do
+    it "should not have any proc if records_starts_from is nil" do
+      subject.find_with = "foo"
+      subject.records_starts_from = nil
+      subject.find_with.should be_nil
+    end
+
+    it "should buld a proc with records_starts_from set" do
+      subject.records_starts_from = :friends_records_starts_from_id
+      subject.find_with.should be_instance_of Proc
+    end
+
+    describe "proc" do
+      let(:proxy_owner) { Person.new :id => "person-1" }
+      let(:find_with_proc) { subject.records_starts_from = :friends_records_starts_from_id; subject.find_with }
+
+      before do
+        subject.class_name = "Person"
+      end
+
+      it "should call proxy_target class with all, start with proxy_owner's start from id response" do
+        Person.should_receive(:all).with(hash_including(:start => proxy_owner.friends_records_starts_from_id))
+        find_with_proc.call(proxy_owner)
+      end
+
+      it "should be possible to send in options to the proc" do
+        Person.should_receive(:all).with(hash_including(:limit => 10, :start => proxy_owner.friends_records_starts_from_id))
+        find_with_proc.call(proxy_owner, {:limit => 10})
+      end
+    end
+  end
+end

data/spec/orm/relations/proxy/references_many_spec.rb

@@ -0,0 +1,624 @@
+require 'spec_helper'
+
+class TestReferencesManyProxy < MassiveRecord::ORM::Relations::Proxy::ReferencesMany; end
+
+describe TestReferencesManyProxy do
+  include SetUpHbaseConnectionBeforeAll 
+  include SetTableNamesToTestTable
+
+  let(:proxy_owner) { Person.new :id => "person-id-1", :name => "Test", :age => 29 }
+  let(:proxy_target) { TestClass.new :id => "test-class-id-1" }
+  let(:proxy_target_2) { TestClass.new :id => "test-class-id-2" }
+  let(:proxy_target_3) { TestClass.new :id => "test-class-id-3" }
+  let(:metadata) { subject.metadata }
+
+  subject { proxy_owner.send(:relation_proxy, 'test_classes') }
+
+  it_should_behave_like "relation proxy"
+
+  
+
+  describe "#find_proxy_target" do
+    describe "with foreig keys stored in proxy_owner" do
+      it "should not try to find proxy_target if foreign_keys is blank" do
+        proxy_owner.test_class_ids.clear
+        TestClass.should_not_receive(:find)
+        subject.load_proxy_target.should be_empty
+      end
+
+      it "should try to load proxy_target if foreign_keys has any keys" do
+        proxy_owner.test_class_ids << proxy_target.id
+        TestClass.should_receive(:find).with([proxy_target.id], anything).and_return([proxy_target])
+        subject.load_proxy_target.should == [proxy_target]
+      end
+
+      it "should not die when loading foreign keys which does not exist in proxy_target table" do
+        proxy_owner.save!
+        proxy_owner.test_classes << proxy_target
+        proxy_owner.test_classes.reset
+        proxy_owner.test_class_ids << "does_not_exists"
+        proxy_owner.test_classes.reload
+        proxy_owner.test_classes.length.should == 1
+      end
+    end
+
+    describe "with start from" do
+      let(:proxy_target) { Person.new :id => proxy_owner.id+"-friend-1", :name => "T", :age => 2 }
+      let(:proxy_target_2) { Person.new :id => proxy_owner.id+"-friend-2", :name => "H", :age => 9 }
+      let(:not_proxy_target) { Person.new :id => "foo"+"-friend-2", :name => "H", :age => 1 }
+      let(:metadata) { subject.metadata }
+
+      subject { proxy_owner.send(:relation_proxy, 'friends') }
+
+      before do
+        proxy_target.save!
+        proxy_target_2.save!
+        not_proxy_target.save!
+      end
+
+      it "should not try to find proxy_target if start from method is blank" do
+        proxy_owner.should_receive(:friends_records_starts_from_id).and_return(nil)
+        Person.should_not_receive(:all)
+        subject.load_proxy_target.should be_empty
+      end
+
+      it "should find all friends when loading" do
+        friends = subject.load_proxy_target
+        friends.length.should == 2
+        friends.should include(proxy_target)
+        friends.should include(proxy_target_2)
+        friends.should_not include(not_proxy_target)
+      end
+    end
+  end
+
+  describe "find with proc" do
+    let(:test_class) { TestClass.new }
+
+    before do
+      subject.metadata.find_with = Proc.new { |proxy_target| TestClass.find("testing-123") }
+    end
+
+    after do
+      subject.metadata.find_with = nil
+    end
+
+    it "should not call find_proxy_target" do
+      should_not_receive :find_proxy_target
+      subject.load_proxy_target
+    end
+
+    it "should load by given proc" do
+      TestClass.should_receive(:find).with("testing-123").and_return([test_class])
+      subject.load_proxy_target.should == [test_class]
+    end
+
+    it "should always wrap the proc's result in an array" do
+      TestClass.should_receive(:find).with("testing-123").and_return(test_class)
+      subject.load_proxy_target.should == [test_class]
+    end
+
+    it "should be empty if the proc return nil" do
+      TestClass.should_receive(:find).with("testing-123").and_return(nil)
+      subject.load_proxy_target.should be_empty
+    end
+  end
+
+
+  describe "adding records to collection" do
+    [:<<, :push, :concat].each do |add_method|
+      describe "by ##{add_method}" do
+        it "should include the proxy_target in the proxy" do
+          subject.send(add_method, proxy_target)
+          subject.proxy_target.should include proxy_target
+        end
+
+        it "should not add invalid objects to collection" do
+          proxy_target.should_receive(:valid?).and_return false
+          subject.send(add_method, proxy_target).should be_false
+          subject.proxy_target.should_not include proxy_target
+        end
+
+        it "should update array of foreign keys in proxy_owner" do
+          proxy_owner.test_class_ids.should be_empty
+          subject.send(add_method, proxy_target)
+          proxy_owner.test_class_ids.should include(proxy_target.id)
+        end
+
+        it "should auto-persist foreign keys if owner has been persisted" do
+          proxy_owner.save!
+          subject.send(add_method, proxy_target)
+          proxy_owner.reload
+          proxy_owner.test_class_ids.should include(proxy_target.id)
+        end
+
+        it "should not persist proxy owner (and it's foreign keys) if owner is a new record" do
+          subject.send(add_method, proxy_target)
+          proxy_owner.should be_new_record
+        end
+
+        it "should not update array of foreign keys in proxy_owner if it does not respond to it" do
+          proxy_owner.should_receive(:respond_to?).twice.and_return(false)
+          subject.send(add_method, proxy_target)
+          proxy_owner.test_class_ids.should_not include(proxy_target.id)
+        end
+
+        it "should not update array of foreign keys in the proxy owner if it has been destroyed" do
+          proxy_owner.should_receive(:destroyed?).and_return true
+          subject.send(add_method, proxy_target)
+          proxy_owner.test_class_ids.should_not include(proxy_target.id)
+        end
+
+        it "should not do anything adding the same record twice" do
+          2.times { subject.send(add_method, proxy_target) }
+          subject.proxy_target.length.should == 1
+          proxy_owner.test_class_ids.length.should == 1
+        end
+
+        it "should be able to add two records at the same time" do
+          subject.send add_method, [proxy_target, proxy_target_2]
+          subject.proxy_target.should include proxy_target
+          subject.proxy_target.should include proxy_target_2
+        end
+
+        it "should return proxy so calls can be chained" do
+          subject.send(add_method, proxy_target).object_id.should == subject.object_id
+        end
+
+        it "should raise an error if there is a type mismatch" do
+          lambda { subject.send add_method, Person.new(:name => "Foo", :age => 2) }.should raise_error MassiveRecord::ORM::RelationTypeMismatch
+        end
+
+        it "should not save the pushed proxy_target if proxy_owner is not persisted" do
+          proxy_owner.should_receive(:persisted?).and_return false
+          proxy_target.should_not_receive(:save)
+          subject.send(add_method, proxy_target)
+        end
+
+        it "should not save the proxy_owner object if it has not been persisted before" do
+          proxy_owner.should_receive(:persisted?).and_return false
+          proxy_owner.should_not_receive(:save)
+          subject.send(add_method, proxy_target)
+        end
+
+        it "should save the pushed proxy_target if proxy_owner is persisted" do
+          proxy_owner.save!
+          proxy_target.should_receive(:save).and_return(true)
+          subject.send(add_method, proxy_target)
+        end
+
+        it "should not save anything if one record is invalid" do
+          proxy_owner.save!
+
+          proxy_target.should_receive(:valid?).and_return(true)
+          proxy_target_2.should_receive(:valid?).and_return(false)
+          
+          proxy_target.should_not_receive(:save)
+          proxy_target_2.should_not_receive(:save)
+          proxy_owner.should_not_receive(:save)
+
+          subject.send(add_method, [proxy_target, proxy_target_2]).should be_false
+        end
+      end
+    end
+  end
+
+  describe "removing records from the collection" do
+    [:destroy, :delete].each do |delete_method|
+      describe "with ##{delete_method}" do
+        before do
+          subject << proxy_target
+        end
+
+        it "should not be in proxy after being removed" do
+          subject.send(delete_method, proxy_target)
+          subject.proxy_target.should_not include proxy_target
+        end
+
+        it "should remove the destroyed records id from proxy_owner foreign keys" do
+          subject.send(delete_method, proxy_target)
+          proxy_owner.test_class_ids.should_not include(proxy_target.id)
+        end
+
+        it "should not remove foreign keys in proxy_owner if it does not respond to it" do
+          proxy_owner.should_receive(:respond_to?).and_return false
+          subject.send(delete_method, proxy_target)
+          proxy_owner.test_class_ids.should include(proxy_target.id)
+        end
+
+        it "should not save the proxy_owner if it has not been persisted" do
+          proxy_owner.should_receive(:persisted?).and_return(false)
+          proxy_owner.should_not_receive(:save)
+          subject.send(delete_method, proxy_target)
+        end
+
+        it "should save the proxy_owner if it has been persisted" do
+          proxy_owner.save!
+          proxy_owner.should_receive(:save)
+          subject.send(delete_method, proxy_target)
+        end
+      end
+    end
+
+    describe "with #destroy" do
+      before do
+        subject << proxy_target
+      end
+
+      it "should ask the record to destroy self" do
+        proxy_target.should_receive(:destroy)
+        subject.destroy proxy_target
+      end
+    end
+    
+    describe "with #delete" do
+      before do
+        subject << proxy_target
+      end
+
+      it "should not ask the record to destroy self" do
+        proxy_target.should_not_receive(:destroy)
+        proxy_target.should_not_receive(:delete)
+        subject.delete(proxy_target)
+      end
+    end
+
+
+
+    describe "with destroy_all" do
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+      end
+
+      it "should not include any records after destroying all" do
+        subject.destroy_all
+        subject.proxy_target.should be_empty
+      end
+
+      it "should remove all foreign keys in proxy_owner" do
+        subject.destroy_all
+        proxy_owner.test_class_ids.should be_empty
+      end
+
+      it "should call reset after all destroyed" do
+        subject.should_receive(:reset)
+        subject.destroy_all
+      end
+
+      it "should be loaded after all being destroyed" do
+        subject.destroy_all
+        should be_loaded
+      end
+
+      it "should call destroy on each record" do
+        proxy_target.should_receive(:destroy)
+        proxy_target_2.should_receive(:destroy)
+        subject.destroy_all
+      end
+    end
+
+    describe "with delete_all" do
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+      end
+
+      it "should not include any records after destroying all" do
+        subject.delete_all
+        subject.proxy_target.should be_empty
+      end
+
+      it "should remove all foreign keys in proxy_owner" do
+        subject.delete_all
+        proxy_owner.test_class_ids.should be_empty
+      end
+
+      it "should call reset after all destroyed" do
+        subject.should_receive(:reset)
+        subject.delete_all
+      end
+
+      it "should be loaded after all being destroyed" do
+        subject.delete_all
+        should be_loaded
+      end
+
+      it "should not call destroy on each record" do
+        proxy_target.should_not_receive(:destroy)
+        proxy_target_2.should_not_receive(:destroy)
+        subject.delete_all
+      end
+    end
+  end
+
+  [:length, :size, :count].each do |method|
+    describe "##{method}" do
+      [true, false].each do |should_persist_proxy_owner|
+        describe "with proxy_owner " + (should_persist_proxy_owner ? "persisted" : "not persisted") do
+          before do
+            proxy_owner.save! if should_persist_proxy_owner
+            subject << proxy_target
+          end
+
+          it "should return the correct #{method} when loaded" do
+            subject.reload if should_persist_proxy_owner
+            subject.send(method).should == 1
+          end
+
+          it "should return the correct #{method} when not loaded" do
+            subject.reset if should_persist_proxy_owner
+            subject.send(method).should == 1
+          end
+
+          it "should return the correct #{method} when a record is added" do
+            subject << proxy_target_2
+            subject.send(method).should == 2
+          end
+
+          it "should return the correct #{method} when a record is added to an unloaded proxy" do
+            subject.reset if should_persist_proxy_owner
+            subject << proxy_target_2
+            subject.send(method).should == 2
+          end
+        end
+      end
+    end
+  end
+
+  describe "#include" do
+    [true, false].each do |should_persist_proxy_owner|
+      describe "with proxy_owner " + (should_persist_proxy_owner ? "persisted" : "not persisted") do
+        before do
+          proxy_owner.save! if should_persist_proxy_owner
+          subject << proxy_target
+        end
+
+        it "should return that it includes it's proxy_target when loaded" do
+          subject.reload if should_persist_proxy_owner
+          should include proxy_target
+        end
+
+        it "should return that it includes it's proxy_target when not loaded" do
+          subject.reset if should_persist_proxy_owner
+          should include proxy_target
+        end
+
+        it "should return that it includes it's proxy_target when a record is added" do
+          subject << proxy_target_2
+          should include proxy_target, proxy_target_2
+        end
+
+        it "should return that it includes it's proxy_target when a record is added to an unloaded proxy" do
+          subject.reset if should_persist_proxy_owner
+          subject << proxy_target_2
+          should include proxy_target, proxy_target_2
+        end
+      end
+    end
+  end
+
+
+
+  describe "#first" do
+    describe "stored foreign keys" do
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+      end
+
+      it "should return nil if no relations are found" do
+        subject.destroy_all
+        subject.first.should be_nil
+      end
+
+      it "should return the first proxy_target" do
+        subject.first.should == proxy_target
+      end
+
+      it "should not be loaded" do
+        subject.first
+        subject.should_not be_loaded
+      end
+
+      it "should just find the first foreign key" do
+        TestClass.should_receive(:find).with(proxy_target.id, anything).and_return(proxy_target)
+        subject.first
+      end
+    end
+
+    describe "with records_starts_from (proc)" do
+      let(:proxy_target) { Person.new :id => proxy_owner.id+"-friend-1", :name => "T", :age => 2 }
+      let(:proxy_target_2) { Person.new :id => proxy_owner.id+"-friend-2", :name => "H", :age => 9 }
+      let(:metadata) { subject.metadata }
+
+      subject { proxy_owner.send(:relation_proxy, 'friends') }
+
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+      end
+
+      it "should return nil if no relations are found" do
+        subject.destroy_all
+        subject.first.should be_nil
+      end
+
+      it "should return the first proxy_target" do
+        subject.first.should == proxy_target
+      end
+
+      it "should not be loaded" do
+        subject.first
+        subject.should_not be_loaded
+      end
+
+      it "should find the first with a limit" do
+        Person.should_receive(:all).with(hash_including(:limit => 1))
+        subject.first
+      end
+    end
+  end
+
+
+  describe "#find" do
+    let(:not_among_targets) { proxy_target_3 }
+
+    describe "stored foreign keys" do
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+
+        not_among_targets.save!
+      end
+
+      it "should find the object from database if id exists among foreig keys" do
+        subject.find(proxy_target.id).should == proxy_target
+      end
+
+      it "should raise error if record is not among records in association" do
+        lambda { subject.find(not_among_targets.id) }.should raise_error MassiveRecord::ORM::RecordNotFound
+      end
+
+      it "should not hit database if proxy has been loaded" do
+        subject.load_proxy_target
+        TestClass.should_not_receive(:find)
+        subject.find(proxy_target.id).should == proxy_target
+      end
+
+      it "should raise error if proxy is loaded, but record is not found in association" do
+        subject.load_proxy_target
+        lambda { subject.find(not_among_targets.id) }.should raise_error MassiveRecord::ORM::RecordNotFound
+      end
+    end
+
+
+    describe "with records_starts_from (proc)" do
+      let(:proxy_target) { Person.new :id => proxy_owner.id+"-friend-1", :name => "T", :age => 2 }
+      let(:proxy_target_2) { Person.new :id => proxy_owner.id+"-friend-2", :name => "H", :age => 9 }
+      let(:not_among_targets) { Person.new :id => "NOT-friend-1", :name => "H", :age => 9 }
+      let(:metadata) { subject.metadata }
+
+      subject { proxy_owner.send(:relation_proxy, 'friends') }
+
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+
+        not_among_targets.save!
+      end
+
+
+      it "should find the object from database if id exists among foreig keys" do
+        subject.find(proxy_target.id).should == proxy_target
+      end
+
+      it "should raise error if record is not among records in association" do
+        lambda { subject.find(not_among_targets.id) }.should raise_error MassiveRecord::ORM::RecordNotFound
+      end
+
+
+
+      it "should not hit database if proxy has been loaded" do
+        subject.load_proxy_target
+        Person.should_not_receive(:find)
+        subject.find(proxy_target.id).should == proxy_target
+      end
+
+      it "should raise error if proxy is loaded, but record is not found in association" do
+        subject.load_proxy_target
+        lambda { subject.find(not_among_targets.id) }.should raise_error MassiveRecord::ORM::RecordNotFound
+      end
+    end
+  end
+
+
+
+  describe "#limit" do
+    let(:not_among_targets) { proxy_target_3 }
+
+    describe "stored foreign keys" do
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+
+        not_among_targets.save!
+      end
+
+      it "should return empty array if no targets are found" do
+        subject.destroy_all
+        subject.limit(1).should be_empty
+      end
+
+
+      it "should do db query with a limited set of ids" do
+        subject.limit(1).should == [proxy_target]
+      end
+
+      it "should not be loaded after a limit query" do
+        subject.limit(1).should == [proxy_target]
+        subject.should_not be_loaded
+      end
+
+      it "should not hit the database if the proxy is loaded" do
+        subject.load_proxy_target
+        TestClass.should_not_receive(:find)
+        subject.limit(1)
+      end
+
+      it "should return correct result set if proxy is loaded" do
+        subject.load_proxy_target
+        subject.limit(1).should == [proxy_target]
+      end
+    end
+
+
+    describe "with records_starts_from (proc)" do
+      let(:proxy_target) { Person.new :id => proxy_owner.id+"-friend-1", :name => "T", :age => 2 }
+      let(:proxy_target_2) { Person.new :id => proxy_owner.id+"-friend-2", :name => "H", :age => 9 }
+      let(:not_among_targets) { Person.new :id => "NOT-friend-1", :name => "H", :age => 9 }
+      let(:metadata) { subject.metadata }
+
+      subject { proxy_owner.send(:relation_proxy, 'friends') }
+
+      before do
+        proxy_owner.save!
+        subject << proxy_target << proxy_target_2
+        subject.reset
+
+        not_among_targets.save!
+      end
+
+      it "should return empty array if no targets are found" do
+        subject.destroy_all
+        subject.limit(1).should be_empty
+      end
+
+
+      it "should do db query with a limited set of ids" do
+        subject.limit(1).should == [proxy_target]
+      end
+
+      it "should not be loaded after a limit query" do
+        subject.limit(1).should == [proxy_target]
+        subject.should_not be_loaded
+      end
+
+      it "should not hit the database if the proxy is loaded" do
+        subject.load_proxy_target
+        Person.should_not_receive(:find)
+        subject.limit(1)
+      end
+
+      it "should return correct result set if proxy is loaded" do
+        subject.load_proxy_target
+        subject.limit(1).should == [proxy_target]
+      end
+    end
+  end
+end