mongoid 5.4.1 → 6.0.0.beta

data/spec/mongoid/matchable/gt_spec.rb

@@ -71,5 +71,16 @@ describe Mongoid::Matchable::Gt do
         end
       end
     end
+
+    context "when the value is not numeric" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$gt" => '4.9')).to be false
+      end
+    end
   end
 end

data/spec/mongoid/matchable/gte_spec.rb

@@ -67,7 +67,17 @@ describe Mongoid::Matchable::Gte do
         it "returns false" do
           expect(matcher.matches?("$gte" => 5)).to be false
         end
+      end
+    end
+
+    context "when the value is not numeric" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
 
+      it "returns false" do
+        expect(matcher.matches?("$gte" => '4.9')).to be false
       end
     end
   end

data/spec/mongoid/matchable/lt_spec.rb

@@ -70,5 +70,16 @@ describe Mongoid::Matchable::Lt do
 
       end
     end
+
+    context "when the value is not numeric" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$lt" => '5.1')).to be false
+      end
+    end
   end
 end

data/spec/mongoid/matchable/lte_spec.rb

@@ -49,6 +49,7 @@ describe Mongoid::Matchable::Lte do
     end
 
     context "when the value is an array" do
+
       context "there are value valid" do
         let(:matcher) do
           described_class.new([3, 4])
@@ -67,7 +68,17 @@ describe Mongoid::Matchable::Lte do
         it "returns false" do
           expect(matcher.matches?("$lte" => 5)).to be false
         end
+      end
+    end
 
+    context "when the value is not numeric" do
+
+      let(:matcher) do
+        described_class.new(5)
+      end
+
+      it "returns false" do
+        expect(matcher.matches?("$lte" => '5.1')).to be false
       end
     end
   end

data/spec/mongoid/matchable_spec.rb

@@ -9,13 +9,12 @@ describe Mongoid::Matchable do
       let(:document) do
         Address.new(street: "Clarkenwell Road")
       end
-      let(:occupants){[{'name' => 'Tim'}]}
 
       before do
         document.locations << Location.new(
           name: 'No.1',
           info: { 'door' => 'Red'},
-          occupants: occupants
+          occupants: [{'name' => 'Tim'}]
         )
       end
 
@@ -77,33 +76,6 @@ describe Mongoid::Matchable do
         end
       end
 
-      context "when matching index of an array" do
-
-        let(:occupants){["Tim","Logan"]}
-
-        context "when the contents match" do
-
-          let(:selector) do
-            { "occupants.0" => "Tim" }
-          end
-          
-          it "returns true" do
-            expect(document.locations.first.matches?(selector)).to be true
-          end
-        end
-
-        context "when the contents do not match" do
-
-          let(:selector) do
-            { "occupants.0" => "Logan" }
-          end
-
-          it "returns false" do
-            expect(document.locations.first.matches?(selector)).to be false
-          end
-        end
-      end
-
       context "when matching values of multiple embedded hashes" do
 
         context "when the contents match" do
@@ -169,28 +141,6 @@ describe Mongoid::Matchable do
           expect(document.matches?(selector)).to be false
         end
       end
-
-      context 'when a BSON::Regexp::Raw object is used' do
-
-        let(:selector) do
-          { street: BSON::Regexp::Raw.new("^Clarkenwell") }
-        end
-
-        it "returns true" do
-          expect(document.matches?(selector)).to be true
-        end
-      end
-
-      context 'when a native Regexp object is used' do
-
-        let(:selector) do
-          { street: /^Clarkenwell/ }
-        end
-
-        it "returns true" do
-          expect(document.matches?(selector)).to be true
-        end
-      end
     end
 
     context "when performing complex matching" do

data/spec/mongoid/persistable/creatable_spec.rb

@@ -529,7 +529,7 @@ describe Mongoid::Persistable::Creatable do
         it "raises an error" do
           expect {
             4.times { Person.create!(ssn: "555-55-1029") }
-          }.to raise_error
+          }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
     end
@@ -562,7 +562,7 @@ describe Mongoid::Persistable::Creatable do
       end
     end
 
-    context "when a callback returns false" do
+    context "when a callback aborts the chain" do
 
       it "raises a callback error" do
         expect { Oscar.create! }.to raise_error(Mongoid::Errors::Callback)

data/spec/mongoid/persistable/deletable_spec.rb

