perpetuity 0.2 → 0.3

data/spec/perpetuity/mapper_spec.rb

@@ -2,30 +2,26 @@ require 'perpetuity/mapper'
 
 module Perpetuity
   describe Mapper do
-    let(:mapper) do
-      Mapper.new do
-      end
-    end
-
+    let(:mapper_class) { Class.new(Mapper) }
+    let(:mapper) { mapper_class.new }
     subject { mapper }
 
     it { should be_a Mapper }
 
     it 'has correct attributes' do
-      Mapper.new { attribute :name, String }.attributes.should eq [:name]
+      Class.new(Mapper) { attribute :name }.attributes.should eq [:name]
     end
 
     it 'returns an empty attribute list when no attributes have been assigned' do
-      Mapper.new.attributes.should be_empty
+      Mapper.attributes.should be_empty
     end
 
     it 'can have embedded attributes' do
-      mapper_with_embedded_attrs = Mapper.new { attribute :comments, Array, embedded: true }
+      mapper_with_embedded_attrs = Class.new(Mapper)
+      mapper_with_embedded_attrs.attribute :comments, embedded: true
       mapper_with_embedded_attrs.attribute_set[:comments].should be_embedded
     end
 
-    its(:mapped_class) { should eq Object }
-
     context 'with unserializable embedded attributes' do
       let(:unserializable_object) { 1.to_c }
       let(:serialized_attrs) do
@@ -35,7 +31,8 @@ module Perpetuity
       it 'serializes attributes' do
         object = Object.new
         object.stub(sub_objects: [unserializable_object])
-        mapper.attribute :sub_objects, Array, embedded: true
+        mapper_class.attribute :sub_objects, embedded: true
+        mapper_class.map Object
         data_source = double(:data_source)
         mapper.stub(data_source: data_source)
         data_source.should_receive(:can_serialize?).with(unserializable_object).and_return false
@@ -43,5 +40,14 @@ module Perpetuity
         mapper.serialize(object)['sub_objects'].should eq serialized_attrs
       end
     end
+
+    describe 'subclassing Mapper' do
+      let!(:mapper_subclass) { Class.new(Mapper) { map String } }
+      let(:mapper) { mapper_subclass.new }
+
+      it 'can explicitly map a class' do
+        MapperRegistry[String].should be_instance_of mapper_subclass
+      end
+    end
   end
 end

data/spec/perpetuity/mongodb/index_spec.rb

@@ -0,0 +1,44 @@
+require 'perpetuity/mongodb/index'
+
+module Perpetuity
+  class MongoDB
+    describe Index do
+      let(:attribute) { double(name: 'name') }
+      let(:index) { Index.new(Object, attribute) }
+
+      it 'is not active by default' do
+        index.should_not be_active
+      end
+
+      it 'can be activated' do
+        index.activate!
+        index.should be_active
+      end
+
+      it 'can be unique' do
+        index = Index.new(Object, attribute, unique: true)
+        index.should be_unique
+      end
+
+      it 'is not unique by default' do
+        index.should_not be_unique
+      end
+
+      describe 'index ordering' do
+        it 'can be ordered in ascending order' do
+          index = Index.new(Object, attribute, order: :ascending)
+          index.order.should be :ascending
+        end
+
+        it 'is ordered ascending by default' do
+          index.order.should be :ascending
+        end
+
+        it 'can be ordered in descending order' do
+          index = Index.new(Object, attribute, order: :descending)
+          index.order.should be :descending
+        end
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_expression_spec.rb

@@ -45,5 +45,23 @@ module Perpetuity
         expression.to_db.should == { attribute: :value }
       end
     end
+
+    describe 'unions' do
+      let(:lhs) { MongoDB::QueryExpression.new :first, :equals, :one }
+      let(:rhs) { MongoDB::QueryExpression.new :second, :equals, :two }
+
+      it 'converts | to an $or query' do
+        (lhs | rhs).to_db.should == { '$or' => [{first: :one}, {second: :two}] }
+      end
+    end
+
+    describe 'intersections' do
+      let(:lhs) { MongoDB::QueryExpression.new :first, :equals, :one }
+      let(:rhs) { MongoDB::QueryExpression.new :second, :equals, :two }
+
+      it 'converts & to an $and query' do
+        (lhs & rhs).to_db.should == { '$and' => [{first: :one}, {second: :two}] }
+      end
+    end
   end
 end

