mongo 2.18.1 → 2.18.2

data/spec/mongo/operation/insert/command_spec.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mongo::Operation::Insert::Command do
-
-  let(:documents) { [{ :_id => 1, :foo => 1 }] }
-  let(:session) { nil }
-  let(:spec) do
-    { :documents     => documents,
-      :db_name       => authorized_collection.database.name,
-      :coll_name     => authorized_collection.name,
-      :write_concern => write_concern,
-      :ordered       => true,
-      :session       => session
-    }
-  end
-
-  let(:write_concern) do
-    Mongo::WriteConcern.get(w: :majority)
-  end
-
-  let(:op) { described_class.new(spec) }
-
-  describe '#initialize' do
-
-    context 'spec' do
-
-      it 'sets the spec' do
-        expect(op.spec).to eq(spec)
-      end
-    end
-  end
-
-  describe '#==' do
-
-    context 'spec' do
-
-      context 'when two ops have the same specs' do
-        let(:other) { described_class.new(spec) }
-
-        it 'returns true' do
-          expect(op).to eq(other)
-        end
-      end
-
-      context 'when two ops have different specs' do
-        let(:other_documents) { [{ :bar => 1 }] }
-        let(:other_spec) do
-          { :documents     => other_documents,
-            :db_name       => authorized_collection.database.name,
-            :insert        => authorized_collection.name,
-            :write_concern => write_concern.options,
-            :ordered       => true
-          }
-        end
-        let(:other) { described_class.new(other_spec) }
-
-        it 'returns false' do
-          expect(op).not_to eq(other)
-        end
-      end
-    end
-  end
-
-  describe 'write concern' do
-    # https://jira.mongodb.org/browse/RUBY-2224
-    require_no_linting
-
-    context 'when write concern is not specified' do
-
-      let(:spec) do
-        { :documents     => documents,
-          :db_name       => authorized_collection.database.name,
-          :coll_name     => authorized_collection.name,
-          :ordered       => true
-        }
-      end
-
-      it 'does not include write concern in the selector' do
-        expect(op.send(:command, double('server'))[:writeConcern]).to be_nil
-      end
-    end
-
-    context 'when write concern is specified' do
-
-      it 'includes write concern in the selector' do
-        expect(op.send(:command, double('server'))[:writeConcern]).to eq(write_concern.options)
-      end
-    end
-  end
-
-  describe '#message' do
-    # https://jira.mongodb.org/browse/RUBY-2224
-    require_no_linting
-
-    context 'when the server does not support OP_MSG' do
-      max_server_version '3.4'
-
-      let(:expected_selector) do
-        { :documents     => documents,
-          :insert        => authorized_collection.name,
-          :writeConcern => write_concern.options,
-          :ordered       => true
-        }
-      end
-
-      it 'creates a query wire protocol message with correct specs' do
-        expect(Mongo::Protocol::Query).to receive(:new).with(authorized_collection.database.name,
-                                                             '$cmd',
-                                                             expected_selector,
-                                                             { limit: -1, validating_keys: true })
-        op.send(:message, authorized_primary)
-      end
-    end
-  end
-end

data/spec/mongo/operation/update/command_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mongo::Operation::Update::Command do
-
-  let(:updates) { [{:q => { :foo => 1 },
-                    :u => { :$set => { :bar => 1 } },
-                    :multi => true,
-                    :upsert => false }] }
-
-  let(:write_concern) do
-    Mongo::WriteConcern.get(w: :majority)
-  end
-  let(:session) { nil }
-  let(:spec) do
-    { :updates       => updates,
-      :db_name       => SpecConfig.instance.test_db,
-      :coll_name     => TEST_COLL,
-      :write_concern => write_concern,
-      :ordered       => true,
-      :session       => session
-    }
-  end
-
-  let(:op) { described_class.new(spec) }
-
-  describe '#initialize' do
-
-    context 'spec' do
-
-      it 'sets the spec' do
-        expect(op.spec).to eq(spec)
-      end
-    end
-  end
-
-  describe '#==' do
-
-    context 'spec' do
-
-      context 'when two ops have the same specs' do
-        let(:other) { described_class.new(spec) }
-
-        it 'returns true' do
-          expect(op).to eq(other)
-        end
-      end
-
-      context 'when two ops have different specs' do
-        let(:other_updates) { [{:q => { :bar => 1 },
-                                :u => { :$set => { :bar => 2 } },
-                                :multi => true,
-                                :upsert => false }] }
-        let(:other_spec) do
-          { :updates       => other_updates,
-            :db_name       => SpecConfig.instance.test_db,
-            :coll_name     => TEST_COLL,
-            :write_concern => Mongo::WriteConcern.get(w: :majority),
-            :ordered       => true
-          }
-        end
-        let(:other) { described_class.new(other_spec) }
-
-        it 'returns false' do
-          expect(op).not_to eq(other)
-        end
-      end
-    end
-  end
-
-  describe 'write concern' do
-    # https://jira.mongodb.org/browse/RUBY-2224
-    require_no_linting
-
-    context 'when write concern is not specified' do
-
-      let(:spec) do
-        { :updates       => updates,
-          :db_name       => SpecConfig.instance.test_db,
-          :coll_name     => TEST_COLL,
-          :ordered       => true
-        }
-      end
-
-      it 'does not include write concern in the selector' do
-        expect(op.send(:command, double('server'))[:writeConcern]).to be_nil
-      end
-    end
-
-    context 'when write concern is specified' do
-
-      it 'includes write concern in the selector' do
-        expect(op.send(:command, double('server'))[:writeConcern]).to eq(write_concern.options)
-      end
-    end
-  end
-
-  describe '#message' do
-    # https://jira.mongodb.org/browse/RUBY-2224
-    require_no_linting
-
-    context 'when the server does not support OP_MSG' do
-      max_server_version '3.4'
-
-      let(:expected_selector) do
-        {
-            :update        => TEST_COLL,
-            :updates       => updates,
-            :ordered       => true,
-            :writeConcern   => write_concern.options
-        }
-      end
-
-      it 'creates the correct Command message' do
-        expect(Mongo::Protocol::Query).to receive(:new).with(SpecConfig.instance.test_db, '$cmd', expected_selector, { limit: -1 })
-        op.send(:message, authorized_primary)
-      end
-    end
-  end
-end

