dm-mongo-adapter 0.2.0.pre1

data/spec/public/embedded_resource_spec.rb

@@ -0,0 +1,220 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Mongo::EmbeddedResource do
+  before(:all) do
+    class ::Address
+      include DataMapper::Mongo::EmbeddedResource
+      property :street, String
+      property :city,   String, :field => 'conurbation'
+    end
+
+    class ::AddressWithDefault
+      include DataMapper::Mongo::EmbeddedResource
+      property :city, String, :default => 'Rock Ridge'
+    end
+
+    class ::User
+      include DataMapper::Mongo::Resource
+      property :id, ObjectID
+      embeds 1, :address, :model => Address
+    end
+  end
+
+  #
+  # attributes
+  #
+
+  describe 'attributes' do
+    before(:all) do
+      @address = Address.new(:street => 'Main Street', :city => 'Rock Ridge')
+    end
+
+    it 'should return a Hash' do
+      @address.attributes.should be_kind_of(Hash)
+    end
+
+    it 'should use the property names when key_on=:name' do
+      @address.attributes(:name).should ==
+        { :street => 'Main Street', :city => 'Rock Ridge' }
+    end
+
+    it 'should use the field names when key_on=:field' do
+      @address.attributes(:field).should ==
+        { 'street' => 'Main Street', 'conurbation' => 'Rock Ridge' }
+    end
+
+    it 'should use the property instances when key_on=:property' do
+      @address.attributes(:property).should == {
+        Address.properties[:street] => 'Main Street',
+        Address.properties[:city]   => 'Rock Ridge'
+      }
+    end
+  end
+
+  #
+  # dirty?
+  #
+
+  describe '#dirty?' do
+    describe 'on a new embedded resource' do
+      it 'should return false' do
+        Address.new.should_not be_dirty
+      end
+
+      it 'should return true if an attribute has been changed' do
+        Address.new(:city => 'Rock Ridge').should be_dirty
+      end
+
+      it 'should return false if a changed attribute has been saved' do
+        address = Address.new(:city => 'Rock Ridge')
+
+        lambda { User.create(:address => address) }.should \
+          change(address, :dirty?).to(false)
+      end
+    end
+
+    describe 'on a persisted embedded resource' do
+      before(:each) do
+        user = User.create(:address => Address.new(:city => 'Rock Ridge'))
+        @address = user.address
+      end
+
+      it 'should return false when no changes have been made' do
+        @address.should_not be_dirty
+      end
+
+      it 'should return true if an attribute has been changed' do
+        @address.street = 'Main Street'
+        @address.should be_dirty
+      end
+
+      it 'should return false if a changed attribute has been saved' do
+        @address.street = 'Main Street'
+
+        lambda { @address.parent.save }.should \
+          change(@address, :dirty?).to(false)
+      end
+    end
+  end
+
+  #
+  # dirty_self?
+  #
+
+  describe '#dirty_self?' do
+    describe 'on a new embedded resource' do
+      it 'should return false if no changes have been made and no ' \
+         'properties have a default' do
+        Address.new.should_not be_dirty_self
+      end
+
+      it 'should return true if no changes have been made, but a property ' \
+         'has a default' do
+        AddressWithDefault.new.should be_dirty_self
+      end
+
+      it 'should return true if a change has been made' do
+        Address.new(:city => 'Rock Ridge').should be_dirty_self
+      end
+    end
+
+    describe 'on a persisited embedded resource' do
+      before(:each) do
+        user = User.create(:address => Address.new(:city => 'Rock Ridge'))
+        @address = user.address
+      end
+
+      it 'should return false if no changes have been made' do
+        @address.should_not be_dirty_self
+      end
+
+      it 'should return true if a change has been made' do
+        @address.street = 'Main Street'
+        @address.should be_dirty_self
+      end
+    end
+  end
+
+  #
+  # parent?
+  #
+
+  describe '#parent?' do
+    it 'should return true if the embedded resource has a parent' do
+      address = Address.new
+      address.parent = User.new
+      address.parent?.should be_true
+    end
+
+    it 'should return false if the embedded resource has no parent' do
+      Address.new.parent?.should be_false
+    end
+  end
+
+  #
+  # new?
+  #
+
+  describe '#new?' do
+    it 'should return false if it has been persisted' do
+      user = User.create(:address => Address.new(:city => 'Rock Ridge'))
+      user.address.should_not be_new
+    end
+
+    it 'should return true if its parent has not been persisted' do
+      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+      user.address.should be_new
+    end
+
+    it 'should return true if it has no parent' do
+      Address.new.should be_new
+    end
+  end
+
+  #
+  # saved?
+  #
+
+  describe '#saved?' do
+    it 'should return true if it has been persisted' do
+      user = User.create(:address => Address.new(:city => 'Rock Ridge'))
+      user.address.should be_saved
+    end
+
+    it 'should return false if its parent has not been persisted' do
+      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+      user.address.should_not be_saved
+    end
+
+    it 'should return false if it has no parent' do
+      Address.new.should_not be_saved
+    end
+  end
+
+  #
+  # save
+  #
+
+  describe '#save' do
+    it 'should raise MissingParentError if no parent is set' do
+      lambda { Address.new.save }.should raise_error(
+        DataMapper::Mongo::EmbeddedResource::MissingParentError)
+    end
+
+    it 'should clear the original attributes if the parent saved' do
+      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+
+      expectation = lambda { user.address.original_attributes.empty? }
+      lambda { user.address.save }.should change(&expectation).to(true)
+    end
+
+    it 'should not clear the original_attributes is the parent did not save' do
+      user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+      user.stub!(:save).and_return(false)
+
+      expectation = lambda { user.address.original_attributes.empty? }
+      lambda { user.address.save }.should_not change(&expectation).to(true)
+    end
+  end
+
+end

