mongoid 7.2.1 → 9.0.0

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -72,12 +72,8 @@ describe String do
 
     context "when the string without timezone" do
 
-      context "when using active support's time zone" do
-
-        before do
-          Mongoid.use_activesupport_time_zone = true
-          ::Time.zone = "Tokyo"
-        end
+      context "when setting ActiveSupport time zone" do
+        time_zone_override "Tokyo"
 
         let(:date) do
           "2010-01-01 5:00:00"
@@ -91,26 +87,6 @@ describe String do
           expect(evolved).to eq(Time.zone.parse(date).utc)
         end
       end
-
-      context "when not using active support's time zone" do
-
-        before do
-          Mongoid.use_activesupport_time_zone = false
-          ::Time.zone = nil
-        end
-
-        let(:date) do
-          "2010-01-01 5:00:00"
-        end
-
-        let(:evolved) do
-          date.__evolve_time__
-        end
-
-        it "parses string using system time zone" do
-          expect(evolved).to eq(Time.parse(date).utc)
-        end
-      end
     end
   end
 
@@ -205,143 +181,83 @@ describe String do
     end
   end
 
-  describe "#__expr_part__" do
-
-    let(:specified) do
-      "field".__expr_part__(10)
-    end
-
-    it "returns the string with the value" do
-      expect(specified).to eq({ "field" => 10 })
-    end
-
-    context "with a regexp" do
-
-      let(:specified) do
-        "field".__expr_part__(/test/)
-      end
-
-      it "returns the symbol with the value" do
-        expect(specified).to eq({ "field" => /test/ })
-      end
-
-    end
-
-    context "when negated" do
-
-      context "with a regexp" do
-
-        let(:specified) do
-          "field".__expr_part__(/test/, true)
-        end
-
-        it "returns the string with the value negated" do
-          expect(specified).to eq({ "field" => { "$not" => /test/ } })
-        end
-
-      end
-
-      context "with anything else" do
-
-        let(:specified) do
-          "field".__expr_part__('test', true)
-        end
-
-        it "returns the string with the value negated" do
-          expect(specified).to eq({ "field" => { "$ne" => "test" }})
-        end
-      end
-    end
-  end
-
-  describe "#to_direction" do
+  describe '#__expr_part__' do
+    subject(:specified) { 'field'.__expr_part__(value) }
+    let(:value) { 10 }
 
-    context "when ascending" do
-
-      it "returns 1" do
-        expect("ascending".to_direction).to eq(1)
-      end
+    it 'returns the expression with the value' do
+      expect(specified).to eq({ 'field' => 10 })
     end
 
-    context "when asc" do
+    context 'with a Regexp' do
+      let(:value) { /test/ }
 
-      it "returns 1" do
-        expect("asc".to_direction).to eq(1)
+      it 'returns the expression with the value' do
+        expect(specified).to eq({ 'field' => /test/ })
       end
     end
 
-    context "when ASCENDING" do
+    context 'with a BSON::Regexp::Raw' do
+      let(:value) { BSON::Regexp::Raw.new('^[123]') }
 
-      it "returns 1" do
-        expect("ASCENDING".to_direction).to eq(1)
+      it 'returns the expression with the value' do
+        expect(specified).to eq({ 'field' => BSON::Regexp::Raw.new('^[123]') })
       end
     end
 
-    context "when ASC" do
+    context 'when negated' do
+      subject(:specified) { 'field'.__expr_part__(value, true) }
 
-      it "returns 1" do
-        expect("ASC".to_direction).to eq(1)
-      end
-    end
+      context 'with a Regexp' do
+        let(:value) { /test/ }
 
-    context "when descending" do
-
-      it "returns -1" do
-        expect("descending".to_direction).to eq(-1)
-      end
-    end
-
-    context "when desc" do
-
-      it "returns -1" do
-        expect("desc".to_direction).to eq(-1)
+        it 'returns the expression with the value negated' do
+          expect(specified).to eq({ 'field' => { '$not' => /test/ } })
+        end
       end
-    end
 