data/spec/perpetuity/mongodb/query_intersection_spec.rb

@@ -0,0 +1,16 @@
+require 'perpetuity/mongodb/query_intersection'
+require 'perpetuity/mongodb/query_expression'
+
+module Perpetuity
+  class MongoDB
+    describe QueryIntersection do
+      let(:lhs) { QueryExpression.new :first, :equals, 'one' }
+      let(:rhs) { QueryExpression.new :second, :equals, 'two' }
+      let(:intersection) { QueryIntersection.new lhs, rhs }
+
+      it 'returns a Mongo representation of the union of 2 expressions' do
+        intersection.to_db.should be == { '$and' => [{first: 'one'}, {second: 'two'}] }
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb/query_union_spec.rb

@@ -0,0 +1,16 @@
+require 'perpetuity/mongodb/query_union'
+require 'perpetuity/mongodb/query_expression'
+
+module Perpetuity
+  class MongoDB
+    describe QueryUnion do
+      let(:lhs) { QueryExpression.new :first, :equals, 'one' }
+      let(:rhs) { QueryExpression.new :second, :equals, 'two' }
+      let(:union) { QueryUnion.new lhs, rhs }
+
+      it 'returns the proper union of two expressions' do
+        union.to_db.should be == { '$or' => [{first: 'one'}, {second: 'two'}] }
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb_spec.rb

@@ -13,7 +13,7 @@ module Perpetuity
 
     it 'connects to its host' do
       connection = double('connection')
-      Mongo::Connection.stub(new: connection)
+      Mongo::MongoClient.should_receive(:new).and_return connection
       mongo.connect
       mongo.should be_connected
       mongo.connection.should == connection
@@ -99,5 +99,32 @@ module Perpetuity
         end
       end
     end
+
+    describe 'indexing' do
+      let(:collection) { Object }
+      let(:key) { 'object_id' }
+
+      before { mongo.index collection, key }
+      after { mongo.drop_collection collection }
+
+      it 'adds indexes for the specified key on the specified collection' do
+        indexes = mongo.indexes(collection).select{ |index| index.attribute == 'object_id' }
+        indexes.should_not be_empty
+        indexes.first.order.should be :ascending
+      end
+
+      it 'adds descending-order indexes' do
+        index = mongo.index collection, 'hash', order: :descending
+        index.order.should be :descending
+      end
+
+      it 'creates indexes on the database collection' do
+        mongo.delete_all collection
+        index = mongo.index collection, 'real_index', order: :descending, unique: true
+        mongo.activate_index! index
+
+        mongo.active_indexes(collection).should include index
+      end
+    end
   end
 end

data/spec/perpetuity/serializer_spec.rb

@@ -0,0 +1,6 @@
+require 'perpetuity/serializer'
+
+module Perpetuity
+  describe Serializer do
+  end
+end

data/spec/perpetuity_spec.rb

@@ -10,28 +10,40 @@ describe Perpetuity do
 
   describe 'mapper generation' do
     it 'generates mappers' do
-      mapper = Perpetuity.generate_mapper_for Object
+      Perpetuity.generate_mapper_for Object
       Perpetuity[Object].should be_a Perpetuity::Mapper
-      Perpetuity[Object].should be == mapper
+    end
+
+    it 'provides a DSL within the generated mapper' do
+      Perpetuity.generate_mapper_for Object do
+        id { object_id + 1 }
+        attribute :object_id
+      end
+
+      mapper = Perpetuity[Object]
+      object = Object.new
+      mapper.insert object
+      object.id.should eq object.object_id + 1
+      mapper.attributes.should eq [:object_id]
     end
   end
 
   describe 'persistence' do
     it "persists an object" do
       article = Article.new 'I have a title'
-      expect { Perpetuity::Mapper[Article].insert article }.
-        to change { Perpetuity::Mapper[Article].count }.by 1
-      Perpetuity::Mapper[Article].find(article.id).title.should eq 'I have a title'
+      expect { Perpetuity[Article].insert article }.
+        to change { Perpetuity[Article].count }.by 1
+      Perpetuity[Article].find(article.id).title.should eq 'I have a title'
     end
 
     it 'returns the id of the persisted object' do
       article = Article.new
