mongoid 5.0.2 → 5.1.0

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -437,4 +437,23 @@ describe Mongoid::Contextual::GeoNear do
       expect(geo_near.time).to_not be_nil
     end
   end
+
+  describe "#empty_and_chainable" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    let(:criteria) do
+      Bar.all
+    end
+
+    let(:geo_near) do
+      described_class.new(collection, criteria, [ 52, 13 ])
+    end
+
+    it "returns true" do
+      expect(geo_near.empty_and_chainable?).to be(true)
+    end
+  end
 end

data/spec/mongoid/criteria/findable_spec.rb

@@ -54,6 +54,17 @@ describe Mongoid::Criteria::Findable do
           it "returns the matching document" do
             expect(found).to eq(band)
           end
+
+          context "when finding by a JSON-dumped id" do
+
+            let(:found) do
+              Band.find(JSON.load(JSON.dump(band.id)))
+            end
+
+            it "properly parses the id format" do
+              expect(found).to eq(band)
+            end
+          end
         end
 
         context "when the id does not match" do

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -1227,4 +1227,130 @@ describe Mongoid::Criteria::Modifiable do
       end
     end
   end
+
+  describe '#create_with' do
+
+    context 'when called on the class' do
+
+      let(:attrs) do
+        { 'username' => 'Turnip' }
+      end
+
+      it 'returns a criteria with the defined attributes' do
+        expect(Person.create_with(attrs).selector).to eq(attrs)
+      end
+
+      context 'when a method is chained' do
+
+        context 'when a write method is chained' do
+
+          it 'executes the method' do
+            expect(Person.create_with(attrs).new.username).to eq('Turnip')
+          end
+        end
+
+        context 'when a write method is chained' do
+
+          let(:query) do
+            { 'age' => 50 }
+          end
+
+          let(:new_person) do
+            Person.create_with(attrs).find_or_create_by(query)
+          end
+
+          it 'executes the write' do
+            expect(new_person.username).to eq('Turnip')
+            expect(new_person.age).to eq(50)
+          end
+
+          context 'when the attributes are shared with the write method args' do
+
+            let(:query) do
+              { 'username' => 'Beet', 'age' => 50 }
+            end
+
+            let(:new_person) do
+              Person.create_with(attrs).find_or_create_by(query)
+            end
+
+            it 'gives the write method args precedence' do
+              #  @todo: uncomment when MONGOID-4193 is closed
+              #expect(new_person.username).to eq('Beet')
+              expect(new_person.age).to eq(50)
+            end
+          end
+        end
+      end
+    end
+
+    context 'when called on a criteria' do
+
+      let(:criteria_selector) do
+        { 'username' => 'Artichoke', 'age' => 25 }
+      end
+
+      let(:criteria) do
+        Person.where(criteria_selector)
+      end
+
+      context 'when the original criteria shares attributes with the attribute args' do
+
+        context 'when all the original attributes are shared with the new attributes' do
+
+          let(:attrs) do
+            { 'username' => 'Beet', 'age' => 50 }
+          end
+
+          it 'overwrites all the original attributes' do
+            expect(criteria.create_with(attrs).selector).to eq(attrs)
+          end
+        end
+      end
+
+      context 'when only some of the original attributes are shared with the attribute args' do
+
+        let(:attrs) do
+          { 'username' => 'Beet' }
+        end
+
+        it 'only overwrites the shared attributes' do
+          expect(criteria.create_with(attrs).selector).to eq(criteria_selector.merge!(attrs))
+        end
+      end
+
+      context 'when a method is chained' do
+
+        let(:attrs) do
+          { 'username' => 'Turnip' }
+        end
+
+        let(:query) do
+          { 'username' => 'Beet', 'age' => 50 }
+        end
+
+        context 'when a write method is chained' do
+
+          it 'executes the method' do
+            #  @todo: uncomment when MONGOID-4193 is closed
+            #expect(criteria.create_with(attrs).new.username).to eq('Beet')
+            expect(criteria.create_with(attrs).new.age).to eq(25)
+          end
+        end
+
+        context 'when a write method is chained' do
+
+          let(:new_person) do
+            criteria.create_with(attrs).find_or_create_by(query)
+          end
+
+          it 'executes the query' do
+            #  @todo: uncomment when MONGOID-4193 is closed
+            #expect(new_person.username).to eq('Beet')
+            #expect(new_person.age).to eq(50)
+          end
+        end
+      end
+    end
+  end
 end

data/spec/mongoid/criteria_spec.rb

@@ -1147,12 +1147,72 @@ describe Mongoid::Criteria do
       end
     end
 
