mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/auth/scram_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Mongo::Auth::SCRAM 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
+
+  describe '#login' do
+
+    context 'when the user is not authorized' do
+
+      let(:user) do
+        Mongo::Auth::User.new(
+          database: 'driver',
+          user: 'notauser',
+          password: 'password'
+        )
+      end
+
+      let(:cr) do
+        described_class.new(user)
+      end
+
+      it 'raises an exception', if: list_command_enabled? do
+        expect {
+          cr.login(connection)
+        }.to raise_error(Mongo::Auth::Unauthorized)
+      end
+    end
+  end
+
+  context 'when the user is authorized for the database' do
+
+    let(:cr) do
+      described_class.new(root_user)
+    end
+
+    let(:login) do
+      cr.login(connection).documents[0]
+    end
+
+    it 'logs the user into the connection', if: list_command_enabled? do
+      expect(login['ok']).to eq(1)
+    end
+  end
+end

data/spec/mongo/auth/user/view_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Mongo::Auth::User::View do
+
+  let(:view) do
+    described_class.new(root_authorized_client.database)
+  end
+
+  describe '#create' do
+
+    let!(:response) do
+      view.create(
+        'durran',
+        password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+      )
+    end
+
+    after do
+      view.remove('durran')
+    end
+
+    context 'when user creation was successful' do
+
+      it 'saves the user in the database' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when creation was not successful' do
+
+      it 'raises an exception' do
+        expect {
+          view.create('durran', password: 'password')
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  describe '#remove' do
+
+    context 'when user removal was successful' do
+
+      before do
+        view.create(
+          'durran',
+          password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+        )
+      end
+
+      let(:response) do
+        view.remove('durran')
+      end
+
+      it 'saves the user in the database' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when removal was not successful' do
+
+      it 'raises an exception', if: write_command_enabled? do
+        expect {
+          view.remove('notauser')
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+
+      it 'does not raise an exception', unless: write_command_enabled? do
+        expect(view.remove('notauser').written_count).to eq(0)
+      end
+    end
+  end
+
+  describe '#update' do
+
+  end
+end

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,175 @@
+require 'spec_helper'
+
+describe Mongo::BulkWrite do
+
+  before do
+    authorized_collection.find.remove_many
+  end
+
+  describe '#execute' do
+
+    let(:bulk) do
+      described_class.new(operations, options, authorized_collection)
+    end
+
+    context 'when the operations are ordered' do
+
+      let(:options) do
+        { ordered: true }
+      end
+
+      it_behaves_like 'a bulk write object'
+
+      context 'when the insert batch requires splitting' do
+
+        context 'when the operations exceed the max batch size' 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 an error' do
+            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+          end
+
+          it 'halts execution after first error and reports correct index' do
+            expect(error.result['writeErrors'].first['index']).to eq(3000)
+            expect(authorized_collection.find.count).to eq(3000)
+          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 an error' do
+            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+          end
+
+          it 'splits messages into multiple messages' do
+            error
+            expect(authorized_collection.find.count).to eq(6)
+          end
+        end
+      end
+    end
+
+    context 'when the operations are unordered' do
+
+      before do
+        authorized_collection.find.remove_many
+      end
+
+      let(:options) do
+        { ordered: false }
+      end
+
+      let(:bulk) do
+        described_class.new(operations, options, authorized_collection)
+      end
+
+      it_behaves_like 'a bulk write object'
+
+      context 'when the insert batch requires splitting' do
+
+        context 'when the operations exceed the max batch size' 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
+
+          after do
+            authorized_collection.find.remove_many
+          end
+
+          it 'raises an error' do
+            expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+          end
+
+          it 'does not halt execution after first error' do
+            expect(error.result['writeErrors'].first['index']).to eq(3000)
+            expect(authorized_collection.find.count).to eq(3001)
+          end
+        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
+
+        after do
+          authorized_collection.find.remove_many
+        end
+
+        it 'raises an error' do
+          expect(error).to be_a(Mongo::Error::BulkWriteFailure)
+        end
+
+        it 'splits messages into multiple messages' do
+          error
+          expect(authorized_collection.find.count).to eq(16)
+        end
+      end
+    end
+  end
+end