mongo 2.1.0.beta → 2.1.0.rc0

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.1.0.beta'.freeze
+  VERSION = '2.1.0.rc0'.freeze
 end

data/spec/mongo/address/unix_spec.rb

@@ -27,7 +27,7 @@ describe Mongo::Address::Unix do
   describe '#socket' do
 
     let(:address) do
-      '/path/to/socket.sock'
+      '/tmp/mongodb-27017.sock'
     end
 
     let(:socket) do

data/spec/mongo/address_spec.rb

@@ -203,4 +203,29 @@ describe Mongo::Address do
       end
     end
   end
+
+  describe "#socket" do
+
+    context 'when providing a DNS entry that resolves to both IPv6 and IPv4' do
+
+      let(:address) do
+        described_class.new(DEFAULT_ADDRESS)
+      end
+
+      let(:host) do
+        DEFAULT_ADDRESS.split(':').first
+      end
+
+      before do
+        allow(::Socket).to receive(:getaddrinfo).and_return(
+          [ ["AF_INET6", 0, '::1', '::1', ::Socket::AF_INET6, 1, 6],
+            ["AF_INET", 0, host, host, ::Socket::AF_INET, 1, 6]]
+        )
+      end
+
+      it "attempts to use IPv6 and fallbacks to IPv4" do
+        expect(address.socket(0.0)).not_to be_nil
+      end
+    end
+  end
 end

data/spec/mongo/auth/ldap/conversation_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Mongo::Auth::LDAP::Conversation do
+
+  let(:user) do
+    Mongo::Auth::User.new(
+      database: Mongo::Database::ADMIN,
+      user: 'user',
+      password: 'pencil'
+    )
+  end
+
+  let(:conversation) do
+    described_class.new(user)
+  end
+
+  describe '#start' do
+
+    let(:query) do
+      conversation.start
+    end
+
+    let(:selector) do
+      query.selector
+    end
+
+    it 'sets the sasl start flag' do
+      expect(selector[:saslStart]).to eq(1)
+    end
+
+    it 'sets the auto authorize flag' do
+      expect(selector[:autoAuthorize]).to eq(1)
+    end
+
+    it 'sets the mechanism' do
+      expect(selector[:mechanism]).to eq('PLAIN')
+    end
+
+    it 'sets the payload' do
+      expect(selector[:payload].data).to eq("\x00user\x00pencil")
+    end
+  end
+end

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

@@ -112,7 +112,32 @@ describe Mongo::Auth::User::View do
     end
   end
 
-  describe '#update' do
+  describe '#info' do
+
+    context 'when a user exists in the database' do
+
+      before do
+        view.create(
+            'emily',
+            password: 'password'
+        )
+      end
+
+      after do
+        view.remove('emily')
+      end
+
+      it 'returns information for that user' do
+        expect(view.info('emily')).to_not be_empty
+      end
+    end
+
+    context 'when a user does not exist in the database' do
+
+      it 'returns nil' do
+        expect(view.info('emily')).to be_empty
+      end
+    end
 
   end
 end

data/spec/mongo/bulk_write/ordered_combiner_spec.rb

