mongoid 7.4.0 → 8.0.1

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

@@ -142,107 +142,6 @@ describe Mongoid::Criteria::Queryable::Optional do
           it_behaves_like "a cloning option"
         end
       end
-
-      context "when using the mongo-1.x driver syntax" do
-
-        let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
-        end
-
-        context "when provided symbols" do
-
-          let(:selection) do
-            query.send(method, :field_one, :field_two)
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ :field_one, 1 ], [ :field_two, 1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided an array of symbols" do
-
-          let(:selection) do
-            query.send(method, [ :field_one, :field_two ])
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ :field_one, 1 ], [ :field_two, 1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided strings" do
-
-          let(:selection) do
-            query.send(method, "field_one", "field_two")
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ "field_one", 1 ], [ "field_two", 1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided an array of strings" do
-
-          let(:selection) do
-            query.send(method, [ "field_one", "field_two" ])
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ "field_one", 1 ], [ "field_two", 1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided no options" do
-
-          let(:selection) do
-            query.send(method)
-          end
-
-          it "does not add any sorting criteria" do
-            expect(selection.options).to be_empty
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided nil" do
-
-          let(:selection) do
-            query.send(method, nil)
-          end
-
-          it "does not add any sorting criteria" do
-            expect(selection.options).to be_empty
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-      end
     end
   end
 
@@ -415,107 +314,6 @@ describe Mongoid::Criteria::Queryable::Optional do
           it_behaves_like "a cloning option"
         end
       end
-
-      context "when using the mongo-1.x driver syntax" do
-
-        let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
-        end
-
-        context "when provided symbols" do
-
-          let(:selection) do
-            query.send(method, :field_one, :field_two)
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ :field_one, -1 ], [ :field_two, -1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided an array of symbols" do
-
-          let(:selection) do
-            query.send(method, [ :field_one, :field_two ])
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ :field_one, -1 ], [ :field_two, -1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided strings" do
-
-          let(:selection) do
-            query.send(method, "field_one", "field_two")
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ "field_one", -1 ], [ "field_two", -1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided an array of strings" do
-
-          let(:selection) do
-            query.send(method, [ "field_one", "field_two" ])
-          end
-
-          it "adds the sorting criteria" do
-            expect(selection.options).to eq(
-              { sort: [[ "field_one", -1 ], [ "field_two", -1 ]]}
-            )
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided no options" do
-
-          let(:selection) do
-            query.send(method)
-          end
-
-          it "does not add any sorting criteria" do
-            expect(selection.options).to be_empty
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided nil" do
-
-          let(:selection) do
-            query.send(method, nil)
-          end
-
-          it "does not add any sorting criteria" do
-            expect(selection.options).to be_empty
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-      end
     end
   end
 
@@ -1172,288 +970,6 @@ describe Mongoid::Criteria::Queryable::Optional do
           it_behaves_like "a cloning option"
         end
       end
-
-      context "when using the mongo-1.x driver syntax" do
-
-        let(:query) do
-          Mongoid::Query.new({}, {}, :mongo1x)
-        end
-
-        context "when provided a hash" do
-
-          context "when the hash has integer values" do
-
-            let(:selection) do
-              query.send("#{method}", field_one: 1, field_two: -1)
-            end
-
-            it "adds the sorting criteria" do
-              expect(selection.options).to eq(
-                { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-              )
-            end
-
-            it_behaves_like "a cloning option"
-          end
-
-          context "when the hash has symbol values" do
-
-            let(:selection) do
-              query.send("#{method}", field_one: :asc, field_two: :desc)
-            end
-
-            it "adds the sorting criteria" do
-              expect(selection.options).to eq(
-                { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-              )
-            end
-
-            it_behaves_like "a cloning option"
-          end
-
-          context "when the hash has string values" do
-
-            let(:selection) do
-              query.send("#{method}", field_one: "asc", field_two: "desc")
-            end
-
-            it "adds the sorting criteria" do
-              expect(selection.options).to eq(
-                { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-              )
-            end
-
-            it_behaves_like "a cloning option"
-          end
-        end
-
-        context "when provided an array" do
-
-          context "when the array is multi-dimensional" do
-
-            context "when the arrays have integer values" do
-
-              let(:selection) do
-                query.send("#{method}", [[ :field_one, 1 ],[ :field_two, -1 ]])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when the arrays have symbol values" do
-
-              let(:selection) do
-                query.send("#{method}", [[ :field_one, :asc ],[ :field_two, :desc ]])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when the arrays have string values" do
-
-              let(:selection) do
-                query.send("#{method}", [[ :field_one, "asc" ],[ :field_two, "desc" ]])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-          end
-
-          context "when the array is selectable keys" do
-
-            let(:selection) do
-              query.send("#{method}", [ :field_one.asc, :field_two.desc ])
-            end
-
-            it "adds the sorting criteria" do
-              expect(selection.options).to eq(
-                { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-              )
-            end
-
-            it_behaves_like "a cloning option"
-          end
-        end
-
-        context "when provided values" do
-
-          context "when the values are arrays" do
-
-            context "when the values have integer directions" do
-
-              let(:selection) do
-                query.send("#{method}", [ :field_one, 1 ],[ :field_two, -1 ])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when the values have symbol directions" do
-
-              let(:selection) do
-                query.send("#{method}", [ :field_one, :asc ],[ :field_two, :desc ])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when the values have string directions" do
-
-              let(:selection) do
-                query.send("#{method}", [ :field_one, "asc" ],[ :field_two, "desc" ])
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-          end
-
-          context "when the values are selectable keys" do
-
-            let(:selection) do
-              query.send("#{method}", :field_one.asc, :field_two.desc)
-            end
-
-            it "adds the sorting criteria" do
-              expect(selection.options).to eq(
-                { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-              )
-            end
-
-            it_behaves_like "a cloning option"
-          end
-        end
-
-        context "when provided a string" do
-
-          context "when the direction is lowercase" do
-
-            context "when abbreviated" do
-
-              let(:selection) do
-                query.send("#{method}", "field_one asc, field_two desc")
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when spelled out" do
-
-              let(:selection) do
-                query.send("#{method}", "field_one ascending, field_two descending")
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-          end
-
-          context "when the direction is uppercase" do
-
-            context "when abbreviated" do
-
-              let(:selection) do
-                query.send("#{method}", "field_one ASC, field_two DESC")
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-
-            context "when spelled out" do
-
-              let(:selection) do
-                query.send("#{method}", "field_one ASCENDING, field_two DESCENDING")
-              end
-
-              it "adds the sorting criteria" do
-                expect(selection.options).to eq(
-                  { sort: [[ :field_one, 1 ], [ :field_two, -1 ]]}
-                )
-              end
-
-              it_behaves_like "a cloning option"
-            end
-          end
-        end
-
-        context "when provided no options" do
-
-          let(:selection) do
-            query.order_by
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-
-        context "when provided nil" do
-
-          let(:selection) do
-            query.send("#{method}", nil)
-          end
-
-          it "returns the query" do
-            expect(selection).to eq(query)
-          end
-
-          it_behaves_like "a cloning option"
-        end
-      end
     end
   end
 

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

@@ -1344,6 +1344,34 @@ describe Mongoid::Criteria::Queryable::Selectable do
           )
         end
       end
+
+      context 'when any_of has multiple arguments' do
+
+        let(:selection) do
+          query.or(field: [ 1, 2 ]).where(foo: 'bar').any_of({a: 1}, {b: 2})
+        end
+
+        it 'adds the new condition to top level' do
+          expect(selection.selector).to eq(
+            '$or' => [{'field' => [1, 2]}],
+            'foo' => 'bar',
+            '$and' => [{'$or' => [{'a' => 1}, {'b' => 2}]}],
+          )
+        end
+
+        context 'when query already has a top-level $and' do
+          let(:selection) do
+            query.or(field: [ 1, 2 ]).where('$and' => [foo: 'bar']).any_of({a: 1}, {b: 2})
+          end
+
+          it 'adds the new condition to top level $and' do
+            expect(selection.selector).to eq(
+              '$or' => [{'field' => [1, 2]}],
+              '$and' => [{'foo' => 'bar'}, {'$or' => [{'a' => 1}, {'b' => 2}]}],
+            )
+          end
+        end
+      end
     end
 
     context "when provided multiple criteria" do
@@ -2065,5 +2093,27 @@ describe Mongoid::Criteria::Queryable::Selectable do
         end
       end
     end
+
+    # This test confirms that MONGOID-5097 has been repaired.
+    context "when using exists on a field of type Time" do
+      let(:criteria) do
+        Dictionary.any_of({:published.exists => true}, published: nil)
+      end
+
+      it "doesn't raise an error" do
+        expect do
+          criteria
+        end.to_not raise_error
+      end
+
+      it "generates the correct selector" do
+        expect(criteria.selector).to eq({
+          "$or" => [ {
+            "published" => { "$exists" => true }
+          }, {
+            "published" => nil
+          } ] } )
+      end
+    end
   end
 end