perpetuity-mongodb 1.0.0.beta

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_spec.rb

@@ -0,0 +1,79 @@
+require 'perpetuity/mongodb/query'
+
+module Perpetuity
+  describe MongoDB::Query do
+    let(:query) { MongoDB::Query }
+
+    it 'generates Mongo equality expressions' do
+      query.new{ |user| user.name == 'Jamie' }.to_db.should == {name: 'Jamie'}
+    end
+
+    it 'generates Mongo less-than expressions' do
+      query.new{ |v| v.quantity < 10 }.to_db.should == {quantity: { '$lt' => 10}}
+    end
+
+    it 'generates Mongo less-than-or-equal expressions' do
+      query.new{ |v| v.quantity <= 10 }.to_db.should == {quantity: { '$lte' => 10}}
+    end
+
+    it 'generates Mongo greater-than expressions' do
+      query.new{ |v| v.quantity > 10 }.to_db.should == {quantity: { '$gt' => 10}}
+    end
+
+    it 'generates Mongo greater-than-or-equal expressions' do
+      query.new{ |v| v.quantity >= 10 }.to_db.should == {quantity: { '$gte' => 10}}
+    end
+
+    it 'generates Mongo inequality expressions' do
+      query.new{ |user| user.name.not_equal? 'Jamie' }.to_db.should == {
+        name: {'$ne' => 'Jamie'}
+      }
+    end
+
+    it 'generates Mongo regexp expressions' do
+      query.new{ |user| user.name =~ /Jamie/ }.to_db.should == {name: /Jamie/}
+    end
+
+    describe 'negated queries' do
+      it 'negates an equality query' do
+        q = query.new { |user| user.name == 'Jamie' }
+        q.negate.to_db.should == { name: { '$ne' => 'Jamie' } }
+      end
+
+      it 'negates a not-equal query' do
+        q = query.new { |account| account.balance != 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$ne' => 10 } } }
+      end
+
+      it 'negates a less-than query' do
+        q = query.new { |account| account.balance < 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$lt' => 10 } } }
+      end
+
+      it 'negates a less-than-or-equal query' do
+        q = query.new { |account| account.balance <= 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$lte' => 10 } } }
+      end
+
+      it 'negates a greater-than query' do
+        q = query.new { |account| account.balance > 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$gt' => 10 } } }
+      end
+
+      it 'negates a greater-than-or-equal query' do
+        q = query.new { |account| account.balance >= 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$gte' => 10 } } }
+      end
+
+      it 'negates a regex query' do
+        q = query.new { |account| account.name =~ /Jamie/ }
+        q.negate.to_db.should == { name: { '$not' => /Jamie/ } }
+      end
+
+      it 'negates a inclusion query' do
+        q = query.new { |article| article.tags.in ['tag1', 'tag2'] }
+        q.negate.to_db.should == { tags: { '$not' => { '$in' => ['tag1', 'tag2'] } } }
+      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/serializer_spec.rb

@@ -0,0 +1,212 @@
+require 'perpetuity/mongodb/serializer'
+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
+    describe Serializer do
+      let(:dave) { User.new('Dave') }
+      let(:andy) { User.new('Andy') }
+      let(:authors) { [dave, andy] }
+      let(:book) { Book.new('The Pragmatic Programmer', authors) }
+      let(:mapper_registry) { MapperRegistry.new }
+      let(:book_mapper) do
+        registry = mapper_registry
+        Class.new(Perpetuity::Mapper) do
+          map Book, registry
+          attribute :title
+          attribute :authors
+        end.new(registry)
+      end
+      let(:user_mapper) do
+        registry = mapper_registry
+        Class.new(Perpetuity::Mapper) do
+          map User, registry
+          attribute :name
+        end.new(registry)
+      end
+      let(:data_source) { double('Data Source') }
+      let(:serializer) { Serializer.new(book_mapper) }
+
+      before do
+        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
+        serializer.serialize(book).should be == {
+          'title' => book.title,
+          'authors' => [
+            {
+              '__metadata__' => {
+                'class' => 'User',
+                'id' => user_mapper.id_for(dave)
+              }
+            },
+            {
+              '__metadata__' => {
+                'class' => 'User',
+                'id' => user_mapper.id_for(andy)
+              }
+            }
+          ]
+        }
+      end
+
+      it 'can serialize only changed attributes' do
+        book = Book.new('Original Title')
+        updated_book = book.dup
+        updated_book.title = 'New Title'
+        book_mapper.stub(data_source: data_source)
+        data_source.stub(:can_serialize?).with('New Title') { true }
+        data_source.stub(:can_serialize?).with('Original Title') { true }
+        serializer.serialize_changes(updated_book, book).should == {
+          'title' => 'New Title'
+        }
+      end
+
+      context 'with objects that have hashes as attributes' do
+        let(:name_data) { {first_name: 'Jamie', last_name: 'Gaskins'} }
+        let(:serialized_data) { { 'name' => name_data } }
+        let(:user) { User.new(name_data) }
+        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
+
+        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
+
+      describe 'with an array of references' do
+        let(:author) { Reference.new(User, 1) }
+        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 == {
+            'title' => title,
+            'authors' => [{
+              '__metadata__' => {
+                'class' => author.klass.to_s,
+                'id' => author.id
+              }
+            }]
+          }
+        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
+
+      context 'with marshaled data' do
+        let(:unserializable_value) { 1..10 }
+
+        it 'stores metadata with marshal information' do
+          book = Book.new(unserializable_value)
+
+          book_mapper.stub(data_source: data_source)
+          data_source.stub(:can_serialize?).with(book.title) { false }
+
+          serializer.serialize(book).should == {
+            'title' => {
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value)
+            },
+            'authors' => []
+          }
+        end
+
+        it 'stores marshaled attributes within arrays' do
+          book = Book.new([unserializable_value])
+          book_mapper.stub(data_source: data_source)
+          data_source.stub(:can_serialize?).with(book.title.first) { false }
+
+          serializer.serialize(book).should == {
+            'title' => [{
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value)
+            }],
+            'authors' => []
+          }
+        end
+
+        it 'unmarshals data that has been marshaled by the serializer' do
+          data = {
+            'title' => {
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value),
+            }
+          }
+          serializer.unserialize(data).title.should be_a unserializable_value.class
+        end
+
+        it 'does not unmarshal data not marshaled by the serializer' do
+          data = { 'title' => Marshal.dump(unserializable_value) }
+
+          serializer.unserialize(data).title.should be_a String
+        end
+      end
+
+      it 'unserializes a hash of primitives' do
+        time = Time.now
+        serialized_data = {
+          'number' => 1,
+          'string' => 'hello',
+          'boolean' => true,
+          'float' => 7.5,
+          'time' => time
+        }
+
+        object = serializer.unserialize(serialized_data)
+        object.instance_variable_get(:@number).should == 1
+        object.instance_variable_get(:@string).should == 'hello'
+        object.instance_variable_get(:@boolean).should == true
+        object.instance_variable_get(:@float).should == 7.5
+        object.instance_variable_get(:@time).should == time
+      end
+    end
+  end
+end

data/spec/perpetuity/mongodb_spec.rb

@@ -0,0 +1,218 @@
+require 'perpetuity/mongodb'
+require 'date'
+
+module Perpetuity
+  describe MongoDB do
+    let(:mongo) { MongoDB.new db: 'perpetuity_gem_test' }
+    let(:klass) { String }
+    subject { mongo }
+
+    it 'is not connected when instantiated' do
+      mongo.should_not be_connected
+    end
+
+    it 'connects to its host' do
+      mongo.connect
+      mongo.should be_connected
+    end
+
+    it 'connects automatically when accessing the database' do
+      mongo.database
+      mongo.should be_connected
+    end
+
+    describe 'initialization params' do
+      let(:host)      { double('host') }
+      let(:port)      { double('port') }
+      let(:db)        { double('db') }
+      let(:pool_size) { double('pool size') }
+      let(:username)  { double('username') }
+      let(:password)  { double('password') }
+      let(:mongo) do
+        MongoDB.new(
+          host:      host,
+          port:      port,
+          db:        db,
+          pool_size: pool_size,
+          username:  username,
+          password:  password
+        )
+      end
+      subject { mongo }
+
+      its(:host)      { should == host }
+      its(:port)      { should == port }
+      its(:db)        { should == db }
+      its(:pool_size) { should == pool_size }
+      its(:username)  { should == username }
+      its(:password)  { should == password }
+    end
+
+    it 'inserts documents into a collection' do
+      expect { mongo.insert klass, { name: 'foo' }, [] }.to change { mongo.count klass }.by 1
+    end
+
+    it 'inserts multiple documents into a collection' do
+      expect { mongo.insert klass, [{name: 'foo'}, {name: 'bar'}], [] }
+        .to change { mongo.count klass }.by 2
+    end
+
+    it 'removes all documents from a collection' do
+      mongo.insert klass, {}, []
+      mongo.delete_all klass
+      mongo.count(klass).should == 0
+    end
+
+    it 'counts the documents in a collection' do
+      mongo.delete_all klass
+      3.times do
+        mongo.insert klass, {}, []
+      end
+      mongo.count(klass).should == 3
+    end
+
+    it 'counts the documents matching a query' do
+      mongo.delete_all klass
+      1.times { mongo.insert klass, { name: 'bar' }, [] }
+      3.times { mongo.insert klass, { name: 'foo' }, [] }
+      mongo.count(klass) { |o| o.name == 'foo' }.should == 3
+    end
+
+    it 'gets the first document in a collection' do
+      value = {value: 1}
+      mongo.insert klass, value, []
+      mongo.first(klass)[:hypothetical_value].should == value['value']
+    end
+
+    it 'gets all of the documents in a collection' do
+      values = [{value: 1}, {value: 2}]
+      mongo.should_receive(:retrieve).with(Object, mongo.nil_query, {})
+           .and_return(values)
+      mongo.all(Object).should == values
+    end
+
+    it 'retrieves by id if the id is a string' do
+      time = Time.now.utc
+      id = mongo.insert Object, {inserted: time}, []
+
+      object = mongo.retrieve(Object, mongo.query{|o| o.id == id.to_s }).first
+      retrieved_time = object["inserted"]
+      retrieved_time.to_f.should be_within(0.001).of time.to_f
+    end
+
+    describe 'serialization' do
+      let(:object) { Object.new }
+      let(:foo_attribute) { double('Attribute', name: :foo) }
+      let(:baz_attribute) { double('Attribute', name: :baz) }
+      let(:mapper) { double('Mapper',
+                            mapped_class: Object,
+                            mapper_registry: {},
+                            attribute_set: Set[foo_attribute, baz_attribute],
+                            data_source: mongo,
+                           ) }
+
+      before do
+        object.instance_variable_set :@foo, 'bar'
+        object.instance_variable_set :@baz, 'quux'
+      end
+
+      it 'serializes objects' do
+        mongo.serialize(object, mapper).should == {
+          'foo' => 'bar',
+          'baz' => 'quux'
+        }
+      end
+
+      it 'can serialize only modified attributes of objects' do
+        updated = object.dup
+        updated.instance_variable_set :@foo, 'foo'
+
+        serialized = mongo.serialize_changed_attributes(updated, object, mapper)
+        serialized.should == { 'foo' => 'foo' }
+      end
+    end
+
+    describe 'serializable objects' do
+      let(:serializable_values) { [nil, true, false, 1, 1.2, '', [], {}, Time.now] }
+
+      it 'can insert serializable values' do
+        serializable_values.each do |value|
+          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' }
+
+      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
+
+      it 'removes indexes' do
+        mongo.drop_collection collection
+        index = mongo.index collection, 'real_index', order: :descending, unique: true
+        mongo.activate_index! index
+        mongo.remove_index index
+        mongo.active_indexes(collection).should_not include index
+      end
+    end
+
+    describe 'atomic operations' do
+      after(:all) { mongo.delete_all klass }
+
+      it 'increments the value of an attribute' do
+        id = mongo.insert klass, { count: 1 }, []
+        mongo.increment klass, id, :count
+        mongo.increment klass, id, :count, 10
+        query = mongo.query { |o| o.id == id }
+        mongo.retrieve(klass, query).first['count'].should be == 12
+        mongo.increment klass, id, :count, -1
+        mongo.retrieve(klass, query).first['count'].should be == 11
+      end
+    end
+
+    describe 'operation errors' do
+      let(:data) { { foo: 'bar' } }
+      let(:index) { mongo.index Object, :foo, unique: true }
+
+      before do
+        mongo.delete_all Object
+        mongo.activate_index! index
+      end
+
+      after { mongo.drop_collection Object }
+
+      it 'raises an exception when insertion fails' do
+        mongo.insert Object, data, []
+
+        expect { mongo.insert Object, data, [] }.to raise_error DuplicateKeyError,
+          'Tried to insert Object with duplicate unique index: foo => "bar"'
+      end
+    end
+  end
+end