perpetuity 0.5.0 → 0.6.0

data/spec/perpetuity/dereferencer_spec.rb

@@ -3,22 +3,20 @@ require 'perpetuity/reference'
 
 module Perpetuity
   describe Dereferencer do
-    let(:registry) { double('Mapper Registry') }
     let(:mapper) { double('ObjectMapper') }
-    let(:first) { double('Object', id: 1, class: Object) }
-    let(:second) { double('Object', id: 2, class: Object) }
+    let(:first) { double('Object', class: Object) }
+    let(:second) { double('Object', class: Object) }
     let(:first_ref) { Reference.new(Object, 1) }
     let(:second_ref) { Reference.new(Object, 2) }
     let(:objects) { [first, second] }
+    let(:registry) { { Object => mapper } }
     let(:derefer) { Dereferencer.new(registry) }
 
     context 'with one reference' do
-      before do
-        registry.should_receive(:[]).with(Object) { mapper }
+      it 'loads objects based on the specified objects and attribute' do
+        first.instance_variable_set :@id, 1
         mapper.should_receive(:find).with(1) { first }
-      end
 
-      it 'loads objects based on the specified objects and attribute' do
         derefer.load first_ref
         derefer[first_ref].should == first
       end
@@ -31,12 +29,8 @@ module Perpetuity
     end
 
     context 'with multiple references' do
-      before do
-        registry.should_receive(:[]).with(Object) { mapper }
-        mapper.should_receive(:select) { objects }
-      end
-
       it 'returns the array of dereferenced objects' do
+        mapper.should_receive(:select) { objects }
         derefer.load([first_ref, second_ref]).should == objects
       end
     end

data/spec/perpetuity/identity_map_spec.rb

@@ -2,19 +2,28 @@ require 'perpetuity/identity_map'
 
 module Perpetuity
   describe IdentityMap do
+    let(:object_mapper) { double('Mapper', id_for: 1) }
+    let(:object) { double('Object', class: Object) }
+    let(:id_map) { IdentityMap.new }
+
     context 'when the object exists in the IdentityMap' do
-      let(:object) { double('Object', id: 1, class: Object) }
+      let(:object) { double('Object', class: Object) }
+
+      before { object.instance_variable_set :@id, 1 }
 
       it 'returns the object with the given class and id' do
-        id_map = IdentityMap.new
         id_map << object
         id_map[Object, 1].should == object
       end
+
+      it 'stringifies keys when checking' do
+        id_map << object
+        id_map[Object, '1'].should == object
+      end
     end
 
     context 'when the object does not exist in the IdentityMap' do
       it 'returns nil' do
-        id_map = IdentityMap.new
         id_map[Object, 1].should be_nil
       end
     end

data/spec/perpetuity/mapper_spec.rb

@@ -61,7 +61,7 @@ module Perpetuity
 
       describe 'finding a single object' do
         let(:options) { {:attribute=>nil, :direction=>nil, :limit=>nil, :page=>nil} }
-        let(:returned_object) { double('Retrieved Object') }
+        let(:returned_object) { double('Retrieved Object', class: Object) }
 
         it 'finds an object by ID' do
           criteria = { id: 1 }
@@ -87,12 +87,33 @@ module Perpetuity
           mapper.find   { |o| o.name == 'foo' }.should == returned_object
           mapper.detect { |o| o.name == 'foo' }.should == returned_object
         end
+
+        it 'caches results' do
+          mapper.give_id_to returned_object, 1
+          criteria = { id: 1 }
+          data_source.should_receive(:retrieve)
+                     .with(Object, criteria, options) { [returned_object] }
+                     .once
+
+          mapper.find(1)
+          mapper.find(1)
+        end
+
+        it 'does not cache nil results' do
+          criteria = { id: 1 }
+          data_source.should_receive(:retrieve)
+                     .with(Object, criteria, options) { [] }
+                     .twice
+
+          mapper.find(1)
+          mapper.find(1)
+        end
       end
 
       it 'saves an object' do
         mapper_class.attribute :foo
         object = Object.new
-        object.define_singleton_method(:id) { 1 }
+        mapper.give_id_to object, 1
         object.instance_variable_set '@foo', 'bar'
         data_source.should_receive(:can_serialize?).with('bar') { true }
         data_source.should_receive(:update).with Object, 1, { 'foo' => 'bar' }
