mongo 2.13.0 → 2.15.0.alpha

data/spec/mongo/caching_cursor_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Mongo::CachingCursor do
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  let(:authorized_collection) do
+    authorized_client['caching_cursor']
+  end
+
+  before do
+    authorized_collection.drop
+  end
+
+  let(:server) do
+    view.send(:server_selector).select_server(authorized_client.cluster)
+  end
+
+  let(:reply) do
+    view.send(:send_initial_query, server)
+  end
+
+  let(:cursor) do
+    described_class.new(view, reply, server)
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection)
+  end
+
+  before do
+    authorized_collection.delete_many
+    3.times { |i| authorized_collection.insert_one(_id: i) }
+  end
+
+  describe '#cached_docs' do
+    context 'when no query has been performed' do
+      it 'returns nil' do
+        expect(cursor.cached_docs).to be_nil
+      end
+    end
+
+    context 'when a query has been performed' do
+      it 'returns the number of documents' do
+        cursor.to_a
+        expect(cursor.cached_docs.length).to eq(3)
+        expect(cursor.cached_docs).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+      end
+    end
+  end
+
+  describe '#try_next' do
+    it 'fetches the next document' do
+      expect(cursor.try_next).to eq('_id' => 0)
+      expect(cursor.try_next).to eq('_id' => 1)
+      expect(cursor.try_next).to eq('_id' => 2)
+    end
+  end
+
+  describe '#each' do
+    it 'iterates the cursor' do
+      result = cursor.each.to_a
+      expect(result.length).to eq(3)
+      expect(result).to eq([{ '_id' => 0 }, { '_id' => 1 }, { '_id' => 2 }])
+    end
+  end
+end

data/spec/mongo/client_construction_spec.rb

@@ -463,7 +463,56 @@ describe Mongo::Client do
             SpecConfig.instance.all_test_options.merge(options))
         end
 
-        context 'when the compressor is supported' do
+        context 'when the compressor is not supported by the driver' do
+          require_warning_clean
+
+          let(:options) do
+            { compressors: ['snoopy'] }
+          end
+
+          it 'does not set the compressor and warns' do
+            expect(Mongo::Logger.logger).to receive(:warn)
+            expect(client.options['compressors']).to be_nil
+          end
+
+          it 'sets the compression key of the handshake document to an empty array' do
+            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
+          end
+
+          context 'when one supported compressor and one unsupported compressor are provided' do
+            require_compression
+            min_server_fcv '3.6'
+
+            let(:options) do
+              { compressors: ['zlib', 'snoopy'] }
+            end
+
+            it 'does not set the unsupported compressor and warns' do
+              expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
+              expect(client.options['compressors']).to eq(['zlib'])
+            end
+
+            it 'sets the compression key of the handshake document to the list of supported compressors' do
+              expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(['zlib'])
+            end
+          end
+        end
+
+        context 'when the compressor is not supported by the server' do
+          max_server_version '3.4'
+
+          let(:options) do
+            { compressors: ['zlib'] }
+          end
+
+          it 'does not set the compressor and warns' do
+            expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
+            expect(client.cluster.next_primary.monitor.compressor).to be_nil
+          end
+        end
+
+        context 'when zlib compression is requested' do
+          require_zlib_compression
 
           let(:options) do
             { compressors: ['zlib'] }
@@ -478,7 +527,6 @@ describe Mongo::Client do
           end
 
           context 'when server supports compression' do
-            require_compression
             min_server_fcv '3.6'
 
             it 'uses compression for messages' do
@@ -495,50 +543,55 @@ describe Mongo::Client do
           end
         end
 
-        context 'when the compressor is not supported by the driver' do
+        context 'when snappy compression is requested and supported by the server' do
+          min_server_version '3.6'
 
           let(:options) do
-            { compressors: ['snoopy'] }
+            { compressors: ['snappy'] }
           end
 
-          it 'does not set the compressor and warns' do
-            expect(Mongo::Logger.logger).to receive(:warn)
-            expect(client.options['compressors']).to be_nil
-          end
-
-          it 'sets the compression key of the handshake document to an empty array' do
-            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
-          end
-
-          context 'when one supported compressor and one unsupported compressor are provided' do
-            require_compression
-            min_server_fcv '3.6'
+          context 'when snappy gem is installed' do
+            require_snappy_compression
 