-      Perpetuity::Mapper[Article].insert(article).should eq article.id
+      Perpetuity[Article].insert(article).should eq article.id
     end
 
     it "gives an id to objects" do
       article = Article.new
-      Perpetuity::Mapper[Article].give_id_to article, 1
+      Perpetuity[Article].give_id_to article, 1
 
       article.id.should eq 1
     end
@@ -40,20 +52,20 @@ describe Perpetuity do
       let(:article) { Article.new }
 
       it 'assigns an id to the inserted object' do
-        Perpetuity::Mapper[Article].insert article
+        Perpetuity[Article].insert article
         article.should respond_to :id
       end
 
       it "assigns an id using Mapper.first" do
-        Perpetuity::Mapper[Article].first.should respond_to :id
+        Perpetuity[Article].first.should respond_to :id
       end
 
       it 'assigns an id using Mapper.retrieve.first' do
-        Perpetuity::Mapper[Article].retrieve.first.should respond_to :id
+        Perpetuity[Article].retrieve.first.should respond_to :id
       end
 
       it 'assigns an id using Mapper.all.first' do
-        Perpetuity::Mapper[Article].all.first.should respond_to :id
+        Perpetuity[Article].all.first.should respond_to :id
       end
     end
 
@@ -62,15 +74,15 @@ describe Perpetuity do
 
       it 'persists arrays' do
         article.comments << 1 << 2 << 3
-        Perpetuity::Mapper[Article].insert article
-        Perpetuity::Mapper[Article].find(article.id).comments.should eq [1, 2, 3]
+        Perpetuity[Article].insert article
+        Perpetuity[Article].find(article.id).comments.should eq [1, 2, 3]
       end
 
       it 'persists arrays with unserializable objects in them' do
         comment = Comment.new('my comment')
         article.comments << comment
-        Perpetuity::Mapper[Article].insert article
-        Perpetuity::Mapper[Article].find(article.id).comments.first.tap do |persisted_comment|
+        Perpetuity[Article].insert article
+        Perpetuity[Article].find(article.id).comments.first.tap do |persisted_comment|
           persisted_comment.should be_a Comment
           persisted_comment.body.should eq comment.body
         end
@@ -78,54 +90,55 @@ describe Perpetuity do
     end
 
     it "allows mappers to set the id field" do
-      book = Book.new('My Title')
+      noise = Time.now.to_f.to_s.sub('.', '')
+      book = Book.new("My Title #{noise}")
 
-      Perpetuity::Mapper[Book].insert book
-      book.id.should eq 'my-title'
+      Perpetuity[Book].insert book
+      book.id.should eq "my-title-#{noise}"
     end
   end
 
   describe "deletion" do
     it 'deletes an object' do
-      2.times { Perpetuity::Mapper[Article].insert Article.new }
-      expect { Perpetuity::Mapper[Article].delete Perpetuity::Mapper[Article].first }.to change { Perpetuity::Mapper[Article].count }.by(-1)
+      2.times { Perpetuity[Article].insert Article.new }
+      expect { Perpetuity[Article].delete Perpetuity[Article].first }.to change { Perpetuity[Article].count }.by(-1)
     end
 
     it 'deletes an object with a given id' do
-      article_id = Perpetuity::Mapper[Article].insert Article.new
+      article_id = Perpetuity[Article].insert Article.new
       expect {
-        Perpetuity::Mapper[Article].delete article_id
-      }.to change { Perpetuity::Mapper[Article].count }.by(-1)
+        Perpetuity[Article].delete article_id
+      }.to change { Perpetuity[Article].count }.by(-1)
     end
     
     describe "#delete_all" do
       it "should delete all objects of a certain class" do
-        Perpetuity::Mapper[Article].insert Article.new
-        Perpetuity::Mapper[Article].delete_all
-        Perpetuity::Mapper[Article].count.should eq 0
+        Perpetuity[Article].insert Article.new
+        Perpetuity[Article].delete_all
+        Perpetuity[Article].count.should eq 0
       end
     end
   end
 
   describe "retrieval" do
     it "gets all the objects of a class" do
