mongoid 3.1.6 → 4.0.0

data/spec/mongoid/persistable/upsertable_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+describe Mongoid::Persistable::Upsertable do
+
+  describe "#upsert" do
+
+    context "when the document validates on upsert" do
+
+      let(:account) do
+        Account.new(name: "testing")
+      end
+
+      context "when the document is not valid in the upsert context" do
+
+        before do
+          account.upsert
+        end
+
+        it "adds the validation errors" do
+          expect(account.errors[:nickname]).to_not be_empty
+        end
+
+        it "does not upsert the document" do
+          expect(account).to be_a_new_record
+        end
+      end
+    end
+
+    context "when the document is new" do
+
+      let!(:existing) do
+        Band.create(name: "Photek")
+      end
+
+      context "when a matching document exists in the db" do
+
+        let(:updated) do
+          Band.new(name: "Tool") do |band|
+            band.id = existing.id
+          end
+        end
+
+        before do
+          updated.upsert
+        end
+
+        it "updates the existing document" do
+          expect(existing.reload.name).to eq("Tool")
+        end
+
+        it "flags the document as persisted" do
+          expect(existing).to be_persisted
+        end
+      end
+
+      context "when no matching document exists in the db" do
+
+        let(:insert) do
+          Band.new(name: "Tool")
+        end
+
+        before do
+          insert.upsert
+        end
+
+        it "inserts a new document" do
+          expect(insert.reload).to eq(insert)
+        end
+
+        it "does not modify any fields" do
+          expect(insert.reload.name).to eq("Tool")
+        end
+
+        it "flags the document as persisted" do
+          expect(insert).to be_persisted
+        end
+      end
+    end
+
+    context "when the document is not new" do
+
+      let!(:existing) do
+        Band.create(name: "Photek")
+      end
+
+      context "when updating fields outside of the id" do
+
+        before do
+          existing.name = "Depeche Mode"
+        end
+
+        let!(:upsert) do
+          existing.upsert
+        end
+
+        it "updates the existing document" do
+          expect(existing.reload.name).to eq("Depeche Mode")
+        end
+
+        it "returns true" do
+          expect(upsert).to be true
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/persistable_spec.rb