data/spec/mongo/protocol/delete_spec.rb

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'lite_spec_helper'
-require 'support/shared/protocol'
-
-describe Mongo::Protocol::Delete do
-
-  let(:opcode)   { 2006 }
-  let(:db)       { SpecConfig.instance.test_db }
-  let(:collection_name) { 'protocol-test' }
-  let(:ns)       { "#{db}.#{collection_name}" }
-  let(:selector) { { :name => 'Tyler' } }
-  let(:options)     { Hash.new }
-
-  let(:message) do
-    described_class.new(db, collection_name, selector, options)
-  end
-
-  describe '#initialize' do
-
-    it 'sets the namepsace' do
-      expect(message.namespace).to eq(ns)
-    end
-
-    it 'sets the selector' do
-      expect(message.selector).to eq(selector)
-    end
-
-    context 'when options are provided' do
-
-      context 'when flags are provided' do
-        let(:options) { { :flags => [:single_remove] } }
-
-        it 'sets the flags' do
-          expect(message.flags).to eq(options[:flags])
-        end
-      end
-    end
-  end
-
-  describe '#==' do
-
-    context 'when the other is a delete' do
-
-      context 'when the fields are equal' do
-        let(:other) do
-          described_class.new(db, collection_name, selector, options)
-        end
-
-        it 'returns true' do
-          expect(message).to eq(other)
-        end
-      end
-
-      context 'when the database is not equal' do
-        let(:other) do
-          described_class.new('tyler', collection_name, selector, options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the collection is not equal' do
-        let(:other) do
-          described_class.new(db, 'tyler', selector, options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the selector is not equal' do
-        let(:other) do
-          described_class.new(db, collection_name, { :a => 1 }, options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the options are not equal' do
-        let(:other) do
-          described_class.new(db, collection_name, selector, :flags => [:single_remove])
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-    end
-
-    context 'when the other is not a delete' do
-      let(:other) do
-        expect(message).not_to eq('test')
-      end
-    end
-  end
-
-  describe '#hash' do
-    let(:values) do
-      message.send(:fields).map do |field|
-        message.instance_variable_get(field[:name])
-      end
-    end
-
-    it 'returns a hash of the field values' do
-      expect(message.hash).to eq(values.hash)
-    end
-  end
-
-  describe '#replyable?' do
-
-    it 'returns false' do
-      expect(message).to_not be_replyable
-    end
-  end
-
-  describe '#serialize' do
-    let(:bytes) { message.serialize }
-
-    include_examples 'message with a header'
-
-    describe 'zero' do
-      let(:field) { bytes.to_s[16..19] }
-
-      it 'serializes a zero' do
-        expect(field).to be_int32(0)
-      end
-    end
-
-    describe 'namespace' do
-      let(:field) { bytes.to_s[20..36] }
-      it 'serializes the namespace' do
-        expect(field).to be_cstring(ns)
-      end
-    end
-
-    describe 'flags' do
-      let(:field) { bytes.to_s[37..40] }
-
-      context 'when no flags are provided' do
-        it 'does not set any bits' do
-          expect(field).to be_int32(0)
-        end
-      end
-
-      context 'when flags are provided' do
-        let(:options) { { :flags => flags } }
-
-        context 'single remove flag' do
-          let(:flags) { [:single_remove] }
-          it 'sets the first bit' do
-            expect(field).to be_int32(1)
-          end
-        end
-      end
-    end
-
-    describe 'selector' do
-      let(:field) { bytes.to_s[41..-1] }
-      it 'serializes the selector' do
-        expect(field).to be_bson(selector)
-      end
-    end
-  end
-
-  describe '#registry' do
-
-    context 'when the class is loaded' do
-
-      it 'registers the op code in the Protocol Registry' do
-        expect(Mongo::Protocol::Registry.get(described_class::OP_CODE)).to be(described_class)
-      end
-
-      it 'creates an #op_code instance method' do
-        expect(message.op_code).to eq(described_class::OP_CODE)
-      end
-    end
-  end
-end

data/spec/mongo/protocol/insert_spec.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'lite_spec_helper'
-require 'support/shared/protocol'
-
-describe Mongo::Protocol::Insert do
-
-  let(:opcode) { 2002 }
-  let(:db)     { SpecConfig.instance.test_db }
-  let(:collection_name) { 'protocol-test' }
-  let(:ns)     { "#{db}.#{collection_name}" }
-  let(:doc1)   { { :name => 'Tyler' } }
-  let(:doc2)   { { :name => 'Brandon' } }
-  let(:docs)   { [doc1, doc2] }
-  let(:options)   { Hash.new }
-
-  let(:message) do
-    described_class.new(db, collection_name, docs, options)
-  end
-
-  describe '#initialize' do
-
-    it 'sets the namepsace' do
-      expect(message.namespace).to eq(ns)
-    end
-
-    it 'sets the documents' do
-      expect(message.documents).to eq(docs)
-    end
-
-    context 'when options are provided' do
-
-      context 'when flags are provided' do
-        let(:options) { { :flags => [:continue_on_error] } }
-
-        it 'sets the flags' do
-          expect(message.flags).to eq(options[:flags])
-        end
-      end
-    end
-  end
-
-  describe '#==' do
-
-    context 'when the other is an insert' do
-
-      context 'when the fields are equal' do
-        let(:other) do
-          described_class.new(db, collection_name, docs, options)
-        end
-
-        it 'returns true' do
-          expect(message).to eq(other)
-        end
-      end
-
-      context 'when the database is not equal' do
-        let(:other) do
-          described_class.new('tyler', collection_name, docs, options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the collection is not equal' do
-        let(:other) do
-          described_class.new(db, 'tyler', docs, options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the documents are not equal' do
-        let(:other) do
-          described_class.new(db, collection_name, docs[1..1], options)
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-
-      context 'when the options are not equal' do
-        let(:other) do
-          described_class.new(db, collection_name, docs, :flags => [:continue_on_error])
-        end
-
-        it 'returns false' do
-          expect(message).not_to eq(other)
-        end
-      end
-    end
-
-    context 'when the other is not an insert' do
-      let(:other) do
-        expect(message).not_to eq('test')
-      end
-    end
-  end
-
-  describe '#hash' do
-    let(:values) do
-      message.send(:fields).map do |field|
-        message.instance_variable_get(field[:name])
-      end
-    end
-
-    it 'returns a hash of the field values' do
-      expect(message.hash).to eq(values.hash)
-    end
-  end
-
-  describe '#replyable?' do
-
-    it 'returns false' do
-      expect(message).to_not be_replyable
-    end
-  end
-
-  describe '#serialize' do
-    let(:bytes) { message.serialize }
-
-    include_examples 'message with a header'
-
-    describe 'flags' do
-      let(:field) { bytes.to_s[16..19] }
-
-      context 'when no flags are provided' do
-        it 'does not set any bits' do
-          expect(field).to be_int32(0)
-        end
-      end
-
-      context 'when flags are provided' do
-        let(:options) { { :flags => flags } }
-
-        context 'continue on error flag' do
-          let(:flags) { [:continue_on_error] }
-          it 'sets the first bit' do
-            expect(field).to be_int32(1)
-          end
-        end
-      end
-    end
-
-    describe 'namespace' do
-      let(:field) { bytes.to_s[20..36] }
-      it 'serializes the namespace' do
-        expect(field).to be_cstring(ns)
-      end
-    end
-
-    describe 'documents' do
-      let(:field) { bytes.to_s[37..-1] }
-      it 'serializes the documents' do
-        expect(field).to be_bson_sequence(docs)
-      end
-    end
-  end
-
-  describe '#registry' do
-
-    context 'when the class is loaded' do
-
-      it 'registers the op code in the Protocol Registry' do
-        expect(Mongo::Protocol::Registry.get(described_class::OP_CODE)).to be(described_class)
-      end
-
-      it 'creates an #op_code instance method' do
-        expect(message.op_code).to eq(described_class::OP_CODE)
-      end
-    end
-  end
-end