-      expect { Perpetuity::Mapper[Article].insert Article.new }.
-        to change { Perpetuity::Mapper[Article].all.count }.by 1
+      expect { Perpetuity[Article].insert Article.new }.
+        to change { Perpetuity[Article].all.count }.by 1
     end
     
     it "has an ID when retrieved" do
-      Perpetuity::Mapper[Article].insert Article.new
-      Perpetuity::Mapper[Article].first.should respond_to :id
+      Perpetuity[Article].insert Article.new
+      Perpetuity[Article].first.should respond_to :id
     end
     
     it "returns a Perpetuity::Retrieval object" do
-      Perpetuity::Mapper[Article].retrieve(id: 1).should be_an_instance_of Perpetuity::Retrieval
+      Perpetuity[Article].retrieve(id: 1).should be_an_instance_of Perpetuity::Retrieval
     end
 
     it "gets an item with a specific ID" do
       article = Article.new
-      Perpetuity::Mapper[Article].insert article
-      retrieved = Perpetuity::Mapper[Article].find(article.id)
+      Perpetuity[Article].insert article
+      retrieved = Perpetuity[Article].find(article.id)
 
       retrieved.id.should eq article.id
       retrieved.title.should eq article.title
@@ -134,8 +147,8 @@ describe Perpetuity do
 
     it "gets an item by its attributes" do
       article = Article.new
-      Perpetuity::Mapper[Article].insert article
-      retrieved = Perpetuity::Mapper[Article].retrieve(title: article.title)
+      Perpetuity[Article].insert article
+      retrieved = Perpetuity[Article].retrieve(title: article.title)
 
       retrieved.to_a.should_not be_empty
       retrieved.first.title.should eq article.title
@@ -145,60 +158,60 @@ describe Perpetuity do
       let(:draft) { Article.new 'Draft', 'draft content', nil, Time.now + 30 }
       let(:published) { Article.new 'Published', 'content', nil, Time.now - 30, 3 }
       before do
-        Perpetuity::Mapper[Article].insert draft
-        Perpetuity::Mapper[Article].insert published
+        Perpetuity[Article].insert draft
+        Perpetuity[Article].insert published
       end
 
       it 'selects objects using equality' do
-        selected = Perpetuity::Mapper[Article].select { title == 'Published' }
+        selected = Perpetuity[Article].select { title == 'Published' }
         selected.map(&:id).should include published.id
         selected.map(&:id).should_not include draft.id
       end
 
       it 'selects objects using greater-than' do
-        selected = Perpetuity::Mapper[Article].select { published_at < Time.now }
+        selected = Perpetuity[Article].select { published_at < Time.now }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using greater-than-or-equal' do
-        selected = Perpetuity::Mapper[Article].select { views >= 3 }
+        selected = Perpetuity[Article].select { views >= 3 }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using less-than' do
-        selected = Perpetuity::Mapper[Article].select { views < 3 }
+        selected = Perpetuity[Article].select { views < 3 }
         ids = selected.map(&:id)
         ids.should include draft.id
         ids.should_not include published.id
       end
 
       it 'selects objects using less-than-or-equal' do
-        selected = Perpetuity::Mapper[Article].select { views <= 0 }
+        selected = Perpetuity[Article].select { views <= 0 }
         ids = selected.map(&:id)
         ids.should include draft.id
         ids.should_not include published.id
       end
 
       it 'selects objects using inequality' do
-        selected = Perpetuity::Mapper[Article].select { title.not_equal? 'Draft' }
+        selected = Perpetuity[Article].select { title.not_equal? 'Draft' }
         ids = selected.map(&:id)
         ids.should_not include draft.id
         ids.should include published.id
       end
 
       it 'selects objects using regular expressions' do
-        selected = Perpetuity::Mapper[Article].select { title =~ /Pub/ }
+        selected = Perpetuity[Article].select { title =~ /Pub/ }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using inclusion' do
-        selected = Perpetuity::Mapper[Article].select { title.in %w( Published ) }
+        selected = Perpetuity[Article].select { title.in %w( Published ) }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
@@ -208,22 +221,24 @@ describe Perpetuity do
 
   describe 'pagination' do
     it 'specifies the page we want' do
