mongo 2.3.1 → 2.4.0.rc0

data/spec/mongo/crud_spec.rb

@@ -25,15 +25,14 @@ describe 'CRUD' do
           end
 
           it "returns the correct result" do
-            skip 'Test results only match with server version >= 2.6' if test.requires_2_6?(write_command_enabled?,
-                                                                                            authorized_collection)
+            skip 'Test cannot be run on this server version' unless test.feature_enabled?(authorized_collection)
             expect(results).to eq(test.result)
           end
 
           it 'has the correct data in the collection' do
-            skip 'Test results only match with server version >= 2.6' if test.requires_2_6?(write_command_enabled?,
-                                                                                            authorized_collection)
-            expect(test.run(authorized_collection)).to match_collection_data(test)
+            skip 'Test cannot be run on this server version' unless test.feature_enabled?(authorized_collection)
+            results
+            expect(authorized_collection.find.to_a).to match_collection_data(test)
           end
         end
       end

data/spec/mongo/database_spec.rb

@@ -327,6 +327,70 @@ describe Mongo::Database do
         }.to raise_error(Mongo::Error::NoServerAvailable)
       end
     end
+
+    context 'when a write concern is not defined on the client/database object' do
+
+      context 'when a write concern is provided in the selector', if: standalone? do
+
+        let(:cmd) do
+          {
+              insert: TEST_COLL,
+              documents: [ { a: 1 } ],
+              writeConcern: { w: WRITE_CONCERN[:w]+1 }
+          }
+        end
+
+        it 'uses the write concern' do
+          expect {
+            database.command(cmd)
+          }.to raise_exception(Mongo::Error::OperationFailure)
+        end
+      end
+    end
+
+    context 'when a write concern is defined on the client/database object' do
+
+      let(:client_options) do
+        {
+          write: { w: WRITE_CONCERN[:w] + 1 }
+        }
+      end
+
+      let(:database) do
+        described_class.new(authorized_client.with(client_options), TEST_DB)
+      end
+
+      context 'when a write concern is not in the command selector', if: write_command_enabled? do
+
+        let(:cmd) do
+          {
+              insert: TEST_COLL,
+              documents: [ { a: 1 } ]
+          }
+        end
+
+        it 'does not apply a write concern' do
+          expect(database.command(cmd).written_count).to eq(1)
+        end
+      end
+
+      context 'when a write concern is provided in the command selector', if: write_command_enabled? && standalone? do
+
+        let(:cmd) do
+          {
+              insert: TEST_COLL,
+              documents: [ { a: 1 } ],
+              writeConcern: { w: WRITE_CONCERN[:w]+1 }
+          }
+        end
+
+        it 'uses the write concern' do
+          expect {
+            database.command(cmd)
+          }.to raise_exception(Mongo::Error::OperationFailure)
+        end
+      end
+    end
   end
 
   describe '#drop' do
@@ -339,11 +403,45 @@ describe Mongo::Database do
       expect(database.drop).to be_successful
     end
 
-    it 'raises an exception', unless: write_command_enabled? do
+    it 'raises an exception', if: (!write_command_enabled? && auth_enabled?) do
       expect {
         database.drop
       }.to raise_error(Mongo::Error::OperationFailure)
     end
+
+    context 'when the client/database has a write concern' do
+
+      let(:client_options) do
+        {
+          write: { w: WRITE_CONCERN[:w] + 1 },
+          database: :safe_to_drop
+        }
+      end
+
+      let(:client) do
+        root_authorized_client.with(client_options)
+      end
+
+      let(:database_with_write_options) do
+        client.database
+      end
+
+      context 'when the server supports write concern on the dropDatabase command', if: (collation_enabled? && standalone?) do
+
+        it 'applies the write concern' do
+          expect{
+            database_with_write_options.drop
+          }.to raise_exception(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when the server does not support write concern on the dropDatabase command', unless: collation_enabled? do
+
+        it 'does not apply the write concern' do
+          expect(database_with_write_options.drop).to be_successful
+        end
+      end
+    end
   end
 
   describe '#initialize' do

data/spec/mongo/index/view_spec.rb

@@ -16,6 +16,10 @@ describe Mongo::Index::View do
       view.create_one(spec, unique: true)
     end
 
+    after do
+      begin; view.drop_one('another_-1'); rescue; end
+    end
+
     context 'when the index exists' do
 
       let(:result) do
@@ -35,6 +39,68 @@ describe Mongo::Index::View do
         }.to raise_error(Mongo::Error::MultiIndexDrop)
       end
     end
