mongo 2.14.0 → 2.15.0.alpha

data/spec/mongo/operation/update_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe Mongo::Operation::Update do
+  require_no_required_api_version
+
+  let(:context) { Mongo::Operation::Context.new }
 
   let(:document) do
     { :q => { :foo => 1 },
@@ -100,7 +103,7 @@ describe Mongo::Operation::Update do
         end
 
         let(:result) do
-          update.execute(authorized_primary, client: nil)
+          update.execute(authorized_primary, context: context)
         end
 
         it 'updates the document' do
@@ -128,7 +131,7 @@ describe Mongo::Operation::Update do
 
         it 'raises an exception' do
           expect {
-            update.execute(authorized_primary, client: nil)
+            update.execute(authorized_primary, context: context)
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
@@ -152,7 +155,7 @@ describe Mongo::Operation::Update do
         end
 
         let(:result) do
-          update.execute(authorized_primary, client: nil)
+          update.execute(authorized_primary, context: context)
         end
 
         it 'updates the documents' do
@@ -180,7 +183,7 @@ describe Mongo::Operation::Update do
 
         it 'raises an exception' do
           expect {
-            update.execute(authorized_primary, client: nil)
+            update.execute(authorized_primary, context: context)
           }.to raise_error(Mongo::Error::OperationFailure)
         end
       end
@@ -193,7 +196,7 @@ describe Mongo::Operation::Update do
 
         it 'raises an error' do
           expect {
-            update.execute(authorized_primary, client: nil)
+            update.execute(authorized_primary, context: context)
           }.to raise_error(Mongo::Error::MaxBSONSize)
         end
       end
@@ -205,7 +208,7 @@ describe Mongo::Operation::Update do
         end
 
         let(:result) do
-          update.execute(authorized_primary, client: nil)
+          update.execute(authorized_primary, context: context)
         end
 
         it 'inserts the document' do
@@ -243,7 +246,7 @@ describe Mongo::Operation::Update do
       end
 
       let(:result) do
-        update.execute(authorized_primary, client: nil)
+        update.execute(authorized_primary, context: context)
       end
 
       before do

data/spec/mongo/operation/update_user_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe Mongo::Operation::UpdateUser do
+  require_no_required_api_version
+
+  let(:context) { Mongo::Operation::Context.new }
 
   describe '#execute' do
 
@@ -35,7 +38,7 @@ describe Mongo::Operation::UpdateUser do
     context 'when user update was successful' do
 
       let!(:response) do
-        operation.execute(root_authorized_primary, client: nil)
+        operation.execute(root_authorized_primary, context: context)
       end
 
       it 'updates the user in the database' do

data/spec/mongo/protocol/compressed_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::Protocol::Compressed do
 
@@ -10,15 +10,35 @@ describe Mongo::Protocol::Compressed do
     described_class.new(original_message, compressor, level)
   end
 
+  let(:original_message_bytes) do
+    buf = BSON::ByteBuffer.new
+    original_message.send(:serialize_fields, buf)
+    buf.to_s
+  end
+
   describe '#serialize' do
 
-    context 'when zlib compression level is not provided' do
+    context "when using the snappy compressor" do
+      require_snappy_compression
+      let(:compressor) { 'snappy' }
+
+      it "uses snappy" do
+        expect(Snappy).to receive(:deflate).with(original_message_bytes).and_call_original
+        message.serialize
+      end
+    end
 
-      let(:original_message_bytes) do
-        buf = BSON::ByteBuffer.new
-        original_message.send(:serialize_fields, buf)
-        buf.to_s
+    context "when using the zstd compressor" do
+      require_zstd_compression
+      let(:compressor) { 'zstd' }
+
+      it "uses zstd with default compression level" do
+        expect(Zstd).to receive(:compress).with(original_message_bytes).and_call_original
+        message.serialize
       end
+    end
+
+    context 'when zlib compression level is not provided' do
 
       it 'does not set a compression level' do
         expect(Zlib::Deflate).to receive(:deflate).with(original_message_bytes, nil).and_call_original
@@ -30,12 +50,6 @@ describe Mongo::Protocol::Compressed do
 
       let(:level) { 1 }
 
-      let(:original_message_bytes) do
-        buf = BSON::ByteBuffer.new
-        original_message.send(:serialize_fields, buf)
-        buf.to_s
-      end
-
       it 'uses the compression level' do
         expect(Zlib::Deflate).to receive(:deflate).with(original_message_bytes, 1).and_call_original
         message.serialize

data/spec/mongo/query_cache_middleware_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe Mongo::QueryCache::Middleware do
+
+  let :middleware do
+    described_class.new(app)
+  end
+
+  context "when not touching query cache in the app" do
+
+    let(:app) do
+      lambda do |env|
+        @enabled = Mongo::QueryCache.enabled?
+        [200, env, "app"]
+      end
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it "enables the query cache" do
+      middleware.call({})
+      expect(@enabled).to be true
+    end
+  end
+
+  context "when querying in the app" do
+
+    before do
+      authorized_client['test'].insert_one(test: 1)
+    end
+
+    let(:app) do
+      lambda do |env|
+        authorized_client['test'].find
+        [200, env, "app"]
+      end
+    end
+
+    it "returns success" do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it "cleans the query cache after it responds" do
+      middleware.call({})
+      expect(Mongo::QueryCache.send(:cache_table)).to be_empty
+    end
+  end
+end

data/spec/mongo/retryable_spec.rb

@@ -574,8 +574,9 @@ describe Mongo::Retryable do
     context 'when an error due to using an unsupported storage engine occurs' do
       before do
         expect(operation).to receive(:execute).and_raise(
-          Mongo::Error::OperationFailure.new('Transaction numbers are only allowed on...',
-            nil, :code=>20)).ordered
+          Mongo::Error::OperationFailure.new('message which is not checked',
+            nil, code: 20, server_message: 'Transaction numbers are only allowed on...',
+        )).ordered
       end
 
       it 'raises an exception with the correct error message' do

data/spec/mongo/server/app_metadata_spec.rb

@@ -53,6 +53,8 @@ describe Mongo::Server::AppMetadata do
     end
 
     context 'when the client document exceeds the max of 512 bytes' do
+      # Server api parameters change metadata length
+      require_no_required_api_version
 
       context 'when the os.type length is too long' do
 

data/spec/mongo/server/connection_pool/populator_spec.rb

@@ -61,7 +61,9 @@ describe Mongo::Server::Populator do
 
       it 'populates the pool up to min_size' do
         populator.run!
-        sleep 1
+        ::Utils.wait_for_condition(3) do
+          pool.size >= 2
+        end
         expect(pool.size).to eq 2
         expect(populator.running?).to be true
       end

data/spec/mongo/server/connection_pool_spec.rb

@@ -531,7 +531,7 @@ describe Mongo::Server::ConnectionPool do
         authorized_client
       end
 
-       let(:pool) do
+      let(:pool) do
         client.cluster.next_primary.pool
       end
 

data/spec/mongo/server/connection_spec.rb

@@ -589,6 +589,8 @@ describe Mongo::Server::Connection do
 
     let(:server) { monitored_server }
 
+    let(:context) { Mongo::Operation::Context.new }
+
     let!(:connection) do
       described_class.new(
         server,
@@ -620,12 +622,12 @@ describe Mongo::Server::Connection do
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ query ])
+        connection.dispatch([ query ], context)
       end
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        authorized_collection.insert_one(name: 'testing')
       end
 
       it 'it dispatches the message to the socket' do