@@ -0,0 +1,206 @@
+require "spec_helper"
+
+describe Mongoid::Persistable do
+
+  describe "#atomically" do
+
+    let(:document) do
+      Band.create(member_count: 0, likes: 60, origin: "London")
+    end
+
+    context "when providing a block" do
+
+      shared_examples_for "an atomically updatable root document" do
+
+        it "performs inc updates" do
+          expect(document.member_count).to eq(10)
+        end
+
+        it "performs bit updates" do
+          expect(document.likes).to eq(12)
+        end
+
+        it "performs set updates" do
+          expect(document.name).to eq("Placebo")
+        end
+
+        it "performs unset updates" do
+          expect(document.origin).to be_nil
+        end
+
+        it "returns true" do
+          expect(update).to be true
+        end
+
+        it "persists inc updates" do
+          expect(document.reload.member_count).to eq(10)
+        end
+
+        it "persists bit updates" do
+          expect(document.reload.likes).to eq(12)
+        end
+
+        it "persists set updates" do
+          expect(document.reload.name).to eq("Placebo")
+        end
+
+        it "persists unset updates" do
+          expect(document.reload.origin).to be_nil
+        end
+      end
+
+      context "when not chaining the operations" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          expect_any_instance_of(Moped::Query).to receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.inc(member_count: 10)
+            document.bit(likes: { and: 13 })
+            document.set(name: "Placebo")
+            document.unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+
+      context "when chaining the operations" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          expect_any_instance_of(Moped::Query).to receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.
+              inc(member_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+
+      context "when given multiple operations of the same type" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10, "other_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          expect_any_instance_of(Moped::Query).to receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do
+            document.
+              inc(member_count: 10).
+              inc(other_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+
+        it "performs multiple inc updates" do
+          expect(document.other_count).to eq(10)
+        end
+
+        it "persists multiple inc updates" do
+          expect(document.reload.other_count).to eq(10)
+        end
+      end
+
+      context "when expecting the document to be yielded" do
+
+        let(:operations) do
+          {
+            "$inc" => { "member_count" => 10 },
+            "$bit" => { "likes" => { :and => 13 }},
+            "$set" => { "name" => "Placebo" },
+            "$unset" => { "origin" => true }
+          }
+        end
+
+        before do
+          expect_any_instance_of(Moped::Query).to receive(:update).with(operations).and_call_original
+        end
+
+        let!(:update) do
+          document.atomically do |doc|
+            doc.
+              inc(member_count: 10).
+              bit(likes: { and: 13 }).
+              set(name: "Placebo").
+              unset(:origin)
+          end
+        end
+
+        it_behaves_like "an atomically updatable root document"
+      end
+    end
+
+    context "when providing no block "do
+
+      it "returns true" do
+        expect(document.atomically).to be true
+      end
+    end
+  end
+
+  describe "#fail_due_to_valiation!" do
+
+    let(:document) do
+      Band.new
+    end
+
+    it "raises the validation error" do
+      expect {
+        document.fail_due_to_validation!
+      }.to raise_error(Mongoid::Errors::Validations)
+    end
+  end
+
+  describe "#fail_due_to_callback!" do
+
+    let(:document) do
+      Band.new
+    end
+
+    it "raises the callback error" do
+      expect {
+        document.fail_due_to_callback!(:save!)
+      }.to raise_error(Mongoid::Errors::Callback)
+    end
+  end
+end

data/spec/mongoid/{atomic/positionable_spec.rb → positional_spec.rb}

@@ -1,12 +1,12 @@
 require "spec_helper"
 
-describe Mongoid::Atomic::Positionable do
+describe Mongoid::Positional do
 
   describe "#positionally" do
 
     let(:positionable) do
       Class.new do
-        include Mongoid::Atomic::Positionable
+        include Mongoid::Positional
       end.new
     end
 
@@ -46,7 +46,7 @@ describe Mongoid::Atomic::Positionable do
         end
 
         it "does not do any replacement" do
-          processed.should eq(ops)
+          expect(processed).to eq(ops)
         end
       end
 
@@ -80,7 +80,7 @@ describe Mongoid::Atomic::Positionable do
         end
 
         it "does not do any replacement" do
-          processed.should eq(expected)
+          expect(processed).to eq(expected)
         end
       end
     end
@@ -96,7 +96,7 @@ describe Mongoid::Atomic::Positionable do
       end
 
       it "does not do any replacement" do
-        processed.should eq(updates)
+        expect(processed).to eq(updates)
       end
     end
 
@@ -127,7 +127,7 @@ describe Mongoid::Atomic::Positionable do
         end
 
         it "replaces the first index with the positional operator" do
-          processed.should eq(expected)
+          expect(processed).to eq(expected)
         end
       end
 
@@ -156,7 +156,7 @@ describe Mongoid::Atomic::Positionable do
         end
 
         it "replaces the first index with the positional operator" do
-          processed.should eq(expected)
+          expect(processed).to eq(expected)
         end
       end
     end
@@ -186,7 +186,7 @@ describe Mongoid::Atomic::Positionable do
       end
 
       it "replaces the first index with the positional operator" do
-        processed.should eq(expected)
+        expect(processed).to eq(expected)
       end
     end
 
@@ -220,7 +220,7 @@ describe Mongoid::Atomic::Positionable do
       end
 
       it "replaces the first index with the positional operator" do
-        processed.should eq(expected)
+        expect(processed).to eq(expected)
       end
     end
   end

data/spec/mongoid/query_cache_spec.rb

@@ -0,0 +1,231 @@
+require "spec_helper"
+
+describe Mongoid::QueryCache do
+
+  around do |spec|
+    Mongoid::QueryCache.clear_cache
+    Mongoid::QueryCache.cache { spec.run }
+  end
+
+  context "when querying for a single document" do
+
+    [ :first, :one, :last ].each do |method|
+
+      before do
+        Band.all.send(method)
+      end
+
+      context "when query cache disable" do
+
+        before do
+          Mongoid::QueryCache.enabled = false
+        end
+
+        it "queries again" do
+          expect_query(1) do
+            Band.all.send(method)
+          end
+        end
+      end
+
+      context "with same selector" do
+
+        it "does not query again" do
+          expect_no_queries do
+            Band.all.send(method)
+          end
+        end
+      end
+
+      context "with different selector" do
+
+        it "queries again" do
+          expect_query(1) do
+            Band.where(id: 1).send(method)
+          end
+        end
+      end
+    end
+  end
+
+  context "when querying in the same collection" do
+
+    before do
+      Band.all.to_a
+    end
+
+    context "when query cache disable" do
+
+      before do
+        Mongoid::QueryCache.enabled = false
+      end
+
+      it "queries again" do
+        expect_query(1) do
+          Band.all.to_a
+        end
+      end
+    end
+
+    context "with same selector" do
+
+      it "does not query again" do
+        expect_no_queries do
+          Band.all.to_a
+        end
+      end
+
+      context "when querying only the first" do
+        let(:game) { Game.create!(name: "2048") }
+
+        before do
+          game.ratings.where(:value.gt => 5).asc(:id).all.to_a
+        end
+
+        it "queries again" do
+          expect_query(1) do
+            game.ratings.where(:value.gt => 5).asc(:id).first
+          end
+        end
+      end
+
+      context "limiting the result" do
+        it "queries again" do
+          expect_query(1) do
+            Band.limit(2).all.to_a
+          end
+        end
+      end
+
+      context "specifying a different skip value" do
+        before do
+          Band.limit(2).skip(1).all.to_a
+        end
+
+        it "queries again" do
+          expect_query(1) do
+            Band.limit(2).skip(3).all.to_a
+          end
+        end
+      end
+    end
+
+    context "with different selector" do
+
+      it "queries again" do
+        expect_query(1) do
+          Band.where(id: 1).to_a
+        end
+      end
+    end
+  end
+
+  context "when querying in different collection" do
+
+    before do
+      Person.all.to_a
+    end
+
+    it "queries again" do
+      expect_query(1) do
+        Band.all.to_a
+      end
+    end
+  end
+
+  context "when inserting a new document" do
+
+    before do
+      Band.all.to_a
+      Band.create!
+    end
+
+    it "queries again" do
+      expect_query(1) do
+        Band.all.to_a
+      end
+    end
+  end
+
+  context "when deleting all documents" do
+
+    before do
+      Band.create!
+      Band.all.to_a
+      Band.delete_all
+    end
+
+    it "queries again" do
+      expect_query(1) do
+        Band.all.to_a
+      end
+    end
+  end
+
+  context "when destroying all documents" do
+
+    before do
+      Band.create!
+      Band.all.to_a
+      Band.destroy_all
+    end
+
+    it "queries again" do
+      expect_query(1) do
+        Band.all.to_a
+      end
+    end
+  end
+
+  context "when inserting an index" do
+
+    it "does not cache the query" do
+      expect(Mongoid::QueryCache).to receive(:cache_table).never
+      Band.collection.indexes.create(name: 1)
+    end
+  end
+end
+
+describe Mongoid::QueryCache::Middleware do
+
+  let :middleware do
+    Mongoid::QueryCache::Middleware.new(app)
+  end
+
+  context "when not touching mongoid on the app" do
+
+    let(:app) do
+      ->(env) { @enabled = Mongoid::QueryCache.enabled?; [200, env, "app"] }
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it "enableds the query cache" do
+      middleware.call({})
+      expect(@enabled).to be true
+    end
+  end
+
+  context "when querying on the app" do
+
+    let(:app) do
+      ->(env) {
+        Band.all.to_a
+        [200, env, "app"]
+      }
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it "cleans the query cache after reponds" do
+      middleware.call({})
+      expect(Mongoid::QueryCache.cache_table).to be_empty
+    end
+  end
+end

data/spec/mongoid/railties/document_spec.rb

@@ -12,13 +12,13 @@ describe "A document loaded from rails" do
   end
 
   it "defines a _destroy method" do
-    Person.new.should respond_to(:_destroy)
+    expect(Person.new).to respond_to(:_destroy)
   end
 
   describe "#_destroy" do
 
     it "always returns false" do
-      Person.new._destroy.should be_false
+      expect(Person.new._destroy).to be false
     end
   end
 end