mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/operation/aggregate/result_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Aggregate::Result do
+
+  let(:result) do
+    described_class.new(reply)
+  end
+
+  let(:cursor_id) { 0 }
+  let(:documents) { [] }
+  let(:flags) { [] }
+  let(:starting_from) { 0 }
+
+  let(:reply) do
+    Mongo::Protocol::Reply.new.tap do |reply|
+      reply.instance_variable_set(:@flags, flags)
+      reply.instance_variable_set(:@cursor_id, cursor_id)
+      reply.instance_variable_set(:@starting_from, starting_from)
+      reply.instance_variable_set(:@number_returned, documents.size)
+      reply.instance_variable_set(:@documents, documents)
+    end
+  end
+
+  let(:aggregate) do
+    [
+      { '_id' => 'New York', 'totalpop' => 40270 },
+      { '_id' => 'Berlin', 'totalpop' => 103056 }
+    ]
+  end
+
+  describe '#cursor_id' do
+
+    context 'when the result is not using a cursor' do
+
+      let(:documents) do
+        [{ 'result' => aggregate, 'ok' => 1.0 }]
+      end
+
+      it 'returns zero' do
+        expect(result.cursor_id).to eq(0)
+      end
+    end
+
+    context 'when the result is using a cursor' do
+
+      let(:documents) do
+        [{ 'cursor' => { 'id' => 15, 'ns' => 'test', 'firstBatch' => aggregate }, 'ok' => 1.0 }]
+      end
+
+      it 'returns the cursor id' do
+        expect(result.cursor_id).to eq(15)
+      end
+    end
+  end
+
+  describe '#documents' do
+
+    context 'when the result is not using a cursor' do
+
+      let(:documents) do
+        [{ 'result' => aggregate, 'ok' => 1.0 }]
+      end
+
+      it 'returns the documents' do
+        expect(result.documents).to eq(aggregate)
+      end
+    end
+
+    context 'when the result is using a cursor' do
+
+      let(:documents) do
+        [{ 'cursor' => { 'id' => 15, 'ns' => 'test', 'firstBatch' => aggregate }, 'ok' => 1.0 }]
+      end
+
+      it 'returns the documents' do
+        expect(result.documents).to eq(aggregate)
+      end
+    end
+  end
+end

