mongo 1.12.5 → 2.0.0

data/spec/mongo/auth/user_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe Mongo::Auth::User do
+
+  let(:options) do
+    { database: 'testing', user: 'user', password: 'pass' }
+  end
+
+  let(:user) do
+    described_class.new(options)
+  end
+
+  describe '#auth_key' do
+
+    let(:nonce) do
+
+    end
+
+    let(:expected) do
+      Digest::MD5.hexdigest("#{nonce}#{user.name}#{user.hashed_password}")
+    end
+
+    it 'returns the users authentication key' do
+      expect(user.auth_key(nonce)).to eq(expected)
+    end
+  end
+
+  describe '#encoded_name' do
+
+    context 'when the user name contains an =' do
+
+      let(:options) do
+        { user: 'user=' }
+      end
+
+      it 'escapes the = character to =3D' do
+        expect(user.encoded_name).to eq('user=3D')
+      end
+
+      it 'returns a UTF-8 string' do
+        expect(user.encoded_name.encoding.name).to eq('UTF-8')
+      end
+    end
+
+    context 'when the user name contains a ,' do
+
+      let(:options) do
+        { user: 'user,' }
+      end
+
+      it 'escapes the , character to =2C' do
+        expect(user.encoded_name).to eq('user=2C')
+      end
+
+      it 'returns a UTF-8 string' do
+        expect(user.encoded_name.encoding.name).to eq('UTF-8')
+      end
+    end
+
+    context 'when the user name contains no special characters' do
+
+      it 'does not alter the user name' do
+        expect(user.name).to eq('user')
+      end
+
+      it 'returns a UTF-8 string' do
+        expect(user.encoded_name.encoding.name).to eq('UTF-8')
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    it 'sets the database' do
+      expect(user.database).to eq('testing')
+    end
+
+    it 'sets the name' do
+      expect(user.name).to eq('user')
+    end
+
+    it 'sets the password' do
+      expect(user.password).to eq('pass')
+    end
+  end
+
+  describe '#hashed_password' do
+
+    let(:expected) do
+      Digest::MD5.hexdigest("user:mongo:pass")
+    end
+
+    it 'returns the hashed password' do
+      expect(user.hashed_password).to eq(expected)
+    end
+  end
+
+  describe '#mechanism' do
+
+    context 'when the option is provided' do
+
+      let(:options) do
+        { database: 'testing', user: 'user', password: 'pass', auth_mech: :plain }
+      end
+
+      let(:user) do
+        described_class.new(options)
+      end
+
+      it 'returns the option' do
+        expect(user.mechanism).to eq(:plain)
+      end
+    end
+
+    context 'when no option is provided' do
+
+      let(:user) do
+        described_class.new(options)
+      end
+
+      it 'returns the default' do
+        expect(user.mechanism).to eq(:mongodb_cr)
+      end
+    end
+  end
+
+  describe '#auth_mech_properties' do
+
+    context 'when the option is provided' do
+
+      let(:auth_mech_properties) do
+        { service_name: 'test',
+          service_realm: 'test',
+          canonicalize_host_name: true }
+      end
+
+      let(:options) do
+        { database: 'testing', user: 'user', password: 'pass', auth_mech_properties: auth_mech_properties }
+      end
+
+      let(:user) do
+        described_class.new(options)
+      end
+
+      it 'returns the option' do
+        expect(user.auth_mech_properties).to eq(auth_mech_properties)
+      end
+    end
+
+    context 'when no option is provided' do
+
+      let(:user) do
+        described_class.new(options)
+      end
+
+      it 'returns an empty hash' do
+        expect(user.auth_mech_properties).to eq({})
+      end
+    end
+  end
+
+  describe '#roles' do
+
+    context 'when roles are provided' do
+
+      let(:roles) do
+        [ Mongo::Auth::Roles::ROOT ]
+      end
+
+      let(:user) do
+        described_class.new(roles: roles)
+      end
+
+      it 'returns the roles' do
+        expect(user.roles).to eq(roles)
+      end
+    end
+
+    context 'when no roles are provided' do
+
+      let(:user) do
+        described_class.new({})
+      end
+
+      it 'returns an empty array' do
+        expect(user.roles).to be_empty
+      end
+    end
+  end
+end

data/spec/mongo/auth/x509_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Mongo::Auth::X509 do
+
+  let(:address) do
+    Mongo::Address.new(DEFAULT_ADDRESS)
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, Mongo::Event::Listeners.new)
+  end
+
+  let(:connection) do
+    Mongo::Server::Connection.new(server)
+  end
+
+  let(:user) do
+    Mongo::Auth::User.new(database: TEST_DB, user: 'driver', password: 'password')
+  end
+
+  describe '#login' do
+
+    context 'when the user is not authorized for the database' do
+
+      let(:cr) do
+        described_class.new(user)
+      end
+
+      let(:login) do
+        cr.login(connection).documents[0]
+      end
+
+      it 'logs the user into the connection' do
+        expect {
+          cr.login(connection)
+        }.to raise_error(Mongo::Auth::Unauthorized)
+      end
+    end
+  end
+end