@@ -0,0 +1,271 @@
+require 'spec_helper'
+
+describe Mongo::BulkWrite::OrderedCombiner do
+
+  describe '#combine' do
+
+    let(:combiner) do
+      described_class.new(requests)
+    end
+
+    context 'when provided a series of delete one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { delete_one: { filter: { _id: 0 }}},
+            { delete_one: { filter: { _id: 1 }}}
+          ]
+        end
+
+        it 'returns a single delete one' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                delete_one: [
+                  { q: { _id: 0 }, limit: 1 },
+                  { q: { _id: 1 }, limit: 1 }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { delete_one: { filter: { _id: 0 }}},
+            { delete_one: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of delete many' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { delete_many: { filter: { _id: 0 }}},
+            { delete_many: { filter: { _id: 1 }}}
+          ]
+        end
+
+        it 'returns a single delete many' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                delete_many: [
+                  { q: { _id: 0 }, limit: 0 },
+                  { q: { _id: 1 }, limit: 0 }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { delete_many: { filter: { _id: 0 }}},
+            { delete_many: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of insert one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [{ insert_one: { _id: 0 }}, { insert_one: { _id: 1 }}]
+        end
+
+        it 'returns a single insert one' do
+          expect(combiner.combine).to eq(
+            [{ insert_one: [{ _id: 0 }, { _id: 1 }]}]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [{ insert_one: { _id: 0 }}, { insert_one: 'whoami' }]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of replace one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { replace_one: { filter: { _id: 0 }, replacement: { name: 'test' }}},
+            { replace_one: { filter: { _id: 1 }, replacement: { name: 'test' }}}
+          ]
+        end
+
+        it 'returns a single replace one' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                replace_one: [
+                  { q: { _id: 0 }, u: { name: 'test' }, multi: false, upsert: false },
+                  { q: { _id: 1 }, u: { name: 'test' }, multi: false, upsert: false }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { replace_one: { filter: { _id: 0 }, replacement: { name: 'test' }}},
+            { replace_one: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of update one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { update_one: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_one: { filter: { _id: 1 }, update: { '$set' => { name: 'test' }}}}
+          ]
+        end
+
+        it 'returns a single update one' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                update_one: [
+                  { q: { _id: 0 }, u: { '$set' => { name: 'test' }}, multi: false, upsert: false },
+                  { q: { _id: 1 }, u: { '$set' => { name: 'test' }}, multi: false, upsert: false }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { update_one: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_one: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of update many ops' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { update_many: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_many: { filter: { _id: 1 }, update: { '$set' => { name: 'test' }}}}
+          ]
+        end
+
+        it 'returns a single update many' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                update_many: [
+                  { q: { _id: 0 }, u: { '$set' => { name: 'test' }}, multi: true, upsert: false },
+                  { q: { _id: 1 }, u: { '$set' => { name: 'test' }}, multi: true, upsert: false }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { update_many: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_many: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a mix of operations' do
+
+      let(:requests) do
+        [
+          { insert_one: { _id: 0 }},
+          { delete_one: { filter: { _id: 0 }}},
+          { insert_one: { _id: 1 }}
+        ]
+      end
+
+      it 'returns an ordered grouping' do
+        expect(combiner.combine).to eq(
+          [
+            { insert_one: [{ _id: 0 }]},
+            { delete_one: [{ q: { _id: 0 }, limit: 1 }]},
+            { insert_one: [{ _id: 1 }]}
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/mongo/bulk_write/unordered_combiner_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+describe Mongo::BulkWrite::UnorderedCombiner do
+
+  describe '#combine' do
+
+    let(:combiner) do
+      described_class.new(requests)
+    end
+
+    context 'when provided a series of delete one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { delete_one: { filter: { _id: 0 }}},
+            { delete_one: { filter: { _id: 1 }}}
+          ]
+        end
+
+        it 'returns a single delete one' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                delete_one: [
+                  { q: { _id: 0 }, limit: 1 },
+                  { q: { _id: 1 }, limit: 1 }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { delete_one: { filter: { _id: 0 }}},
+            { delete_one: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of delete many' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { delete_many: { filter: { _id: 0 }}},
+            { delete_many: { filter: { _id: 1 }}}
+          ]
+        end
+
+        it 'returns a single delete many' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                delete_many: [
+                  { q: { _id: 0 }, limit: 0 },
+                  { q: { _id: 1 }, limit: 0 }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { delete_many: { filter: { _id: 0 }}},
+            { delete_many: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of insert one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [{ insert_one: { _id: 0 }}, { insert_one: { _id: 1 }}]
+        end
+
+        it 'returns a single insert one' do
+          expect(combiner.combine).to eq(
+            [{ insert_one: [{ _id: 0 }, { _id: 1 }]}]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [{ insert_one: { _id: 0 }}, { insert_one: 'whoami' }]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of update one' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { update_one: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_one: { filter: { _id: 1 }, update: { '$set' => { name: 'test' }}}}
+          ]
+        end
+
+        it 'returns a single update one' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                update_one: [
+                  { q: { _id: 0 }, u: { '$set' => { name: 'test' }}, multi: false, upsert: false },
+                  { q: { _id: 1 }, u: { '$set' => { name: 'test' }}, multi: false, upsert: false }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { update_one: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_one: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a series of update many ops' do
+
+      context 'when the documents are valid' do
+
+        let(:requests) do
+          [
+            { update_many: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_many: { filter: { _id: 1 }, update: { '$set' => { name: 'test' }}}}
+          ]
+        end
+
+        it 'returns a single update many' do
+          expect(combiner.combine).to eq(
+            [
+              {
+                update_many: [
+                  { q: { _id: 0 }, u: { '$set' => { name: 'test' }}, multi: true, upsert: false },
+                  { q: { _id: 1 }, u: { '$set' => { name: 'test' }}, multi: true, upsert: false }
+                ]
+              }
+            ]
+          )
+        end
+      end
+
+      context 'when a document is not valid' do
+
+        let(:requests) do
+          [
+            { update_many: { filter: { _id: 0 }, update: { '$set' => { name: 'test' }}}},
+            { update_many: 'whoami' }
+          ]
+        end
+
+        it 'raises an exception' do
+          expect {
+            combiner.combine
+          }.to raise_error(Mongo::Error::InvalidBulkOperation)
+        end
+      end
+    end
+
+    context 'when provided a mix of operations' do
+
+      let(:requests) do
+        [
+          { insert_one: { _id: 0 }},
+          { delete_one: { filter: { _id: 0 }}},
+          { insert_one: { _id: 1 }},
+          { delete_one: { filter: { _id: 1 }}}
+        ]
+      end
+
+      it 'returns an unordered mixed grouping' do
+        expect(combiner.combine).to eq(
+          [
+            {
+              insert_one: [
+                { _id: 0 },
+                { _id: 1 }
+              ]
+            },
+            {
+              delete_one: [
+                { q: { _id: 0 }, limit: 1 },
+                { q: { _id: 1 }, limit: 1 }
+              ]
+            }
+          ]
+        )
+      end
+    end
+  end
+end