-    context "when DESCENDING" do
+      context 'with a BSON::Regexp::Raw' do
+        let(:value) { BSON::Regexp::Raw.new('^[123]') }
 
-      it "returns -1" do
-        expect("DESCENDING".to_direction).to eq(-1)
+        it 'returns the expression with the value' do
+          expect(specified).to eq({ 'field' => { '$not' => BSON::Regexp::Raw.new('^[123]') } })
+        end
       end
-    end
 
-    context "when DESC" do
+      context 'with anything else' do
+        let(:value) { 'test' }
 
-      it "returns -1" do
-        expect("DESC".to_direction).to eq(-1)
+        it 'returns the expression with the value negated' do
+          expect(specified).to eq({ 'field' => { '$ne' => 'test' }})
+        end
       end
     end
   end
 
-  describe ".evolve" do
+  describe '.evolve' do
+    subject(:evolved) { described_class.evolve(object) }
 
-    context "when provided a regex" do
+    context 'when provided a Regexp' do
+      let(:object) { /\A[123]/.freeze }
 
-      let(:regex) do
-        /\A[123]/.freeze
-      end
-
-      let(:evolved) do
-        described_class.evolve(regex)
-      end
-
-      it "returns the regex" do
-        expect(evolved).to eq(regex)
+      it 'returns the regexp' do
+        expect(evolved).to eq(/\A[123]/)
       end
     end
 
-    context "when provided an object" do
+    context 'when provided a BSON::Regexp::Raw' do
+      let(:object) { BSON::Regexp::Raw.new('^[123]') }
 
-      let(:object) do
-        1234
+      it 'returns the BSON::Regexp::Raw' do
+        expect(evolved).to eq(BSON::Regexp::Raw.new('^[123]'))
       end
+    end
 
-      let(:evolved) do
-        described_class.evolve(object)
-      end
+    context 'when provided an object' do
+      let(:object) { 1234 }
 
-      it "returns the object as a string" do
-        expect(evolved).to eq("1234")
+      it 'returns the object as a string' do
+        expect(evolved).to eq('1234')
       end
     end
   end

data/spec/mongoid/criteria/queryable/extensions/symbol_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -13,6 +13,10 @@ describe Symbol do
       end
     end
 
+    after do
+      Symbol.undef_method(:fubar)
+    end
+
     let(:fubar) do
       :testing.fubar
     end
@@ -108,63 +112,4 @@ describe Symbol do
       end
     end
   end
-
-  describe "#to_direction" do
-
-    context "when ascending" do
-
-      it "returns 1" do
-        expect(:ascending.to_direction).to eq(1)
-      end
-    end
-
-    context "when asc" do
-
-      it "returns 1" do
-        expect(:asc.to_direction).to eq(1)
-      end
-    end
-
-    context "when ASCENDING" do
-
-      it "returns 1" do
-        expect(:ASCENDING.to_direction).to eq(1)
-      end
-    end
-
-    context "when ASC" do
-
-      it "returns 1" do
-        expect(:ASC.to_direction).to eq(1)
-      end
-    end
-
-    context "when descending" do
-
-      it "returns -1" do
-        expect(:descending.to_direction).to eq(-1)
-      end
-    end
-
-    context "when desc" do
-
-      it "returns -1" do
-        expect(:desc.to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESCENDING" do
-
-      it "returns -1" do
-        expect(:DESCENDING.to_direction).to eq(-1)
-      end
-    end
-
-    context "when DESC" do
-
-      it "returns -1" do
-        expect(:DESC.to_direction).to eq(-1)
-      end
-    end
-  end
 end

data/spec/mongoid/criteria/queryable/extensions/time_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "lite_spec_helper"
 
@@ -344,6 +344,17 @@ describe Time do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do

data/spec/mongoid/criteria/queryable/extensions/time_with_zone_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -317,6 +317,17 @@ describe ActiveSupport::TimeWithZone do
       end
     end
 
+    context "when provided an invalid string" do
+
+      let(:evolved) do
+        described_class.evolve("bogus")
+      end
+
+      it "returns that string" do
+        expect(evolved).to eq("bogus")
+      end
+    end
+
     context "when provided nil" do
 
       it "returns nil" do

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require "spec_helper"
 
@@ -44,7 +44,7 @@ describe Mongoid::Criteria::Queryable::Mergeable do
 
   describe '#_mongoid_expand_keys' do
     it 'expands simple keys' do
-      query.send(:_mongoid_expand_keys, {a: 1}).should == {a: 1}
+      query.send(:_mongoid_expand_keys, {a: 1}).should == {'a' => 1}
     end
 
     let(:gt) do
@@ -68,18 +68,116 @@ describe Mongoid::Criteria::Queryable::Mergeable do
         'age' => {'$gt' => 42, '$lt' => 50}}
     end
 