-    context "when providing a hash" do
+    context "when providing a list of associations" do
 
-      it "raises an error" do
-        expect {
-          Person.includes(preferences: :members)
-        }.to raise_error(Mongoid::Errors::InvalidIncludes)
+      let!(:user) do
+        User.create(posts: [ post1 ], descriptions: [ description1 ])
+      end
+
+      let!(:post1) do
+        Post.create
+      end
+
+      let!(:description1) do
+        Description.create(details: 1)
+      end
+
+      let(:result) do
+        User.includes(:posts, :descriptions).first
+      end
+
+      it "executes the query" do
+        expect(result).to eq(user)
+      end
+
+      it "includes the related objects" do
+        expect(result.posts).to eq([ post1 ])
+        expect(result.descriptions).to eq([ description1 ])
+      end
+    end
+
+    context "when providing a nested association" do
+
+      let!(:user) do
+        User.create
+      end
+
+      before do
+        p = Post.create(alerts: [ Alert.create ])
+        user.posts = [ p ]
+        user.save
+      end
+
+      let(:result) do
+        User.includes(:posts => [:alerts]).first
+      end
+
+      it "executes the query" do
+        expect(result).to eq(user)
+      end
+
+      it "includes the related objects" do
+        expect(result.posts.size).to eq(1)
+        expect(result.posts.first.alerts.size).to eq(1)
+      end
+    end
+
+    context "when providing a deeply nested association" do
+
+      let!(:user) do
+        User.create
+      end
+
+      let(:results) do
+        User.includes(:posts => [{ :alerts => :items }]).to_a
+      end
+
+      it "executes the query" do
+        expect(results.first).to eq(user)
       end
     end
 
@@ -1759,6 +1819,22 @@ describe Mongoid::Criteria do
         person.preferences.create(name: "two")
       end
 
+      context "when one of the related items is deleted" do
+
+        before do
+          person.preferences = [ preference_one, preference_two ]
+          preference_two.delete
+        end
+
+        let(:criteria) do
+          Person.where(id: person.id).includes(:preferences)
+        end
+
+        it "only loads the existing related items" do
+          expect(criteria.entries.first.preferences).to eq([ preference_one ])
+        end
+      end
+
       context "when the criteria has no options" do
 
         let!(:criteria) do

data/spec/mongoid/document_spec.rb

@@ -441,6 +441,62 @@ describe Mongoid::Document do
     end
   end
 
+  describe "#as_json" do
+
+    let!(:person) do
+      Person.new(title: "Sir")
+    end
+
+    context "when no options are provided" do
+
+      it "does not apply any options" do
+        expect(person.as_json["title"]).to eq("Sir")
+        expect(person.as_json["age"]).to eq(100)
+      end
+
+      context "when options for the super method are provided" do
+
+        let(:options) do
+          { only: :title }
+        end
+
+        it "passes the options through to the super method" do
+          expect(person.as_json(options)["title"]).to eq("Sir")
+          expect(person.as_json(options).keys).not_to include("age")
+        end
+      end
+    end
+
+    context "when the Mongoid-specific options are provided" do
+
+      let(:options) do
+        { compact: true }
+      end
+
+      it "applies the Mongoid-specific options" do
+        expect(person.as_json(options)["title"]).to eq("Sir")
+        expect(person.as_json(options)["age"]).to eq(100)
+        expect(person.as_json(options).keys).not_to include("lunch_time")
+      end
+
+      context "when options for the super method are provided" do
+
+        let(:options) do
+          { compact: true, only: [:title, :pets, :ssn] }
+        end
+
+        it "passes the options through to the super method" do
+          expect(person.as_json(options)["title"]).to eq("Sir")
+          expect(person.as_json(options)["pets"]).to eq(false)
+        end
+
+        it "applies the Mongoid-specific options" do
+          expect(person.as_json(options).keys).not_to include("ssn")
+        end
+      end
+    end
+  end
+
   describe "#as_document" do
 
     let!(:person) do

data/spec/mongoid/fields/foreign_key_spec.rb

@@ -444,6 +444,29 @@ describe Mongoid::Fields::ForeignKey do
         end
       end
     end
+
+    context "when the metadata is polymoprhic" do
+
+      let(:metadata) do
+        Agent.reflect_on_association(:names)
+      end
+
+      let(:field) do
+        described_class.new(:nameable_id, type: Object, metadata: metadata)
+      end
+
+      let(:value) do
+        BSON::ObjectId.new().to_s
+      end
+
+      let(:evolved) do
+        field.evolve(value)
+      end
+
+      it "does not change the foreign key" do
+        expect(evolved).to be(value)
+      end
+    end
   end
 
   describe "#lazy?" do