+
+    context 'when the collection has a write concern' do
+
+      let(:collection) do
+        authorized_collection.with(write: { w: WRITE_CONCERN[:w] + 1})
+      end
+
+      let(:view_with_write_concern) do
+        described_class.new(collection)
+      end
+
+      let(:result) do
+        view_with_write_concern.drop_one('another_-1')
+      end
+
+      context 'when the server accepts writeConcern for the dropIndexes operation', if: collation_enabled? do
+
+        it 'applies the write concern' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when the server does not accept writeConcern for the dropIndexes operation', unless: collation_enabled? do
+
+        it 'does not apply the write concern' do
+          expect(result).to be_successful
+        end
+      end
+    end
+
+    context 'when there are multiple indexes with the same key pattern', if: collation_enabled? do
+
+      before do
+        view.create_one({ random: 1 }, unique: true)
+        view.create_one({ random: 1 },
+                          name: 'random_1_with_collation',
+                          unique: true,
+                          collation: { locale: 'en_US', strength: 2 })
+      end
+
+      context 'when a name is supplied' do
+
+        let!(:result) do
+          view.drop_one('random_1_with_collation')
+        end
+
+        let(:index_names) do
+          view.collect { |model| model['name'] }
+        end
+
+        it 'returns ok' do
+          expect(result).to be_successful
+        end
+
+        it 'drops the correct index' do
+          expect(index_names).not_to include('random_1_with_collation')
+          expect(index_names).to include('random_1')
+        end
+      end
+    end
   end
 
   describe '#drop_all' do
@@ -56,6 +122,41 @@ describe Mongo::Index::View do
       it 'drops the index' do
         expect(result).to be_successful
       end
+
+      context 'when the collection has a write concern' do
+
+        let(:collection) do
+          authorized_collection.with(write: { w: WRITE_CONCERN[:w] + 1})
+        end
+
+        let(:view_with_write_concern) do
+          described_class.new(collection)
+        end
+
+        let(:result) do
+          view_with_write_concern.drop_all
+        end
+
+        after do
+          view.drop_all
+        end
+
+        context 'when the server accepts writeConcern for the dropIndexes operation', if: collation_enabled? do
+
+          it 'applies the write concern' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when the server does not accept writeConcern for the dropIndexes operation', unless: collation_enabled? do
+
+          it 'does not apply the write concern' do
+            expect(result).to be_successful
+          end
+        end
+      end
     end
   end
 
@@ -65,39 +166,227 @@ describe Mongo::Index::View do
 
       context 'when passing multi-args' do
 
-        let(:result) do
-          view.create_many(
-            { key: { random: 1 }, unique: true },
-            { key: { testing: -1 }, unique: true }
-          )
+        context 'when the index creation is successful' do
+
+          let!(:result) do
+            view.create_many(
+              { key: { random: 1 }, unique: true },
+              { key: { testing: -1 }, unique: true }
+            )
+          end
+
+          after do
+            view.drop_one('random_1')
+            view.drop_one('testing_-1')
+          end
+
+          it 'returns ok' do
+            expect(result).to be_successful
+          end
         end
 
