mongo 2.2.7 → 2.3.0

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -370,7 +370,7 @@ describe Mongo::Collection::View::Aggregation do
     end
 
 
-    context 'when the context is not a valid server for writing' do
+    context 'when the server is not a valid for writing' do
 
      it 'reroutes the operation to a primary' do
        allow(aggregation).to receive(:valid_server?).and_return(false)
@@ -379,7 +379,7 @@ describe Mongo::Collection::View::Aggregation do
      end
     end
 
-    context 'when the context is a valid server for writing' do
+    context 'when the server is a valid for writing' do
 
      it 'does not reroute the operation to a primary' do
        expect(Mongo::Logger.logger).not_to receive(:warn?)

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -328,7 +328,7 @@ describe Mongo::Collection::View::MapReduce do
         expect(map_reduce.send(:secondary_ok?)).to be false
       end
 
-      context 'when the context is not a valid server for writing' do
+      context 'when the server is not a valid for writing' do
 
         it 'reroutes the operation to a primary' do
           allow(map_reduce).to receive(:valid_server?).and_return(false)
@@ -337,7 +337,7 @@ describe Mongo::Collection::View::MapReduce do
         end
       end
 
-      context 'when the context is a valid server for writing' do
+      context 'when the server is a valid for writing' do
 
         it 'does not reroute the operation to a primary' do
           expect(Mongo::Logger.logger).not_to receive(:warn?)

data/spec/mongo/collection/view/readable_spec.rb

@@ -309,6 +309,93 @@ describe Mongo::Collection::View::Readable do
       expect(view.count(read: { mode: :secondary })).to eq(10)
     end
 
