perpetuity 1.0.0 → 1.0.1

data/spec/integration/serialization_spec.rb

@@ -45,16 +45,16 @@ describe 'serialization' do
   end
 
   it 'serializes objects into hashes' do
-    mapper.serialize(article).should be == serialized_value
+    expect(mapper.serialize(article)).to be == serialized_value
   end
 
   it 'deserializes hashes into proper objects' do
     unserialized = mapper.find mapper.id_for(article)
-    unserialized.should be_a Article
-    unserialized.title.should be == article.title
-    unserialized.body.should be == article.body
+    expect(unserialized).to be_a Article
+    expect(unserialized.title).to be == article.title
+    expect(unserialized.body).to be == article.body
     unserialized.comments.first.tap do |unserialized_comment|
-      unserialized_comment.body.should be == comment.body
+      expect(unserialized_comment.body).to be == comment.body
     end
   end
 end

data/spec/integration/update_spec.rb

@@ -12,13 +12,13 @@ describe 'updating' do
 
   it 'updates an object in the database' do
     mapper.update article, title: new_title
-    mapper.find(mapper.id_for article).title.should eq new_title
+    expect(mapper.find(mapper.id_for article).title).to eq new_title
   end
 
   it 'resaves the object in the database' do
     article.title = new_title
     mapper.save article
-    mapper.find(mapper.id_for article).title.should eq new_title
+    expect(mapper.find(mapper.id_for article).title).to eq new_title
   end
 
   it 'only updates attributes which have changed since last retrieval' do
@@ -35,8 +35,8 @@ describe 'updating' do
     second_mapper.save second_article
 
     canonical_article = mapper.find(article_id)
-    canonical_article.title.should == 'New title'
-    canonical_article.views.should == 7
+    expect(canonical_article.title).to be == 'New title'
+    expect(canonical_article.views).to be == 7
   end
 
   it 'updates an object with referenced attributes' do
@@ -49,7 +49,7 @@ describe 'updating' do
     mapper.save retrieved_article
 
     retrieved_article = mapper.find(mapper.id_for retrieved_article)
-    retrieved_article.author.should be_a Perpetuity::Reference
+    expect(retrieved_article.author).to be_a Perpetuity::Reference
   end
 
   it 'updates an object with an array of referenced attributes' do
@@ -66,8 +66,8 @@ describe 'updating' do
     mapper.save retrieved_book
 
     retrieved_authors = Perpetuity[Book].find(mapper.id_for retrieved_book).authors
-    retrieved_authors.map(&:klass).should be == [User, User]
-    retrieved_authors.map(&:id).should be == [mapper.id_for(dave), mapper.id_for(andy)]
+    expect(retrieved_authors.map(&:klass)).to be == [User, User]
+    expect(retrieved_authors.map(&:id)).to be == [mapper.id_for(dave), mapper.id_for(andy)]
   end
 
   describe 'atomic increments/decrements' do
@@ -77,13 +77,13 @@ describe 'updating' do
     it 'increments attributes of objects in the database' do
       mapper.increment article, :views
       mapper.increment article, :views, 10
-      mapper.find(mapper.id_for(article)).views.should == view_count + 11
+      expect(mapper.find(mapper.id_for(article)).views).to be == view_count + 11
     end
 
     it 'decrements attributes of objects in the database' do
       mapper.decrement article, :views
       mapper.decrement article, :views, 10
-      mapper.find(mapper.id_for(article)).views.should == view_count - 11
+      expect(mapper.find(mapper.id_for(article)).views).to be == view_count - 11
     end
   end
 end

data/spec/perpetuity/attribute_set_spec.rb

@@ -6,14 +6,14 @@ module Perpetuity
       attribute = double('Attribute', name: :foo)
       subject << attribute
 
-      subject.first.should eq attribute
+      expect(subject.first).to eq attribute
     end
 
     it 'can access attributes by name' do
       user_attribute = double('Attribute', name: :user)
       subject << user_attribute
 
-      subject[:user].should eq user_attribute
+      expect(subject[:user]).to eq user_attribute
     end
   end
 end

data/spec/perpetuity/attribute_spec.rb

@@ -6,29 +6,29 @@ module Perpetuity
     subject { attribute }
 
     it 'has a name' do
-      subject.name.should == :article
+      expect(subject.name).to be == :article
     end
 
     it 'has a type' do
-      subject.type.should == Object
+      expect(subject.type).to be == Object
     end
 
     it 'can get extra options' do