data/spec/public/model/embedment_spec.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe DataMapper::Mongo::Embedments do
+  # Removes the Engine constant, runs the block, then redefines the Engine
+  # class.
+  def without_engine_defined
+    old_engine = ::Engine
+    Object.send(:remove_const, :Engine) if defined?(::Engine)
+    yield
+    Object.send(:const_set, :Engine, old_engine)
+  end
+
+  before(:all) do
+    class ::Car
+      include DataMapper::Mongo::Resource
+      property :id, ObjectID
+      property :name, String
+    end
+
+    class ::Engine
+      include DataMapper::Mongo::EmbeddedResource
+      property :name, String
+    end
+
+    class ::Door
+      include DataMapper::Mongo::EmbeddedResource
+      property :name, String
+    end
+  end
+
+  def n
+    Car.n
+  end
+
+  it { Car.should respond_to(:embeds) }
+  it { Car.should respond_to(:embedments) }
+
+  describe '#embeds(1, ...)' do
+    before(:all) do
+      @model = Engine
+      @name  = :engine
+
+      Car.embeds(1, :engine)
+
+      @car = Car.new(:name => 'Ford')
+    end
+
+    it_should_behave_like 'A singular embedment reader'
+    it_should_behave_like 'A singular embedment writer'
+  end
+
+  describe '#embeds(n, ...)' do
+    before(:all) do
+      @model = Door
+      @name = :doors
+
+      Car.embeds(n, :doors)
+      @car = Car.new(:name => 'Ford')
+    end
+
+    it_should_behave_like 'A many embedment reader'
+    it_should_behave_like 'A many embedment writer'
+  end
+
+  describe '#embeds(n, :through ...)' do
+    it 'should raise an ArgumentError' do
+      pending ':through option not supported on embedments'
+    end
+  end
+
+  describe '#embeds(1..4)' do
+    before(:all) do
+      @model = Door
+      @name = :doors
+
+      Car.embeds(1..4, :doors)
+      @car = Car.new(:name => 'Ford')
+    end
+
+    it_should_behave_like 'A many embedment reader'
+    it_should_behave_like 'A many embedment writer'
+  end
+
+  describe '#embeds' do
+    describe 'when inferring the model from the name' do
+      it 'should set the relationship target model' do
+        Car.embeds(1, :engine)
+        Car.embedments[:engine].target_model.should == Engine
+      end
+
+      it 'should set the relationship target model when it is not defined' do
+        without_engine_defined do
+          Car.embeds(1, :engine)
+        end
+
+        Car.embedments[:engine].target_model.should == Engine
+      end
+    end
+
+    describe 'when the third argument is a model' do
+      it 'should set the relationship target model' do
+        Car.embeds(1, :engine, Engine)
+        Car.embedments[:engine].target_model.should == Engine
+      end
+    end
+
+    describe 'when the third argument is a string' do
+      it 'should set the relationship target model' do
+        without_engine_defined do
+          Car.embeds(1, :engine, 'Engine')
+        end
+
+        Car.embedments[:engine].target_model.should == Engine
+      end
+
+      it 'should raise NameError when given an invalid string' do
+        Car.embeds(1, :engine, 'DoesNotExist')
+        running = lambda { Car.embedments[:engine].target_model }
+        running.should raise_error(NameError)
+      end
+    end
+
+    describe 'when a :model option is given' do
+      it 'should set the relationship target model when given a string' do
+        without_engine_defined do
+          Car.embeds(1, :engine, :model => 'Engine')
+        end
+
+        Car.embedments[:engine].target_model.should == Engine
+      end
+
+      it 'should raise NameError when given an invalid string' do
+        Car.embeds(1, :engine, :model => 'DoesNotExist')
+        running = lambda { Car.embedments[:engine].target_model }
+        running.should raise_error(NameError)
+      end
+
+      it 'should set the relationship target model when given a model' do
+        Car.embeds(1, :engine, :model => Engine)
+        Car.embedments[:engine].target_model.should == Engine
+      end
+    end
+
+    describe 'when no model is given' do
+      it 'should raise NameError' do
+        Car.embeds(1, :does_not_exist)
+        running = lambda { Car.embedments[:engine].target_model }
+        running.should raise_error(NameError)
+      end
+    end
+
+    it 'should raise an exception if a :through option is given' do
+      running = lambda { Car.embeds(1, Engine, :through => :engines) }
+      running.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if a :remote_name option is given' do
+      running = lambda { Car.embeds(1, Engine, :remote_name => :engines) }
+      running.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if a :via option is given' do
+      running = lambda { Car.embeds(1, Engine, :via => :engines) }
+      running.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if a :inverse option is given' do
+      running = lambda { Car.embeds(1, Engine, :inverse => :parent) }
+      running.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if a :parent_key option is given' do
+      running = lambda { Car.embeds(1, Engine, :parent_key => :id) }
+      running.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if the cardinality is not understood' do
+      lambda { Car.embeds(n..n, :doors) }.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an exception if the minimum constraint is larger than the maximum' do
+      lambda { Car.embeds(2..1, :doors) }.should raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/public/model_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Mongo::Model do
+
+  before(:all) do
+    class ::PropertyTest
+      include DataMapper::Mongo::Resource
+      property :array,     Array
+      property :hash,      Hash
+      property :date,      Date
+      property :date_time, DateTime
+    end
+  end
+
+  describe '#property' do
+    it 'should cast Array types to EmbeddedArray' do
+      prop = PropertyTest.properties[:array]
+      prop.type.should == DataMapper::Mongo::Types::EmbeddedArray
+    end
+
+    it 'should cast Hash types to EmbeddedHash' do
+      prop = PropertyTest.properties[:hash]
+      prop.type.should == DataMapper::Mongo::Types::EmbeddedHash
+    end
+
+    it 'should cast Hash types to Types::Date' do
+      prop = PropertyTest.properties[:date]
+      prop.type.should == DataMapper::Mongo::Types::Date
+    end
+
+    it 'should cast Hash types to Types::DateTime' do
+      prop = PropertyTest.properties[:date_time]
+      prop.type.should == DataMapper::Mongo::Types::DateTime
+    end
+  end
+
+end