-            let(:options) do
-              { compressors: ['zlib', 'snoopy'] }
+            it 'creates the client' do
+              expect(client.options['compressors']).to eq(['snappy'])
             end
+          end
 
-            it 'does not set the unsupported compressor and warns' do
-              expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
-              expect(client.options['compressors']).to eq(['zlib'])
-            end
+          context 'when snappy gem is not installed' do
+            require_no_snappy_compression
 
-            it 'sets the compression key of the handshake document to the list of supported compressors' do
-              expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(['zlib'])
+            it 'raises an exception' do
+              expect do
+                client
+              end.to raise_error(Mongo::Error::UnmetDependency, /Cannot enable snappy compression/)
             end
           end
         end
 
-        context 'when the compressor is not supported by the server' do
-          max_server_version '3.4'
+        context 'when zstd compression is requested and supported by the server' do
+          min_server_version '4.2'
 
           let(:options) do
-            { compressors: ['zlib'] }
+            { compressors: ['zstd'] }
           end
 
-          it 'does not set the compressor and warns' do
-            expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
-            expect(client.cluster.next_primary.monitor.compressor).to be_nil
+          context 'when zstd gem is installed' do
+            require_zstd_compression
+
+            it 'creates the client' do
+              expect(client.options['compressors']).to eq(['zstd'])
+            end
+          end
+
+          context 'when zstd gem is not installed' do
+            require_no_zstd_compression
+
+            it 'raises an exception' do
+              expect do
+                client
+              end.to raise_error(Mongo::Error::UnmetDependency, /Cannot enable zstd compression/)
+            end
           end
         end
       end
@@ -674,7 +727,7 @@ describe Mongo::Client do
       context 'when providing a custom logger' do
 
         let(:logger) do
-          Logger.new($stdout).tap do |l|
+          Logger.new(STDOUT).tap do |l|
             l.level = Logger::FATAL
           end
         end
@@ -844,13 +897,14 @@ describe Mongo::Client do
         end
 
         context 'mri' do
-          only_mri
+          require_mri
 
           let(:platform_string) do
             [
               "Ruby #{RUBY_VERSION}",
               RUBY_PLATFORM,
-              RbConfig::CONFIG['build']
+              RbConfig::CONFIG['build'],
+              'A',
             ].join(', ')
           end
 
@@ -868,7 +922,8 @@ describe Mongo::Client do
               "like Ruby #{RUBY_VERSION}",
               RUBY_PLATFORM,
               "JVM #{java.lang.System.get_property('java.version')}",
-              RbConfig::CONFIG['build']
+              RbConfig::CONFIG['build'],
+              'A',
             ].join(', ')
           end
 
@@ -1311,7 +1366,7 @@ describe Mongo::Client do
         end
 
         context 'when not linting' do
-          skip_if_linting
+          require_no_linting
 
           it 'rejects bogus read preference as symbol' do
             expect do
@@ -1343,6 +1398,46 @@ describe Mongo::Client do
         end
       end
 
+      context 'when setting read concern options' do
+        min_server_fcv '3.2'
+
+        context 'when read concern is valid' do
+          let(:options) do
+            { read_concern: { level: :local } }
+          end
+
+          it 'does not warn' do
+            expect(Mongo::Logger.logger).to_not receive(:warn)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has an invalid key' do
+          require_no_linting
+
+          let(:options) do
+            { read_concern: { hello: :local } }
+          end
+
+          it 'logs a warning' do
+            expect(Mongo::Logger.logger).to receive(:warn).with(/Read concern has invalid keys: hello/)
+            new_local_client_nmio(SpecConfig.instance.addresses, options)
+          end
+        end
+
+        context 'when read concern has a non-user-settable key' do
+          let(:options) do
+            { read_concern: { after_cluster_time: 100 } }
+          end
+
+          it 'raises an exception' do
+            expect do
+              new_local_client_nmio(SpecConfig.instance.addresses, options)
+            end.to raise_error(Mongo::Error::InvalidReadConcern, 'The after_cluster_time read_concern option cannot be specified by the user')
+          end
+        end
+      end
+
       context 'when an invalid option is provided' do
 
         let(:options) do