@@ -112,5 +133,31 @@ module Perpetuity
         mapper.delete_all
       end
     end
+
+    describe 'checking persistence of an object' do
+      let(:object) { Object.new }
+
+      context 'when persisted' do
+        before { mapper.give_id_to object, 1 }
+
+        it 'knows the object is persisted' do
+          mapper.persisted?(object).should be_true
+        end
+
+        it 'knows the id of the object' do
+          mapper.id_for(object).should be == 1
+        end
+      end
+
+      context 'when not persisted' do
+        it 'knows the object is not persisted' do
+          mapper.persisted?(object).should be_false
+        end
+
+        it 'returns a nil id' do
+          mapper.id_for(object).should be_nil
+        end
+      end
+    end
   end
 end

data/spec/perpetuity/mongodb/serializer_spec.rb

@@ -3,6 +3,7 @@ require 'perpetuity/mapper'
 require 'perpetuity/mapper_registry'
 require 'support/test_classes/book'
 require 'support/test_classes/user'
+require 'support/test_classes/car'
 
 module Perpetuity
   class MongoDB
@@ -12,32 +13,32 @@ module Perpetuity
       let(:authors) { [dave, andy] }
       let(:book) { Book.new('The Pragmatic Programmer', authors) }
       let(:mapper_registry) { MapperRegistry.new }
-      let!(:book_mapper_class) do
+      let(:book_mapper) do
         registry = mapper_registry
         Class.new(Perpetuity::Mapper) do
           map Book, registry
           attribute :title
           attribute :authors
-        end
+        end.new(registry)
       end
-      let!(:user_mapper_class) do
+      let(:user_mapper) do
         registry = mapper_registry
         Class.new(Perpetuity::Mapper) do
           map User, registry
           attribute :name
-        end
+        end.new(registry)
       end
       let(:data_source) { double('Data Source') }
-      let(:serializer) { Serializer.new(mapper_registry[Book]) }
+      let(:serializer) { Serializer.new(book_mapper) }
 
       before do
-        dave.extend PersistedObject
-        andy.extend PersistedObject
-        user_mapper_class.stub(data_source: data_source)
-        book_mapper_class.stub(data_source: data_source)
+        serializer.give_id_to dave, 1
+        serializer.give_id_to andy, 2
       end
 
       it 'serializes an array of non-embedded attributes as references' do
+        user_mapper.stub(data_source: data_source)
+        book_mapper.stub(data_source: data_source)
         data_source.should_receive(:can_serialize?).with(book.title).and_return true
         data_source.should_receive(:can_serialize?).with(dave).and_return false
         data_source.should_receive(:can_serialize?).with(andy).and_return false
@@ -47,13 +48,13 @@ module Perpetuity
             {
               '__metadata__' => {
                 'class' => 'User',
-                'id' => dave.id
+                'id' => user_mapper.id_for(dave)
               }
             },
             {
               '__metadata__' => {
                 'class' => 'User',
-                'id' => andy.id
+                'id' => user_mapper.id_for(andy)
               }
             }
           ]
@@ -68,10 +69,11 @@ module Perpetuity
           }
         end
         let(:user) { User.new(name_data) }
-        let(:user_mapper) { mapper_registry[User] }
         let(:user_serializer) { Serializer.new(user_mapper) }
 
         before do
+          user_mapper.stub(data_source: data_source)
+          book_mapper.stub(data_source: data_source)
           data_source.stub(:can_serialize?).with(name_data) { true }
         end
 
@@ -90,6 +92,11 @@ module Perpetuity
         let(:objects) { serializer.unserialize(serialized_attrs)  }
         subject { objects.first }
 
+        before do
+          user_mapper.stub(data_source: data_source)
+          book_mapper.stub(data_source: data_source)
+        end
+
         it { should be_a Complex }
         it { should eq unserializable_object}
       end
@@ -99,6 +106,11 @@ module Perpetuity
         let(:title) { 'title' }
         let(:book) { Book.new(title, [author]) }
 
+        before do
+          user_mapper.stub(data_source: data_source)
+          book_mapper.stub(data_source: data_source)
+        end
+
         it 'passes the reference unserialized' do
           data_source.should_receive(:can_serialize?).with('title') { true }
           serializer.serialize(book).should == {
@@ -112,6 +124,29 @@ module Perpetuity
           }
         end
       end