-        after do
-          view.drop_one('random_1')
-          view.drop_one('testing_-1')
+        context 'when collation is specified', if: collation_enabled? do
+
+          let(:result) do
+            view.create_many(
+              { key: { random: 1 },
+                unique: true,
+                collation: { locale: 'en_US', strength: 2 } }
+            )
+          end
+
+          after do
+            begin; view.drop_one('random_1'); rescue; end
+          end
+
+          let(:index_info) do
+            view.get('random_1')
+          end
+
+          context 'when the server supports collations', if: collation_enabled? do
+
+            it 'returns ok' do
+              expect(result).to be_successful
+            end
+
+            it 'applies the collation to the new index' do
+              result
+              expect(index_info['collation']).not_to be_nil
+              expect(index_info['collation']['locale']).to eq('en_US')
+              expect(index_info['collation']['strength']).to eq(2)
+            end
+          end
+
+          context 'when the server does not support collations', unless: collation_enabled? do
+
+            it 'raises an exception' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::UnsupportedCollation)
+            end
+          end
         end
 
-        it 'returns ok' do
-          expect(result).to be_successful
+        context 'when the collection has a write concern' do
+
+          after do
+            begin; view.drop_one('random_1'); rescue; end
+            begin; view.drop_one('testing_-1'); rescue; end
+          end
+
+          let(:collection) do
+            authorized_collection.with(write: { w: WRITE_CONCERN[:w] + 1})
+          end
+
+          let(:view_with_write_concern) do
+            described_class.new(collection)
+          end
+
+          let(:result) do
+            view_with_write_concern.create_many(
+                { key: { random: 1 }, unique: true },
+                { key: { testing: -1 }, unique: true }
+            )
+          end
+
+          context 'when the server accepts writeConcern for the createIndexes operation', if: collation_enabled? do
+
+            it 'applies the write concern' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::OperationFailure)
+            end
+          end
+
+          context 'when the server does not accept writeConcern for the createIndexes operation', unless: collation_enabled? do
+
+            context 'when the server supports the createIndexes command', if: write_command_enabled? do
+
+              it 'does not apply the write concern' do
+                expect(result).to be_successful
+              end
+            end
+
+            context 'when the driver inserts into the system.indexes collection', unless: write_command_enabled? do
+
+              it 'does not apply the write concern' do
+                expect(result).to be_successful
+              end
+            end
+          end
         end
       end
 
       context 'when passing an array' do
 
-        let(:result) do
-          view.create_many([
-            { key: { random: 1 }, unique: true },
-            { key: { testing: -1 }, unique: true }
-          ])
+        context 'when the index creation is successful' do
+
+          let!(:result) do
+            view.create_many([
+                                 { key: { random: 1 }, unique: true },
+                                 { key: { testing: -1 }, unique: true }
+                             ])
+          end
+
+          after do
+            view.drop_one('random_1')
+            view.drop_one('testing_-1')
+          end
+
+          it 'returns ok' do
+            expect(result).to be_successful
+          end
         end
 
-        after do
-          view.drop_one('random_1')
-          view.drop_one('testing_-1')
+        context 'when collation is specified' do
+
+          let(:result) do
+            view.create_many([
+                                 { key: { random: 1 },
+                                   unique: true,
+                                   collation: { locale: 'en_US', strength: 2 }},
+                             ])
+          end
+
+          let(:index_info) do
+            view.get('random_1')
+          end
+
+          after do
+            begin; view.drop_one('random_1'); rescue; end
+          end
+
+          context 'when the server supports collations', if: collation_enabled? do
+
+            it 'returns ok' do
+              expect(result).to be_successful
+            end
+
+            it 'applies the collation to the new index' do
+              result
+              expect(index_info['collation']).not_to be_nil
+              expect(index_info['collation']['locale']).to eq('en_US')
+              expect(index_info['collation']['strength']).to eq(2)
+            end
+          end
+
+          context 'when the server does not support collations', unless: collation_enabled? do
+
+            it 'raises an exception' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::UnsupportedCollation)
+            end
+          end
         end
 
