mongoid 7.2.1 → 9.0.0

data/spec/integration/dots_and_dollars_spec.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require "spec_helper"
+
+describe "Dots and Dollars" do
+  min_server_version '5.0'
+
+  before(:all) do
+    class DADMUser
+      include Mongoid::Document
+      field :"first.last", type: String, default: "Neil.Shweky"
+      field :"$_amount", type: Integer, default: 0
+      field :"$a.b", type: Boolean, default: true
+    end
+  end
+
+  let!(:user) { DADMUser.create! }
+
+  describe "accessing the fields" do
+
+    context "when using the field getters" do
+
+      context "on dotted fields" do
+        it "gets the right value" do
+          expect(user.send(:"first.last")).to eq("Neil.Shweky")
+        end
+      end
+
+      context "on dollared fields" do
+        it "gets the right value" do
+          expect(user.send(:"$_amount")).to eq(0)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "gets the right value" do
+          expect(user.send(:"$a.b")).to be true
+        end
+      end
+    end
+
+    context "when using the read_attribute" do
+
+      context "on dotted fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("first.last")).to eq("Neil.Shweky")
+        end
+      end
+
+      context "on dollared fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("$_amount")).to eq(0)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "gets the right value" do
+          expect(user.read_attribute("$a.b")).to be true
+        end
+      end
+    end
+
+    context "when using the field setters" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"first.last=", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"$_amount=", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.send(:"$a.b=", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via write_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("first.last", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("$_amount", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.write_attribute("$a.b", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via update_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("first.last", "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("$_amount", 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attribute("$a.b", false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via update_attributes!" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("first.last": "Nissim.Shweky")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("$_amount": 1)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.update_attributes!("$a.b": false)
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via []=" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user[:"first.last"] = "Nissim.Shweky"
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user[:"$_amount"] = 1
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user[:"$a.b"] = false
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+
+    context "when updating via remove_attribute" do
+
+      context "on dotted fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("first.last")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dollared fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("$_amount")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+
+      context "on dotted and dollared fields" do
+        it "raises an error" do
+          expect do
+            user.remove_attribute("$a.b")
+          end.to raise_error(Mongoid::Errors::InvalidDotDollarAssignment)
+        end
+      end
+    end
+  end
+
+  describe "persisting to the db" do
+
+    context "when saving to the db" do
+
+      let(:user) { DADMUser.new }
+
+      it "the save succeeds" do
+        expect do
+          user.save!
+        end.to_not raise_error
+      end
+    end
+
+    context "when retrieving it from the db" do
+
+      let(:from_db) { DADMUser.first }
+
+      it "has the fields populated correctly" do
+        expect(from_db.attributes["first.last"]).to eq("Neil.Shweky")
+        expect(from_db.attributes["$_amount"]).to eq(0)
+        expect(from_db.attributes["$a.b"]).to eq(true)
+      end
+    end
+  end
+
+  describe "querying that field" do
+
+    context "when attempting to query a dotted field" do
+
+      let(:queried) do
+        DADMUser.where("first.last": "Neil.Shweky").first
+      end
+
+      it "does not work" do
+        expect(queried).to be nil
+      end
+    end
+
+    context "when attempting to query a dollared field" do
+
+      let(:queried) do
+        DADMUser.where("$_amount": 0).first
+      end
+
+      it "raise an error" do
+        expect do
+          queried
+        end.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

data/spec/integration/encryption_spec.rb

@@ -0,0 +1,100 @@
+# rubocop:todo all
+require 'spec_helper'
+require 'support/crypt/models'
+
+describe 'Encryption' do
+  require_enterprise
+  require_libmongocrypt
+  include_context 'with encryption'
+  restore_config_clients
+
+  let(:config) do
+    {
+      default: { hosts: SpecConfig.instance.addresses, database: database_id },
+      key_vault: { hosts: SpecConfig.instance.addresses, database: :key_vault },
+      encrypted: {
+        hosts: SpecConfig.instance.addresses,
+        database: database_id,
+        options: {
+          auto_encryption_options: {
+            key_vault_client: :key_vault,
+            kms_providers: kms_providers,
+            key_vault_namespace: key_vault_namespace,
+            extra_options: extra_options
+          }
+        }
+      }
+    }
+  end
+
+  let(:unencrypted_client) do
+    Mongoid.default_client
+  end
+
+  around do |example|
+    Mongoid.default_client[Crypt::Patient.collection_name].drop
+    Mongoid.default_client[Crypt::Car.collection_name].drop
+    existing_key_id = Crypt::Patient.encrypt_metadata[:key_id]
+    Crypt::Patient.set_key_id(data_key_id)
+    Crypt::Car.set_key_id(data_key_id)
+    Mongoid::Config.send(:clients=, config)
+    Mongoid::Clients.with_name(:key_vault)[key_vault_collection].drop
+    Crypt::Patient.store_in(client: :encrypted)
+    Crypt::Car.store_in(client: :encrypted, database: Crypt::Car.storage_options[:database])
+
+    example.run
+
+    Crypt::Patient.reset_storage_options!
+    Crypt::Patient.set_key_id(existing_key_id)
+    Crypt::Car.set_key_id(existing_key_id)
+  end
+
+  it 'encrypts and decrypts fields' do
+    patient = Crypt::Patient.create!(
+      code: '12345',
+      medical_records: ['one', 'two', 'three'],
+      blood_type: 'A+',
+      blood_type_key_name: key_alt_name,
+      ssn: 123456789,
+      insurance: Crypt::Insurance.new(policy_number: 123456789)
+    )
+    Crypt::Patient.find(patient.id).tap do |found_patient|
+      expect(found_patient.code).to eq(patient.code)
+      expect(found_patient.medical_records).to eq(patient.medical_records)
+      expect(found_patient.blood_type).to eq(patient.blood_type)
+      expect(found_patient.ssn).to eq(patient.ssn)
+      expect(found_patient.insurance.policy_number).to eq(patient.insurance.policy_number)
+    end
+  end
+
+  it 'stores data encrypted in the database' do
+    patient = Crypt::Patient.create!(
+      code: '12345',
+      medical_records: ['one', 'two', 'three'],
+      blood_type: 'A+',
+      blood_type_key_name: key_alt_name,
+      ssn: 123456789,
+      insurance: Crypt::Insurance.new(policy_number: 123456789)
+    )
+    unencrypted_client[Crypt::Patient.collection.name].find(_id: patient.id).first.tap do |doc|
+      %w[medical_records blood_type ssn].each do |field|
+        expect(doc[field]).to be_a(BSON::Binary)
+        expect(doc[field].type).to eq(:ciphertext)
+      end
+      expect(doc['insurance']['policy_number']).to be_a(BSON::Binary)
+      expect(doc['code']).to eq('12345')
+    end
+  end
+
+  it 'stores data encrypted in the non-default database' do
+    car = Crypt::Car.create!(vin: 'VA1234')
+    unencrypted_client
+      .use(Crypt::Car.storage_options[:database])[Crypt::Car.collection.name]
+      .find(_id: car.id).first.tap do |doc|
+        expect(doc[:vin]).to be_a(BSON::Binary)
+        expect(doc[:vin].type).to eq(:ciphertext)
+    end
+  end
+
+
+end

data/spec/integration/i18n_fallbacks_spec.rb

@@ -1,26 +1,15 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
 describe 'i18n fallbacks' do
-  # These tests modify the environment
-  before(:all) do
-    unless %w(yes true 1).include?((ENV['TEST_I18N_FALLBACKS'] || '').downcase)
-      skip 'Set TEST_I18N_FALLBACKS=1 environment variable to run these tests'
-    end
-  end
-
-  before(:all) do
-    puts "I18n version: #{I18n::VERSION}"
-
-    require "i18n/backend/fallbacks"
-    I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-  end
+  require_fallbacks
 
   context 'when fallbacks are enabled with a locale list' do
+    with_default_i18n_configs
+
     before do
-      I18n.default_locale = :en
       I18n.fallbacks[:de] = [ :en ]
     end
 
@@ -37,7 +26,6 @@ describe 'i18n fallbacks' do
     end
 
     context 'when translation is missing in active locale and present in fallback locale' do
-
       it 'falls back on default locale' do
         product = Product.new
         I18n.locale = :en
@@ -45,45 +33,15 @@ describe 'i18n fallbacks' do
         I18n.locale = :de
         product.description.should == 'Marvelous!'
       end
-
     end
 
     context 'when translation is missing in all locales' do
-
-      context 'i18n >= 1.1' do
-
-        before(:all) do
-          unless Gem::Version.new(I18n::VERSION) >= Gem::Version.new('1.1')
-            skip "Test requires i18n >= 1.1, we have #{I18n::VERSION}"
-          end
-        end
-
-        it 'returns nil' do
-          product = Product.new
-          I18n.locale = :en
-          product.description = "Marvelous!"
-          I18n.locale = :ru
-          product.description.should be nil
-        end
-
-      end
-
-      context 'i18n 1.0' do
-
-        before(:all) do
-          unless Gem::Version.new(I18n::VERSION) < Gem::Version.new('1.1')
-            skip "Test requires i18n < 1.1, we have #{I18n::VERSION}"
-          end
-        end
-
-        it 'falls back on default locale' do
-          product = Product.new
-          I18n.locale = :en
-          product.description = "Marvelous!"
-          I18n.locale = :ru
-          product.description.should == 'Marvelous!'
-        end
-
+      it 'returns nil' do
+        product = Product.new
+        I18n.locale = :en
+        product.description = "Marvelous!"
+        I18n.locale = :ru
+        product.description.should be nil
       end
     end
   end

data/spec/integration/matcher_examples_spec.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 require 'spec_helper'
 
@@ -653,10 +653,12 @@ describe 'Matcher' do
 
     describe 'range match on array element' do
 
+      let(:record) do
+        Record.new(producers: [123, 456])
+      end
+
       let!(:band) do
-        Band.create!(records: [
-          Record.new(producers: [123, 456]),
-        ])
+        Band.create!(records: [ record ])
       end
 
       describe 'MongoDB query' do
@@ -668,14 +670,13 @@ describe 'Matcher' do
           expect(found_band).to eq(band)
         end
 
-        # https://jira.mongodb.org/browse/MONGOID-4911
         context 'no match' do
 
-        let!(:band) do
-          Band.create!(records: [
-            Record.new(producers: [50]),
-          ])
-        end
+          let!(:band) do
+            Band.create!(records: [
+              Record.new(producers: [50, 250]),
+            ])
+          end
 
           it 'does not find' do
             expect(found_band).to be nil
@@ -688,10 +689,16 @@ describe 'Matcher' do
           band.records.where(producers: 100..200).first
         end
 
-        it 'raises InvalidQuery' do
-          lambda do
-            found_record
-          end.should raise_error(Mongoid::Errors::InvalidQuery)
+        let(:no_record) do
+          band.records.where(producers: 199..200).first
+        end
+
+        it 'finds correctly' do
+          expect(found_record).to eq(record)
+        end
+
+        it "correctly does not find" do
+          expect(no_record).to eq(nil)
         end
       end
     end

data/spec/integration/matcher_operator_data/bits_all_clear.yml

@@ -0,0 +1,144 @@
+- name: existing field - matches with int
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: 35
+  matches: true
+
+- name: existing field - does not match with int
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: 24
+  matches: false
+
+- name: existing field - matches with binData
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: !ruby/object:BSON::Binary
+        data: !binary |-
+          IW==
+        type: :generic
+  matches: true
+
+- name: existing field - does not match with binData
+  document:
+    a: 21
+    binaryValueofA: "00010101"
+  query:
+    a:
+      $bitsAllClear: !ruby/object:BSON::Binary
+        data: !binary |-
+          IW==
+        type: :generic
+  matches: false
+
+- name: existing binData field matches
+  document:
+    a: !ruby/object:BSON::Binary
+      data: !binary |-
+        IW==
+      type: :generic
+  query:
+    a:
+      $bitsAllClear: 20
+  matches: true
+
+- name: existing binData field does not match
+  document:
+    a: !ruby/object:BSON::Binary
+      data: !binary |-
+        IW==
+      type: :generic
+  query:
+    a:
+      $bitsAllClear: 15
+  matches: false
+
+- name: existing field - matches with array
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: [0, 3]
+  matches: true
+
+- name: existing field - does not match with array
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: [0, 2]
+  matches: false
+
+- name: float condition representable as an integer
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: 35.0
+  matches: true
+
+- name: float condition not representable as an integer
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: 35.1
+  error: true
+
+- name: string condition
+  document:
+    a: 54
+    binaryValueofA: "00110110"
+  query:
+    a:
+      $bitsAllClear: hello
+  error: true
+
+- name: empty array condition
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: []
+  matches: true
+
+- name: integer 0 condition
+  document:
+    a: 20
+    binaryValueofA: "00010100"
+  query:
+    a:
+      $bitsAllClear: 0
+  matches: true
+
+- name: negative integer condition
+  document:
+    a: 54
+    binaryValueofA: "00110110"
+  query:
+    a:
+      $bitsAllClear: -1
+  error: true
+
+- name: negative float condition
+  document:
+    a: 54
+    binaryValueofA: "00110110"
+  query:
+    a:
+      $bitsAllClear: -1.0
+  error: true