data/spec/mongo/operation/aggregate_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Aggregate do
+  include_context 'operation'
+
+  let(:selector) do
+    { :aggregate => coll_name,
+      :pipeline => [],
+    }
+  end
+  let(:spec) do
+    { :selector => selector,
+      :options => {},
+      :db_name => db_name
+    }
+  end
+  let(:op) { described_class.new(spec) }
+
+
+  describe '#initialize' do
+
+    context 'spec' do
+
+      it 'sets the spec' do
+        expect(op.spec).to be(spec)
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context ' when two ops have different specs' do
+      let(:other_selector) do
+        { :aggregate => 'another_test_coll',
+          :pipeline => [],
+        }
+      end
+      let(:other_spec) do
+        { :selector => other_selector,
+          :options => options,
+          :db_name => db_name,
+        }
+      end
+      let(:other) { described_class.new(other_spec) }
+
+      it 'returns false' do
+        expect(op).not_to eq(other)
+      end
+    end
+  end
+
+  context '#merge' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  context '#merge!' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    context 'message' 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
+
+        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)
+      end
+    end
+
+    context 'connection' do
+
+      it 'dispatches the message on the connection' do
+        allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
+          primary_server
+        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
+          { :aggregate => 'test_coll',
+            :pipeline => [{ '$out' => 'test_coll' }],
+          }
+        end
+
+        it 'raises an error' do
+          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
+            primary_server
+          end
+          expect {
+            op.execute(secondary_context)
+          }.to raise_error(Mongo::Error::NeedPrimaryServer)
+        end
+      end
+
+      context 'when out is specified and server is a primary' do
+        let(:selector) do
+          { :aggregate => 'test_coll',
+            :pipeline => [{ '$out' => 'test_coll' }],
+          }
+        end
+
+        it 'sends the operation to the primary' do
+          allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:server) do
+            primary_server
+          end
+          expect(primary_context).to receive(:with_connection)
+          op.execute(primary_context)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/operation/command_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Command do
+
+  let(:selector) { { :ismaster => 1 } }
+  let(:options) { { :limit => -1 } }
+  let(:spec) do
+    { :selector => selector,
+      :options     => options,
+      :db_name  => TEST_DB
+    }
+  end
+  let(:op) { described_class.new(spec) }
+
+  describe '#initialize' do
+
+    it 'sets the spec' do
+      expect(op.spec).to be(spec)
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the ops have different specs' do
+
+      let(:other_selector) { { :ping => 1 } }
+      let(:other_spec) do
+        { :selector => other_selector,
+          :options => {},
+          :db_name => 'test',
+        }
+      end
+      let(:other) { described_class.new(other_spec) }
+
+      it 'returns false' do
+        expect(op).not_to eq(other)
+      end
+    end
+  end
+
+  context '#merge' do
+
+    let(:other_op) { described_class.new(spec) }
+
+    it 'raises an exception' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  context '#merge!' do
+
+    let(:other_op) { described_class.new(spec) }
+
+    it 'raises an exception' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    context 'when the command succeeds' do
+
+      let(:response) do
+        op.execute(authorized_primary.context)
+      end
+
+      it 'returns the reponse' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when the command fails' do
+
+      let(:selector) do
+        { notacommand: 1 }
+      end
+
+      it 'raises an exception' do
+        expect {
+          op.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      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
+
+        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/kill_cursors_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Mongo::Operation::KillCursors do
+  include_context 'operation'
+
+  let(:spec) { { :cursor_ids => [1,2] } }
+  let(:op) { described_class.new(spec) }
+
+  describe '#initialize' do
+
+    it 'sets the spec' do
+      expect(op.spec).to be(spec)
+    end
+  end
+
+  describe '#==' do
+
+    context ' when two ops have different specs' do
+      let(:other_spec) do
+        { :cursor_ids => [1, 2, 3] }
+      end
+      let(:other) { described_class.new(other_spec) }
+
+      it 'returns false' do
+        expect(op).not_to eq(other)
+      end
+    end
+  end
+
+  context '#merge' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  context '#merge!' do
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    context 'message' do
+
+      it 'creates a kill cursors wire protocol message with correct specs' do
+        expect(Mongo::Protocol::KillCursors).to receive(:new) do |ids|
+          expect(ids).to eq(spec[:cursor_ids])
+        end
+        op.execute(primary_context)
+      end
+    end
+
+    context 'connection' do
+
+      it 'dispatches the message on the connection' do
+        expect(connection).to receive(:dispatch)
+        op.execute(primary_context)
+      end
+    end
+  end
+end

data/spec/mongo/operation/limited_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Limited do
+
+  describe '#options' do
+
+    let(:limited) do
+      Class.new do
+        include Mongo::Operation::Specifiable
+        include Mongo::Operation::Limited
+      end.new({ :options => spec })
+    end
+
+    context 'when no limit is provided' do
+
+      let(:spec) do
+        { :skip => 5 }
+      end
+
+      it 'returns a limit of -1' do
+        expect(limited.options).to eq({ :skip => 5, :limit => -1 })
+      end
+    end
+
+    context 'when a limit is already provided' do
+
+      context 'when the limit is -1' do
+
+        let(:spec) do
+          { :skip => 5, :limit => -1 }
+        end
+
+        it 'returns a limit of -1' do
+          expect(limited.options).to eq({ :skip => 5, :limit => -1 })
+        end
+      end
+
+      context 'when the limit is not -1' do
+
+        let(:spec) do
+          { :skip => 5, :limit => 5 }
+        end
+
+        it 'returns a limit of -1' do
+          expect(limited.options).to eq({ :skip => 5, :limit => -1 })
+        end
+      end
+    end
+  end
+end

data/spec/mongo/operation/map_reduce_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Mongo::Operation::MapReduce do
+
+  let(:map) do
+  %Q{
+  function() {
+    emit(this.name, { population: this.population });
+  }}
+  end
+
+  let(:reduce) do
+    %Q{
+    function(key, values) {
+      var result = { population: 0 };
+      values.forEach(function(value) {
+        result.population += value.population;
+      });
+      return result;
+    }}
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:selector) do
+    { :mapreduce => TEST_COLL,
+      :map => map,
+      :reduce => reduce,
+      :query => {},
+      :out => { inline: 1 }
+    }
+  end
+
+  let(:spec) do
+    { :selector => selector,
+      :options  => options,
+      :db_name  => TEST_DB
+    }
+  end
+
+  let(:op) do
+    described_class.new(spec)
+  end
+
+  describe '#initialize' do
+
+    context 'spec' do
+
+      it 'sets the spec' do
+        expect(op.spec).to be(spec)
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context ' when two ops have different specs' do
+      let(:other_selector) do
+        { :mapreduce => 'other_test_coll',
+          :map => '',
+          :reduce => '',
+        }
+      end
+      let(:other_spec) do
+        { :selector => other_selector,
+          :options => {},
+          :db_name => TEST_DB,
+        }
+      end
+      let(:other) { described_class.new(other_spec) }
+
+      it 'returns false' do
+        expect(op).not_to eq(other)
+      end
+    end
+  end
+
+  describe '#merge' do
+
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#merge!' do
+
+    let(:other_op) { described_class.new(spec) }
+
+    it 'is not allowed' do
+      expect{ op.merge!(other_op) }.to raise_exception
+    end
+  end
+
+  describe '#execute' do
+
+    let(:documents) do
+      [
+        { name: 'Berlin', population: 3000000 },
+        { name: 'London', population: 9000000 }
+      ]
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    after do
+      authorized_collection.find.remove_many
+    end
+
+    context 'when the map/reduce succeeds' do
+
+      let(:response) do
+        op.execute(authorized_primary.context)
+      end
+
+      it 'returns the response' do
+        expect(response).to be_successful
+      end
+    end
+
+    context 'when the map/reduce fails' do
+
+      let(:selector) do
+        { :mapreduce => TEST_COLL,
+          :map => map,
+          :reduce => reduce,
+          :query => {}
+        }
+      end
+
+      it 'raises an exception' do
+        expect {
+          op.execute(authorized_primary.context)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end