perpetuity 0.4.4 → 0.4.5

data/spec/integration/deletion_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe "deletion" do
+  it 'deletes an object' do
+    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[Article].insert Article.new
+    expect {
+      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[Article].insert Article.new
+      Perpetuity[Article].delete_all
+      Perpetuity[Article].count.should eq 0
+    end
+  end
+end

data/spec/integration/indexing_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'indexing' do
+  let(:mapper_class) do
+    Class.new(Perpetuity::Mapper) do
+      map Object
+      attribute :name
+      index :name, unique: true
+    end
+  end
+  let(:mapper) { mapper_class.new }
+  let(:name_index) do
+    mapper.indexes.find do |index|
+      index.attribute.to_s == :name
+    end
+  end
+
+  after { mapper.data_source.drop_collection Object }
+
+  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
+    mapper.remove_index! name_index
+  end
+
+  it 'specifies uniqueness of the index' do
+    name_index.should be_unique
+  end
+end
+

data/spec/integration/pagination_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'pagination' do
+  it 'specifies the page we want' do
+    Perpetuity[Article].all.should respond_to :page
+  end
+
+  it 'specify the quantity per page' do
+    Perpetuity[Article].all.should respond_to :per_page
+  end
+
+  it 'returns an empty set when there is no data for that page' do
+    mapper = Perpetuity[Article]
+    mapper.delete_all
+    data = mapper.all.page(2)
+    data.should be_empty
+  end
+
+  it 'specifies per-page quantity' do
+    Perpetuity[Article].delete_all
+    5.times { |i| Perpetuity[Article].insert Article.new i }
+    data = Perpetuity[Article].all.page(3).per_page(2)
+    data.should have(1).item
+  end
+end
+

data/spec/integration/persistence_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'Persistence' do
+  it "persists an object" do
+    article = Article.new '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[Article].insert(article).should eq article.id
+  end
+
+  it "gives an id to objects" do
+    article = Article.new
+    Perpetuity[Article].give_id_to article, 1
+
+    article.id.should eq 1
+  end
+
+  it 'persists referenced objects if they are not persisted' do
+    article = Article.new
+    article.author = User.new
+    Perpetuity[Article].insert article
+
+    Perpetuity[Article].find(article.id).author.id.should be == article.author.id
+  end
+
+  it 'persists arrays of referenced objects if they are not persisted' do
+    authors = [User.new('Dave'), User.new('Andy')]
+    book = Book.new
+    book.authors = authors
+    Perpetuity[Book].insert book
+
+    Perpetuity[Book].find(book.id).authors.first.id.should be == authors.first.id
+  end
+
+  describe 'id injection' do
+    let(:article) { Article.new }
+
+    it 'assigns an id to the inserted object' do
+      Perpetuity[Article].insert article
+      article.should respond_to :id
+    end
+
+    it "assigns an id using Mapper.first" do
+      Perpetuity[Article].first.should respond_to :id
+    end
+
+    it 'assigns an id using Mapper.all.first' do
+      Perpetuity[Article].all.first.should respond_to :id
+    end
+  end
+
+  describe 'persisting arrays' do
+    let(:article) { Article.new }
+
+    it 'persists arrays' do
+      article.comments << 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[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
+    end
+  end
+
+  describe 'persisting hashes' do
+    let(:name_hash) { { 'first_name' => 'Jamie', 'last_name' => 'Gaskins' } }
+    let(:user) { User.new(name_hash) }
+    let(:user_mapper) { Perpetuity[User] }
+
+    it 'saves and retrieves hashes' do
+      user_mapper.insert user
+      user_mapper.find(user.id).name.should be == name_hash
+    end
+  end
+
+  it "allows mappers to set the id field" do
+    noise = Time.now.to_f.to_s.sub('.', '')
+    book = Book.new("My Title #{noise}")
+
+    Perpetuity[Book].insert book
+    book.id.should eq "my-title-#{noise}"
+  end
+end
+

data/spec/integration/retrieval_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe "retrieval" do
+  it "gets all the objects of a class" do
+    expect { Perpetuity[Article].insert Article.new }.
+      to change { Perpetuity[Article].all.count }.by 1
+  end
+
+  it "has an ID when retrieved" do
+    Perpetuity[Article].insert Article.new
+    Perpetuity[Article].first.should respond_to :id
+  end
+
+  it "gets an item with a specific ID" do
+    article = Article.new
+    Perpetuity[Article].insert article
+    retrieved = Perpetuity[Article].find(article.id)
+
+    retrieved.id.should eq article.id
+    retrieved.title.should eq article.title
+    retrieved.body.should eq article.body
+  end
+
+  describe 'sorting' do
+    let(:first) { Article.new('First', '', nil, Time.now - 20) }
+    let(:second) { Article.new('Second', '', nil, Time.now - 10) }
+    let(:third) { Article.new('Third', '', nil, Time.now) }
+
+    before do
+      Perpetuity[Article].delete_all
+      [second, third, first].each { |article| Perpetuity[Article].insert article }
+    end
+
+    it 'sorts results' do
+      titles = Perpetuity[Article].all.sort(:published_at).map(&:title)
+      titles.should be == %w(First Second Third)
+    end
+
+    it 'reverse-sorts results' do
+      titles = Perpetuity[Article].all.sort(:published_at).reverse.map(&:title)
+      titles.should be == %w(Third Second First)
+    end
+  end
+
+  it 'limits result set' do
+    5.times { Perpetuity[Article].insert Article.new }
+    Perpetuity[Article].all.limit(4).should have(4).items
+  end
+
+  describe "Array-like syntax" 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[Article].insert draft
+      Perpetuity[Article].insert published
+    end
+
+    it 'selects objects using equality' do
+      selected = Perpetuity[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.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[Article].select { |article| article.title.in %w( Published ) }
+      ids = selected.map(&:id)
+      ids.should include published.id
+      ids.should_not include draft.id
+    end
+  end
+end

data/spec/integration/serialization_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'serialization' do
+  let(:author) { User.new 'username' }
+  let(:comment) { Comment.new }
+  let(:article) { Article.new }
+  let(:mapper) { Perpetuity[Article] }
+  let(:serialized_value) do
+    {
+      'title' => article.title,
+      'body' => article.body,
+      'author' => {
+        '__metadata__' => {
+          'class' => author.class.to_s,
+          'id' => author.id
+        }
+      },
+      'comments' => [
+        {
+          '__metadata__' => {
+            'class' => comment.class.to_s
+          },
+          'body' => comment.body,
+          'author' => {
+            '__metadata__' => {
+              'class' => author.class.to_s,
+              'id' => author.id
+            }
+          }
+        },
+      ],
+      'published_at' => article.published_at,
+      'views' => article.views
+    }
+  end
+
+  before do
+    article.author = author
+    article.comments = [comment]
+    comment.author = author
+
+    Perpetuity[User].insert author
+    Perpetuity[Article].insert article
+  end
+
+  it 'serializes objects into hashes' do
+    mapper.serialize(article).should be == serialized_value
+  end
+
+  it 'deserializes hashes into proper objects' do
+    unserialized = mapper.find article.id
+    unserialized.should be_a Article
+    unserialized.title.should be == article.title
+    unserialized.body.should be == article.body
+    unserialized.comments.first.tap do |unserialized_comment|
+      unserialized_comment.body.should be == comment.body
+    end
+  end
+end

data/spec/integration/update_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'updating' do
+  let(:article) { Article.new }
+  let(:mapper) { Perpetuity[Article] }
+  let(:new_title) { 'I has a new title!' }
+
+  before do
+    mapper.insert article
+  end
+
+  it 'updates an object in the database' do
+    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
+
+

data/spec/integration/validations_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'validations' do
+  let(:car_mapper) { Perpetuity[Car] }
+
+  it 'raises an exception when inserting an invalid object' do
+    car = Car.new
+    expect { car_mapper.insert car }.to raise_error
+  end
+
+  it 'does not raise an exception when validations are met' do
+    car = Car.new
+    car.make = "Volkswagen"
+    expect { car_mapper.insert car }.not_to raise_error
+  end
+end

data/spec/perpetuity/mapper_spec.rb

@@ -1,5 +1,6 @@
 require 'perpetuity/mapper_registry'
 require 'perpetuity/mapper'
+require 'perpetuity/mongodb'
 
 module Perpetuity
   describe Mapper do
@@ -49,7 +50,7 @@ module Perpetuity
     end
 
     describe 'talking to the data source' do
-      let(:data_source) { double }
+      let(:data_source) { MongoDB.new(db: nil) }
       before do
         mapper_class.stub(data_source: data_source)
         mapper_class.map Object, registry
@@ -78,7 +79,7 @@ module Perpetuity
       end
 
       it 'finds an object by ID' do
-        returned_object = double
+        returned_object = double('Retrieved Object')
         criteria = { id: 1 }
         options = {:attribute=>nil, :direction=>nil, :limit=>nil, :page=>nil}
         data_source.should_receive(:retrieve)

data/spec/perpetuity/mongodb_spec.rb

@@ -12,11 +12,8 @@ module Perpetuity
     end
 
     it 'connects to its host' do
-      connection = double('connection')
-      Mongo::MongoClient.should_receive(:new).and_return connection
       mongo.connect
       mongo.should be_connected
-      mongo.connection.should == connection
     end
 
     it 'connects automatically when accessing the database' do
@@ -85,8 +82,10 @@ module Perpetuity
     it 'retrieves by id if the id is a string' do
       time = Time.now.utc
       id = mongo.insert Object, {inserted: time}
-      objects = mongo.retrieve(Object, id: id.to_s).to_a
-      objects.map{|i| i["inserted"].to_f}.first.should be_within(0.001).of time.to_f
+
+      object = mongo.retrieve(Object, id: id.to_s).first
+      retrieved_time = object["inserted"]
+      retrieved_time.to_f.should be_within(0.001).of time.to_f
     end
 
     describe 'serializable objects' do
@@ -94,12 +93,16 @@ module Perpetuity
 
       it 'can insert serializable values' do
         serializable_values.each do |value|
-          mongo.insert(Object, {value: value}).should be_a BSON::ObjectId
+          mongo.insert(Object, {value: value}).should be_a Moped::BSON::ObjectId
           mongo.can_serialize?(value).should be_true
         end
       end
     end
 
+    it 'generates a new query DSL object' do
+      mongo.query { |object| object.whatever == 1 }.should respond_to :to_db
+    end
+
     describe 'indexing' do
       let(:collection) { Object }
       let(:key) { 'object_id' }

data/spec/perpetuity/persisted_object_spec.rb

@@ -0,0 +1,16 @@
+require 'perpetuity/persisted_object'
+
+module Perpetuity
+  describe PersistedObject do
+    let(:object) { Object.new }
+
+    before do
+      object.instance_variable_set '@id', :fake_id
+      object.extend PersistedObject
+    end
+
+    it 'gives an object an ID method' do
+      object.id.should be == :fake_id
+    end
+  end
+end

data/spec/perpetuity/retrieval_spec.rb

@@ -3,7 +3,9 @@ require 'perpetuity/retrieval'
 module Perpetuity
   describe Retrieval do
     let(:data_source) { double('data_source') }
-    let(:retrieval) { Perpetuity::Retrieval.new Object, {}, data_source }
+    let(:registry) { double('mapper_registry') }
+    let(:mapper) { double(mapped_class: Object, data_source: data_source, mapper_registry: registry) }
+    let(:retrieval) { Perpetuity::Retrieval.new mapper, {} }
     subject { retrieval }
 
     it "sorts the results" do

data/spec/perpetuity/serializer_spec.rb

@@ -11,7 +11,7 @@ module Perpetuity
     let(:authors) { [dave, andy] }
     let(:book) { Book.new('The Pragmatic Programmer', authors) }
     let(:mapper_registry) { MapperRegistry.new }
-    let!(:book_mapper) do
+    let!(:book_mapper_class) do
       registry = mapper_registry
       Class.new(Perpetuity::Mapper) do
         map Book, registry
@@ -19,7 +19,7 @@ module Perpetuity
         attribute :authors
       end
     end
-    let!(:user_mapper) do
+    let!(:user_mapper_class) do
       registry = mapper_registry
       Class.new(Perpetuity::Mapper) do
         map User, registry
@@ -27,13 +27,13 @@ module Perpetuity
       end
     end
     let(:data_source) { double('Data Source') }
-    let(:serializer) { Serializer.new(mapper_registry[Book], mapper_registry) }
+    let(:serializer) { Serializer.new(mapper_registry[Book]) }
 
     before do
-      dave.stub(id: 1)
-      andy.stub(id: 2)
-      user_mapper.stub(data_source: data_source)
-      book_mapper.stub(data_source: data_source)
+      dave.extend PersistedObject
+      andy.extend PersistedObject
+      user_mapper_class.stub(data_source: data_source)
+      book_mapper_class.stub(data_source: data_source)
     end
 
     it 'serializes an array of non-embedded attributes as references' do
@@ -58,5 +58,29 @@ module Perpetuity
         ]
       }
     end
+
+    context 'with objects that have hashes as attributes' do
+      let(:name_data) { {first_name: 'Jamie', last_name: 'Gaskins'} }
+      let(:serialized_data) do
+        {
+          'name' => name_data
+        }
+      end
+      let(:user) { User.new(name_data) }
+      let(:user_mapper) { mapper_registry[User] }
+      let(:user_serializer) { Serializer.new(user_mapper) }
+
+      before do
+        data_source.stub(:can_serialize?).with(name_data) { true }
+      end
+
+      it 'serializes' do
+        user_serializer.serialize(user).should be == serialized_data
+      end
+
+      it 'unserializes' do
+        user_serializer.unserialize(serialized_data).name.should be == user.name
+      end
+    end
   end
 end