mongo 2.4.3 → 2.5.0.beta

data/spec/mongo/cursor/builder/get_more_command_spec.rb

@@ -28,6 +28,25 @@ describe Mongo::Cursor::Builder::GetMoreCommand do
       specification[:selector]
     end
 
+    context 'when the operation has a session' do
+
+      let(:view) do
+        Mongo::Collection::View.new(authorized_collection)
+      end
+
+      let(:session) do
+        double('session')
+      end
+
+      let(:builder) do
+        described_class.new(cursor, session)
+      end
+
+      it 'adds the session to the specification' do
+        expect(builder.specification[:session]).to be(session)
+      end
+    end
+
     shared_examples_for 'a getmore command builder' do
 
       it 'includes the database name' do

data/spec/mongo/cursor_spec.rb

@@ -5,7 +5,7 @@ describe Mongo::Cursor do
   describe '#each' do
 
     let(:server) do
-      view.read.select_server(authorized_client.cluster)
+      view.send(:server_selector).select_server(authorized_client.cluster)
     end
 
     let(:reply) do
@@ -22,7 +22,7 @@ describe Mongo::Cursor do
         Mongo::Collection::View.new(authorized_collection)
       end
 
-      context 'when the initial query retieves all documents' do
+      context 'when the initial query retrieves all documents' do
 
         let(:documents) do
           (1..10).map{ |i| { field: "test#{i}" }}

data/spec/mongo/database_spec.rb

@@ -79,7 +79,8 @@ describe Mongo::Database do
       end
 
       it 'applies the options to the collection' do
-        expect(collection.read_preference).to eq(Mongo::ServerSelector.get(mode: :secondary))
+        expect(collection.server_selector).to eq(Mongo::ServerSelector.get(mode: :secondary))
+        expect(collection.read_preference).to eq(BSON::Document.new(mode: :secondary))
       end
     end
   end
@@ -106,6 +107,19 @@ describe Mongo::Database do
       expect(database.collection_names).to_not include('system.indexes')
     end
 
