mongo 1.12.5 → 2.0.0

data/spec/mongo/operation/command_spec.rb

@@ -0,0 +1,98 @@
+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 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.delete_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

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Read::CollectionsInfo do
+
+  let(:spec) do
+    { :db_name => TEST_DB }
+  end
+
+  let(:names) do
+    [ 'berlin', 'london' ]
+  end
+
+  let(:op) do
+    described_class.new(spec)
+  end
+
+  describe '#execute' do
+
+    before do
+      names.each do |name|
+        authorized_client[name].insert_one(x: 1)
+      end
+    end
+
+    after do
+      names.each do |name|
+        authorized_client[name].drop
+      end
+    end
+
+    let(:info) do
+      docs = op.execute(authorized_primary.context).documents
+      docs.collect { |info| info['name'].sub("#{TEST_DB}.", '') }
+    end
+
+    it 'returns the list of collection info' do
+      expect(info).to include(*names)
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Read::GetMore do
+  include_context 'operation'
+
+  let(:to_return) { 50 }
+  let(:cursor_id) { 1 }
+
+  let(:spec) do
+    { :db_name   => db_name,
+      :coll_name => coll_name,
+      :to_return => to_return,
+      :cursor_id => cursor_id }
+  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 two ops have different specs' do
+      let(:other_spec) do
+        { :db_name   => 'test_db',
+          :coll_name => 'test_coll',
+          :to_return => 50,
+          :cursor_id => 2 }
+      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 get more wire protocol message with correct specs' do
+        expect(Mongo::Protocol::GetMore).to receive(:new) do |db, coll, to_ret, id|
+          expect(db).to eq(db_name)
+          expect(coll).to eq(coll_name)
+          expect(to_ret).to eq(to_return)
+          expect(id).to eq(cursor_id)
+        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/read/indexes_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Read::Indexes do
+
+  describe '#execute' do
+
+    let(:spec) do
+      { name: 1 }
+    end
+
+    before do
+      authorized_collection.indexes.create_one(spec, unique: true)
+    end
+
+    after do
+      authorized_collection.indexes.drop_one('name_1')
+    end
+
+    let(:operation) do
+      described_class.new(db_name: TEST_DB, coll_name: TEST_COLL)
+    end
+
+    let(:indexes) do
+      operation.execute(authorized_primary.context)
+    end
+
+    it 'returns the indexes for the collection' do
+      expect(indexes.documents.size).to eq(2)
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Mongo::Operation::Read::Query do
+  include_context 'operation'
+
+  let(:selector) { {} }
+  let(:query_options) { {} }
+  let(:spec) do
+    { :selector  => selector,
+      :options      => query_options,
+      :db_name   => db_name,
+      :coll_name => coll_name,
+      :read => Mongo::ServerSelector.get
+    }
+  end
+  let(:op) { described_class.new(spec) }
+
+  describe '#initialize' do
+
+    context 'query spec' do
+      it 'sets the query spec' do
+        expect(op.spec).to be(spec)
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context 'when two ops have different specs' do
+      let(:other_spec) do
+        { :selector  => { :a => 1 },
+          :options      => query_options,
+          :db_name   => db_name,
+          :coll_name => coll_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
+        expect(Mongo::Protocol::Query).to receive(:new) do |db, coll, sel, options|
+          expect(db).to eq(db_name)
+          expect(coll).to eq(coll_name)
+          expect(sel).to eq(selector)
+        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
+