data/spec/mongo/auth_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Mongo::Auth do
+
+  describe '#get' do
+
+    context 'when a mongodb_cr user is provided' do
+
+      let(:user) do
+        Mongo::Auth::User.new(auth_mech: :mongodb_cr)
+      end
+
+      let(:cr) do
+        described_class.get(user)
+      end
+
+      it 'returns CR' do
+        expect(cr).to be_a(Mongo::Auth::CR)
+      end
+    end
+
+    context 'when a mongodb_x509 user is provided' do
+
+      let(:user) do
+        Mongo::Auth::User.new(auth_mech: :mongodb_x509)
+      end
+
+      let(:x509) do
+        described_class.get(user)
+      end
+
+      it 'returns X509' do
+        expect(x509).to be_a(Mongo::Auth::X509)
+      end
+    end
+
+    context 'when a plain user is provided' do
+
+      let(:user) do
+        Mongo::Auth::User.new(auth_mech: :plain)
+      end
+
+      let(:ldap) do
+        described_class.get(user)
+      end
+
+      it 'returns LDAP' do
+        expect(ldap).to be_a(Mongo::Auth::LDAP)
+      end
+    end
+
+    context 'when an invalid mechanism is provided' do
+
+      let(:user) do
+        Mongo::Auth::User.new(auth_mech: :nothing)
+      end
+
+      it 'raises an error' do
+        expect {
+          described_class.get(user)
+        }.to raise_error(Mongo::Auth::InvalidMechanism)
+      end
+    end
+  end
+end

data/spec/mongo/bulk/bulk_write_spec.rb

@@ -0,0 +1,262 @@
+require 'spec_helper'
+
+describe Mongo::BulkWrite do
+
+  before do
+    authorized_collection.find.delete_many
+  end
+
+  after do
+    authorized_collection.find.delete_many
+  end
+
+  let(:bulk) do
+    described_class.get(authorized_collection, operations, options)
+  end
+
+  describe '#get' do
+
+    let(:operations) do
+      [{ insert_one: { _id: 0 } }]
+    end
+
+    context 'When an ordered bulk write object is created' do
+
+      let(:options) do
+        { ordered: true }
+      end
+
+      it 'returns an OrderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
+      end
+    end
+
+    context 'When an unordered bulk write object is created' do
+
+      let(:options) do
+        { ordered: false }
+      end
+
+      it 'returns an UnorderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::UnorderedBulkWrite)
+      end
+    end
+
+    context 'When ordered is not specified in options' do
+
+      let(:options) do
+        { }
+      end
+
+      it 'returns an OrderedBulkWrite object' do
+        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
+      end
+    end
+  end
+
+  describe 'Ordered bulk write' do
+
+    let(:options) do
+       { ordered: true }
+    end
+     
+    it_behaves_like 'a bulk write object'
+    
+    context 'when the batch requires splitting' do
+    
+      context 'when the operations are the same type' do
+    
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+    
+        let(:operations) do
+          [].tap do |ops|
+            3000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 3001 } }
+          end
+        end
+    
+        it 'raises a BulkWriteError' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'halts execution after first error and reports correct index' do
+          expect(error.result[:write_errors].first['index']).to eq(3000)
+          expect(authorized_collection.find.count).to eq(3000)
+        end
+      end
+
+      context 'when operations are mixed types' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+
+        let(:operations) do
+          [].tap do |ops|
+            2000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { delete_one: { _id: 0 } }
+            ops << { insert_one: { _id: 1 } }
+            ops << { insert_one: { _id: 2000 } }
+          end
+        end
+
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'halts execution after first error and reports correct index' do
+          expect(error.result[:write_errors].first['index']).to eq(2001)
+          expect(authorized_collection.find.count).to eq(1999)
+        end
+      end
+
+      context 'when the operations exceed the max bson size' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+    
+        let(:operations) do
+          [].tap do |ops|
+            6.times do |i|
+              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 100 } }
+          end
+        end
+    
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+    
+        it 'splits messages into multiple messages' do
+          error
+          expect(authorized_collection.find.count).to eq(6)
+        end
+      end
+    end
+  end
+
+  describe 'Unordered bulk write' do
+
+    let(:options) do
+       { ordered: false }
+    end
+
+    it_behaves_like 'a bulk write object'
+
+    context 'when the operations exceed the max batch size' do
+
+      context 'when operations are all the same type' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+
+        let(:operations) do
+          [].tap do |ops|
+            3000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 3001 } }
+          end
+        end
+
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'does not halt execution after first error' do
+          expect(error.result[:write_errors].first['index']).to eq(3000)
+          expect(authorized_collection.find.count).to eq(3001)
+        end
+      end
+
+      context 'when operations are mixed types' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+
+        let(:operations) do
+          [].tap do |ops|
+            2000.times do |i|
+              ops << { insert_one: { _id: i } }
+            end
+            ops << { delete_one: { _id: 0 } }
+            ops << { insert_one: { _id: 1 } }
+            ops << { insert_one: { _id: 2000 } }
+          end
+        end
+
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'does not halt execution after first error' do
+          expect(error.result[:write_errors].first['index']).to eq(2001)
+          expect(authorized_collection.find.count).to eq(2000)
+        end
+      end
+
+      context 'when the operations exceed the max bson size' do
+
+        let(:error) do
+          begin
+            bulk.execute
+          rescue => ex
+            ex
+          end
+        end
+
+        let(:operations) do
+          [].tap do |ops|
+            15.times do |i|
+              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
+            end
+            ops << { insert_one: { _id: 0 } }
+            ops << { insert_one: { _id: 100 } }
+          end
+        end
+
+        it 'raises a BulkWriteError error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        end
+
+        it 'splits messages into multiple messages' do
+          error
+          expect(authorized_collection.find.count).to eq(16)
+        end
+      end
+    end
+  end
+end