-    it 'expands simple and Key instances on the same field' do
-      query.send(:_mongoid_expand_keys, {'age' => 42, lt => 50}).should == {
-        'age' => {'$eq' => 42, '$lt' => 50}}
+    context 'given implicit equality and Key instance on the same field' do
+      [42, 'infinite', [nil]].each do |value|
+        context "for non-regular expression value #{value}" do
+          context 'implicit equality then Key instance' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {'age' => value, lt => 50}).should == {
+                'age' => {'$eq' => value, '$lt' => 50}}
+            end
+          end
+
+          context 'symbol operator then implicit equality' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {gt => 42, 'age' => value}).should == {
+                'age' => {'$gt' => 42, '$eq' => value}}
+            end
+          end
+        end
+      end
     end
 
-    it 'expands Key and simple instances on the same field' do
-      query.send(:_mongoid_expand_keys, {gt => 42, 'age' => 50}).should == {
-        'age' => {'$gt' => 42, '$eq' => 50}}
+    context 'given implicit equality with Regexp argument and Key instance on the same field' do
+      [/42/, BSON::Regexp::Raw.new('42')].each do |value|
+        context "for regular expression value #{value}" do
+          context 'implicit equality then Key instance' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {'age' => value, lt => 50}).should == {
+                'age' => {'$regex' => value, '$lt' => 50}}
+            end
+          end
+
+          context 'Key instance then implicit equality' do
+            it 'expands implicit equality with $eq and combines with Key operator' do
+              query.send(:_mongoid_expand_keys, {gt => 50, 'age' => value}).should == {
+                'age' => {'$gt' => 50, '$regex' => value}}
+            end
+          end
+        end
+      end
     end
 
     it 'Ruby does not allow same symbol operator with different values' do
       {gt => 42, gtp => 50}.should == {gtp => 50}
     end
+
+    let(:expanded) do
+      query.send(:_mongoid_expand_keys, condition)
+    end
+
+    context 'field name => value' do
+      shared_examples_for 'expands' do
+
+        it 'expands' do
+          expanded.should == {'foo' => 'bar'}
+        end
+      end
+
+      context 'string key' do
+        let(:condition) do
+          {'foo' => 'bar'}
+        end
+
+        it_behaves_like 'expands'
+      end
+
+      context 'symbol key' do
+        let(:condition) do
+          {foo: 'bar'}
+        end
+
+        it_behaves_like 'expands'
+      end
+    end
+
+    context 'Key instance => value' do
+      let(:key) do
+        Mongoid::Criteria::Queryable::Key.new(:foo, :__override__, '$gt')
+      end
+
+      let(:condition) do
+        {key => 'bar'}
+      end
+
+      it 'expands' do
+        expanded.should == {'foo' => {'$gt' => 'bar'}}
+      end
+    end
+
+    context 'operator => operator value expression' do
+      shared_examples_for 'expands' do
+
+        it 'expands' do
+          expanded.should == {'foo' => {'$in' => ['bar']}}
+        end
+      end
+
+      context 'string key' do
+        let(:condition) do
+          {foo: {'$in' => %w(bar)}}
+        end
+
+        it_behaves_like 'expands'
+      end
+
+      context 'symbol key' do
+        let(:condition) do
+          {foo: {:$in => %w(bar)}}
+        end
+
+        it_behaves_like 'expands'
+      end
+    end
   end
 end