-        it 'returns ok' do
-          expect(result).to be_successful
+        context 'when the collection has a write concern' do
+
+          after do
+            begin; view.drop_one('random_1'); rescue; end
+            begin; view.drop_one('testing_-1'); rescue; end
+          end
+
+          let(:collection) do
+            authorized_collection.with(write: { w: WRITE_CONCERN[:w] + 1})
+          end
+
+          let(:view_with_write_concern) do
+            described_class.new(collection)
+          end
+
+          let(:result) do
+            view_with_write_concern.create_many([
+                                 { key: { random: 1 }, unique: true },
+                                 { key: { testing: -1 }, unique: true }
+                             ])
+          end
+
+          context 'when the server accepts writeConcern for the createIndexes operation', if: collation_enabled? do
+
+            it 'applies the write concern' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::OperationFailure)
+            end
+          end
+
+          context 'when the server does not accept writeConcern for the createIndexes operation', unless: collation_enabled? do
+
+            context 'when the server accepts the createIndexes command', if: write_command_enabled? do
+
+              it 'does not apply the write concern' do
+                expect(result).to be_successful
+              end
+            end
+
+            context 'when the driver inserts into the system.indexes collection', unless: write_command_enabled? do
+
+              it 'does not apply the write concern' do
+                expect(result).to be_successful
+              end
+            end
+          end
         end
       end
 
@@ -148,22 +437,44 @@ describe Mongo::Index::View do
         expect(result).to be_successful
       end
 
-      context 'when the index is created on an subdocument field' do
+      context 'when the collection has a write concern' do
 
-        let(:spec) do
-          { 'sub_document.random' => 1 }
+        let(:collection) do
+          authorized_collection.with(write: { w: WRITE_CONCERN[:w] + 1})
+        end
+
+        let(:view_with_write_concern) do
+          described_class.new(collection)
         end
 
         let(:result) do
-          view.create_one(spec, unique: true)
+          view_with_write_concern.create_one(spec, unique: true)
         end
 
-        after do
-          begin; view.drop_one('sub_document.random_1'); rescue; end
+        context 'when the server accepts writeConcern for the createIndexes operation', if: collation_enabled? do
+
+          it 'applies the write concern' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
         end
 
-        it 'returns ok' do
-          expect(result).to be_successful
+        context 'when the server does not accept writeConcern for the createIndexes operation', unless: collation_enabled? do
+
+          context 'when the server supports the createIndexes command', if: write_command_enabled? do
+
+            it 'does not apply the write concern' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'when the driver inserts into the system.indexes collection', unless: write_command_enabled? do
+
+            it 'does not apply the write concern' do
+              expect(result).to be_successful
+            end
+          end
         end
       end
     end
@@ -254,7 +565,6 @@ describe Mongo::Index::View do
       it 'passes partialFilterExpression correctly' do
         expect(indexes[:partialFilterExpression]).to eq(expression)
       end
-
     end
   end
 
@@ -364,7 +674,7 @@ describe Mongo::Index::View do
       end
 
       let(:models) do
-        view.send(:normalize_models, [ options ])
+        view.send(:normalize_models, [ options ], authorized_primary)
       end
 
       let(:expected) do
@@ -397,7 +707,26 @@ describe Mongo::Index::View do
         end
 
         let(:models) do
-          view.send(:normalize_models, [ extended_options ])
+          view.send(:normalize_models, [ extended_options ], authorized_primary)
+        end
+
+        it 'maps the ruby options to the server options' do
+          expect(models).to eq([ extended_expected ])
+        end
+      end
+
+      context 'when the server supports collations', if: collation_enabled? do
+
+        let(:extended_options) do
+          options.merge(:collation => { locale: 'en_US' } )
+        end
+
+        let(:models) do
+          view.send(:normalize_models, [ extended_options ], authorized_primary)
+        end
+
+        let(:extended_expected) do
+          expected.tap { |exp| exp[:collation] = { locale: 'en_US' } }
         end
 
         it 'maps the ruby options to the server options' do