-      attribute.options.should == { default: 1 }
-      attribute.options(:default).should == 1
+      expect(attribute.options).to be == { default: 1 }
+      expect(attribute.options(:default)).to be == 1
     end
 
     it 'can be embedded' do
       attribute = Attribute.new :article, Object, embedded: true
-      attribute.should be_embedded
+      expect(attribute).to be_embedded
     end
 
     it 'can match a regex' do
-      expect(attribute =~ /article/).to be_true
+      expect(attribute =~ /article/).to be_truthy
     end
 
     it 'uses its name when converted to a string' do
-      attribute.to_s.should == 'article'
+      expect(attribute.to_s).to be == 'article'
     end
   end
 end

data/spec/perpetuity/config_spec.rb

@@ -3,6 +3,7 @@ require 'perpetuity/postgres'
 
 module Perpetuity
   describe Configuration do
+    before(:all) { Perpetuity.register_standard_adapters }
     let(:config) { Configuration.new }
 
     it 'sets a data source' do
@@ -13,28 +14,28 @@ module Perpetuity
                          host: 'host',
                          port: 1337
 
-      config.data_source.should be_a Postgres
-      config.data_source.db.should == 'perpetuity'
-      config.data_source.username.should == 'username'
-      config.data_source.password.should == 'password'
-      config.data_source.host.should == 'host'
-      config.data_source.port.should == 1337
+      expect(config.data_source).to be_a Postgres
+      expect(config.data_source.db).to eq 'perpetuity'
+      expect(config.data_source.username).to eq 'username'
+      expect(config.data_source.password).to eq 'password'
+      expect(config.data_source.host).to eq 'host'
+      expect(config.data_source.port).to eq 1337
     end
 
     it 'allows a URL as its data source' do
       db = "postgres://username:password@host:1337/database"
       data_source = config.data_source(db, pool_size: 20)
-      data_source.should be_a Postgres
-      data_source.username.should == 'username'
-      data_source.password.should == 'password'
-      data_source.host.should == 'host'
-      data_source.port.should == 1337
-      data_source.db.should == 'database'
-      data_source.pool_size.should == 20
+      expect(data_source).to be_a Postgres
+      expect(data_source.username).to eq 'username'
+      expect(data_source.password).to eq 'password'
+      expect(data_source.host).to eq 'host'
+      expect(data_source.port).to eq 1337
+      expect(data_source.db).to eq 'database'
+      expect(data_source.pool_size).to eq 20
     end
 
     it 'sets up a logger by default' do
-      config.logger.should be_a Logger
+      expect(config.logger).to be_a Logger
     end
   end
 end

data/spec/perpetuity/data_injectable_spec.rb

@@ -9,23 +9,23 @@ module Perpetuity
 
     it 'injects an attribute into an object' do
       klass.inject_attribute object, :a, 1
-      object.instance_variable_get(:@a).should eq 1
+      expect(object.instance_variable_get(:@a)).to eq 1
     end
 
     it 'injects data into an object' do
       klass.inject_data object, { a: 1, b: 2 }
-      object.instance_variable_get(:@a).should eq 1
-      object.instance_variable_get(:@b).should eq 2
+      expect(object.instance_variable_get(:@a)).to eq 1
+      expect(object.instance_variable_get(:@b)).to eq 2
     end
 
     it 'injects an id' do
       klass.inject_data object, { id: 1 }
-      object.instance_variable_get(:@id).should eq 1
+      expect(object.instance_variable_get(:@id)).to eq 1
     end
 
     it 'injects a specified id' do
       klass.give_id_to object, 2
-      object.instance_variable_get(:@id).should eq 2
+      expect(object.instance_variable_get(:@id)).to eq 2
     end
   end
 end

data/spec/perpetuity/dereferencer_spec.rb

@@ -15,28 +15,29 @@ module Perpetuity
     context 'with one reference' do
       it 'loads objects based on the specified objects and attribute' do
         first.instance_variable_set :@id, 1
-        mapper.should_receive(:find).with(1) { first }
+        expect(mapper).to receive(:find).with(1) { first }
         id_map = IdentityMap.new
-        derefer.stub(map: id_map)
-        registry.stub(:mapper_for)
-                .with(Object, identity_map: id_map) { mapper }
+        allow(derefer).to receive(:map) { id_map }
+        allow(registry).to receive(:mapper_for)
+                       .with(Object, identity_map: id_map)
+                       .and_return mapper
 
         derefer.load first_ref
         id = derefer[first_ref].instance_variable_get(:@id)
