mongoid 5.0.0 → 5.0.1

data/spec/mongoid/query_cache_spec.rb

@@ -123,6 +123,25 @@ describe Mongoid::QueryCache do
         end
       end
     end
+
+    context "when query caching is enabled and the batch_size is set" do
+
+      around(:each) do |example|
+        query_cache_enabled = Mongoid::QueryCache.enabled?
+        Mongoid::QueryCache.enabled = true
+        example.run
+        Mongoid::QueryCache.enabled = query_cache_enabled
+      end
+
+      it "does not raise an error when requesting the second batch" do
+        expect {
+          Band.batch_size(4).where(:views.gte => 0).each do |doc|
+            doc.set(likes: Random.rand(100))
+          end
+        }.not_to raise_error
+      end
+
+    end
   end
 
   context "when querying in different collection" do

data/spec/mongoid/relations/auto_save_spec.rb

@@ -219,7 +219,7 @@ describe Mongoid::Relations::AutoSave do
         end
       end
 
-      context "when it has two ralations with autosaves" do
+      context "when it has two relations with autosaves" do
 
         before do
           Person.autosave(Person.relations["drugs"].merge!(autosave: true))

data/spec/mongoid/relations/bindings/referenced/many_to_many_spec.rb

@@ -112,7 +112,7 @@ describe Mongoid::Relations::Bindings::Referenced::ManyToMany do
         binding.bind_one(target.first)
       end
 
-      it "never performs a persistance operation" do
+      it "never performs a persistence operation" do
         expect(person).to receive(:delete).never
         expect(person).to receive(:save).never
         expect(preference).to receive(:delete).never

data/spec/mongoid/relations/counter_cache_spec.rb

@@ -290,27 +290,80 @@ describe Mongoid::Relations::CounterCache do
 
   describe "#add_counter_cache_callbacks" do
 
-    let(:person) do
-      Person.create
-    end
+    context "when parent is not frozen" do
 
-    let!(:drug) do
-      person.drugs.create
-    end
+      context 'when #destroy is called on the object' do
 
-    context "when parent is not frozen" do
+        let(:person) do
+          Person.create
+        end
 
-      before do
-        drug.destroy
+        let!(:drug) do
+          person.drugs.create
+        end
+
+        before do
+          drug.destroy
+        end
+
+        it "updates the counter cache" do
+          expect(person.drugs_count).to eq(0)
+        end
       end
 
-      it "before_destroy updates counter cache" do
-        expect(person.drugs_count).to eq(0)
+      context 'when #create is called on the object' do
+
+        let(:person) do
+          Person.create { |p| p.drugs += [Drug.create, Drug.create] }
+        end
+
+        it "updates the counter cache" do
+          expect(person.drugs_count).to eq(2)
+        end
+      end
+
+      context 'when #update is called on the object' do
+
+        let(:person1) do
+          Person.create { |p| p.drugs += [Drug.create, Drug.create] }
+        end
+
+        let(:drug) do
+          person1.drugs.first
+        end
+
+        let(:person2) do
+          Person.create
+        end
+
+        before do
+          drug.update_attribute(:person, person2)
+        end
+
+        it "updates the current counter cache" do
+          expect(drug.person.drugs_count).to eq(1)
+        end
+
+        it "updates the current counter cache" do
+          expect(person2.drugs_count).to eq(1)
+        end
+
+        it "updates the original object's counter cache" do
+          expect(person1.reload.drugs_count).to eq(1)
+        end
       end
     end
 
     context "when parent is frozen" do
 
+      let(:person) do
+        Person.create
+      end
+
+      let!(:drug) do
+        person.drugs.create
+      end
+
       before do
         person.destroy
         drug.destroy

data/spec/mongoid/relations/eager/has_many_spec.rb

@@ -177,6 +177,43 @@ describe Mongoid::Relations::Eager::HasMany do
           expect(eager.last.ivar(:posts)).to be_empty
         end
       end
+
+      context "when the child has a default scope" do
+
+        let(:criteria) do
+          Exhibitor.where(:status.ne => "removed")
+        end
+
+        let(:exhibitorPresent) do
+          Exhibitor.create!(status: "present")
+        end
+
+        let(:exhibitorRemoved) do
+          Exhibitor.create!(status: "removed")
+        end
+
+        let(:exhibitionIncludesExhibitors) do
+          Exhibition.includes(:exhibitors).first
+        end
+
+        before do
+          Exhibitor.default_scope ->{ criteria }
+          exhibition = Exhibition.create!
+          exhibition.exhibitors << exhibitorPresent
+          exhibition.exhibitors << exhibitorRemoved
+          exhibitionIncludesExhibitors
+        end
+
+        after do
+          Exhibitor.default_scoping = nil
+        end
+
+        it "does not send another query when the children are accessed" do
+          expect_query(0) do
+            expect(exhibitionIncludesExhibitors.exhibitors).to eq( [exhibitorPresent] )
+          end
+        end
+      end
     end
 
     context "when the relation is polymorphic" do