@@ -1494,6 +1589,107 @@ describe Mongo::Client do
           end
         end
       end
+
+      context ':auth_mech_properties option' do
+        context 'is nil' do
+          let(:options) do
+            {auth_mech_properties: nil}
+          end
+
+          it 'creates the client without the option' do
+            client.options.should_not have_key(:auth_mech_properties)
+          end
+        end
+      end
+
+      context ':server_api parameter' do
+        context 'is a hash with symbol keys' do
+          context 'using known keys' do
+            let(:options) do
+              {server_api: {
+                version: '1',
+                strict: true,
+                deprecation_errors: false,
+              }}
+            end
+
+            it 'is accepted' do
+              client.options[:server_api].should == {
+                'version' => '1',
+                'strict' => true,
+                'deprecation_errors' => false,
+              }
+            end
+          end
+
+          context 'using an unknown version' do
+            let(:options) do
+              {server_api: {
+                version: '42',
+              }}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, 'Unknown server API version: 42')
+            end
+          end
+
+          context 'using an unknown option' do
+            let(:options) do
+              {server_api: {
+                vversion: '1',
+              }}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, 'Unknown keys under :server_api: "vversion"')
+            end
+          end
+
+          context 'using a value which is not a hash' do
+            let(:options) do
+              {server_api: 42}
+            end
+
+            it 'is rejected' do
+              lambda do
+                client
+              end.should raise_error(ArgumentError, ':server_api value must be a hash: 42')
+            end
+          end
+        end
+
+        context 'when connected to a pre-OP_MSG server' do
+          max_server_version '3.4'
+
+          let(:options) do
+            {server_api: {version: 1}}
+          end
+
+          let(:client) do
+            new_local_client(SpecConfig.instance.addresses,
+              SpecConfig.instance.all_test_options.merge(options))
+          end
+
+          it 'constructs the client' do
+            client.should be_a(Mongo::Client)
+          end
+
+          it 'discovers servers' do
+            client.summary.should_not =~ /UNKNOWN/
+          end
+
+          it 'fails operations' do
+            lambda do
+              client.command(ping: 1)
+            end.should raise_error(Mongo::Error::ServerApiNotSupported)
+          end
+        end
+      end
     end
 
     context 'when making a block client' do
@@ -2092,6 +2288,7 @@ describe Mongo::Client do
             sdam_proc: sdam_proc,
             connect_timeout: 3.08, socket_timeout: 3.09,
             server_selection_timeout: 2.92,
+            heartbeat_frequency: 100,
             database: SpecConfig.instance.test_db))
       end
 
@@ -2112,6 +2309,10 @@ describe Mongo::Client do
       end
 
       it 'does not notify subscribers set up by sdam_proc' do
+        # On 4.4, the push monitor also is receiving heartbeats.
+        # Give those some time to be processed.
+        sleep 2
+
         expect(subscriber.started_events.length).to be > 0
         subscriber.started_events.clear
 
@@ -2119,10 +2320,47 @@ describe Mongo::Client do
         # subscriber may receive events from the original client.
 
         new_client.cluster.next_primary
+
+        # Diagnostics
+        unless subscriber.started_events.empty?
+          p subscriber.started_events
+        end
+
         expect(subscriber.started_events.length).to eq 0
         new_client.cluster.topology.class.should_not be Mongo::Cluster::Topology::Unknown
       end
     end
+
+    context 'when :server_api is changed' do
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'])
+      end
+
+      let(:new_client) do
+        client.with(server_api: {version: '1'})
+      end
+
+      it 'changes :server_api' do
+        new_client.options[:server_api].should == {'version' => '1'}
+      end
+    end
+
+    context 'when :server_api is cleared' do
+
+      let(:client) do
+        new_local_client_nmio(['127.0.0.1:27017'], server_api: {version: '1'})
+      end
+
+      let(:new_client) do
+        client.with(server_api: nil)
+      end
+
+      it 'clears :server_api' do
+        new_client.options[:server_api].should be nil
+      end
+    end
+
   end
 
   describe '#dup' do