-        id.should == 1
+        expect(id).to be == 1
       end
     end
 
     context 'with no references' do
       it 'returns an empty array' do
-        derefer.load(nil).should == []
+        expect(derefer.load(nil)).to be == []
       end
     end
 
     context 'with multiple references' do
       it 'returns the array of dereferenced objects' do
-        mapper.should_receive(:find).with([1, 2]) { objects }
-        derefer.load([first_ref, second_ref]).should == objects
+        expect(mapper).to receive(:find).with([1, 2]) { objects }
+        expect(derefer.load([first_ref, second_ref])).to be == objects
       end
     end
   end

data/spec/perpetuity/dirty_tracker_spec.rb

@@ -18,7 +18,7 @@ module Perpetuity
       let(:object) { klass.new(1, 'foo') }
 
       before do
-        mapper.stub(:id_for).with(object) { object.id }
+        allow(mapper).to receive(:id_for).with(object) { object.id }
         tracker << object
       end
 
@@ -26,23 +26,23 @@ module Perpetuity
         object.name = 'bar'
         retrieved = tracker[klass, 1]
 
-        retrieved.id.should == 1
-        retrieved.name.should == 'foo'
+        expect(retrieved.id).to be == 1
+        expect(retrieved.name).to be == 'foo'
       end
 
       specify 'the object returned is a duplicate' do
-        tracker[klass, 1].should_not be object
+        expect(tracker[klass, 1]).not_to be object
       end
 
       it 'stringifies keys when checking' do
         retrieved = tracker[klass, '1']
-        retrieved.id.should == 1
+        expect(retrieved.id).to be == 1
       end
     end
 
     context 'when the object does not exist in the IdentityMap' do
       it 'returns nil' do
-        tracker[Object, 1].should be_nil
+        expect(tracker[Object, 1]).to be_nil
       end
     end
   end

data/spec/perpetuity/duplicator_spec.rb

@@ -9,27 +9,27 @@ module Perpetuity
     let(:duper) { Duplicator.new(book) }
 
     it 'duplicates an object' do
-      duper.object.should be_a Book
-      duper.object.should_not be book
+      expect(duper.object).to be_a Book
+      expect(duper.object).not_to be book
     end
 
     it 'duplicates attributes inside an object' do
       duped_book = duper.object
-      duped_book.title.should be_a String
-      duped_book.title.should == book.title
-      duped_book.title.should_not be book.title
+      expect(duped_book.title).to be_a String
+      expect(duped_book.title).to be == book.title
+      expect(duped_book.title).not_to be book.title
     end
 
     it 'does not duplicate non-duplicable attributes' do
       # Symbols cannot be duped
       book = Book.new(:foo)
       duper = Duplicator.new(book)
-      duper.object.title.should be :foo
+      expect(duper.object.title).to be :foo
     end
 
     it 'duplicates objects contained within array attributes' do
-      duper.object.authors.first.should be_a User
-      duper.object.authors.first.should_not be authors.first
+      expect(duper.object.authors.first).to be_a User
+      expect(duper.object.authors.first).not_to be authors.first
     end
   end
 end

data/spec/perpetuity/identity_map_spec.rb

@@ -21,23 +21,23 @@ module Perpetuity
       it 'returns the object with the given class and id' do
         retrieved = id_map[klass, 1]
 
-        retrieved.id.should == 1
+        expect(retrieved.id).to be == 1
       end
 
       specify 'the object returned is the same object' do
-        id_map[klass, 1].should be object
+        expect(id_map[klass, 1]).to be object
       end
     end
 
     context 'when the object does not exist in the IdentityMap' do
       it 'returns nil' do
-        id_map[Object, 1].should be_nil
+        expect(id_map[Object, 1]).to be_nil
       end
     end
 
     it 'returns all of the ids it contains' do
       id_map << object
-      id_map.ids_for(klass).should == [1]
+      expect(id_map.ids_for(klass)).to be == [1]
     end
   end
 end

data/spec/perpetuity/mapper_registry_spec.rb

@@ -11,7 +11,7 @@ module Perpetuity
 
     it { should have_mapper Object }
     it 'maps classes to instances of their mappers' do
-      registry[Object].should be_a mapper
+      expect(registry[Object]).to be_a mapper
     end
 
     it 'raises a KeyError when trying to find a mapper for a missing class' do
@@ -26,8 +26,8 @@ module Perpetuity
       end
 
       it 'loads the definition for the specified mapper class' do
