mongo 2.0.0.beta → 2.0.0.rc

data/spec/mongo/operation/aggregate_spec.rb

@@ -67,36 +67,28 @@ describe Mongo::Operation::Aggregate do
 
   describe '#execute' do
 
-    context 'message' do
+    context 'when the aggregation fails' do
 
-      it 'creates a query wire protocol message with correct specs' do
-        allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
-          primary_server
-        end
+      let(:selector) do
+        { :aggregate => coll_name,
+          :pipeline => [{ '$invalid' => 'operator' }],
+        }
+      end
 
-        expect(Mongo::Protocol::Query).to receive(:new) do |db, coll, sel, options|
-          expect(db).to eq(db_name)
-          expect(coll).to eq(Mongo::Database::COMMAND)
-          expect(sel).to eq(selector)
-          expect(options).to eq(options)
-        end
-        op.execute(primary_context)
+      it 'raises an exception' do
+        expect {
+          op.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
       end
     end
 
-    context 'connection' do
+    context 'rerouting' do
 
-      it 'dispatches the message on the connection' do
-        allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
-          primary_server
+      before do
+        allow_any_instance_of(Mongo::Operation::Aggregate::Result).to receive(:validate!) do
+          true
         end
-
-        expect(connection).to receive(:dispatch)
-        op.execute(primary_context)
       end
-    end
-
-    context 'rerouting' do
 
       context 'when out is specified and server is a secondary' do
         let(:selector) do

data/spec/mongo/operation/command_spec.rb

@@ -82,25 +82,17 @@ describe Mongo::Operation::Command do
       end
     end
 
-    context 'when the command cannot run on a secondary' do
-
-      context 'when the server is a secondary' do
-
-        pending 'it re-routes to the primary'
-      end
-    end
-
     context 'when a document exceeds max bson size' do
 
-        let(:selector) do
-          { :ismaster => '1'*17000000 }
-        end
+      let(:selector) do
+        { :ismaster => '1'*17000000 }
+      end
 
-        it 'raises an error' do
-          expect {
-            op.execute(authorized_primary.context)
-          }.to raise_error(Mongo::Error::MaxBSONSize)
-        end
+      it 'raises an error' do
+        expect {
+          op.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::MaxBSONSize)
       end
+    end
   end
 end

data/spec/mongo/operation/map_reduce_spec.rb

@@ -109,7 +109,7 @@ describe Mongo::Operation::MapReduce do
     end
 
     after do
-      authorized_collection.find.remove_many
+      authorized_collection.find.delete_many
     end
 
     context 'when the map/reduce succeeds' do

data/spec/mongo/operation/read/indexes_spec.rb

@@ -9,11 +9,11 @@ describe Mongo::Operation::Read::Indexes do
     end
 
     before do
-      authorized_collection.indexes.create(spec, unique: true)
+      authorized_collection.indexes.create_one(spec, unique: true)
     end
 
     after do
-      authorized_collection.indexes.drop(spec)
+      authorized_collection.indexes.drop_one('name_1')
     end
 
     let(:operation) do

data/spec/mongo/operation/write/bulk_delete_spec.rb

@@ -73,213 +73,6 @@ describe Mongo::Operation::Write::BulkDelete do
     end
   end
 
-  describe '#write_concern' do
-
-    let(:other_write_concern) do
-      { :w => 2 }
-    end
-
-    context 'when the write concern is set' do
-
-      it 'sets the write concern' do
-        new_op = op.write_concern(other_write_concern)
-        expect(new_op.write_concern.options).to eq(other_write_concern)
-      end
-    end
-  end
-
-  describe '#batch' do
-
-    context 'when number of deletes is evenly divisible by n_batches' do
-      let(:documents) do
-        [ { q: { a: 1 } },
-          { q: { b: 1 } },
-          { q: { c: 1 } },
-          { q: { d: 1 } },
-          { q: { e: 1 } },
-          { q: { f: 1 } } ]
-      end
-      let(:n_batches) { 3 }
-
-      it 'batches the op into the divisor number of children ops' do
-        expect(op.batch(n_batches).size).to eq(n_batches)
-      end
-
-      it 'divides the deletes evenly between children ops' do
-        ops = op.batch(n_batches)
-        batch_size = documents.size / n_batches
-
-        n_batches.times do |i|
-          start_index = i * batch_size
-          expect(ops[i].spec[:deletes]).to eq(documents[start_index, batch_size])
-        end
-      end
-    end
-
-    context 'when number of deletes is less than batch size' do
-      let(:documents) do
-        [ { q: { a: 1 } } ]
-      end
-      let(:n_batches) { 3 }
-
-      it 'raises an exception' do
-        expect {
-            op.batch(n_batches)
-          }.to raise_error(Exception)
-      end
-    end
-
-    context 'when number of deletes is not evenly divisible by n_batches' do
-      let(:documents) do
-        [ { q: { a: 1 } },
-          { q: { b: 1 } },
-          { q: { c: 1 } },
-          { q: { d: 1 } },
-          { q: { e: 1 } },
-          { q: { f: 1 } } ]
-      end
-      let(:n_batches) { 4 }
-
-      it 'batches the op into the n_batches number of children ops' do
-        expect(op.batch(n_batches).size).to eq(n_batches)
-      end
-
-      it 'divides the deletes evenly between children ops' do
-        ops = op.batch(n_batches)
-        batch_size = documents.size / n_batches
-
-        n_batches.times do |i|
-          start_index = i * batch_size
-          if i == n_batches - 1
-            expect(ops[i].spec[:deletes]).to eq(documents[start_index..-1])
-          else
-            expect(ops[i].spec[:deletes]).to eq(documents[start_index, batch_size])
-          end
-        end
-      end
-    end
-  end
-
-  describe '#merge!' do
-
-    context 'same collection and database' do
-
-      let(:other_docs) do
-        [ { q: { bar: 1 }, limit: 1 } ]
-      end
-
-      let(:other_spec) do
-        { deletes: other_docs,
-          db_name: db_name,
-          coll_name: coll_name
-        }
-      end
-
-      let(:other) { described_class.new(other_spec) }
-
-      it 'merges the two ops' do
-        expect{ op.merge!(other) }.not_to raise_exception
-      end
-    end
-
-    context 'different database' do
-
-      let(:other_docs) do
-        [ { q: { bar: 1 }, limit: 1 } ]
-      end
-
-      let(:other_spec) do
-        { deletes: other_docs,
-          db_name: 'different',
-          coll_name: coll_name
-        }
-      end
-
-      let(:other) { described_class.new(other_spec) }
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'different collection' do
-
-      let(:other_docs) do
-        [ { q: { bar: 1 }, limit: 1 } ]
-      end
-
-      let(:other_spec) do
-        { deletes: other_docs,
-          db_name: db_name,
-          coll_name: 'different'
-        }
-      end
-
-      let(:other) { described_class.new(other_spec) }
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'different operation type' do
-      let(:other) { Mongo::Write::Update.new(spec) }
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'merged deletes' do
-
-      let(:other_docs) do
-        [ { q: { bar: 1 }, limit: 1 } ]
-      end
-
-      let(:other_spec) do
-        { deletes: other_docs,
-          db_name: db_name,
-          coll_name: coll_name
-        }
-      end
-
-      let(:other) { described_class.new(other_spec) }
-
-      let(:expected) do
-        documents + other_docs
-      end
-
-      it 'merges the list of deletes' do
-        expect(op.merge!(other).spec[:deletes]).to eq(expected)
-      end
-    end
-
-    context 'mutability' do
-      let(:other_docs) do
-        [ { q: { bar: 1 }, limit: 1 } ]
-      end
-
-      let(:other_spec) do
-        { deletes: other_docs,
-          db_name: db_name,
-          coll_name: coll_name
-        }
-      end
-
-      let(:other) { described_class.new(other_spec) }
-
-      it 'returns a new object' do
-        expect(op.merge!(other)).to be(op)
-      end
-    end
-  end
-
   describe '#execute' do
 
     before do
@@ -290,7 +83,7 @@ describe Mongo::Operation::Write::BulkDelete do
     end
 
     after do
-      authorized_collection.find.remove_many
+      authorized_collection.find.delete_many
     end
 
     context 'when deleting a single document' do
@@ -438,36 +231,5 @@ describe Mongo::Operation::Write::BulkDelete do
         end
       end
     end
-
-    context 'when a write concern override is specified' do
-
-      let(:documents) do
-        [ { q: { field: 'test' }, limit: 1 } ]
-      end
-
-      let(:op) do
-        described_class.new({
-            deletes: documents,
-            db_name: db_name,
-            coll_name: coll_name,
-            write_concern: Mongo::WriteConcern.get(w: 1),
-            ordered: false
-          })
-      end
-
-      let(:unacknowledged) do
-        { w: 0 }
-      end
-
-      it 'uses that write concern', if: write_command_enabled? do
-        result = op.write_concern(unacknowledged).execute(authorized_primary.context)
-        expect(result.replies.size).to eq(1)
-      end
-
-      it 'uses that write concern', unless: write_command_enabled? do
-        result = op.write_concern(unacknowledged).execute(authorized_primary.context)
-        expect(result.replies).to be(nil)
-      end
-    end
   end
 end

data/spec/mongo/operation/write/bulk_insert_spec.rb

@@ -81,220 +81,15 @@ describe Mongo::Operation::Write::BulkInsert do
     end
   end
 
-  describe '#write_concern' do
-
-    let(:other_write_concern) do
-      { w: 2 }
-    end
-
-    context 'when the write concern is set' do
-
-      it 'sets the write concern' do
-        new_op = op.write_concern(other_write_concern)
-        expect(new_op.write_concern.options).to eq(other_write_concern)
-      end
-    end
-  end
-
-  describe '#batch' do
-
-    context 'when number of inserts is evenly divisible by number of batches' do
-      let(:documents) do
-        [ { a: 1 },
-          { b: 1 },
-          { c: 1 },
-          { d: 1 },
-          { e: 1 },
-          { f: 1 } ]
-      end
-      let(:n_batches) { 3 }
-
-      it 'batches the insert into the n_batches number of children inserts' do
-        expect(op.batch(n_batches).size).to eq(n_batches)
-      end
-
-      it 'divides the inserts evenly between children inserts' do
-        inserts = op.batch(n_batches)
-        batch_size = documents.size / n_batches
-    
-        n_batches.times do |i|
-          start_index = i * batch_size
-          expect(inserts[i].spec[:documents]).to eq(documents[start_index, batch_size])
-        end
-      end
-    end
-
-    context 'when number of documents is less than number of batches' do
-      let(:documents) do
-        [ { a: 1 } ]
-      end
-      let(:n_batches) { 3 }
-
-      it 'raises an exception' do
-        expect {
-            op.batch(n_batches)
-          }.to raise_error(Exception)
-      end
-    end
-
-    context 'when number of inserts is not evenly divisible by number of batches' do
-      let(:documents) do
-        [ { a: 1 },
-          { b: 1 },
-          { c: 1 },
-          { d: 1 },
-          { e: 1 },
-          { f: 1 } ]
-      end
-      let(:n_batches) { 4 }
-
-      it 'batches the insert into the n_batches number of children inserts' do
-        expect(op.batch(n_batches).size).to eq(n_batches)
-      end
-
-      it 'batches the inserts evenly between children inserts' do
-        inserts = op.batch(n_batches)
-        batch_size = documents.size / n_batches
-    
-        n_batches.times do |i|
-          start_index = i * batch_size
-          if i == n_batches - 1
-            expect(inserts[i].spec[:documents]).to eq(documents[start_index..-1])
-          else
-            expect(inserts[i].spec[:documents]).to eq(documents[start_index, batch_size])
-          end
-        end
-      end
-    end
-  end
-
-  describe '#merge!' do
-
-    context 'when collection and database are the same' do
-
-      let(:other_docs) do
-        [ { bar: 1 } ]
-      end
-
-      let(:other_spec) do
-        { :documents     => other_docs,
-          :db_name       => db_name,
-          :coll_name     => coll_name
-        }
-      end
-
-      let(:other) do
-        described_class.new(other_spec)
-      end
-
-      it 'merges the two inserts' do
-        expect do
-          op.merge!(other)
-        end.not_to raise_exception
-      end
-    end
-
-    context 'when the database differs' do
-
-      let(:other_docs) do
-        [ { bar: 1 } ]
-      end
-
-      let(:other_spec) do
-        { :documents     => other_docs,
-          :db_name       => 'different',
-          :coll_name     => coll_name
-        }
-      end
-
-      let(:other) do
-        described_class.new(other_spec)
-      end
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'when the collection differs' do
-
-      let(:other_docs) do
-        [ { bar: 1 } ]
-      end
-
-      let(:other_spec) do
-        { :documents     => other_docs,
-          :db_name       => db_name,
-          :coll_name     => 'different'
-        }
-      end
-
-      let(:other) do
-        described_class.new(other_spec)
-      end
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'when the command type differs' do
-
-      let(:other) do
-        Mongo::Write::Update.new(spec)
-      end
-
-      it 'raises an exception' do
-        expect do
-          op.merge!(other)
-        end.to raise_exception
-      end
-    end
-
-    context 'when the commands can be merged' do
-
-      let(:other_docs) do
-        [ { bar: 1 } ]
-      end
-
-      let(:other_spec) do
-        { :documents     => other_docs,
-          :db_name       => db_name,
-          :coll_name     => coll_name
-        }
-      end
-
-      let(:other) do
-        described_class.new(other_spec)
-      end
-
-      let(:expected) do
-        documents + other_docs
-      end
-
-      it 'merges the list of documents' do
-        expect(op.merge!(other).spec[:documents]).to eq(expected)
-      end
-
-      it 'mutates the original spec' do
-        expect(op.merge!(other)).to be(op)
-      end
-    end
-  end
-
   describe '#execute' do
 
     before do
-      authorized_collection.indexes.create({ name: 1 }, { unique: true })
+      authorized_collection.indexes.create_one({ name: 1 }, { unique: true })
     end
 
     after do
-      authorized_collection.find.remove_many
-      authorized_collection.indexes.drop({ name: 1 })
+      authorized_collection.find.delete_many
+      authorized_collection.indexes.drop_one('name_1')
     end
 
     context 'when inserting a single document' do
@@ -436,31 +231,5 @@ describe Mongo::Operation::Write::BulkInsert do
         end
       end
     end
-
-    context 'when a write concern override is specified' do
-
-      let(:op) do
-        described_class.new({
-            documents: documents,
-            db_name: db_name,
-            coll_name: coll_name,
-            write_concern: Mongo::WriteConcern.get(w: 0),
-            ordered: false
-          })
-      end
-
-      let(:documents) do
-        [{ name: 'test' }, { name: 'test' }, { name: 'test1' }]
-      end
-
-      let(:acknowledged) do
-        { w: 1 }
-      end
-
-      it 'uses that write concern' do
-        result = op.write_concern(acknowledged).execute(authorized_primary.context)
-        expect(result.n_inserted).to eq(2)
-      end
-    end
   end
 end