data/spec/mongoid/fields/localized_spec.rb

@@ -269,32 +269,50 @@ describe Mongoid::Fields::Localized do
                 ::I18n.fallbacks[:de] = [ :de, :en, :es ]
               end
 
-              context "when the first fallback translation exists" do
+              context 'when fallbacks are enabled' do
 
-                let(:value) do
-                  field.demongoize({ "en" => 1 })
-                end
+                context "when the first fallback translation exists" do
 
-                it "returns the fallback translation" do
-                  expect(value).to eq(1)
+                  let(:value) do
+                    field.demongoize({ "en" => 1 })
+                  end
+
+                  it "returns the fallback translation" do
+                    expect(value).to eq(1)
+                  end
                 end
-              end
 
-              context "when another fallback translation exists" do
+                context "when another fallback translation exists" do
 
-                let(:value) do
-                  field.demongoize({ "es" => 100 })
+                  let(:value) do
+                    field.demongoize({ "es" => 100 })
+                  end
+
+                  it "returns the fallback translation" do
+                    expect(value).to eq(100)
+                  end
                 end
 
-                it "returns the fallback translation" do
-                  expect(value).to eq(100)
+                context "when the fallback translation does not exist" do
+
+                  let(:value) do
+                    field.demongoize({ "fr" => 50 })
+                  end
+
+                  it "returns nil" do
+                    expect(value).to be_nil
+                  end
                 end
               end
 
-              context "when the fallback translation does not exist" do
+              context 'when fallbacks are disabled' do
+
+                let(:field) do
+                  described_class.new(:description, localize: true, type: Integer, fallbacks: false)
+                end
 
                 let(:value) do
-                  field.demongoize({ "fr" => 50 })
+                  field.demongoize({ "es" => 100 })
                 end
 
                 it "returns nil" do

data/spec/mongoid/matchable_spec.rb

@@ -149,7 +149,8 @@ describe Mongoid::Matchable do
         Address.new(
           services: ["first", "second", "third"],
           number: 100,
-          map: { key: "value" }
+          map: { key: "value" },
+          street: "Clarkenwell Road"
         )
       end
 
@@ -303,6 +304,131 @@ describe Mongoid::Matchable do
         end
       end
 
+      context "with a $not selector" do
+
+        context "regexes" do
+
+          context "when the predicate matches" do
+
+            let(:selector) do
+              {
+                street: {"$not" => /Avenue/}
+              }
+            end
+
+            it "returns true" do
+              expect(document.matches?(selector)).to be true
+            end
+          end
+
+          context "when the predicate does not match" do
+
+            let(:selector) do
+              {
+                street: {"$not" => /Road/}
+              }
+            end
+
+            it "returns false" do
+              expect(document.matches?(selector)).to be false
+            end
+          end
+        end
+
+        context "other operators" do
+
+          context "numerical comparisons" do
+
+            context "$lt and $gt" do
+
+              context "when the predicate matches" do
+
+                let(:selector) do
+                  {
+                    number: {"$not" => {"$lt" => 0}}
+                  }
+                end
+
+                it "returns true" do
+                  expect(document.matches?(selector)).to be true
+                end
+              end
+
+              context "when the predicate does not match" do
+
+                let(:selector) do
+                  {
+                    number: {"$not" => {"$gt" => 50}}
+                  }
+                end
+
+                it "returns false" do
+                  expect(document.matches?(selector)).to be false
+                end
+              end
+            end
+
+            context "$in" do
+
+              context "when the predicate matches" do
+
+                let(:selector) do
+                  {
+                    number: {"$not" => {"$in" => [10]}}
+                  }
+                end
+
+                it "returns true" do
+                  expect(document.matches?(selector)).to be true
+                end
+              end
+
+              context "when the predicate does not match" do
+
+                let(:selector) do
+                  {
+                    number: {"$not" => {"$in" => [100]}}
+                  }
+                end
+
+                it "returns false" do
+                  expect(document.matches?(selector)).to be false
+                end
+              end
+            end
+          end
+        end
+
+        context "symbol keys" do
+
+          context "when the predicate matches" do
+
+            let(:selector) do
+              {
+                street: {:$not => /Avenue/}
+              }
+            end
+
+            it "returns true" do
+              expect(document.matches?(selector)).to be true
+            end
+          end
+
+          context "when the predicate does not match" do
+
+            let(:selector) do
+              {
+                street: {:$not => /Road/}
+              }
+            end
+
+            it "returns false" do
+              expect(document.matches?(selector)).to be false
+            end
+          end
+        end
+      end
+
       context "with an $in selector" do
 
         context "when the attributes match" do