-        Dir.should_receive(:[]).with('app/**/*_mapper.rb') { [mapper_file] }
-        registry.should_receive(:load).with(mapper_file)
+        expect(Dir).to receive(:[]).with('app/**/*_mapper.rb') { [mapper_file] }
+        expect(registry).to receive(:load).with(mapper_file)
         registry.load_mappers
       end
     end
@@ -35,7 +35,7 @@ module Perpetuity
     it 'returns a mapper initialized with the specified identity map' do
       identity_map = double('IdentityMap')
       mapper = registry.mapper_for(Object, identity_map: identity_map)
-      mapper.identity_map.should be identity_map
+      expect(mapper.identity_map).to be identity_map
     end
   end
 end

data/spec/perpetuity/mapper_spec.rb

@@ -13,49 +13,49 @@ module Perpetuity
 
     it 'has correct attributes' do
       mapper_class.attribute :name
-      mapper_class.attributes.should eq [:name]
+      expect(mapper_class.attributes).to eq [:name]
     end
 
     it 'returns an empty attribute list when no attributes have been assigned' do
-      mapper_class.attributes.should be_empty
+      expect(mapper_class.attributes).to be_empty
     end
 
     it 'can have embedded attributes' do
       mapper_class.attribute :comments, embedded: true
-      mapper_class.attribute_set[:comments].should be_embedded
+      expect(mapper_class.attribute_set[:comments]).to be_embedded
     end
 
     it 'registers itself with the mapper registry' do
       mapper_class.map Object, registry
-      registry[Object].should be_instance_of mapper_class
+      expect(registry[Object]).to be_instance_of mapper_class
     end
 
     describe 'talking to the data source' do
       let(:data_source) { MongoDB.new(db: nil) }
       before do
-        mapper_class.stub(data_source: data_source)
+        allow(mapper_class).to receive(:data_source) { data_source }
         mapper_class.map Object, registry
       end
 
       specify 'mappers use the data source that the mapper class uses' do
-        mapper.data_source.should be data_source
+        expect(mapper.data_source).to be data_source
       end
 
       it 'inserts objects into a data source' do
         mapper_class.attribute :my_attribute
         obj = Object.new
         obj.instance_variable_set '@my_attribute', 'foo'
-        data_source.should_receive(:can_serialize?).with('foo') { true }
-        data_source.should_receive(:insert)
+        expect(data_source).to receive(:can_serialize?).with('foo') { true }
+        expect(data_source).to receive(:insert)
                    .with('Object', [{ 'my_attribute' => 'foo' }], mapper.attribute_set)
                    .and_return(['bar'])
 
-        mapper.insert(obj).should be == 'bar'
+        expect(mapper.insert(obj)).to be == 'bar'
       end
 
       it 'counts objects of its mapped class in the data source' do
-        data_source.should_receive(:count).with('Object') { 4 }
-        mapper.count.should be == 4
+        expect(data_source).to receive(:count).with('Object') { 4 }
+        expect(mapper.count).to be == 4
       end
 
       describe 'finding specific objects' do
@@ -65,10 +65,10 @@ module Perpetuity
         it 'finds an object by ID' do
           returned_object.instance_variable_set :@id, 1
           criteria = data_source.query { |o| o.id == 1 }
-          data_source.should_receive(:retrieve)
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options) { [returned_object] }
 
-          mapper.find(1).should be == returned_object
+          expect(mapper.find(1)).to be == returned_object
         end
 
         it 'finds multiple objects by ID' do
@@ -77,38 +77,38 @@ module Perpetuity
           mapper.give_id_to second, 2
           criteria = data_source.query { |o| o.id.in [1, 2] }
           options.merge! limit: nil
-          data_source.should_receive(:retrieve)
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options)
                      .and_return [first, second]
 
-          mapper.find([1, 2]).to_a.should be == [first, second]
+          expect(mapper.find([1, 2]).to_a).to be == [first, second]
         end
 
         it 'finds multiple objects with a block' do
           criteria = data_source.query { |o| o.name == 'foo' }
           options = self.options.merge(limit: nil)
-          data_source.should_receive(:retrieve)
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options) { [returned_object] }.twice
 
-          mapper.select   { |e| e.name == 'foo' }.to_a.should be == [returned_object]
-          mapper.find_all { |e| e.name == 'foo' }.to_a.should be == [returned_object]
+          expect(mapper.select   { |e| e.name == 'foo' }.to_a).to be == [returned_object]
+          expect(mapper.find_all { |e| e.name == 'foo' }.to_a).to be == [returned_object]
         end
 
         it 'finds an object with a block' do
           criteria = data_source.query { |o| o.name == 'foo' }