+    context 'when provided a session' do
+
+      let(:operation) do
+        database.collection_names(session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+    end
+
     context 'when specifying a batch size' do
 
       it 'returns the stripped names of the collections' do
@@ -223,6 +237,28 @@ describe Mongo::Database do
       expect(database.command(:ismaster => 1).written_count).to eq(0)
     end
 
+    it 'does not mutate the command selector' do
+      expect(database.command({:ismaster => 1}.freeze).written_count).to eq(0)
+    end
+
+    context 'when provided a session' do
+
+      let(:operation) do
+        database.command({ :ismaster => 1 }, session: session)
+      end
+
+      let(:failed_operation) do
+        database.command({ :invalid => 1 }, session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+      it_behaves_like 'a failed operation using a session'
+    end
+
     context 'when a read concern is provided', if: find_command_enabled? do
 
       context 'when the read concern is valid' do
@@ -409,6 +445,19 @@ describe Mongo::Database do
       }.to raise_error(Mongo::Error::OperationFailure)
     end
 
+    context 'when provided a session' do
+
+      let(:operation) do
+        database.drop(session: session)
+      end
+
+      let(:client) do
+        authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
+    end
+
     context 'when the client/database has a write concern' do
 
       let(:client_options) do

data/spec/mongo/grid/fs_bucket_spec.rb

@@ -3,7 +3,11 @@ require 'spec_helper'
 describe Mongo::Grid::FSBucket do
 
   let(:fs) do
-    described_class.new(authorized_client.database, options)
+    described_class.new(client.database, options)
+  end
+
+  let(:client) do
+    authorized_client
   end
 
   let(:options) do
@@ -54,12 +58,8 @@ describe Mongo::Grid::FSBucket do
           { read: { mode: :secondary } }
         end
 
-        let(:read_pref) do
-          Mongo::ServerSelector.get(Mongo::Options::Redacted.new(options[:read].merge(authorized_client.options)))
-        end
-
         it 'sets the read preference' do
-          expect(fs.send(:read_preference)).to eq(read_pref)
+          expect(fs.send(:read_preference)).to eq(options[:read])
         end
       end
 
@@ -486,7 +486,7 @@ describe Mongo::Grid::FSBucket do
   context 'when a read stream is opened' do
 
     let(:fs) do
-      described_class.new(authorized_client.database)
+      described_class.new(authorized_client.database, options)
     end
 
     let(:io) do
@@ -594,6 +594,29 @@ describe Mongo::Grid::FSBucket do
 
     describe '#download_to_stream' do
 
+      context 'sessions' do
+
+        let(:options) do
+          { session: session }
+        end
+
+        let(:file_id) do
+          fs.open_upload_stream(filename) do |stream|
+            stream.write(file)
+          end.file_id
+        end
+
+        let(:operation) do
+          fs.download_to_stream(file_id, io)
+        end
+
+        let(:client) do
+          authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
+      end
+
       context 'when the file is found' do
 
         let!(:file_id) do
@@ -678,12 +701,13 @@ describe Mongo::Grid::FSBucket do
       end
 
       it 'sets the read preference on the Stream::Read object' do
-        expect(stream.read_preference).to eq(Mongo::ServerSelector.get(options[:read]))
+        expect(stream.read_preference).to eq(options[:read])
       end
     end
 
     describe '#download_to_stream_by_name' do
 
+
       let(:files) do
         [
             StringIO.new('hello 1'),
@@ -693,75 +717,105 @@ describe Mongo::Grid::FSBucket do
         ]
       end
 
-      before do
-        files.each do |file|
-          fs.upload_from_stream('test.txt', file)
+      context ' when using a session' do
+
+        let(:options) do
+          { session: session }
         end
-      end
 
-      let(:io) do
-        StringIO.new
-      end
+        let(:operation) do
+          fs.download_to_stream_by_name('test.txt', io)
+        end
 
-      context 'when revision is not specified' do
+        let(:client) do
+          authorized_client
+        end
 
-        let!(:result) do
-          fs.download_to_stream_by_name('test.txt', io)
+        before do
+          files.each do |file|
+            authorized_client.database.fs.upload_from_stream('test.txt', file)
+          end
         end
 
-        it 'returns the most recent version' do
-          expect(io.string).to eq('hello 4')
+        let(:io) do
+          StringIO.new
         end
+
+        it_behaves_like 'an operation using a session'
       end
 
-      context 'when revision is 0' do
+      context 'when not using a session' do
 
-        let!(:result) do
-          fs.download_to_stream_by_name('test.txt', io, revision: 0)
+        before do
+          files.each do |file|
+            fs.upload_from_stream('test.txt', file)
+          end
         end
 
-        it 'returns the original stored file' do
-          expect(io.string).to eq('hello 1')
+        let(:io) do
+          StringIO.new
         end
-      end
 
-      context 'when revision is negative' do
+        context 'when revision is not specified' do
+
+          let!(:result) do
+            fs.download_to_stream_by_name('test.txt', io)
+          end
 
-        let!(:result) do
-          fs.download_to_stream_by_name('test.txt', io, revision: -2)
+          it 'returns the most recent version' do
+            expect(io.string).to eq('hello 4')
+          end
         end
 
-        it 'returns that number of versions from the most recent' do
-          expect(io.string).to eq('hello 3')
+        context 'when revision is 0' do
+
+          let!(:result) do
+            fs.download_to_stream_by_name('test.txt', io, revision: 0)
+          end
+
+          it 'returns the original stored file' do
+            expect(io.string).to eq('hello 1')
+          end
         end
-      end
 
-      context 'when revision is positive' do
+        context 'when revision is negative' do
+
+          let!(:result) do
+            fs.download_to_stream_by_name('test.txt', io, revision: -2)
+          end
 
-        let!(:result) do
-          fs.download_to_stream_by_name('test.txt', io, revision: 1)
+          it 'returns that number of versions from the most recent' do
+            expect(io.string).to eq('hello 3')
+          end
         end
 
-        it 'returns that number revision' do
-          expect(io.string).to eq('hello 2')
+        context 'when revision is positive' do
+
+          let!(:result) do
+            fs.download_to_stream_by_name('test.txt', io, revision: 1)
+          end
+
+          it 'returns that number revision' do
+            expect(io.string).to eq('hello 2')
+          end
         end
-      end
 
-      context 'when the file revision is not found' do
+        context 'when the file revision is not found' do
 
-        it 'raises a FileNotFound error' do
-          expect {
-            fs.download_to_stream_by_name('test.txt', io, revision: 100)
-          }.to raise_exception(Mongo::Error::InvalidFileRevision)
+          it 'raises a FileNotFound error' do
+            expect {
+              fs.download_to_stream_by_name('test.txt', io, revision: 100)
+            }.to raise_exception(Mongo::Error::InvalidFileRevision)
+          end
         end
-      end
 
-      context 'when the file is not found' do
+        context 'when the file is not found' do
 
-        it 'raises a FileNotFound error' do
-          expect {
-            fs.download_to_stream_by_name('non-existent.txt', io)
-          }.to raise_exception(Mongo::Error::FileNotFound)
+          it 'raises a FileNotFound error' do
+            expect {
+              fs.download_to_stream_by_name('non-existent.txt', io)
+            }.to raise_exception(Mongo::Error::FileNotFound)
+          end
         end
       end
     end
@@ -777,124 +831,154 @@ describe Mongo::Grid::FSBucket do
         ]
       end
 