+    context 'when the collection has a read preference set' do
+
+      after do
+        client.close
+      end
+
+      let(:client) do
+        # Set a timeout in case the collection read_preference does get used.
+        # Otherwise, the test will hang for 30 seconds.
+        authorized_client.with(server_selection_timeout: 1)
+      end
+
+      let(:read_preference) do
+        { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
+      end
+
+      let(:collection) do
+        client[authorized_collection.name, read: read_preference]
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, selector, options)
+      end
+
+      context 'when a read preference argument is provided' do
+
+        let(:result) do
+          view.count(read: { mode: :primary })
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect(result).to eq(10)
+        end
+      end
+
+      context 'when no read preference argument is provided', unless: sharded? do
+
+        before do
+          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
+        end
+
+        let(:result) do
+          view.count
+        end
+
+        it 'uses the read preference of the collection' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context 'when the collection does not have a read preference set', unless: sharded? do
+
+        after do
+          client.close
+        end
+
+        let(:client) do
+          authorized_client.with(server_selection_timeout: 1)
+        end
+
+        before do
+          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
+        end
+
+        let(:collection) do
+          client[authorized_collection.name]
+        end
+
+        let(:view) do
+          Mongo::Collection::View.new(collection, selector, options)
+        end
+
+        let(:result) do
+          read_preference = { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
+          view.count(read: read_preference)
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+    end
+
     it 'takes a max_time_ms option', if: write_command_enabled? do
       expect {
         view.count(max_time_ms: 0.1)
@@ -434,7 +521,7 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
-    context 'when a read preference is specified' do
+    context 'when the collection has a read preference set' do
 
       let(:documents) do
         (1..3).map{ |i| { field: "test#{i}" }}
@@ -444,12 +531,93 @@ describe Mongo::Collection::View::Readable do
         authorized_collection.insert_many(documents)
       end
 
-      let(:distinct) do
-        view.distinct(:field, read: { mode: :secondary })
+      after do
+        client.close
       end
 
-      it 'returns the distinct values' do
-        expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
+      let(:client) do
+        # Set a timeout in case the collection read_preference does get used.
+        # Otherwise, the test will hang for 30 seconds.
+        authorized_client.with(server_selection_timeout: 1)
+      end
+
+      let(:read_preference) do
+        { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
+      end
+
+      let(:collection) do
+        client[authorized_collection.name, read: read_preference]
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, selector, options)
+      end
+
+      context 'when a read preference argument is provided' do
+
+        let(:distinct) do
+          view.distinct(:field, read: { mode: :primary })
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
+        end
+      end
+
+      context 'when no read preference argument is provided', unless: sharded? do
+
+        before do
+          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
+        end
+
+        let(:distinct) do
+          view.distinct(:field)
+        end
+
+        it 'uses the read preference of the collection' do
+          expect {
+            distinct
+          }.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context 'when the collection does not have a read preference set', unless: sharded? do
+
+        let(:documents) do
+          (1..3).map{ |i| { field: "test#{i}" }}
+        end
+
+        before do
+          authorized_collection.insert_many(documents)
+          allow(view.collection.client.cluster).to receive(:single?).and_return(false)
+        end
+
+        after do
+          client.close
+        end
+
+        let(:client) do
+          authorized_client.with(server_selection_timeout: 1)
+        end
+
+        let(:collection) do
+          client[authorized_collection.name]
+        end
+
+        let(:view) do
+          Mongo::Collection::View.new(collection, selector, options)
+        end
+
+        let(:distinct) do
+          read_preference = { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }
+          view.distinct(:field, read: read_preference)
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect {
+            distinct
+          }.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
       end
     end
 
@@ -793,6 +961,36 @@ describe Mongo::Collection::View::Readable do
     end
   end
 
+  describe '#cusor_type' do
+
+    let(:options) do
+      { :cursor_type => :tailable }
+    end
+
+    context 'when cursor_type is specified' do
+
+      let(:new_cursor_type) do
+        :tailable_await
+      end
+
+      it 'sets the cursor_type value' do
+        new_view = view.cursor_type(new_cursor_type)
+        expect(new_view.cursor_type).to eq(new_cursor_type)
+      end
+
+      it 'returns a new View' do
+        expect(view.cursor_type(new_cursor_type)).not_to be(view)
+      end
+    end
+
+    context 'when cursor_type is not specified' do
+
+      it 'returns the cursor_type value' do
+        expect(view.cursor_type).to eq(options[:cursor_type])
+      end
+    end
+  end
+
   describe '#skip' do
 
     context 'when a skip is specified' do

data/spec/mongo/collection/view_spec.rb

@@ -246,6 +246,16 @@ describe Mongo::Collection::View do
       it 'parses standard options' do
         expect(view.options).to eq(options)
       end
+
+      it 'only freezes the view filter, not the user filter' do
+        expect(view.filter.frozen?).to be(true)
+        expect(filter.frozen?).to be(false)
+      end
+
+      it 'only freezes the view options, not the user options' do
+        expect(view.options.frozen?).to be(true)
+        expect(options.frozen?).to be(false)
+      end
     end
 
     context 'when the filter contains modifiers' do

data/spec/mongo/collection_spec.rb

@@ -135,12 +135,8 @@ describe Mongo::Collection do
           Mongo::Client.new(ADDRESSES, server_selection_timeout: 2)
         end
 
-        let(:server_selection_timeout) do
-          new_collection.read_preference.server_selection_timeout
-        end
-
-        it 'keeps the server_selection_timeout setting from client' do
-          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        it 'passes the the server_selection_timeout to the cluster' do
+          expect(client.cluster.options[:server_selection_timeout]).to eq(client.options[:server_selection_timeout])
         end
       end
 
@@ -152,6 +148,7 @@ describe Mongo::Collection do
 
         it 'sets the new read options on the new collection' do
           expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+          expect(new_collection.read_preference).not_to eq(client.read_preference)
         end
       end
 
@@ -161,16 +158,12 @@ describe Mongo::Collection do
           Mongo::Client.new(ADDRESSES, read: { mode: :primary_preferred }, server_selection_timeout: 2)
         end
 
-        let(:server_selection_timeout) do
-          new_collection.read_preference.server_selection_timeout
-        end
-
         it 'sets the new read options on the new collection' do
           expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
         end
 
-        it 'keeps the server_selection_timeout setting from client' do
-          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        it 'passes the server_selection_timeout setting to the cluster' do
+          expect(client.cluster.options[:server_selection_timeout]).to eq(client.options[:server_selection_timeout])
         end
       end
     end
@@ -228,12 +221,8 @@ describe Mongo::Collection do
           Mongo::Client.new(ADDRESSES, server_selection_timeout: 2)
         end
 
-        let(:server_selection_timeout) do
-          new_collection.read_preference.server_selection_timeout
-        end
-
-        it 'keeps the server_selection_timeout setting from client' do
-          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        it 'passes the server_selection_timeout setting to the cluster' do
+          expect(client.cluster.options[:server_selection_timeout]).to eq(client.options[:server_selection_timeout])
         end
       end
 
@@ -245,6 +234,7 @@ describe Mongo::Collection do
 
         it 'sets the new read options on the new collection' do
           expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+          expect(new_collection.read_preference).not_to be(client.read_preference)
         end
       end
     end
@@ -719,6 +709,19 @@ describe Mongo::Collection do
       expect(result.inserted_ids.size).to eq(2)
     end
 
+    context 'when a document contains invalid keys' do
+
+      let(:docs) do
+        [ { 'first.name' => 'test1' }, { name: 'test2' } ]
+      end
+
+      it 'raises a BSON::String::IllegalKey exception' do
+        expect {
+          authorized_collection.insert_many(docs)
+        }.to raise_exception(BSON::String::IllegalKey)
+      end
+    end
+
     context 'when the client has a custom id generator' do
 
       let(:generator) do
@@ -842,6 +845,19 @@ describe Mongo::Collection do
       expect(result.inserted_id).to_not be_nil
     end
 
+    context 'when the document contains invalid keys' do
+
+      let(:doc) do
+        { 'testing.test' => 'value' }
+      end
+
+      it 'raises a BSON::String::IllegalKey exception' do
+        expect {
+          authorized_collection.insert_one(doc)
+        }.to raise_exception(BSON::String::IllegalKey)
+      end
+    end
+
     context 'when the insert fails' do
 
       let(:result) do
@@ -1216,6 +1232,36 @@ describe Mongo::Collection do
         end
       end
     end
+
+    context 'when the collection has a read preference', unless: sharded? do
+
+      before do
+        allow(collection.client.cluster).to receive(:single?).and_return(false)
+      end
+
+      after do
+        client.close
+      end
+
+      let(:client) do
+        authorized_client.with(server_selection_timeout: 0.2)
+      end
+
+      let(:collection) do
+        client[authorized_collection.name,
+               read: { :mode => :secondary, :tag_sets => [{ 'non' => 'existent' }] }]
+      end
+
+      let(:result) do
+        collection.parallel_scan(2)
+      end
+
+      it 'uses that read preference' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::NoServerAvailable)
+      end
+    end
   end
 
   describe '#replace_one' do

data/spec/mongo/cursor_spec.rb

@@ -232,6 +232,95 @@ describe Mongo::Cursor do
         end
       end
     end
+
+    context 'when the cursor is not fully iterated and is garbage collected' do
+
+      let(:documents) do
+        (1..3).map{ |i| { field: "test#{i}" }}
+      end
+
+      before do
+        authorized_collection.insert_many(documents)
+        cursor_reaper.schedule_kill_cursor(cursor.id,
+                                            cursor.send(:kill_cursors_op_spec),
+                                            cursor.instance_variable_get(:@server))
+      end
+
+      after do
+        authorized_collection.delete_many
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(
+            authorized_collection,
+            {},
+            :batch_size => 2
+        )
+      end
+
+      let!(:cursor) do
+        view.to_enum.next
+        view.instance_variable_get(:@cursor)
+      end
+
+      let(:cursor_reaper) do
+        authorized_client.cluster.instance_variable_get(:@cursor_reaper)
+      end
+
+
+      it 'schedules a kill cursors op' do
+        sleep(Mongo::Cluster::CursorReaper::FREQUENCY + 0.5)
+        expect {
+          cursor.to_a
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+
+      context 'when the cursor is unregistered before the kill cursors operations are executed' do
+
+        it 'does not send a kill cursors operation for the unregistered cursor' do
+          cursor_reaper.unregister_cursor(cursor.id)
+          expect(cursor.to_a.size).to eq(documents.size)
+        end
+      end
+    end
+
+    context 'when the cursor is fully iterated' do
+
+      let(:documents) do
+        (1..3).map{ |i| { field: "test#{i}" }}
+      end
+
+      before do
+        authorized_collection.insert_many(documents)
+      end
+
+      after do
+        authorized_collection.delete_many
+      end
+
+      let(:view) do
+        authorized_collection.find({}, batch_size: 2)
+      end
+
+      let!(:cursor_id) do
+        enum.next
+        enum.next
+        view.instance_variable_get(:@cursor).id
+      end
+
+      let(:enum) do
+        view.to_enum
+      end
+
+      let(:cursor_reaper) do
+        authorized_collection.client.cluster.instance_variable_get(:@cursor_reaper)
+      end
+
+      it 'removes the cursor id from the active cursors tracked by the cluster cursor manager' do
+        enum.next
+        expect(cursor_reaper.instance_variable_get(:@active_cursors)).not_to include(cursor_id)
+      end
+    end
   end
 
   describe '#inspect' do