+
+      context 'with uninitialized attributes' do
+        let(:car_model) { 'Corvette' }
+        let(:car) { Car.new(model: car_model) }
+        let(:mapper) do
+          registry = mapper_registry
+          Class.new(Mapper) do
+            map Car, registry
+
+            attribute :make
+            attribute :model
+          end.new(registry)
+        end
+        let(:serializer) { Serializer.new(mapper) }
+
+
+        it 'does not persist uninitialized attributes' do
+          mapper.stub data_source: data_source
+          data_source.should_receive(:can_serialize?).with(car_model) { true }
+
+          serializer.serialize(car).should == { 'model' => car_model }
+        end
+      end
     end
   end
 end

data/spec/perpetuity/reference_spec.rb

@@ -3,6 +3,7 @@ require 'perpetuity/reference'
 module Perpetuity
   describe Reference do
     let(:reference) { Reference.new Object, 1 }
+    let(:object) { double('Object', class: Object, id: 1) }
     subject { reference }
 
     its(:klass) { should be Object }
@@ -11,8 +12,10 @@ module Perpetuity
     describe 'comparability' do
       describe 'equality' do
         let(:duplicate) { reference.dup }
+
         it { should be == duplicate }
         it { should eql duplicate }
+        it { should be == object }
       end
 
       describe 'inequality' do
@@ -20,6 +23,7 @@ module Perpetuity
         it { should_not eql Reference.new(String, reference.id) }
         it { should_not be == Reference.new(reference.klass, 2) }
         it { should_not eql Reference.new(reference.klass, 2) }
+        it { should_not be_eql object }
       end
     end
   end

data/spec/perpetuity_spec.rb

@@ -17,29 +17,36 @@ describe Perpetuity do
       mapper = Perpetuity[Object]
       object = Object.new
       mapper.insert object
-      object.id.should eq object.object_id + 1
+      mapper.id_for(object).should be == object.object_id + 1
       mapper.attributes.should eq [:object_id]
     end
   end
 
   describe 'methods on mappers' do
-    it 'allows methods to act as scopes' do
-      published = Article.new('Published', 'I love cats', nil, Time.now - 30)
-      draft = Article.new('Draft', 'I do not like moose', nil, nil)
-      not_yet_published = Article.new('Tomorrow', 'Dogs', nil, Time.now + 30)
+    let(:published)            { Article.new('Published', 'I love cats', nil, Time.now - 30) }
+    let(:draft)                { Article.new('Draft', 'I do not like moose', nil, nil) }
+    let(:not_yet_published)    { Article.new('Tomorrow', 'Dogs', nil, Time.now + 30) }
+    let(:mapper)               { Perpetuity[Article] }
+
+    # Counting on late-bound memoization for this.
+    let(:published_id)         { mapper.id_for(published) }
+    let(:draft_id)             { mapper.id_for(draft) }
+    let(:not_yet_published_id) { mapper.id_for(not_yet_published) }
 
-      mapper = Perpetuity[Article]
+    before do
       mapper.insert published
       mapper.insert draft
       mapper.insert not_yet_published
+    end
 
-      published_ids = mapper.published.to_a.map(&:id)
-      published_ids.should include published.id
-      published_ids.should_not include draft.id, not_yet_published.id
+    it 'allows methods to act as scopes' do
+      published_ids = mapper.published.to_a.map { |article| mapper.id_for(article) }
+      published_ids.should include published_id
+      published_ids.should_not include draft_id, not_yet_published_id
 
-      unpublished_ids = mapper.unpublished.to_a.map(&:id)
-      unpublished_ids.should_not include published.id
-      unpublished_ids.should include draft.id, not_yet_published.id
+      unpublished_ids = mapper.unpublished.to_a.map { |article| mapper.id_for(article) }
+      unpublished_ids.should_not include published_id
+      unpublished_ids.should include draft_id, not_yet_published_id
     end
   end
 end

data/spec/support/test_classes/car.rb

@@ -1,3 +1,9 @@
 class Car
   attr_accessor :make, :model, :seats
+
+  def initialize attributes={}
+    attributes.each do |attr, value|
+      public_send "#{attr}=", value
+    end
+  end
 end