@@ -30,7 +30,7 @@ describe Mongoid::Persistable::Deletable do
       it "deletes the document from the collection" do
         expect {
           Person.find(person.id)
-        }.to raise_error
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
       end
 
       it "returns true" do

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -30,7 +30,7 @@ describe Mongoid::Persistable::Destroyable do
       it "destroys the document from the collection" do
         expect {
           Person.find(person.id)
-        }.to raise_error
+        }.to raise_error(Mongoid::Errors::DocumentNotFound)
       end
 
       it "returns true" do
@@ -164,7 +164,11 @@ describe Mongoid::Persistable::Destroyable do
       end
 
       before do
-        expect(album).to receive(:set_parent_name).and_return(false)
+        Album.before_destroy(:set_parent_name_fail)
+      end
+
+      after do
+        Album.reset_callbacks(:destroy)
       end
 
       it "raises an exception" do

data/spec/mongoid/persistable/savable_spec.rb

@@ -189,8 +189,8 @@ describe Mongoid::Persistable::Savable do
               "title" => "King",
               "name.first_name" => "Ryan"
             },
-            "$push"=> {
-              "addresses" => {'$each' => [ { "_id" => address.id, "street" => "Bond St" } ]}
+            "$pushAll"=> {
+              "addresses" => [ { "_id" => address.id, "street" => "Bond St" } ]
             }
           })
         end
@@ -295,20 +295,37 @@ describe Mongoid::Persistable::Savable do
       end
     end
 
-    context "when the document is readonly" do
-
-      let(:person) do
-        Person.only(:title).first
-      end
+    context "when the changed attribute is not writable" do
 
       before do
         Person.create(title: "sir")
       end
 
+      let(:person) do
+        Person.only(:title).first
+      end
+
       it "raises an error" do
         expect {
+          person.username = 'unloaded-attribute'
           person.save
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+        }.to raise_error(Mongoid::Errors::ReadonlyAttribute)
+      end
+
+      context 'when the changed attribute is aliased' do
+
+        before do
+          Person.create(at: Time.now)
+        end
+
+        let(:person) do
+          Person.only(:at).first
+        end
+
+        it "saves the document" do
+          person.aliased_timestamp = Time.now
+          expect(person.save(validate: false)).to be true
+        end
       end
     end
 
@@ -357,8 +374,8 @@ describe Mongoid::Persistable::Savable do
           Person.create!(ssn: "555-55-9999")
         end
 
-        it "raises an error" do
-          expect { person.save! }.to raise_error
+        it "raises an OperationFailure" do
+          expect { person.save! }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
     end
@@ -374,12 +391,12 @@ describe Mongoid::Persistable::Savable do
       end
 
       it "raises an error with multiple save attempts" do
-        expect { subject.save! }.to raise_error
-        expect { subject.save! }.to raise_error
+        expect { service.save! }.to raise_error(Mongoid::Errors::Validations)
+        expect { service.save! }.to raise_error(Mongoid::Errors::Validations)
       end
     end
 
-    context "when a callback returns false" do
+    context "when a callback aborts the callback chain" do
 
       let(:oscar) do
         Oscar.new
@@ -495,22 +512,5 @@ describe Mongoid::Persistable::Savable do
         expect(from_db.shapes.first.canvas).to eq(firefox)
       end
     end