@@ -644,7 +646,7 @@ describe Mongo::Server::Connection do
       end
 
       let(:reply) do
-        connection.dispatch([ insert, command ])
+        connection.dispatch([ insert, command ], context)
       end
 
       before do
@@ -681,22 +683,22 @@ describe Mongo::Server::Connection do
       end
 
       before do
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
         # Fake a query for which we did not read the response. See RUBY-1117
         allow(query_bob).to receive(:replyable?) { false }
-        connection.dispatch([ query_bob ])
+        connection.dispatch([ query_bob ], context)
       end
 
       it 'raises an UnexpectedResponse error' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse,
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
       it 'marks connection perished' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         connection.should be_error
@@ -704,16 +706,17 @@ describe Mongo::Server::Connection do
 
       it 'makes the connection no longer usable' do
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         expect {
-          connection.dispatch([ query_alice ])
+          connection.dispatch([ query_alice ], context)
         }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
 
     context 'when a request is interrupted (Thread.kill)' do
+      require_no_required_api_version
 
       let(:documents) do
         [{ 'name' => 'bob' }, { 'name' => 'alice' }]
@@ -733,18 +736,19 @@ describe Mongo::Server::Connection do
 
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ])
+        connection.dispatch([ insert ], context)
       end
 
       it 'closes the socket and does not use it for subsequent requests' do
         t = Thread.new {
           # Kill the thread just before the reply is read
           allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill && !t.alive? }