-      Perpetuity::Mapper[Article].retrieve.should respond_to :page
+      Perpetuity[Article].retrieve.should respond_to :page
     end
 
     it 'specify the quantity per page' do
-      Perpetuity::Mapper[Article].retrieve.should respond_to :per_page
+      Perpetuity[Article].retrieve.should respond_to :per_page
     end
 
     it 'returns an empty set when there is no data for that page' do
-      data = Perpetuity::Mapper[Article].retrieve.page(2)
+      mapper = Perpetuity[Article]
+      mapper.delete_all
+      data = mapper.retrieve.page(2)
       data.should be_empty
     end
 
     it 'specifies per-page quantity' do
-      Perpetuity::Mapper[Article].delete_all
-      5.times { |i| Perpetuity::Mapper[Article].insert Article.new i }
-      data = Perpetuity::Mapper[Article].retrieve.page(3).per_page(2)
+      Perpetuity[Article].delete_all
+      5.times { |i| Perpetuity[Article].insert Article.new i }
+      data = Perpetuity[Article].retrieve.page(3).per_page(2)
       data.should have(1).item
     end
   end
@@ -231,8 +246,8 @@ describe Perpetuity do
   describe 'associations with other objects' do
     let(:user) { User.new }
     let(:topic) { Topic.new }
-    let(:user_mapper) { Perpetuity::Mapper[User] }
-    let(:topic_mapper) { Perpetuity::Mapper[Topic] }
+    let(:user_mapper) { Perpetuity[User] }
+    let(:topic_mapper) { Perpetuity[Topic] }
 
     before do
       user.name = 'Flump'
@@ -262,18 +277,32 @@ describe Perpetuity do
 
   describe 'updating' do
     let(:article) { Article.new }
+    let(:mapper) { Perpetuity[Article] }
+    let(:new_title) { 'I has a new title!' }
+
     before do
-      Perpetuity::Mapper[Article].insert article
+      mapper.insert article
     end
 
     it 'updates an object in the database' do
-      Perpetuity::Mapper[Article].update article, title: 'I has a new title!'
-      Perpetuity::Mapper[Article].find(article.id).title.should eq 'I has a new title!'
+      mapper.update article, title: new_title
+      mapper.find(article.id).title.should eq new_title
+    end
+
+    it 'updates the object in memory' do
+      mapper.update article, title: new_title
+      article.title.should eq new_title
+    end
+
+    it 'resaves the object in the database' do
+      article.title = new_title
+      mapper.save article
+      mapper.find(article.id).title.should eq new_title
     end
   end
 
   describe 'validations' do
-    let(:car_mapper) { Perpetuity::Mapper[Car] }
+    let(:car_mapper) { Perpetuity[Car] }
 
     it 'raises an exception when inserting an invalid object' do
       car = Car.new
@@ -290,8 +319,8 @@ describe Perpetuity do
   # The Message class stores its data members differently internally than it receives them
   it 'uses accessor methods to read/write data' do
     message = Message.new 'My Message!'
-    Perpetuity::Mapper[Message].insert message
-    saved_message = Perpetuity::Mapper[Message].find(message.id)
+    Perpetuity[Message].insert message
+    saved_message = Perpetuity[Message].find(message.id)
     saved_message.instance_variable_get(:@text).should eq 'My Message!'.reverse
     saved_message.text.should eq 'My Message!'
   end
@@ -353,4 +382,54 @@ describe Perpetuity do
       end
     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)
+
+      mapper = Perpetuity[Article]
+      mapper.insert published
+      mapper.insert draft
+      mapper.insert not_yet_published
+
+      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
+
+      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
+    end
+  end
+
+  describe 'indexing' do
+    let(:mapper_class) do
+      Class.new(Perpetuity::Mapper) do
+        map Object
+        attribute :name
+        index :name
+      end
+    end
+    let(:mapper) { mapper_class.new }
+    let(:name_index) do
+      mapper.indexes.find do |index|
+        index.attribute.to_s == :name
+      end
+    end
+
+    it 'adds indexes to database collections/tables' do
+      name_index.attribute.name.should be == :name
+    end
+
+    it 'verifies that indexes are inactive' do
+      name_index.should be_inactive
+    end
+
+    it 'creates indexes' do
+      mapper.reindex!
+      name_index.should be_active
+    end
+  end
 end