mongoid 6.4.8 → 7.5.4

data/spec/integration/criteria/default_scope_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'Criteria and default scope' do
+
+  context 'order in query' do
+    let(:query) do
+      Acolyte.order(status: :desc)
+    end
+
+    let(:sort_options) do
+      query.options[:sort]
+    end
+
+    it 'is added after order of default scope' do
+      sort_options.should == {'status' => -1, 'name' => 1}
+
+      # Keys in Ruby are ordered
+      sort_options.keys.should == %w(name status)
+    end
+  end
+
+  context 'default scope + logical operator' do
+
+    context 'logical operator applied to a criteria' do
+      let(:base) { Appointment.where }
+
+      it 'has default scope' do
+        base.selector.should == {'active' => true}
+      end
+
+      context '.or' do
+        let(:criteria) do
+          base.or(timed: true)
+        end
+
+        it 'adds new condition in parallel to default scope conditions' do
+          criteria.selector.should == {'$or' => [
+            {'active' => true},
+            {'timed' => true},
+          ]}
+        end
+      end
+
+      context '.any_of' do
+        let(:criteria) do
+          base.any_of(timed: true)
+        end
+
+        it 'maintains default scope conditions' do
+          criteria.selector.should == {'active' => true, 'timed' => true}
+        end
+      end
+    end
+
+    context 'logical operator called on the class' do
+      let(:base) { Appointment }
+
+      context '.or' do
+        let(:criteria) do
+          base.or(timed: true)
+        end
+
+        it 'adds new condition in parallel to default scope conditions' do
+          criteria.selector.should == {'$or' => [
+            {'active' => true},
+            {'timed' => true},
+          ]}
+        end
+      end
+    end
+  end
+end

data/spec/integration/criteria/logical_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe 'Criteria logical operations' do
+  let!(:ap) { Band.create!(name: 'Astral Projection', origin: 'SFX', genres: ['Goa', 'Psy']) }
+  let!(:im) { Band.create!(name: 'Infected Mushroom', origin: 'Computers', genres: ['Psy']) }
+  let!(:sp) { Band.create!(name: 'Sun Project', genres: ['Goa']) }
+
+  describe 'and' do
+    it 'combines conditions on different fields given as hashes' do
+      bands = Band.where(name: /Proj/).and(genres: 'Psy')
+      expect(bands.to_a).to eq([ap])
+    end
+
+    it 'combines conditions on different fields given as scopes' do
+      bands = Band.where(name: /Proj/).and(Band.where(genres: 'Psy'))
+      expect(bands.to_a).to eq([ap])
+    end
+
+    it 'combines conditions on same field given as hashes' do
+      bands = Band.where(name: /Proj/).and(name: /u/)
+      expect(bands.to_a).to eq([sp])
+    end
+
+    it 'combines conditions on same field given as scopes' do
+      bands = Band.where(name: /Proj/).and(Band.where(name: /u/))
+      expect(bands.to_a).to eq([sp])
+    end
+
+    context "when broken_and feature flag is not set" do
+      config_override :broken_and, false
+
+      it 'combines existing `$and` clause in query and `where` condition' do
+        bands = Band.where(id: 1).and({year: {'$in' => [2020]}}, {year: {'$in' => [2021]}}).where(id: 2)
+        expect(bands.selector).to eq(
+          {
+            "_id"=>1,
+            "year"=>{"$in"=>[2020]},
+            "$and"=>[{"year"=>{"$in"=>[2021]}}, {"_id"=>2}]
+          }
+        )
+      end
+    end
+
+    context "when broken_and feature flag is set" do
+      config_override :broken_and, true
+
+      it 'combines existing `$and` clause in query and `where` condition' do
+        bands = Band.where(id: 1).and({year: {'$in' => [2020]}}, {year: {'$in' => [2021]}}).where(id: 2)
+        expect(bands.selector).to eq(
+          {
+            "_id"=>1,
+            "year"=>{"$in"=>[2020]},
+            "$and"=>[{"_id"=>2}]
+          }
+        )
+      end
+    end
+  end
+
+  describe 'or' do
+    it 'combines conditions on different fields given as hashes' do
+      bands = Band.where(name: /Sun/).or(origin: 'SFX')
+      expect(bands.order_by(name: 1).to_a).to eq([ap, sp])
+    end
+
+    it 'combines conditions on different fields given as scopes' do
+      bands = Band.where(name: /Sun/).or(Band.where(origin: 'SFX'))
+      expect(bands.order_by(name: 1).to_a).to eq([ap, sp])
+    end
+
+    it 'combines conditions on same field given as hashes' do
+      bands = Band.where(name: /jecti/).or(name: /ush/)
+      expect(bands.order_by(name: 1).to_a).to eq([ap, im])
+    end
+
+    it 'combines conditions on same field given as scopes' do
+      bands = Band.where(name: /jecti/).or(Band.where(name: /ush/))
+      expect(bands.order_by(name: 1).to_a).to eq([ap, im])
+    end
+
+    context 'when using a symbol operator' do
+      context 'when field has a serializer' do
+        let!(:doc) { Dokument.create! }
+
+        it 'works' do
+          scope = Dokument.or(:created_at.lte => DateTime.now).sort(id: 1)
+          # input was converted from DateTime to Time
+          scope.criteria.selector['$or'].first['created_at']['$lte'].should be_a(Time)
+          scope.to_a.should == [doc]
+        end
+      end
+    end
+  end
+
+  describe 'not' do
+    context 'hash argument with string value' do
+      let(:actual) do
+        Band.not(name: 'test').selector
+      end
+
+      let(:expected) do
+        {'name' => {'$ne' => 'test'}}
+      end
+
+      it 'expands to use $ne' do
+        expect(actual).to eq(expected)
+      end
+    end
+
+    context 'hash argument with regexp value' do
+      let(:actual) do
+        Band.not(name: /test/).selector
+      end
+
+      let(:expected) do
+        {'name' => {'$not' => /test/}}
+      end
+
+      it 'expands to use $not' do
+        expect(actual).to eq(expected)
+      end
+    end
+  end
+end