-          data_source.should_receive(:retrieve)
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options) { [returned_object] }.twice
-          mapper.find   { |o| o.name == 'foo' }.should be == returned_object
-          mapper.detect { |o| o.name == 'foo' }.should be == returned_object
+          expect(mapper.find   { |o| o.name == 'foo' }).to be == returned_object
+          expect(mapper.detect { |o| o.name == 'foo' }).to be == returned_object
         end
 
         it 'caches results' do
           mapper.give_id_to returned_object, 1
           criteria = data_source.query { |o| o.id == 1 }
           duplicate = returned_object.dup
-          duplicate.stub(class: returned_object.class)
-          returned_object.stub(dup: duplicate)
-          data_source.should_receive(:retrieve)
+          allow(duplicate).to receive(:class) { returned_object.class }
+          allow(returned_object).to receive(:dup) { duplicate }
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options) { [returned_object] }
                      .once
 
@@ -118,7 +118,7 @@ module Perpetuity
 
         it 'does not cache nil results' do
           criteria = data_source.query { |o| o.id == 1 }
-          data_source.should_receive(:retrieve)
+          expect(data_source).to receive(:retrieve)
                      .with('Object', criteria, options) { [] }
                      .twice
 
@@ -132,8 +132,8 @@ module Perpetuity
         object = Object.new
         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' }
+        expect(data_source).to receive(:can_serialize?).with('bar') { true }
+        expect(data_source).to receive(:update).with 'Object', 1, { 'foo' => 'bar' }
 
         mapper.save object
       end
@@ -149,7 +149,7 @@ module Perpetuity
 
         object.instance_variable_set :@modified, true
 
-        mapper.serialize_changed_attributes(object).should == {
+        expect(mapper.serialize_changed_attributes(object)).to be == {
           'modified' => true
         }
       end
@@ -157,12 +157,12 @@ module Perpetuity
       it 'deletes an object from the data source' do
         object = Object.new
 
-        data_source.should_receive(:delete).with [object], 'Object'
+        expect(data_source).to receive(:delete).with [object], 'Object'
         mapper.delete object
       end
 
       it 'deletes all objects it manages' do
-        data_source.should_receive(:delete_all).with('Object')
+        expect(data_source).to receive(:delete_all).with('Object')
         mapper.delete_all
       end
     end
@@ -174,21 +174,27 @@ module Perpetuity
         before { mapper.give_id_to object, 1 }
 
         it 'knows the object is persisted' do
-          mapper.persisted?(object).should be_true
+          expect(mapper.persisted?(object)).to be_truthy
         end
 
         it 'knows the id of the object' do
-          mapper.id_for(object).should be == 1
+          expect(mapper.id_for(object)).to be == 1
         end
       end
 
       context 'when not persisted' do
         it 'knows the object is not persisted' do
-          mapper.persisted?(object).should be_false
+          expect(mapper.persisted?(object)).to be_falsey
         end
 
         it 'returns a nil id' do
-          mapper.id_for(object).should be_nil
+          expect(mapper.id_for(object)).to be_nil
+        end
+
+        it 'knows an object is not persisted even when id is nil' do
+          mapper.give_id_to object, nil
+
+          expect(mapper.persisted?(object)).to be_falsey
         end
       end
     end
@@ -198,14 +204,14 @@ module Perpetuity
         it 'adds the attribute to the attribute set' do
           mapper_class.id(String) { 1.to_s }
           id_attr = mapper_class.attribute_set[:id]
-          id_attr.type.should be String
+          expect(id_attr.type).to be String
         end
       end
 
       context 'when not setting the type' do
         it 'does not add the attribute' do
           mapper_class.id { 1.to_s }
-          mapper_class.attribute_set[:id].should be_nil
+          expect(mapper_class.attribute_set[:id]).to be_nil
         end
       end
     end
@@ -215,19 +221,19 @@ module Perpetuity
         registry = Object.new
         id_map = Object.new
         mapper = Mapper.new(registry, id_map)
-        mapper.identity_map.should be id_map
+        expect(mapper.identity_map).to be id_map
       end
     end
 
     describe 'specifying the collection/table name' do
       it 'changes the collection name' do
         mapper_class.collection_name = 'articles'
-        mapper.collection_name.should == 'articles'
+        expect(mapper.collection_name).to be == 'articles'
       end
 
       it 'defaults to the mapped class name' do
         mapper_class.map Object
-        mapper.collection_name.should == 'Object'
+        expect(mapper.collection_name).to be == 'Object'
       end
     end
   end