-          connection.dispatch([ query_bob ])
+          connection.dispatch([ query_bob ], context)
         }
         t.join
         allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
-        expect(connection.dispatch([ query_alice ]).documents.first['name']).to eq('alice')
+        resp = connection.dispatch([ query_alice ], context)
+        expect(resp.documents.first['name']).to eq('alice')
       end
     end
 
@@ -761,7 +765,7 @@ describe Mongo::Server::Connection do
         end
 
         let(:reply) do
-          connection.dispatch([ insert ])
+          connection.dispatch([ insert ], context)
         end
 
         it 'checks the size against the max message size' do
@@ -788,7 +792,7 @@ describe Mongo::Server::Connection do
         end
 
         let(:reply) do
-          connection.dispatch([ command ])
+          connection.dispatch([ command ], context)
         end
 
         it 'checks the size against the max bson size' do
@@ -828,7 +832,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           end.to raise_error(Mongo::Error::SocketError)
         end
 
@@ -862,7 +866,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ])
+            connection.dispatch([ insert ], context)
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
@@ -906,6 +910,7 @@ describe Mongo::Server::Connection do
       end
 
       before do
+        authorized_collection.insert_one(test: 1)
         client.cluster.next_primary
       end
 
@@ -919,6 +924,8 @@ describe Mongo::Server::Connection do
           end_time = Time.now
           expect(ex).to be_a(Mongo::Error::SocketTimeoutError)
           expect(ex.message).to match(/Took more than 1.5 seconds to receive data/)
+        else
+          fail 'Expected a timeout'
         end
         # allow 1.5 seconds +- 0.5 seconds
         expect(end_time - start).to be_within(1).of(2)
@@ -938,7 +945,7 @@ describe Mongo::Server::Connection do
 
         before do
           expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message, nil)
+          connection.send(:deliver, message, context)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end

data/spec/mongo/server/monitor/connection_spec.rb

@@ -9,13 +9,21 @@ describe Mongo::Server::Monitor::Connection do
 
   declare_topology_double
 
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
   let(:cluster) do
-    double('cluster').tap do |cl|
-      allow(cl).to receive(:topology).and_return(topology)
-      allow(cl).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
-      allow(cl).to receive(:options).and_return({})
-      allow(cl).to receive(:heartbeat_interval).and_return(1000)
-      allow(cl).to receive(:run_sdam_flow)
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:topology).and_return(topology)
+      allow(cluster).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
+      allow(cluster).to receive(:options).and_return({})
+      allow(cluster).to receive(:monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:push_monitor_app_metadata).and_return(monitor_app_metadata)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+      allow(cluster).to receive(:run_sdam_flow)
     end
   end
 
@@ -27,10 +35,12 @@ describe Mongo::Server::Monitor::Connection do
   end
 
   let(:monitor) do
+    metadata = Mongo::Server::Monitor::AppMetadata.new(options)
     register_background_thread_object(
       Mongo::Server::Monitor.new(server, server.event_listeners, server.monitoring,
         {
-          app_metadata: Mongo::Server::Monitor::AppMetadata.new(options),
+          app_metadata: metadata,
+          push_monitor_app_metadata: metadata,
         }.update(options))
     ).tap do |monitor|
       monitor.scan!