data/spec/integration/criteria/range_spec.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Queries with Range criteria' do
+  let(:now_utc) { Time.utc(2020, 1, 1, 16, 0, 0, 0) }
+  let(:now_in_zone) { now_utc.in_time_zone('Asia/Tokyo') }
+  let(:today) { Date.new(2020, 1, 1) }
+
+  let!(:band1) { Band.create!(likes: 0, rating: 0.9, founded: today, updated_at: now_utc) }
+  let!(:band2) { Band.create!(likes: 1, rating: 1.0, founded: today + 1.day, updated_at: now_utc + 1.days) }
+  let!(:band3) { Band.create!(likes: 2, rating: 2.9, founded: today + 2.days, updated_at: now_utc + 2.days) }
+  let!(:band4) { Band.create!(likes: 3, rating: 3.0, founded: today + 3.days, updated_at: now_utc + 3.days) }
+  let!(:band5) { Band.create!(likes: 4, rating: 3.1, founded: today + 4.days, updated_at: now_utc + 4.days) }
+
+  context 'Range<Integer> criteria vs Integer field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(likes: 1..3).to_a).to eq [band2, band3, band4]
+      expect(Band.where(likes: 1...3).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(likes: eval('1..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(likes: eval('..3')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(likes: eval('...3')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Integer> criteria vs Float field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(rating: 1..3).to_a).to eq [band2, band3, band4]
+      expect(Band.where(rating: 1...3).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(rating: eval('1..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(rating: eval('..3')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(rating: eval('...3')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Float> criteria vs Integer field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(likes: 0.95..3.05).to_a).to eq [band2, band3, band4]
+      expect(Band.where(likes: 0.95...3.0).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(likes: eval('0.95..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(likes: eval('..3.05')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(likes: eval('...3.0')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Float> criteria vs Float field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(rating: 0.95..3.05).to_a).to eq [band2, band3, band4]
+      expect(Band.where(rating: 0.95...3.0).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(rating: eval('0.95..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(rating: eval('..3.05')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(rating: eval('...3.0')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Time> criteria vs Time field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(updated_at: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [band2, band3, band4]
+      expect(Band.where(updated_at: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(updated_at: eval('(now_utc + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(updated_at: eval('..(now_utc + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(updated_at: eval('...(now_utc + 3.days)')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Time> criteria vs Date field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(founded: (now_utc + 1.day)..(now_utc + 3.days)).to_a).to eq [band2, band3, band4]
+      expect(Band.where(founded: (now_utc + 1.day)...(now_utc + 3.days)).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(founded: eval('(now_utc + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(founded: eval('..(now_utc + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(founded: eval('...(now_utc + 3.days)')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<ActiveSupport::TimeWithZone> criteria vs Time field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(updated_at: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [band2, band3, band4]
+      expect(Band.where(updated_at: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(updated_at: eval('(now_in_zone + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(updated_at: eval('..(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(updated_at: eval('...(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<ActiveSupport::TimeWithZone> criteria vs Date field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(founded: (now_in_zone + 1.day)..(now_in_zone + 3.days)).to_a).to eq [band3, band4, band5]
+      expect(Band.where(founded: (now_in_zone + 1.day)...(now_in_zone + 3.days)).to_a).to eq [band3, band4]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(founded: eval('(now_in_zone + 1.day)..')).to_a).to eq [band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(founded: eval('..(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4, band5]
+        expect(Band.where(founded: eval('...(now_in_zone + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+      end
+    end
+  end
+
+  context 'Range<Date> criteria vs Date field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(founded: (today + 1.day)..(today + 3.days)).to_a).to eq [band2, band3, band4]
+      expect(Band.where(founded: (today + 1.day)...(today + 3.days)).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(founded: eval('(today + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(founded: eval('..(today + 3.days)')).to_a).to eq [band1, band2, band3, band4]
+        expect(Band.where(founded: eval('...(today + 3.days)')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+
+  context 'Range<Date> criteria vs Time field' do
+
+    it 'returns objects within the range' do
+      expect(Band.where(updated_at: (today + 1.day)..(today + 3.days)).to_a).to eq [band2, band3]
+      expect(Band.where(updated_at: (today + 1.day)...(today + 3.days)).to_a).to eq [band2, band3]
+    end
+
+    context 'endless range' do
+      ruby_version_gte '2.6'
+
+      it 'returns all objects above the value' do
+        expect(Band.where(updated_at: eval('(today + 1.day)..')).to_a).to eq [band2, band3, band4, band5]
+      end
+    end
+
+    context 'beginless range' do
+      ruby_version_gte '2.7'
+
+      it 'returns all objects under the value' do
+        expect(Band.where(updated_at: eval('..(today + 3.days)')).to_a).to eq [band1, band2, band3]
+        expect(Band.where(updated_at: eval('...(today + 3.days)')).to_a).to eq [band1, band2, band3]
+      end
+    end
+  end
+end

data/spec/integration/criteria/time_with_zone_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'TimeWithZone in queries' do
+  let(:now_utc) { Time.now.utc }
+  let(:now_in_zone) { now_utc.in_time_zone(time_zone) }
+
+  shared_examples_for 'time zone queries' do
+    let!(:book_earlier) { Book.create!(updated_at: now_utc - 20.minutes, dynamic_time: now_utc - 20.minutes).reload }
+    let!(:book_now)     { Book.create!(dynamic_time: now_in_zone).reload }
+    let!(:book_later)   { Book.create!(updated_at: now_in_zone + 20.minutes, dynamic_time: now_in_zone + 20.minutes).reload }
+
+    context 'Mongo driver static field' do
+
+      let(:view_lt) do
+        Book.collection.find(updated_at: {'$lt' => query_time + 10.minutes})
+      end
+
+      let(:view_gt) do
+        Book.collection.find(updated_at: {'$gt' => query_time - 10.minutes})
+      end
+
+      let(:view_range) do
+        Book.collection.find(updated_at: {'$gt' => query_time - 10.minutes, '$lt' => query_time + 10.minutes})
+      end
+
+      it 'finds the document' do
+        expect(view_lt.to_a).to eq([book_earlier.attributes, book_now.attributes])
+        expect(view_gt.to_a).to eq([book_now.attributes, book_later.attributes])
+        expect(view_range.to_a).to eq([book_now.attributes])
+      end
+    end
+
+    context 'Mongo driver dynamic field' do
+
+      let(:view_lt) do
+        Book.collection.find(dynamic_time: {'$lt' => query_time + 10.minutes})
+      end
+
+      let(:view_gt) do
+        Book.collection.find(dynamic_time: {'$gt' => query_time - 10.minutes})
+      end
+
+      let(:view_range) do
+        Book.collection.find(dynamic_time: {'$gt' => query_time - 10.minutes, '$lt' => query_time + 10.minutes})
+      end
+
+      it 'finds the document' do
+        expect(view_lt.to_a).to eq([book_earlier.attributes, book_now.attributes])
+        expect(view_gt.to_a).to eq([book_now.attributes, book_later.attributes])
+        expect(view_range.to_a).to eq([book_now.attributes])
+      end
+    end
+
+    context 'Mongoid static field' do
+
+      let(:view_lt) do
+        Book.all.lt(updated_at: query_time + 10.minutes)
+      end
+
+      let(:view_gt) do
+        Book.all.gt(updated_at: query_time - 10.minutes)
+      end
+
+      let(:view_range) do
+        Book.all.where(updated_at: (query_time - 10.minutes)..(query_time + 10.minutes))
+      end
+
+      it 'finds the document' do
+        expect(view_lt.pluck(:_id).sort).to eq([book_earlier, book_now].pluck(:_id).sort)
+        expect(view_gt.pluck(:_id).sort).to eq([book_now, book_later].pluck(:_id).sort)
+        expect(view_range.pluck(:_id).sort).to eq([book_now].pluck(:_id).sort)
+      end
+    end
+
+    context 'Mongoid dynamic field' do
+
+      let(:view_lt) do
+        Book.all.lt(dynamic_time: query_time + 10.minutes)
+      end
+
+      let(:view_gt) do
+        Book.all.gt(dynamic_time: query_time - 10.minutes)
+      end
+
+      let(:view_range) do
+        Book.all.where(dynamic_time: (query_time - 10.minutes)..(query_time + 10.minutes))
+      end
+
+      it 'finds the document' do
+        expect(view_lt.pluck(:_id).sort).to eq([book_earlier, book_now].pluck(:_id).sort)
+        expect(view_gt.pluck(:_id).sort).to eq([book_now, book_later].pluck(:_id).sort)
+        expect(view_range.pluck(:_id).sort).to eq([book_now].pluck(:_id).sort)
+      end
+    end
+  end
+
+  context 'query with Time' do
+    let(:query_time) { now_utc }
+
+    context 'when zone of queried time is UTC' do
+      let(:time_zone) { 'UTC' }
+      it { expect(now_in_zone.utc_offset).to eq 0 }
+      it_behaves_like 'time zone queries'
+    end
+
+    context 'when zone of queried time is JST' do
+      let(:time_zone) { 'Asia/Tokyo' }
+      it { expect(now_in_zone.utc_offset).to be > 0 }
+      it_behaves_like 'time zone queries'
+    end
+
+    context 'when zone of queried time is PST' do
+      let(:time_zone) { 'Pacific Time (US & Canada)' }
+      it { expect(now_in_zone.utc_offset).to be < 0 }
+      it_behaves_like 'time zone queries'
+    end
+  end
+
+  context 'query with ActiveSupport::TimeWithZone' do
+    let(:query_time) { now_in_zone }
+
+    context 'when zone of queried time is UTC' do
+      let(:time_zone) { 'UTC' }
+      it { expect(now_in_zone.utc_offset).to eq 0 }
+      it_behaves_like 'time zone queries'
+    end
+
+    context 'when zone of queried time is JST' do
+      let(:time_zone) { 'Asia/Tokyo' }
+      it { expect(now_in_zone.utc_offset).to be > 0 }
+      it_behaves_like 'time zone queries'
+    end
+
+    context 'when zone of queried time is PST' do
+      let(:time_zone) { 'Pacific Time (US & Canada)' }
+      it { expect(now_in_zone.utc_offset).to be < 0 }
+      it_behaves_like 'time zone queries'
+    end
+  end
+end