mongoid 5.4.1 → 6.1.1

data/spec/mongoid/criteria/modifiable_spec.rb

@@ -538,6 +538,135 @@ describe Mongoid::Criteria::Modifiable do
         it "sets the additional attributes" do
           expect(document.origin).to eq("Essex")
         end
+
+        context 'when attributes contain keys also in the criteria selector' do
+
+          context 'when the selector has symbol keys' do
+
+            context 'when the attributes use symbol keys' do
+
+              let(:document) do
+                Band.where(name: 'Tool').first_or_create(name: 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+
+            context 'when the attributes use string keys' do
+
+              let(:document) do
+                Band.where(name: 'Tool').first_or_create('name' => 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+          end
+
+          context 'when the selector has string keys' do
+
+            context 'when the attributes use symbol keys' do
+
+              let(:document) do
+                Band.where('name' => 'Tool').first_or_create(name: 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+
+            context 'when the attributes use string keys' do
+
+              let(:document) do
+                Band.where('name' => 'Tool').first_or_create('name' => 'Essex')
+              end
+
+              it 'uses the values from the attributes' do
+                expect(document.name).to eq('Essex')
+              end
+            end
+          end
+        end
+
+        context 'when the query criteria is on a hash attribute' do
+
+          let(:document) do
+            Person.where(map: { foo: :bar }).first_or_create
+          end
+
+          it 'uses the values from the attributes' do
+            expect(document.map).to eq({ foo: :bar })
+          end
+        end
+
+        context 'when the criteria has a selector with query operators' do
+
+          let(:document) do
+            Band.in(genres: ['Hiphop', 'Soul']).first_or_create(name: 'Smooth')
+          end
+
+          it 'does not create a document with the query operators' do
+            expect(document.attributes.keys).not_to include('genres')
+          end
+        end
+
+        context 'when the criteria has a nested selector with query operators' do
+
+          let(:band) do
+            record = Record.new(producers: ['testing'])
+            band = Band.create(records: [record])
+          end
+
+          let(:document) do
+            band.records.in(producers: ['nonexistent']).first_or_create(name: 'new-embedded-doc')
+            band.reload
+          end
+
+          it 'creates a new embedded document' do
+            expect(document.records.size).to eq(2)
+          end
+
+          it 'does not alter the existing embedded document' do
+            expect(document.records[0].producers).to eq(['testing'])
+          end
+
+          it 'does not create a document with the query operators as attributes' do
+            expect(document.records[1].producers).to be_nil
+          end
+
+          it 'applies the attribute to the new embedded document' do
+            expect(document.records[1].name).to eq('new-embedded-doc')
+          end
+        end
+
+        context 'when the criteria has a deeply-nested selector with query operators' do
+
+          let(:criteria) do
+            band = Band.create
+            Mongoid::Criteria.new(Record) do |criteria|
+              criteria.embedded = true
+              criteria.metadata = Band.reflect_on_association(:records)
+              criteria.parent_document = band
+              criteria.selector = { "records" => { "producers"=>{"$in"=>["nonexistent"] } } }
+            end
+          end
+
+          let(:document) do
+            criteria.first_or_create(name: 'new-record')
+          end
+
+          it 'does not create a document with the query operators' do
+            expect(document.attributes.keys).not_to include('producers')
+          end
+
+          it 'applies the attribute to the new embedded document' do
+            expect(document.name).to eq('new-record')
+          end
+        end
       end
 
       context "when attributes are not provided" do
@@ -736,6 +865,59 @@ describe Mongoid::Criteria::Modifiable do
           end
         end
       end
+
+      context 'when attributes contain keys also in the criteria selector' do
+
+        context 'when the selector has symbol keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_create!(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_create!('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+
+        context 'when the selector has string keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_create!(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_create!('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+      end
     end
   end
 
@@ -830,6 +1012,59 @@ describe Mongoid::Criteria::Modifiable do
           end
         end
       end
+
+      context 'when attributes contain keys also in the criteria selector' do
+
+        context 'when the selector has symbol keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_initialize(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where(name: 'Tool').first_or_initialize('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+
+        context 'when the selector has string keys' do
+
+          context 'when the attributes use symbol keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_initialize(name: 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+
+          context 'when the attributes use string keys' do
+
+            let(:document) do
+              Band.where('name' => 'Tool').first_or_initialize('name' => 'Essex')
+            end
+
+            it 'uses the values from the attributes' do
+              expect(document.name).to eq('Essex')
+            end
+          end
+        end
+      end
     end
   end
 
@@ -1275,8 +1510,7 @@ describe Mongoid::Criteria::Modifiable do
             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.username).to eq('Beet')
               expect(new_person.age).to eq(50)
             end
           end
@@ -1332,8 +1566,7 @@ describe Mongoid::Criteria::Modifiable do
         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.username).to eq('Turnip')
             expect(criteria.create_with(attrs).new.age).to eq(25)
           end
         end
@@ -1345,9 +1578,8 @@ describe Mongoid::Criteria::Modifiable do
           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)