data/spec/mongoid/relations/eager_spec.rb

@@ -131,6 +131,17 @@ describe Mongoid::Relations::Eager do
 
         context.eager_load(docs)
       end
+
+      context 'when combined with a #find_by' do
+
+        let!(:person) do
+          Person.create!(title: 'manager')
+        end
+
+        it 'executes the find_by' do
+          expect(criteria.find_by(title: 'manager')).to eq(person)
+        end
+      end
     end
 
     context "when including multiple relations" do

data/spec/mongoid/relations/embedded/many_spec.rb

@@ -2748,26 +2748,55 @@ describe Mongoid::Relations::Embedded::Many do
       end
 
       let!(:location) do
-        address.locations.create(name: "work")
+        address.locations.create(name: "vacation", number: 0)
+        address.locations.create(name: "work", number: 3)
       end
 
-      context "when updating with a hash" do
+      context "when updating with replacement of embedded array" do
+
+        context "when updating with a hash" do
+
+          before do
+            address.update_attributes(locations: [{ name: "home" }])
+          end
+
+          it "updates the attributes" do
+            expect(address.locations.first.name).to eq("home")
+          end
+
+          it "overwrites the existing documents" do
+            expect(address.locations.count).to eq(1)
+          end
+
+          it "persists the changes" do
+            expect(address.reload.locations.count).to eq(1)
+          end
+        end
+      end
+
+      context "when updating a field in a document of the embedded array" do
 
         before do
-          address.update_attributes(locations: [{ name: "home" }])
+          location.number = 7
+          location.save
         end
 
-        it "updates the attributes" do
-          expect(address.locations.first.name).to eq("home")
+        let(:updated_location_number) do
+          person.reload.addresses.first.locations.find(location.id).number
         end
 
-        it "overwrites the existing documents" do
-          expect(address.locations.count).to eq(1)
+        let(:updated_location_name) do
+          person.reload.addresses.first.locations.find(location.id).name
         end
 
-        it "persists the changes" do
-          expect(address.reload.locations.count).to eq(1)
+        it "the change is persisted" do
+          expect(updated_location_number).to eq(7)
+        end
+
+        it "the other field remains unaffected" do
+          expect(updated_location_name).to eq("work")
         end
+
       end
     end
 

data/spec/mongoid/relations/embedded/one_spec.rb

@@ -963,7 +963,7 @@ describe Mongoid::Relations::Embedded::One do
         end
 
         before do
-          person.reload.addresses.first.code = code
+          address_two.code = code
         end
 
         it "reloads the correct number" do

data/spec/mongoid/relations/proxy_spec.rb

@@ -2,6 +2,28 @@ require "spec_helper"
 
 describe Mongoid::Relations::Proxy do
 
+  describe '#with', if: non_legacy_server? do
+
+    let(:circus) do
+      Circus.new
+    end
+
+    let(:animal) do
+      Animal.new
+    end
+
+    before do
+      circus.animals << animal
+      circus.save
+    end
+
+    it 'uses the new persistence options' do
+      expect {
+        animal.with(write: { w: 100 }).update_attribute(:name, 'kangaroo')
+      }.to raise_exception(Mongo::Error::OperationFailure)
+    end
+  end
+
   describe "#find" do
     let(:person) do
       Person.create

data/spec/mongoid/relations/reflections_spec.rb

@@ -34,7 +34,7 @@ describe Mongoid::Relations::Reflections do
     context "when the name does not exist" do
 
       let(:relation) do
-        klass.reflect_on_association(:nonexistant)
+        klass.reflect_on_association(:nonexistent)
       end
 
       it "returns nil" do

data/spec/mongoid/scopable_spec.rb

@@ -51,7 +51,7 @@ describe Mongoid::Scopable do
       end
 
       let(:rand_criteria) do
-        ->{ Band.gt(likes: rand(100)) }
+        ->{ Band.gt(likes: Mongo::Monitoring.next_operation_id) }
       end
 
       before do
@@ -143,16 +143,34 @@ describe Mongoid::Scopable do
         Band.where(name: "Depeche Mode")
       end
 
-      before do
-        Mongoid::Threaded.current_scope = criteria
-      end
+      context "when using #current_scope=scope" do
 
-      after do
-        Mongoid::Threaded.current_scope = nil
+        before do
+          Mongoid::Threaded.current_scope = criteria
+        end
+
+        after do
+          Mongoid::Threaded.current_scope = nil
+        end
+
+        it "returns the criteria on the stack" do
+          expect(Band.queryable).to eq(criteria)
+        end
       end
 
