mongo 2.14.1 → 2.15.0.alpha

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,51 +543,55 @@ describe Mongo::Client do
           end
         end
 
-        context 'when the compressor is not supported by the driver' do
-          require_warning_clean
+        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 snappy gem is installed' do
+            require_snappy_compression
 
-          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'] }
+            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
@@ -851,7 +903,8 @@ describe Mongo::Client do
             [
               "Ruby #{RUBY_VERSION}",
               RUBY_PLATFORM,
-              RbConfig::CONFIG['build']
+              RbConfig::CONFIG['build'],
+              'A',
             ].join(', ')
           end
 
@@ -869,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
 
@@ -1547,6 +1601,95 @@ describe Mongo::Client do
           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
@@ -2187,6 +2330,37 @@ describe Mongo::Client do
         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

data/spec/mongo/client_spec.rb

@@ -538,6 +538,23 @@ describe Mongo::Client do
     end
   end
 
+  describe '#database' do
+
+    let(:database) { client.database }
+
+    context 'when client has :server_api option' do
+
+      let(:client) do
+        new_local_client_nmio(['localhost'], server_api: {version: '1'})
+      end
+
+      it 'is not transfered to the collection' do
+        database.options[:server_api].should be nil
+      end
+    end
+
+  end
+
   describe '#database_names' do
 
     it 'returns a list of database names' do

data/spec/mongo/cluster_spec.rb

@@ -352,6 +352,7 @@ describe Mongo::Cluster do
     end
 
     before do
+      cluster.next_primary
       cluster.servers.each do |server|
         expect(server).to receive(:reconnect!).and_call_original
       end

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

@@ -82,7 +82,7 @@ describe Mongo::Collection::View::Explainable do
         it 'triggers server error' do
           lambda do
             explain
-          end.should raise_error(Mongo::Error::OperationFailure, /verbosity string must be/)
+          end.should raise_error(Mongo::Error::OperationFailure, /verbosity string must be|value .* for field .*verbosity.* is not a valid value/)
         end
       end
 

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

@@ -604,36 +604,50 @@ describe Mongo::Collection::View::Readable do
 
   describe "#estimated_document_count" do
 
-   let(:documents) do
-      (1..10).map{ |i| { field: "test#{i}" }}
-   end
-
-   before do
-    authorized_collection.delete_many
-    authorized_collection.insert_many(documents)
-   end
-
     let(:result) do
       view.estimated_document_count(options)
     end
 
-    context 'when a selector is provided' do
+    context 'when collection has documents' do
+      let(:documents) do
+        (1..10).map{ |i| { field: "test#{i}" }}
+      end
 
-      let(:selector) do
-        { field: 'test1' }
+      before do
+        authorized_collection.delete_many
+        authorized_collection.insert_many(documents)
       end
 
-      it 'raises an error' do
-        expect {
-          result
-        }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with a filter")
+      context 'when a selector is provided' do
+
+        let(:selector) do
+          { field: 'test1' }
+        end
+
+        it 'raises an error' do
+          expect {
+            result
+          }.to raise_error(ArgumentError, "Cannot call estimated_document_count when querying with a filter")
+        end
+      end
+
+      context 'when no selector is provided' do
+
+        it 'returns the estimated count of matching documents' do
+          expect(view.estimated_document_count).to eq(10)
+        end
       end
     end
 
-    context 'when no selector is provided' do
+    context 'when collection does not exist' do
+
+      let(:view) do
+        Mongo::Collection::View.new(
+          authorized_client['nonexistent-collection-for-estimated-document-count'], selector, options)
+      end
 
-      it 'returns the estimated count of matching documents' do
-        expect(view.estimated_document_count).to eq(10)
+      it 'returns 0' do
+        view.estimated_document_count.should == 0
       end
     end
   end