+            expect(new_person.username).to eq('Beet')
+            expect(new_person.age).to eq(50)
           end
         end
       end

data/spec/mongoid/criteria/options_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Options do
+
+
+  context 'when a persistence context with options is set on the class of the criteria' do
+
+    let(:context) do
+      Band.with(connect_timeout: 10) do |klass|
+        klass.where(name: 'FKA Twigs').persistence_context
+      end
+    end
+
+    it 'uses the persistence context of the class of the criteria' do
+      expect(context.options).to eq({ connect_timeout: 10 })
+    end
+  end
+
+  context 'when a persistence context with options is not set on the class of the criteria' do
+
+    let(:context) do
+      Band.where(name: 'FKA Twigs').persistence_context
+    end
+
+    it 'uses the persistence context of the class of the criteria' do
+      expect(context.options).to eq({ })
+    end
+  end
+end

data/spec/mongoid/criteria/queryable/aggregable_spec.rb

@@ -0,0 +1,370 @@
+require "spec_helper"
+
+describe Mongoid::Criteria::Queryable::Aggregable do
+
+  let(:query) do
+    Mongoid::Query.new("id" => "_id", "alias" => "a")
+  end
+
+  shared_examples_for "an aggregable object" do
+
+    it "clones the queryable" do
+      expect(aggregation).to_not equal(query)
+    end
+
+    it "sets the aggrating flag" do
+      expect(aggregation).to be_aggregating
+    end
+  end
+
+  describe "#project" do
+
+    context "when no selection or options exist" do
+
+      let(:aggregation) do
+        query.project(author: 1, title: 0)
+      end
+
+      let!(:pipeline) do
+        aggregation.pipeline
+      end
+
+      it "sets the projection" do
+        expect(pipeline).to eq([
+          { "$project" => { "author" => 1, "title" => 0 }}
+        ])
+      end
+
+      it_behaves_like "an aggregable object"
+    end
+
+    context "when the field is aliased" do
+
+      let(:aggregation) do
+        query.project(id: 1, title: "$docTitle")
+      end
+
+      let!(:pipeline) do
+        aggregation.pipeline
+      end
+
+      it "sets the aliased projection" do
+        expect(pipeline).to eq([
+          { "$project" => { "_id" => 1, "title" => "$docTitle" }}
+        ])
+      end
+
+      it_behaves_like "an aggregable object"
+    end
+
+    context "when selection exists" do
+
+      let(:aggregation) do
+        query.where(name: "test").project(author: 1, title: 0)
+      end
+
+      let!(:pipeline) do
+        aggregation.pipeline
+      end
+
+      it "converts the selection to a $match" do
+        expect(pipeline).to eq([
+          { "$match" => { "name" => "test" }},
+          { "$project" => { "author" => 1, "title" => 0 }}
+        ])
+      end
+
+      it_behaves_like "an aggregable object"
+    end
+
+    context "when options exist" do
+
+      context "when the option is a sort" do
+
+        let(:aggregation) do
+          query.asc(:name).project(author: 1, title: 0)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "converts the option to a $sort" do
+          expect(pipeline).to eq([
+            { "$sort" => { "name" => 1 }},
+            { "$project" => { "author" => 1, "title" => 0 }}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when the option is a limit" do
+
+        let(:aggregation) do
+          query.limit(10).project(author: 1, title: 0)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "converts the option to a $sort" do
+          expect(pipeline).to eq([
+            { "$limit" => 10 },
+            { "$project" => { "author" => 1, "title" => 0 }}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when the option is a skip" do
+
+        let(:aggregation) do
+          query.skip(10).project(author: 1, title: 0)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "converts the option to a $sort" do
+          expect(pipeline).to eq([
+            { "$skip" => 10 },
+            { "$project" => { "author" => 1, "title" => 0 }}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+
+    context "when selection and options exist" do
+
+      let(:aggregation) do
+        query.skip(10).where(name: "test").project(author: 1, title: 0)
+      end
+
+      let!(:pipeline) do
+        aggregation.pipeline
+      end
+
+      it "converts the option to a $sort" do
+        expect(pipeline).to eq([
+          { "$match" => { "name" => "test" }},
+          { "$skip" => 10 },
+          { "$project" => { "author" => 1, "title" => 0 }}
+        ])
+      end
+
+      it_behaves_like "an aggregable object"
+    end
+  end
+
+  describe "#unwind" do
+
+    context "when another pipeline operation exists" do
+
+      let(:aggregation) do
+        query.project(name: 1).unwind(:author)
+      end
+
+      let!(:pipeline) do
+        aggregation.pipeline
+      end
+
+      it "adds the unwind to the pipeline" do
+        expect(pipeline).to eq([
+          { "$project" => { "name" => 1 }},
+          { "$unwind" => "$author" }
+        ])
+      end
+
+      it_behaves_like "an aggregable object"
+    end
+
+    context "when provided a symbol" do
+
+      context "when the symbol begins with $" do
+
+        let(:aggregation) do
+          query.unwind(:$author)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "converts the symbol to a string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when the symbol does not begin with $" do
+
+        let(:aggregation) do
+          query.unwind(:author)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "converts the symbol to a string and prepends $" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+
+    context "when provided a string" do
+
+      context "when the string begins with $" do
+
+        let(:aggregation) do
+          query.unwind("$author")
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "sets the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when the string does not begin with $" do
+
+        let(:aggregation) do
+          query.unwind(:author)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "prepends $ to the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$author" }])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+
+    context "when provided a string alias" do
+
+      context "when the string does not begin with $" do
+
+        let(:aggregation) do
+          query.unwind(:alias)
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "prepends $ to the string" do
+          expect(pipeline).to eq([{ "$unwind" => "$a" }])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+  end
+
+  describe "#group" do
+
+    context "when the expression fields are not aliased" do
+
+      context "when using full notation" do
+
+        let(:aggregation) do
+          query.group(count: { "$sum" => 1 }, max: { "$max" => "likes" })
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "adds the group operation to the pipeline" do
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when using symbol shortcuts" do
+
+        let(:aggregation) do
+          query.group(:count.sum => 1, :max.max => "likes")
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "adds the group operation to the pipeline" do
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "likes" }}}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+
+    context "when the expression fields are aliased" do
+
+      context "when using full notation" do
+
+        let(:aggregation) do
+          query.group(count: { "$sum" => 1 }, max: { "$max" => "alias" })
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "adds the group operation to the pipeline" do
+          pending
+          fail
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "a" }}}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+
+      context "when using symbol shortcuts" do
+
+        let(:aggregation) do
+          query.group(:count.sum => 1, :max.max => "alias")
+        end
+
+        let!(:pipeline) do
+          aggregation.pipeline
+        end
+
+        it "adds the group operation to the pipeline" do
+          pending
+          fail
+          expect(pipeline).to eq([
+            { "$group" => { "count" => { "$sum" => 1 }, "max" => { "$max" => "a" }}}
+          ])
+        end
+
+        it_behaves_like "an aggregable object"
+      end
+    end
+  end
+end