-      it "returns the criteria on the stack" do
-        expect(Band.queryable).to eq(criteria)
+      context "when using #set_current_scope(scope, klass)" do
+
+        before do
+          Mongoid::Threaded.set_current_scope(criteria, Band)
+        end
+
+        after do
+          Mongoid::Threaded.set_current_scope(nil, Band)
+        end
+
+        it "returns the criteria on the stack" do
+          expect(Band.queryable).to eq(criteria)
+        end
       end
     end
   end
@@ -398,6 +416,45 @@ describe Mongoid::Scopable do
         end
       end
 
+      context 'when the block is an none scope' do
+
+        before do
+          Simple.create!(name: 'Emily')
+        end
+
+        context 'when there is no default scope' do
+
+          before do
+            Simple.scope(:nothing, ->{ none })
+          end
+
+          it 'returns no results' do
+            expect(Simple.nothing).to be_empty
+          end
+        end
+
+        context 'when there is a default scope' do
+
+          let(:criteria) do
+            Simple.where(name: "Emily")
+          end
+
+          before do
+            Simple.default_scope ->{ criteria }
+            Simple.scope(:nothing, ->{ none })
+          end
+
+          after do
+            Simple.default_scoping = nil
+          end
+
+          it 'returns no results' do
+            expect(Simple.nothing).to be_empty
+          end
+        end
+
+      end
+
       context "when no block is provided" do
 
         before do
@@ -509,6 +566,58 @@ describe Mongoid::Scopable do
               expect(criteria.selector).to eq({ "origin" => "England" })
             end
           end
+
+          context "when chaining scopes through more than one model" do
+
+            before do
+              Author.scope(:author, -> { where(author: true) } )
+              Article.scope(:is_public, -> { where(public: true) } )
+              Article.scope(:authored, -> {
+                author_ids = Author.author.pluck(:id)
+                where(:author_id.in => author_ids)
+              })
+
+              Author.create(author: true, id: 1)
+              Author.create(author: true, id: 2)
+              Author.create(author: true, id: 3)
+              Article.create(author_id: 1, public: true)
+              Article.create(author_id: 2, public: true)
+              Article.create(author_id: 3, public: false)
+            end
+
+            after do
+              class << Article
+                undef_method :is_public
+                undef_method :authored
+              end
+              Article._declared_scopes.clear
+              class << Author
+                undef_method :author
+              end
+              Author._declared_scopes.clear
+            end
+
+            context "when calling another model's scope from within a scope" do
+
+              let(:authored_count) do
+                Article.authored.size
+              end
+
+              it "returns the correct documents" do
+                expect(authored_count).to eq(3)
+              end
+            end
+
+            context "when calling another model's scope from within a chained scope" do
+              let(:is_public_authored_count) do
+                Article.is_public.authored.size
+              end
+
+              it "returns the correct documents" do
+                expect(is_public_authored_count).to eq(2)
+              end
+            end
+          end
         end
       end
 
@@ -784,17 +893,38 @@ describe Mongoid::Scopable do
 
       context "when default scope is in a super class" do
 
-        before do
-          Band.scope(:active, ->{ Band.where(active: true) })
-        end
+        context "when scope is already defined in parent class" do
 
-        let(:unscoped) do
-          class U2 < Band; end
-          U2.unscoped.active
+          let(:unscoped) do
+            class U1 < Kaleidoscope; end
+            U1.unscoped.activated
+          end
+
+          it "clears default scope" do
+            expect(unscoped.selector).to eq({ "active" => true })
+          end
         end
 
-        it "clears default scope" do
-          expect(unscoped.selector).to eq({ "active" => true })
+        context "when the scope is created dynamically" do
+
+          before do
+            Band.scope(:active, ->{ Band.where(active: true) })
+          end
+
+          after do
+            class << Band
+              undef_method :active
+            end
+          end
+
+          let(:unscoped) do
+            class U2 < Band; end
+            U2.unscoped.active
+          end
+
+          it "clears default scope" do
+            expect(unscoped.selector).to eq({ "active" => true })
+          end
         end
       end
     end
@@ -899,9 +1029,20 @@ describe Mongoid::Scopable do
       end
     end
 
-    it "pops the criteria off the stack" do
-      Band.with_scope(criteria) {}
-      expect(Mongoid::Threaded.current_scope).to be_nil
+    context "when using #current_scope" do
+
+      it "pops the criteria off the stack" do
+        Band.with_scope(criteria) do;end
+        expect(Mongoid::Threaded.current_scope).to be_nil
+      end
+    end
+
+    context "when using #current_scope(klass)" do
+
+      it "pops the criteria off the stack" do
+        Band.with_scope(criteria) do;end
+        expect(Mongoid::Threaded.current_scope(Band)).to be_nil
+      end
     end
   end