mongo 2.9.2 → 2.10.0.rc0

data/spec/mongo/bulk_write/unordered_combiner_spec.rb

@@ -137,8 +137,8 @@ describe Mongo::BulkWrite::UnorderedCombiner do
             [
               {
                 update_one: [
-                  { 'q' => { _id: 0 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => false, 'upsert' => false },
-                  { 'q' => { _id: 1 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => false, 'upsert' => false }
+                  { 'q' => { _id: 0 }, 'u' => { '$set' => { name: 'test' }}, },
+                  { 'q' => { _id: 1 }, 'u' => { '$set' => { name: 'test' }}, },
                 ]
               }
             ]
@@ -179,8 +179,8 @@ describe Mongo::BulkWrite::UnorderedCombiner do
             [
               {
                 update_many: [
-                  { 'q' => { _id: 0 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => true, 'upsert' => false },
-                  { 'q' => { _id: 1 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => true, 'upsert' => false }
+                  { 'q' => { _id: 0 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => true, },
+                  { 'q' => { _id: 1 }, 'u' => { '$set' => { name: 'test' }}, 'multi' => true, },
                 ]
               }
             ]

data/spec/mongo/bulk_write_spec.rb

@@ -80,7 +80,7 @@ describe Mongo::BulkWrite do
           end
 
           it 'sets the document index on the error' do
-            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(2)
+            expect(error.result['writeErrors'].first['index']).to eq(2)
           end
 
           context 'when a session is provided' do
@@ -1223,6 +1223,10 @@ describe Mongo::BulkWrite do
 
             context 'when write_concern is specified as an option' do
 
+              # In a multi-sharded cluster, the write seems to go to a
+              # different shard from the read
+              require_no_multi_shard
+
               let(:extra_options) do
                 { write_concern: { w: 0 } }
               end
@@ -1844,7 +1848,7 @@ describe Mongo::BulkWrite do
 
           it 'sets the document index on the error' do
             requests.push({ insert_one: { _id: 5 }})
-            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(batch_size)
+            expect(error.result['writeErrors'].first['index']).to eq(batch_size)
           end
         end
 
@@ -1886,9 +1890,15 @@ describe Mongo::BulkWrite do
           end
 
           context 'when retryable writes are supported' do
+            require_wired_tiger
             min_server_fcv '3.6'
             require_topology :replica_set, :sharded
 
+            # In a multi-shard cluster, retries may go to a different server
+            # than original command which these tests are not prepared to handle
+            require_no_multi_shard
+
+
             let(:subscriber) { EventSubscriber.new }
 
             let(:client) do

data/spec/mongo/client_construction_spec.rb

@@ -653,7 +653,7 @@ describe Mongo::Client do
         end
 
         let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 3 },
+          Mongo::Options::Redacted.new(write_concern: { :w => 3 },
             monitoring_io: false, :database => 'testdb', retry_writes: true,
             retry_reads: true)
         end
@@ -811,24 +811,38 @@ describe Mongo::Client do
         end
       end
 
-      context 'when options are provided in the string and explicitly' do
+      context 'when options are provided in the URI and as Ruby options' do
 
         let!(:uri) do
           'mongodb://127.0.0.1:27017/testdb?w=3'
         end
 
         let(:client) do
-          new_local_client_nmio(uri, :write => { :w => 4 })
+          new_local_client_nmio(uri, option_name => { :w => 4 })
         end
 
         let(:expected_options) do
-          Mongo::Options::Redacted.new(:write => { :w => 4 },
+          Mongo::Options::Redacted.new(option_name => { :w => 4 },
             monitoring_io: false, :database => 'testdb', retry_writes: true,
             retry_reads: true)
         end
 
-        it 'allows explicit options to take preference' do
-          expect(client.options).to eq(expected_options)
+        shared_examples_for 'allows explicit options to take preference' do
+          it 'allows explicit options to take preference' do
+            expect(client.options).to eq(expected_options)
+          end
+        end
+
+        context 'when using :write' do
+          let(:option_name) { :write }
+
+          it_behaves_like 'allows explicit options to take preference'
+        end
+
+        context 'when using :write_concern' do
+          let(:option_name) { :write_concern }
+
+          it_behaves_like 'allows explicit options to take preference'
         end
       end
 
@@ -866,6 +880,26 @@ describe Mongo::Client do
           expect(client.options.keys).not_to include('invalid')
         end
       end
+
+=begin WriteConcern object support
+      context 'when write concern is provided via a WriteConcern object' do
+
+        let(:client) do
+          new_local_client_nmio(['127.0.0.1:27017'], write_concern: wc)
+        end
+
+        let(:wc) { Mongo::WriteConcern.get(w: 2) }
+
+        it 'stores write concern options in client options' do
+          expect(client.options[:write_concern]).to eq(
+            Mongo::Options::Redacted.new(w: 2))
+        end
+
+        it 'caches write concern object' do
+          expect(client.write_concern).to be wc
+        end
+      end
+=end
     end
   end
 
@@ -1090,7 +1124,12 @@ describe Mongo::Client do
     context 'when the write concern is changed' do
 
       let(:client) do
-        new_local_client(['127.0.0.1:27017'], :write => { :w => 1 }, :database => SpecConfig.instance.test_db)
+        new_local_client(['127.0.0.1:27017'],
+          {monitoring_io: false}.merge(client_options))
+      end
+
+      let(:client_options) do
+        { :write => { :w => 1 } }
       end
 
       context 'when the write concern has not been accessed' do
@@ -1123,6 +1162,116 @@ describe Mongo::Client do
           expect(get_last_error).to be_nil
         end
       end
+
+      context 'when write concern is given as :write' do
+
+        let(:client_options) do
+          { :write => { :w => 1 } }
+        end
+
+        it 'sets :write option' do
+          expect(client.options[:write]).to eq(Mongo::Options::Redacted.new(w: 1))
+        end
+
+        it 'does not set :write_concern option' do
+          expect(client.options[:write_concern]).to be nil
+        end
+
+        it 'returns correct write concern' do
+          expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+          expect(client.write_concern.options).to eq(w: 1)
+        end
+      end
+
+      context 'when write concern is given as :write_concern' do
+
+        let(:client_options) do
+          { :write_concern => { :w => 1 } }
+        end
+
+        it 'sets :write_concern option' do
+          expect(client.options[:write_concern]).to eq(Mongo::Options::Redacted.new(w: 1))
+        end
+
+        it 'does not set :write option' do
+          expect(client.options[:write]).to be nil
+        end
+
+        it 'returns correct write concern' do
+            expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+            expect(client.write_concern.options).to eq(w: 1)
+        end
+      end
+
+      context 'when write concern is given as both :write and :write_concern' do
+        context 'with identical values' do
+
+          let(:client_options) do
+            { write: {w: 1}, write_concern: { w: 1 } }
+          end
+
+          it 'sets :write_concern option' do
+            expect(client.options[:write_concern]).to eq(Mongo::Options::Redacted.new(w: 1))
+          end
+
+          it 'sets :write option' do
+            expect(client.options[:write]).to eq(Mongo::Options::Redacted.new(w: 1))
+          end
+
+          it 'returns correct write concern' do
+            expect(client.write_concern).to be_a(Mongo::WriteConcern::Acknowledged)
+            expect(client.write_concern.options).to eq(w: 1)
+          end
+        end
+
+        context 'with different values' do
+
+          let(:client_options) do
+            { write: {w: 1}, write_concern: { w: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect do
+              client
+            end.to raise_error(ArgumentError, /If :write and :write_concern are both given, they must be identical/)
+          end
+        end
+      end
+
+      context 'when #with uses a different write concern option name' do
+
+        context 'from :write_concern to :write' do
+
+          let(:client_options) do
+            { :write_concern => { :w => 1 } }
+          end
+
+          let!(:new_client) do
+            client.with(:write => { :w => 2 })
+          end
+
+          it 'uses the new option' do
+            expect(new_client.options[:write]).to eq(Mongo::Options::Redacted.new(w: 2))
+            expect(new_client.options[:write_concern]).to be nil
+          end
+        end
+
+        context 'from :write to :write_concern' do
+
+          let(:client_options) do
+            { :write => { :w => 1 } }
+          end
+
+          let!(:new_client) do
+            client.with(:write_concern => { :w => 2 })
+          end
+
+          it 'uses the new option' do
+            expect(new_client.options[:write_concern]).to eq(Mongo::Options::Redacted.new(w: 2))
+            expect(new_client.options[:write]).to be nil
+          end
+        end
+      end
     end
 
     context 'when an invalid option is provided' do
@@ -1216,9 +1365,12 @@ describe Mongo::Client do
 
       it 'does not notify subscribers set up by sdam_proc' do
         client = new_local_client(['a'], sdam_proc: sdam_proc)
-        expect(subscriber.started_events.length).to eq 1
+        expect(subscriber.started_events.length).to be > 0
         subscriber.started_events.clear
 
+        # If this test takes longer than heartbeat interval,
+        # subscriber may receive events from the original client.
+
         new_client
         expect(subscriber.started_events.length).to eq 0
       end

data/spec/mongo/client_spec.rb

@@ -505,7 +505,7 @@ describe Mongo::Client do
       let(:client_options) { {} }
 
       let(:client) do
-        Mongo::Client.new(['127.0.0.1:27017'], {monitoring_io: false}.update(client_options))
+        new_local_client_nmio(['127.0.0.1:27017'], client_options)
       end
 
       it "defaults to #{default}" do
@@ -649,9 +649,10 @@ describe Mongo::Client do
     end
 
     it 'disconnects the cluster and returns true' do
-      # note that disconnect! is called also in the after block
-      expect(client.cluster).to receive(:disconnect!).and_call_original
-      expect(client.close).to be(true)
+      RSpec::Mocks.with_temporary_scope do
+        expect(client.cluster).to receive(:disconnect!).and_call_original
+        expect(client.close(true)).to be(true)
+      end
     end
   end
 

data/spec/mongo/cluster_spec.rb

@@ -74,7 +74,7 @@ describe Mongo::Cluster do
   describe '#has_readable_server?' do
 
     let(:selector) do
-      Mongo::ServerSelector.get(mode: :primary)
+      Mongo::ServerSelector.primary
     end
 
     it 'delegates to the topology' do
@@ -92,7 +92,7 @@ describe Mongo::Cluster do
   describe '#inspect' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     it 'displays the cluster seeds and topology' do
@@ -104,7 +104,7 @@ describe Mongo::Cluster do
   describe '#replica_set_name' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     context 'when the option is provided' do
@@ -141,7 +141,7 @@ describe Mongo::Cluster do
   describe '#scan!' do
 
     let(:preference) do
-      Mongo::ServerSelector.get(ServerSelector::PRIMARY)
+      Mongo::ServerSelector.primary
     end
 
     let(:known_servers) do
@@ -482,7 +482,7 @@ describe Mongo::Cluster do
     context 'when the cluster_time variable has a value' do
 
       before do
-        cluster.instance_variable_set(:@cluster_time, BSON::Document.new(
+        cluster.instance_variable_set(:@cluster_time, Mongo::ClusterTime.new(
             Mongo::Cluster::CLUSTER_TIME => BSON::Timestamp.new(1, 1)))
         cluster.update_cluster_time(result)
       end
@@ -648,7 +648,7 @@ describe Mongo::Cluster do
       let(:client_options) { {} }
 
       let(:client) do
-        Mongo::Client.new(['127.0.0.1:27017'], {monitoring_io: false}.update(client_options))
+        new_local_client_nmio(['127.0.0.1:27017'], client_options)
       end
 
       let(:cluster) do

data/spec/mongo/cluster_time_spec.rb

@@ -0,0 +1,148 @@
+require 'lite_spec_helper'
+
+describe Mongo::ClusterTime do
+  describe '#>=' do
+    context 'equal but different objects' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is true' do
+        expect(one).to be >= two
+      end
+    end
+
+    context 'first is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(124, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is true' do
+        expect(one).to be >= two
+      end
+    end
+
+    context 'second is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 457)) }
+
+      it 'is false' do
+        expect(one).not_to be >= two
+      end
+    end
+  end
+
+  describe '#>' do
+    context 'equal but different objects' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is false' do
+        expect(one).not_to be > two
+      end
+    end
+
+    context 'first is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(124, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is true' do
+        expect(one).to be > two
+      end
+    end
+
+    context 'second is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 457)) }
+
+      it 'is false' do
+        expect(one).not_to be > two
+      end
+    end
+  end
+
+  describe '#<=' do
+    context 'equal but different objects' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is true' do
+        expect(one).to be <= two
+      end
+    end
+
+    context 'first is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(124, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is false' do
+        expect(one).not_to be <= two
+      end
+    end
+
+    context 'second is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 457)) }
+
+      it 'is true' do
+        expect(one).to be <= two
+      end
+    end
+  end
+
+  describe '#<' do
+    context 'equal but different objects' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is false' do
+        expect(one).not_to be < two
+      end
+    end
+
+    context 'first is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(124, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is false' do
+        expect(one).not_to be < two
+      end
+    end
+
+    context 'second is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 457)) }
+
+      it 'is true' do
+        expect(one).to be < two
+      end
+    end
+  end
+
+  describe '#==' do
+    context 'equal but different objects' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is true' do
+        expect(one).to be == two
+      end
+    end
+
+    context 'first is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(124, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+
+      it 'is false' do
+        expect(one).not_to be == two
+      end
+    end
+
+    context 'second is greater' do
+      let(:one) { described_class.new(clusterTime: BSON::Timestamp.new(123, 456)) }
+      let(:two) { described_class.new(clusterTime: BSON::Timestamp.new(123, 457)) }
+
+      it 'is false' do
+        expect(one).not_to be == two
+      end
+    end
+  end
+end