data/spec/public/resource_spec.rb

@@ -0,0 +1,564 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe DataMapper::Mongo::Resource do
+
+  before(:all) do
+    class ::Address
+      include DataMapper::Mongo::EmbeddedResource
+      property :city,  String
+      property :state, String
+    end
+
+    class ::Location
+      include DataMapper::Mongo::EmbeddedResource
+      property :country,   String
+      property :continent, String
+    end
+
+    class ::User
+      include DataMapper::Mongo::Resource
+      property  :id,        ObjectID
+      property  :name,      String
+      property  :tags,      Array
+      property  :metadata,  Hash
+      property  :created_at, DateTime
+      embeds 1, :address,   :model => Address
+      embeds n, :locations
+    end
+  end
+
+  #
+  # all
+  #
+
+  describe '#all' do
+    describe 'with no query' do
+      it 'should return a collection' do
+        User.all.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return an empty collection when there are no resources' do
+        User.all.destroy!
+        User.all.should be_empty
+      end
+
+      it 'should return all resources' do
+        expected = [User.create(:name => 'One'), User.create(:name => 'Two')]
+        User.all.should == expected
+      end
+
+      it 'should fail if incorrect conditions are given' do
+        lambda {
+          User.all :'adres.blah' => 'New York'
+        }.should raise_error
+      end
+    end
+
+    describe 'with a query' do
+      it 'should return a collection' do
+        User.all.should be_kind_of(DataMapper::Collection)
+      end
+
+      it 'should return an empty collection when there are no matching resources' do
+        User.all.destroy!
+        User.create(:name => 'One')
+        User.all(:name => 'Two').should be_empty
+      end
+
+      it 'should return the specific resources' do
+        User.create(:name => 'One')
+        expected = User.create(:name => 'Two')
+        User.all(:name => 'Two').should == [expected]
+      end
+
+      describe 'including conditions for an embedded has 1 resource' do
+        before(:all) do
+          User.all.destroy!
+          User.create(:name => 'Boston guy', :address => { :city => 'Boston' })
+          @expected = User.create(:name => 'NY guy', :address => { :city => 'New York' })
+        end
+
+        it 'should return a collection' do
+          collection = User.all('address.city' => 'Washington')
+          collection.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return an empty collection when there are no matching resources' do
+          collection = User.all('address.city' => 'Washington')
+          collection.should be_empty
+        end
+
+        it 'should return specific resources' do
+          User.all('address.city' => 'New York').should == [@expected]
+        end
+      end # including conditions for an embedded has 1 resource
+
+      describe 'including conditions for an embedded has n resource' do
+        before(:all) do
+          User.all.destroy!
+          User.create(:name => 'Canada Guy', :locations => [{ :country => 'Canada' }])
+          
+          @expected = User.create(:name => 'John Kowalski', :locations => [
+            { :country => 'US',     :continent => 'North America' },
+            { :country => 'Poland', :continent => 'Europe' }])
+        end
+
+        it 'should return a collection' do
+          collection = User.all('locations.country' => 'Canada')
+          collection.should be_kind_of(DataMapper::Collection)
+        end
+
+        it 'should return an empty collection when there are no matching resources' do
+          collection = User.all('locations.country' => 'Brazil')
+          collection.should be_empty
+        end
+
+        it 'should return specific resources' do
+          User.all('locations.country' => 'US').should == [@expected]
+          User.all('locations.country' => 'Poland', 'locations.continent' => 'Europe').should == [@expected]
+        end
+      end # including conditions for an embedded has n resource
+
+    end
+  end
+
+  #
+  # first
+  #
+
+  describe '#first' do
+    before(:all) do
+      User.all.destroy!
+      @user_one = User.create(:name => 'Three')
+      @user_two = User.create(:name => 'Four')
+    end
+
+    describe 'with no query' do
+      it 'should return a resource' do
+        User.first.should be_kind_of(DataMapper::Mongo::Resource)
+      end
+
+      it 'should return the first resource' do
+        User.first.should == @user_one
+      end
+    end
+
+    describe 'when a query' do
+      it 'should return a resource' do
+        User.first(:name => @user_two.name).should \
+          be_kind_of(DataMapper::Mongo::Resource)
+      end
+
+      it 'should return the first resource' do
+        User.first(:name => @user_two.name).should == @user_two
+      end
+    end
+  end
+
+  #
+  # aggregations
+  #
+  describe 'aggregations' do
+    before(:all) do
+      class ::Student
+        include DataMapper::Mongo::Resource
+
+        property  :id,     ObjectID
+        property  :name,   String
+        property  :school, String
+        property  :score,  Float
+      end
+
+      Student.all.destroy!
+
+      @student_one   = Student.create(:school => 'School 1', :name => 'One',   :score => 3.0)
+      @student_two   = Student.create(:school => 'School 2', :name => 'Two',   :score => 3.5)
+      @student_three = Student.create(:school => 'School 2', :name => 'Three', :score => 4.5)
+    end
+
+    #
+    # count
+    #
+    describe "#count" do
+      describe 'with no query' do
+        it 'should return number of all resources' do
+          Student.count.should == 3
+        end
+      end
+
+      describe 'with a query' do
+        it 'should return number of resources matching conditions' do
+          Student.count(:name => /one|two/i).should == 2
+        end
+      end
+    end
+
+    #
+    # aggregate
+    #
+
+    describe "#aggregate" do
+
+      #
+      # simple aggregation without any operators
+      #
+
+      describe "without operators" do
+        describe "without conditions" do
+          it "should return array of hashes based on all records" do
+            result = Student.aggregate(:school, :score)
+
+            result.should == [
+              {:school => "School 1", :score => 3.0},
+              {:school => "School 2", :score => 3.5},
+              {:school => "School 2", :score => 4.5}]
+          end
+        end
+
+        describe "with conditions" do
+          it "should return array of hashes based on records that match conditions" do
+            result = Student.aggregate(:school, :score, :score.gt => 3.0)
+
+            result.should == [
+              {:school => "School 2", :score => 3.5},
+              {:school => "School 2", :score => 4.5}]
+          end
+        end
+      end
+
+      #
+      # count
+      #
+
+      describe "count operator" do
+        describe "without conditions" do
+          it "should get correct results based on all records" do
+            result = Student.aggregate(:school, :score.count)
+
+            result.size.should == 2
+
+            school_1, school_2 = result
+
+            school_1[:school].should == 'School 1'
+            school_2[:school].should == 'School 2'
+
+            school_1[:score].should == 1
+            school_2[:score].should   == 2
+          end
+        end
+
+        describe "with conditions" do
+          it "should get correct results based on records that match conditions" do
+            result = Student.aggregate(:school, :score.count, :name => /two|three/i)
+
+            result.size.should == 1
+            result.first[:score].should == 2
+            result.first[:school].should == 'School 2'
+          end
+        end
+      end
+
+      #
+      # avg
+      #
+      # TODO: add spec for #avg with conditions
+
+      describe "avg operator" do
+        describe 'without conditions' do
+          it 'should return an avarage value of the given field' do
+            result = Student.aggregate(:school, :score.avg)
+
+            school_1, school_2 = result
+
+            school_1[:school].should == 'School 1'
+            school_2[:school].should == 'School 2'
+
+            school_1[:score].should == 3.0
+            school_2[:score].should == 4.0
+          end
+        end
+      end
+
+      #
+      # min
+      #
+      # TODO: add spec for #min with conditions
+
+      describe "min operator" do
+        describe 'without conditions' do
+          it 'should return the minimum value of the given field' do
+            result = Student.aggregate(:school, :score.min)
+
+            school_1, school_2 = result
+
+            school_1[:school].should == 'School 1'
+            school_2[:school].should == 'School 2'
+
+            school_1[:score].should == 3.0
+            school_2[:score].should == 3.5
+          end
+        end
+      end
+
+      #
+      # max
+      #
+      # TODO: add spec for #max with conditions
+
+      describe "max operator" do
+        describe 'without conditions' do
+          it 'should return the maximum value of the given field' do
+            result = Student.aggregate(:school, :score.max)
+
+            school_1, school_2 = result
+
+            school_1[:school].should == 'School 1'
+            school_2[:school].should == 'School 2'
+
+            school_1[:score].should == 3.0
+            school_2[:score].should == 4.5
+          end
+        end
+      end
+
+       #
+      # max
+      #
+      # TODO: add spec for #sum with conditions
+
+      describe "sum operator" do
+        describe 'without conditions' do
+          it 'should return the maximum value of the given field' do
+            result = Student.aggregate(:school, :score.sum)
+
+            school_1, school_2 = result
+
+            school_1[:school].should == 'School 1'
+            school_2[:school].should == 'School 2'
+
+            school_1[:score].should == 3.0
+            school_2[:score].should == 8.0
+          end
+        end
+      end
+    end
+  end
+
+  #
+  # dirty?
+  #
+
+  describe '#dirty?' do
+    describe 'when the resource has a change' do
+      it 'should return true' do
+        User.new(:name => 'Mongo').should be_dirty
+      end
+    end
+
+    describe 'when the resource has no changes' do
+      it 'should return true if a one-to-one embedment has a change' do
+        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+        user.should be_dirty
+      end
+
+      it 'should return false having just been saved' do
+        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+        user.save
+        user.should_not be_dirty
+      end
+
+      it 'should return true if a one-to-many embedment has a change' do
+        user = User.new
+        user.locations << Address.new(:city => 'Rock Ridge')
+        user.should be_dirty
+      end
+
+      it 'should return false if no embedments have changes' do
+        user = User.new(:address => Address.new(:city => 'Rock Ridge'))
+        user.locations << Address.new(:city => 'Rock Ridge')
+        user.save
+        user.should_not be_dirty
+      end
+    end
+  end
+
+  #
+  # Array properties
+  #
+
+  describe 'Array properties' do
+    it 'should permit nil' do
+      user = User.new(:tags => nil)
+      user.tags.should be_nil
+    end
+
+    it 'should persist nil' do
+      user = User.create(:tags => nil)
+      User.get(user.id).tags.should be_nil
+    end
+
+    it 'should permit an Array' do
+      user = User.new(:tags => ['loud', 'troll'])
+      user.tags.should == ['loud', 'troll']
+    end
+
+    it 'should persist an Array' do
+      user = User.create(:tags => ['loud', 'troll'])
+      User.get(user.id).tags.should ==['loud', 'troll']
+    end
+
+    it 'should persist nested properties in an Array' do
+      user = User.create(:tags => ['troll', ['system', 'banned']])
+      User.get(user.id).tags.should == ['troll', ['system', 'banned']]
+    end
+  end
+
+  #
+  # Hash properties
+  #
+
+  describe 'Hash properties' do
+    it 'should permit nil' do
+      user = User.new(:metadata => nil)
+      user.metadata.should be_nil
+    end
+
+    it 'should persist nil' do
+      user = User.create(:metadata => nil)
+      User.get(user.id).metadata.should be_nil
+    end
+
+    it 'should permit a Hash' do
+      user = User.new(:metadata => { :one => 'two' })
+      user.metadata.should == { :one => 'two' }
+    end
+
+    it 'should persist a Hash' do
+      user = User.create(:metadata => { :one => 'two' })
+      User.get(user.id).metadata.should == { :one => 'two' }
+    end
+
+    it 'should permit Hash-like Arrays' do
+      user = User.new(:metadata => [:one, 'two'])
+      user.metadata.should == { :one => 'two' }
+    end
+
+    it 'should persist Hash-like Arrays' do
+      user = User.create(:metadata => [:one, 'two'])
+      User.get(user.id).metadata.should == { :one => 'two' }
+    end
+
+    it 'should persist nested properties in an Array' do
+      user = User.create(:metadata => { :one => { :two => :three } })
+      pending "EmbeddedHash doesn't typecast nested keys yet" do
+        User.get(user.id).metadata.should == { :one => { :two => :three } }
+      end
+    end
+  end
+
+  describe "Modifier" do
+    before :all do
+      class ::Post
+        include DataMapper::Mongo::Resource
+
+        property :id, ObjectID
+        property :comment_count, Integer
+        property :body, Text
+      end
+
+      Post.all.destroy!
+    end
+
+    describe "#increment" do
+      before :all do
+        @post = Post.create(:comment_count => 1)
+        @post.increment(:comment_count, 1)
+      end
+
+      it "should update the given property with the incremented value" do
+        @post.comment_count.should == 2
+        Post.get(@post.id).comment_count.should == 2
+      end
+
+      it "should reload the updated resource" do
+        @post.dirty?.should be_false
+      end
+    end
+
+    describe "#decrement" do
+      before :all do
+        @post = Post.create(:comment_count => 10)
+        @post.decrement(:comment_count, 5)
+      end
+
+      it "should update the given property with the decremented value" do
+        @post.comment_count.should == 5
+        Post.get(@post.id).comment_count.should == 5
+      end
+
+      it "should reload the updated resource" do
+        @post.dirty?.should be_false
+      end
+    end
+
+    describe "#set" do
+      it "should set the value of a property" do
+        post = Post.create(:body => "This needs to be edited", :comment_count => 2)
+
+        pending "not implemented yet" do
+          post.set(:body => "This was edited", :comment_count => 3)
+          post.body.should == "This was edited"
+          post.comment_count.should == 3
+          fresh_post = Post.get(post.id)
+          fresh_post.body.should == "This was edited"
+          fresh_post.comment_count.should == 3
+        end
+      end
+    end
+
+    describe "#unset" do
+      it "should unset the value of a property" do
+        post = Post.create(:body => "This needs to be removed", :comment_count => 2)
+
+        pending "not implemented yet" do
+          post.unset(:body, :comment_count)
+          post.body.should be_nil
+          post.comment_count.should be_nil
+          fresh_post = Post.get(post.id)
+          fresh_post.body.should be_nil
+          fresh_post.comment_count.should be_nil
+        end
+      end
+    end
+
+    describe "#push" do
+      it "should be implemented" do
+        pending
+      end
+    end
+
+    describe "#push_all" do
+      it "should be implemented" do
+        pending
+      end
+    end
+
+    describe "#pop" do
+      it "should be implemented" do
+        pending
+      end
+    end
+
+    describe "#pull" do
+      it "should be implemented" do
+        pending
+      end
+    end
+
+    describe "#pull_all" do
+      it "should be implemented" do
+        pending
+      end
+    end
+  end
+end