mongo 2.13.0 → 2.15.0.alpha

data/spec/mongo/operation/update/op_msg_spec.rb

@@ -78,7 +78,7 @@ describe Mongo::Operation::Update::OpMsg do
 
   describe 'write concern' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when write concern is not specified' do
 
@@ -105,7 +105,7 @@ describe Mongo::Operation::Update::OpMsg do
 
   describe '#message' do
     # https://jira.mongodb.org/browse/RUBY-2224
-    skip_if_linting
+    require_no_linting
 
     context 'when the server supports OP_MSG' do
       min_server_fcv '3.6'
@@ -159,7 +159,7 @@ describe Mongo::Operation::Update::OpMsg do
 
         context 'when an implicit session is created and the topology is then updated and the server does not support sessions' do
           # Mocks on features are incompatible with linting
-          skip_if_linting
+          require_no_linting
 
           let(:expected_global_args) do
             global_args.dup.tap do |args|

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/query_cache_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe Mongo::QueryCache do
+
+  around do |spec|
+    Mongo::QueryCache.clear
+    Mongo::QueryCache.cache { spec.run }
+  end
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:authorized_collection) { client['collection_spec'] }
+
+  let(:events) do
+    subscriber.command_started_events('find')
+  end
+
+  describe '#enabled' do
+
+    context 'when query cache is disabled' do
+
+      before do
+        Mongo::QueryCache.enabled = false
+      end
+
+      it 'disables the query cache' do
+        expect(Mongo::QueryCache.enabled?).to be(false)
+      end
+    end
+
+    context 'when query cache is enabled' do
+
+      before do
+        Mongo::QueryCache.enabled = true
+      end
+
+      it 'enables the query cache' do
+        expect(Mongo::QueryCache.enabled?).to be(true)
+      end
+    end
+  end
+
+  describe '#cache' do
+
+    before do
+      Mongo::QueryCache.enabled = false
+    end
+
+    it 'enables the query cache inside the block' do
+      Mongo::QueryCache.cache do
+        expect(Mongo::QueryCache.enabled?).to be(true)
+      end
+      expect(Mongo::QueryCache.enabled?).to be(false)
+    end
+  end
+
+  describe '#uncached' do
+
+    it 'disables the query cache inside the block' do
+      Mongo::QueryCache.uncached do
+        expect(Mongo::QueryCache.enabled?).to be(false)
+      end
+      expect(Mongo::QueryCache.enabled?).to be(true)
+    end
+  end
+
+  describe '#cache_table' do
+
+    before do
+      authorized_collection.insert_one({ name: 'testing' })
+      authorized_collection.find(name: 'testing').to_a
+    end
+
+    it 'gets the cached query' do
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(1)
+      authorized_collection.find(name: 'testing').to_a
+      expect(events.length).to eq(1)
+    end
+  end
+
+  describe '#clear' do
+
+    before do
+      authorized_collection.insert_one({ name: 'testing' })
+      authorized_collection.find(name: 'testing').to_a
+    end
+
+    it 'clears the cache' do
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(1)
+      Mongo::QueryCache.clear
+      expect(Mongo::QueryCache.send(:cache_table).length).to eq(0)
+    end
+  end
+
+  describe '#set' do
+    let(:caching_cursor) { double("Mongo::CachingCursor") }
+    let(:namespace) { 'db.coll' }
+    let(:selector) { { field: 'value' } }
+    let(:skip) { 5 }
+    let(:sort) { { field: 'asc' } }
+    let(:limit) { 5 }
+    let(:projection) { { field: 1 } }
+    let(:collation) { { locale: 'fr_CA' } }
+    let(:read_concern) { { level: :majority } }
+    let(:read_preference) { { mode: :secondary } }
+
+    let(:options) do
+      {
+        namespace: namespace,
+        selector: selector,
+        skip: skip,
+        sort: sort,
+        limit: limit,
+        projection: projection,
+        collation: collation,
+        read_concern: read_concern,
+        read_preference: read_preference,
+      }
+    end
+
+    it 'stores the cursor at the correct key' do
+      Mongo::QueryCache.set(caching_cursor, **options)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace][[namespace, selector, skip, sort, projection, collation, read_concern, read_preference]]).to eq(caching_cursor)
+    end
+  end
+
+  describe '#get' do
+    let(:view) { double("Mongo::Collection::View") }
+    let(:result) { double("Mongo::Operation::Result") }
+    let(:server) { double("Mongo::Server") }
+    let(:caching_cursor) { Mongo::CachingCursor.new(view, result, server) }
+
+    let(:options) do
+      {
+        namespace: 'db.coll',
+        selector: { field: 'value' },
+      }
+    end
+
+    before do
+      allow(result).to receive(:cursor_id) { 0 }
+      allow(result).to receive(:namespace) { 'db.coll' }
+      allow(view).to receive(:limit) { nil }
+    end
+
+    context 'when there is no entry in the cache' do
+      it 'returns nil' do
+        expect(Mongo::QueryCache.get(**options)).to be_nil
+      end
+    end
+
+    context 'when there is an entry in the cache' do
+      before do
+        Mongo::QueryCache.set(caching_cursor, **caching_cursor_options)
+      end
+
+      context 'when that entry has no limit' do
+        let(:caching_cursor_options) do
+          {
+            namespace: 'db.coll',
+            selector: { field: 'value' },
+          }
+        end
+
+        let(:query_options) do
+          caching_cursor_options.merge(limit: limit)
+        end
+
+        context 'when the query has a limit' do
+          let(:limit) { 5 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'when the query has no limit' do
+          let(:limit) { nil }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+      end
+
+      context 'when that entry has a limit' do
+        let(:caching_cursor_options) do
+          {
+            namespace: 'db.coll',
+            selector: { field: 'value' },
+            limit: 5,
+          }
+        end
+
+        let(:query_options) do
+          caching_cursor_options.merge(limit: limit)
+        end
+
+        before do
+          allow(view).to receive(:limit) { 5 }
+        end
+
+        context 'and the new query has a smaller limit' do
+          let(:limit) { 4 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'and the new query has a larger limit' do
+          let(:limit) { 6 }
+
+          it 'returns nil' do
+            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          end
+        end
+
+        context 'and the new query has the same limit' do
+          let(:limit) { 5 }
+
+          it 'returns the caching cursor' do
+            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          end
+        end
+
+        context 'and the new query has no limit' do
+          let(:limit) { nil }
+
+          it 'returns nil' do
+            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe '#clear_namespace' do
+    let(:caching_cursor) { double("Mongo::CachingCursor") }
+    let(:namespace1) { 'db.coll' }
+    let(:namespace2) { 'db.coll2' }
+    let(:namespace3) { 'db.coll3' }
+    let(:selector) { { field: 'value' } }
+
+    before do
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace1, selector: selector)
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace2, selector: selector)
+      Mongo::QueryCache.set(caching_cursor, namespace: namespace3, selector: selector, multi_collection: true)
+    end
+
+    it 'returns nil' do
+      expect(Mongo::QueryCache.clear_namespace(namespace1)).to be_nil
+    end
+
+    it 'clears the specified namespace in the query cache' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace1]).to be_nil
+    end
+
+    it 'does not clear other namespaces in the query cache' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[namespace2]).not_to be_nil
+    end
+
+    it 'clears the nil namespace' do
+      Mongo::QueryCache.clear_namespace(namespace1)
+      expect(Mongo::QueryCache.send(:cache_table)[nil]).to be_nil
+    end
+  end
+end