-      before do
-        files.each do |file|
-          fs.upload_from_stream('test.txt', file)
-        end
-      end
-
       let(:io) do
         StringIO.new
       end
 
-      context 'when a block is provided' do
+      context ' when using a session' do
 
-        let(:stream) do
-          fs.open_download_stream_by_name('test.txt') do |stream|
-            io.write(stream.read)
-          end
+        let(:options) do
+          { session: session }
         end
 
-        it 'returns a Stream::Read object' do
-          expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Read)
+        let(:operation) do
+          fs.download_to_stream_by_name('test.txt', io)
         end
 
-        it 'closes the stream after the block completes' do
-          expect(stream.closed?).to be(true)
+        let(:client) do
+          authorized_client
         end
 
-        it 'yields the stream to the block' do
-          stream
-          expect(io.size).to eq(files[0].size)
+        before do
+          files.each do |file|
+            authorized_client.database.fs.upload_from_stream('test.txt', file)
+          end
         end
 
-        context 'when revision is not specified' do
+        let(:io) do
+          StringIO.new
+        end
 
-          let!(:result) do
-            fs.open_download_stream_by_name('test.txt') do |stream|
-              io.write(stream.read)
-            end
-          end
+        it_behaves_like 'an operation using a session'
+      end
 
-          it 'returns the most recent version' do
-            expect(io.string).to eq('hello 4')
+      context 'when not using a session' do
+
+        before do
+          files.each do |file|
+            fs.upload_from_stream('test.txt', file)
           end
         end
 
-        context 'when revision is 0' do
+        context 'when a block is provided' do
 
-          let!(:result) do
-            fs.open_download_stream_by_name('test.txt', revision: 0) do |stream|
+          let(:stream) do
+            fs.open_download_stream_by_name('test.txt') do |stream|
               io.write(stream.read)
             end
           end
 
-          it 'returns the original stored file' do
-            expect(io.string).to eq('hello 1')
+          it 'returns a Stream::Read object' do
+            expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Read)
           end
-        end
 
-        context 'when revision is negative' do
+          it 'closes the stream after the block completes' do
+            expect(stream.closed?).to be(true)
+          end
 
-          let!(:result) do
-            fs.open_download_stream_by_name('test.txt', revision: -2) do |stream|
-              io.write(stream.read)
+          it 'yields the stream to the block' do
+            stream
+            expect(io.size).to eq(files[0].size)
+          end
+
+          context 'when revision is not specified' do
+
+            let!(:result) do
+              fs.open_download_stream_by_name('test.txt') do |stream|
+                io.write(stream.read)
+              end
+            end
+
+            it 'returns the most recent version' do
+              expect(io.string).to eq('hello 4')
             end
           end
 
-          it 'returns that number of versions from the most recent' do
-            expect(io.string).to eq('hello 3')
+          context 'when revision is 0' do
+
+            let!(:result) do
+              fs.open_download_stream_by_name('test.txt', revision: 0) do |stream|
+                io.write(stream.read)
+              end
+            end
+
+            it 'returns the original stored file' do
+              expect(io.string).to eq('hello 1')
+            end
           end
-        end
 