-
-    context "when the document is readonly" do
-
-      let(:person) do
-        Person.only(:title).first
-      end
-
-      before do
-        Person.create(title: "sir")
-      end
-
-      it "raises an error" do
-        expect {
-          person.save!
-        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
-      end
-    end
   end
 end

data/spec/mongoid/persistable/settable_spec.rb

@@ -134,35 +134,6 @@ describe Mongoid::Persistable::Settable do
 
         it_behaves_like "a settable embedded document"
       end
-
-      context 'when the field is a relation' do
-
-        let(:person) do
-          Person.create
-        end
-
-        let(:pet) do
-          Animal.new(name: "somepet")
-        end
-
-        let(:home_phone) do
-          Phone.new(number: "555-555-5555")
-        end
-
-        let(:office_phone) do
-          Phone.new(number: "666-666-6666")
-        end
-
-        it "should persist changes of embeds_one field" do
-          person.set(pet: pet)
-          expect(person.reload.pet).to eq(pet)
-        end
-
-        it "should persist changes of embeds_many fields" do
-          person.set({ phone_numbers: [home_phone, office_phone].map { |p| p.as_document} })
-          expect(person.reload.phone_numbers).to eq([home_phone, office_phone])
-        end
-      end
     end
   end
 
@@ -204,160 +175,4 @@ describe Mongoid::Persistable::Settable do
       expect(agent.reload.title).to eq title
     end
   end
-
-  context 'when the field is already set locally' do
-
-    let(:church) do
-      Church.new.tap do |a|
-        a.location = { 'city' => 'Berlin' }
-        a.name = 'Church1'
-        a.save
-      end
-    end
-
-    context 'when the field is a Hash type' do
-
-      before do
-        church.set('location.neighborhood' => 'Kreuzberg')
-      end
-
-      it 'updates the hash while keeping existing key and values locally' do
-        expect(church.location).to eq({ 'city' => 'Berlin', 'neighborhood' => 'Kreuzberg'})
-      end
-
-      it 'updates the hash in the database' do
-        expect(church.reload.location).to eq({ 'city' => 'Berlin', 'neighborhood' => 'Kreuzberg'})
-      end
-    end
-
-    context 'when the field type is String' do
-
-      before do
-        church.set('name' => 'Church2')
-      end
-
-      it 'updates the field locally' do
-        expect(church.name).to eq('Church2')
-      end
-
-      it 'updates the field in the database' do
-        expect(church.reload.name).to eq('Church2')
-      end
-    end
-
-    context 'when there are two fields of type Hash and String' do
-
-      before do
-        church.set('name' => 'Church2', 'location.street' => 'Yorckstr.')
-      end
-
-      it 'updates the fields locally' do
-        expect(church.name).to eq('Church2')
-        expect(church.location).to eq({ 'city' => 'Berlin', 'street' => 'Yorckstr.'})
-      end
-
-      it 'updates the fields in the database' do
-        expect(church.reload.name).to eq('Church2')
-        expect(church.reload.location).to eq({ 'city' => 'Berlin', 'street' => 'Yorckstr.'})
-      end
-    end
-  end
-
-  context 'when the field is a nested hash' do
-
-    context 'when a leaf value in the nested hash is updated' do
-
-      let(:church) do
-        Church.new.tap do |a|
-          a.location = {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}
-          a.name = 'Church1'
-          a.save
-        end
-      end
-
-      before do
-        church.set('location.address.city' => 'Munich')
-      end
-
-      it 'does not reset the nested hash' do
-        expect(church.name).to eq('Church1')
-        expect(church.location).to eql({'address' => {'city' => 'Munich', 'street' => 'Yorckstr'}})
-      end
-    end
-
-
-    context 'when the nested hash is many levels deep' do
-
-      let(:church) do
-        Church.new.tap do |a|
-          a.location = {'address' => {'state' => {'address' => {'city' => 'Berlin', 'street' => 'Yorckstr'}}}}
-          a.name = 'Church1'
-          a.save
-        end
-      end
-
-      before do
-        church.set('location.address.state.address.city' => 'Munich')
-      end
-
-      it 'does not reset the nested hash' do
-        expect(church.name).to eq('Church1')
-        expect(church.location).to eql({'address' => {'state' => {'address' => {'city' => 'Munich', 'street' => 'Yorckstr'}}}})
-      end
-    end
-  end
-
-  context 'when the field is not already set locally' do
-
-    let(:church) do
-      Church.create
-    end
-
-    context 'when the field is a Hash type' do
-
-      before do
-        church.set('location.neighborhood' => 'Kreuzberg')
-      end
-
-      it 'sets the hash locally' do
-        expect(church.location).to eq({ 'neighborhood' => 'Kreuzberg'})
-      end
-
-      it 'sets the hash in the database' do
-        expect(church.reload.location).to eq({ 'neighborhood' => 'Kreuzberg'})
-      end
-    end
-
-    context 'when the field type is String' do
-
-      before do
-        church.set('name' => 'Church2')
-      end
-
-      it 'sets the field locally' do
-        expect(church.name).to eq('Church2')
-      end
-
-      it 'sets the field in the database' do
-        expect(church.reload.name).to eq('Church2')
-      end
-    end
-
-    context 'when there are two fields of type Hash and String' do
-
-      before do
-        church.set('name' => 'Church2', 'location.street' => 'Yorckstr.')
-      end
-
-      it 'sets the fields locally' do
-        expect(church.name).to eq('Church2')
-        expect(church.location).to eq({ 'street' => 'Yorckstr.'})
-      end
-
-      it 'sets the fields in the database' do
-        expect(church.reload.name).to eq('Church2')
-        expect(church.reload.location).to eq({ 'street' => 'Yorckstr.'})
-      end
-    end
-  end
 end