mongoid 4.0.0.alpha2 → 4.0.0.beta1

data/spec/mongoid/fields/localized_spec.rb

@@ -178,6 +178,21 @@ describe Mongoid::Fields::Localized do
       end
     end
 
+    context "when no type is provided" do
+
+      let(:field) do
+        described_class.new(:description, localize: true)
+      end
+
+      let(:value) do
+        field.demongoize({ "en" => false })
+      end
+
+      it "allows booleans to be returned" do
+        expect(value).to eq(false)
+      end
+    end
+
     context "when the type is not a string" do
 
       let(:field) do

data/spec/mongoid/fields_spec.rb

@@ -309,6 +309,92 @@ describe Mongoid::Fields do
       end
     end
 
+    context "when providing a root Boolean type" do
+
+      let(:klass) do
+        Class.new do
+          include Mongoid::Document
+        end
+      end
+
+      it "converts to Mongoid::Boolean" do
+        expect(klass.field(:test, type: Boolean).type).to be(Mongoid::Boolean)
+      end
+    end
+
+    context "when using symbol types" do
+
+      let(:klass) do
+        Class.new do
+          include Mongoid::Document
+        end
+      end
+
+      it "converts :array to Array" do
+        expect(klass.field(:test, type: :array).type).to be(Array)
+      end
+
+      it "converts :big_decimal to BigDecimal" do
+        expect(klass.field(:test, type: :big_decimal).type).to be(BigDecimal)
+      end
+
+      it "converts :binary to BSON::Binary" do
+        expect(klass.field(:test, type: :binary).type).to be(BSON::Binary)
+      end
+
+      it "converts :boolean to Mongoid::Boolean" do
+        expect(klass.field(:test, type: :boolean).type).to be(Mongoid::Boolean)
+      end
+
+      it "converts :date to Date" do
+        expect(klass.field(:test, type: :date).type).to be(Date)
+      end
+
+      it "converts :date_time to DateTime" do
+        expect(klass.field(:test, type: :date_time).type).to be(DateTime)
+      end
+
+      it "converts :float to Float" do
+        expect(klass.field(:test, type: :float).type).to be(Float)
+      end
+
+      it "converts :hash to Hash" do
+        expect(klass.field(:test, type: :hash).type).to be(Hash)
+      end
+
+      it "converts :integer to Integer" do
+        expect(klass.field(:test, type: :integer).type).to be(Integer)
+      end
+
+      it "converts :object_id to BSON::ObjectId" do
+        expect(klass.field(:test, type: :object_id).type).to be(BSON::ObjectId)
+      end
+
+      it "converts :range to Range" do
+        expect(klass.field(:test, type: :range).type).to be(Range)
+      end
+
+      it "converts :regexp to Rexegp" do
+        expect(klass.field(:test, type: :regexp).type).to be(Regexp)
+      end
+
+      it "converts :set to Set" do
+        expect(klass.field(:test, type: :set).type).to be(Set)
+      end
+
+      it "converts :string to String" do
+        expect(klass.field(:test, type: :string).type).to be(String)
+      end
+
+      it "converts :symbol to Symbol" do
+        expect(klass.field(:test, type: :symbol).type).to be(Symbol)
+      end
+
+      it "converts :time to Time" do
+        expect(klass.field(:test, type: :time).type).to be(Time)
+      end
+    end
+
     context "when the options are valid" do
 
       context "when the options are all standard" do
@@ -729,11 +815,11 @@ describe Mongoid::Fields do
 
     context "when the field name conflicts with mongoid's internals" do
 
-      context "when the field is named metadata" do
+      context "when the field is named __metadata" do
 
         it "raises an error" do
           expect {
-            Person.field(:metadata)
+            Person.field(:__metadata)
           }.to raise_error(Mongoid::Errors::InvalidField)
         end
       end

data/spec/mongoid/log_subscriber_spec.rb

@@ -54,15 +54,15 @@ describe Mongoid::LogSubscriber do
         TestLogSubscriber.log_subscribers.pop
       end
 
-      it "pushes 2 log subscribers" do
-        expect(Mongoid::LogSubscriber.subscribers.size).to eq(2)
+      it "pushes the new log subscriber" do
+        expect(Mongoid::LogSubscriber.subscribers.last).to be_a TestLogSubscriber
       end
 
       context "when quering the database" do
 
         before do
           expect(subscribe).to receive(:debug).once
-          Band.all.to_a
+          PetOwner.all.to_a
         end
 
         it "sends operations logs to TestLogSubscriber" do

data/spec/mongoid/persistable/deletable_spec.rb

@@ -4,10 +4,23 @@ describe Mongoid::Persistable::Deletable do
 
   describe "#delete" do
 
-    let(:person) do
+    let!(:person) do
       Person.create
     end
 
+    context "when deleting a readonly document" do
+
+      let(:from_db) do
+        Person.only(:_id).first
+      end
+
+      it "raises an error" do
+        expect {
+          from_db.delete
+        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+      end
+    end
+
     context "when removing a root document" do
 
       let!(:deleted) do

data/spec/mongoid/persistable/destroyable_spec.rb

@@ -4,10 +4,23 @@ describe Mongoid::Persistable::Destroyable do
 
   describe "#destroy" do
 
-    let(:person) do
+    let!(:person) do
       Person.create
     end
 
+    context "when destroying a readonly document" do
+
+      let(:from_db) do
+        Person.only(:_id).first
+      end
+
+      it "raises an error" do
+        expect {
+          from_db.destroy
+        }.to raise_error(Mongoid::Errors::ReadonlyDocument)
+      end
+    end
+
     context "when removing a root document" do
 
       let!(:destroyd) do
@@ -102,6 +115,37 @@ describe Mongoid::Persistable::Destroyable do
     end
   end
 
+  describe "#destroy!" do
+
+    context "when no validation callback returns false" do
+
+      let(:person) do
+        Person.create
+      end
+
+      it "returns true" do
+        expect(person.destroy!).to eq(true)
+      end
+    end
+
+    context "when a validation callback returns false" do
+
+      let(:album) do
+        Album.create
+      end
+
+      before do
+        expect(album).to receive(:set_parent_name).and_return(false)
+      end
+
+      it "raises an exception" do
+        expect {
+          album.destroy!
+        }.to raise_error(Mongoid::Errors::DocumentNotDestroyed)
+      end
+    end
+  end
+
   describe "#destroy_all" do
 
     let!(:person) do

data/spec/mongoid/persistable/savable_spec.rb

@@ -94,11 +94,6 @@ describe Mongoid::Persistable::Savable do
         it "does not flag the excluded fields as dirty" do
           expect(limited.changes).to be_empty
         end
-
-        it "does not overwrite with the default" do
-          limited.save
-          expect(limited.reload.age).to eq(20)
-        end
       end
 
       context "when iterating over the documents" do
@@ -273,6 +268,23 @@ describe Mongoid::Persistable::Savable do
         end
       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
 
   describe "save!" do
@@ -428,5 +440,22 @@ 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/query_cache_spec.rb

@@ -0,0 +1,197 @@
+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 ].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
+    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