-        context 'when revision is positive' do
+          context 'when revision is negative' do
 
-          let!(:result) do
-            fs.open_download_stream_by_name('test.txt', revision: 1) do |stream|
-              io.write(stream.read)
+            let!(:result) do
+              fs.open_download_stream_by_name('test.txt', revision: -2) do |stream|
+                io.write(stream.read)
+              end
+            end
+
+            it 'returns that number of versions from the most recent' do
+              expect(io.string).to eq('hello 3')
             end
           end
 
-          it 'returns that number revision' do
-            expect(io.string).to eq('hello 2')
+          context 'when revision is positive' do
+
+            let!(:result) do
+              fs.open_download_stream_by_name('test.txt', revision: 1) do |stream|
+                io.write(stream.read)
+              end
+            end
+
+            it 'returns that number revision' do
+              expect(io.string).to eq('hello 2')
+            end
           end
-        end
 
-        context 'when the file revision is not found' do
+          context 'when the file revision is not found' do
 
-          it 'raises a FileNotFound error' do
-            expect {
-              fs.open_download_stream_by_name('test.txt', revision: 100)
-            }.to raise_exception(Mongo::Error::InvalidFileRevision)
+            it 'raises a FileNotFound error' do
+              expect {
+                fs.open_download_stream_by_name('test.txt', revision: 100)
+              }.to raise_exception(Mongo::Error::InvalidFileRevision)
+            end
           end
-        end
 
-        context 'when the file is not found' do
+          context 'when the file is not found' do
 
-          it 'raises a FileNotFound error' do
-            expect {
-              fs.open_download_stream_by_name('non-existent.txt')
-            }.to raise_exception(Mongo::Error::FileNotFound)
+            it 'raises a FileNotFound error' do
+              expect {
+                fs.open_download_stream_by_name('non-existent.txt')
+              }.to raise_exception(Mongo::Error::FileNotFound)
+            end
           end
         end
-      end
 
-      context 'when a block is not provided' do
+        context 'when a block is not provided' do
 
-        let!(:stream) do
-          fs.open_download_stream_by_name('test.txt')
-        end
+          let!(:stream) do
+            fs.open_download_stream_by_name('test.txt')
+          end
 
-        it 'returns a Stream::Read object' do
-          expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Read)
-        end
+          it 'returns a Stream::Read object' do
+            expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Read)
+          end
 
-        it 'does not close the stream' do
-          expect(stream.closed?).to be(false)
-        end
+          it 'does not close the stream' do
+            expect(stream.closed?).to be(false)
+          end
 
-        it 'does not yield the stream to the block' do
-          expect(io.size).to eq(0)
+          it 'does not yield the stream to the block' do
+            expect(io.size).to eq(0)
+          end
         end
       end
     end
@@ -941,32 +1025,36 @@ describe Mongo::Grid::FSBucket do
 
       context 'when a block is provided' do
 
-        let!(:stream) do
-          fs.open_upload_stream(filename) do |stream|
-            stream.write(file)
+        context 'when a session is not used' do
+
+          let!(:stream) do
+            fs.open_upload_stream(filename) do |stream|
+              stream.write(file)
+            end
           end
-        end
 
-        let(:result) do
-          fs.find_one(filename: filename)
-        end
+          let(:result) do
+            fs.find_one(filename: filename)
+          end
 
-        it 'returns the stream' do
-          expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Write)
-        end
+          it 'returns the stream' do
+            expect(stream).to be_a(Mongo::Grid::FSBucket::Stream::Write)
+          end
 
-        it 'creates an ObjectId for the file' do
-          expect(stream.file_id).to be_a(BSON::ObjectId)
-        end
+          it 'creates an ObjectId for the file' do
+            expect(stream.file_id).to be_a(BSON::ObjectId)
+          end
 
-        it 'yields the stream to the block' do
-          expect(result.data.size).to eq(file.size)
-        end
+          it 'yields the stream to the block' do
+            expect(result.data.size).to eq(file.size)
+          end
 
-        it 'closes the stream when the block completes' do
-          expect(stream.closed?).to be(true)
+          it 'closes the stream when the block completes' do
+            expect(stream.closed?).to be(true)
+          end
         end
       end
+
     end
 
     describe '#upload_from_stream' do