mongo 1.12.5 → 2.0.0.beta

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(spec, unique: true)
+    end
+
+    after do
+      authorized_collection.indexes.drop(spec)
+    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
+

data/spec/mongo/operation/result_spec.rb

@@ -0,0 +1,275 @@
+require 'spec_helper'
+
+describe Mongo::Operation::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
+
+  describe '#acknowledged?' do
+
+    context 'when the reply is for a read command' do
+
+      let(:documents) do
+        [{ 'ismaster' => true, 'ok' => 1.0 }]
+      end
+
+      it 'returns true' do
+        expect(result).to be_acknowledged
+      end
+    end
+
+    context 'when the reply is for a write command' do
+
+      context 'when the command was acknowledged' do
+
+        let(:documents) do
+          [{ "ok" => 1, "n" => 2 }]
+        end
+
+        it 'returns true' do
+          expect(result).to be_acknowledged
+        end
+      end
+
+      context 'when the command was not acknowledged' do
+
+        let(:reply) { nil }
+
+        it 'returns false' do
+          expect(result).to_not be_acknowledged
+        end
+      end
+    end
+  end
+
+  describe '#cursor_id' do
+
+    context 'when the reply exists' do
+
+      let(:cursor_id) { 5 }
+
+      it 'delegates to the reply' do
+        expect(result.cursor_id).to eq(5)
+      end
+    end
+
+    context 'when the reply does not exist' do
+
+      let(:reply) { nil }
+
+      it 'returns zero' do
+        expect(result.cursor_id).to eq(0)
+      end
+    end
+  end
+
+  describe '#documents' do
+
+    context 'when the result is for a command' do
+
+      context 'when a reply is received' do
+
+        let(:documents) do
+          [{ "ok" => 1, "n" => 2 }]
+        end
+
+        it 'returns the documents' do
+          expect(result.documents).to eq(documents)
+        end
+      end
+
+      context 'when a reply is not received' do
+
+        let(:reply) { nil }
+
+        it 'returns an empty array' do
+          expect(result.documents).to be_empty
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+
+    let(:documents) do
+      [{ "ok" => 1, "n" => 2 }]
+    end
+
+    context 'when a block is given' do
+
+      it 'yields to each document' do
+        result.each do |document|
+          expect(document).to eq(documents.first)
+        end
+      end
+    end
+
+    context 'when no block is given' do
+
+      it 'returns an enumerator' do
+        expect(result.each).to be_a(Enumerator)
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    it 'sets the replies' do
+      expect(result.replies).to eq([ reply ])
+    end
+  end
+
+  describe '#returned_count' do
+
+    context 'when the reply is for a read command' do
+
+      let(:documents) do
+        [{ 'ismaster' => true, 'ok' => 1.0 }]
+      end
+
+      it 'returns the number returned' do
+        expect(result.returned_count).to eq(1)
+      end
+    end
+
+    context 'when the reply is for a write command' do
+
+      context 'when the write is acknowledged' do
+
+        let(:documents) do
+          [{ "ok" => 1, "n" => 2 }]
+        end
+
+        it 'returns the number returned' do
+          expect(result.returned_count).to eq(1)
+        end
+      end
+
+      context 'when the write is not acknowledged' do
+
+        let(:reply) { nil }
+
+        it 'returns zero' do
+          expect(result.returned_count).to eq(0)
+        end
+      end
+    end
+  end
+
+  describe '#successful?' do
+
+    context 'when the reply is for a read command' do
+
+      let(:documents) do
+        [{ 'ismaster' => true, 'ok' => 1.0 }]
+      end
+
+      it 'returns true' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when the reply is for a query' do
+
+      context 'when the query has no errors' do
+
+        let(:documents) do
+          [{ 'field' => 'name' }]
+        end
+
+        it 'returns true' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'when the query has errors' do
+
+        let(:documents) do
+          [{ '$err' => 'not authorized for query on test.system.namespaces', 'code'=> 16550 }]
+        end
+
+        it 'returns false' do
+          expect(result).to_not be_successful
+        end
+      end
+    end
+
+    context 'when the reply is for a write command' do
+
+      context 'when the write is acknowledged' do
+
+        context 'when ok is 1' do
+
+          let(:documents) do
+            [{ "ok" => 1, "n" => 2 }]
+          end
+
+          it 'returns true' do
+            expect(result).to be_successful
+          end
+        end
+
+        context 'when ok is not 1' do
+
+          let(:documents) do
+            [{ "ok" => 0, "n" => 0 }]
+          end
+
+          it 'returns false' do
+            expect(result).to_not be_successful
+          end
+        end
+      end
+
+      context 'when the write is not acknowledged' do
+
+        let(:reply) { nil }
+
+        it 'returns true' do
+          expect(result).to be_successful
+        end
+      end
+    end
+  end
+
+  describe '#written_count' do
+
+    context 'when the reply is for a read command' do
+
+      let(:documents) do
+        [{ 'ismaster' => true, 'ok' => 1.0 }]
+      end
+
+      it 'returns the number written' do
+        expect(result.written_count).to eq(0)
+      end
+    end
+
+    context 'when the reply is for a write command' do
+
+      let(:documents) do
+        [{ "ok" => 1, "n" => 2 }]
+      end
+
+      it 'returns the number written' do
+        expect(result.written_count).to eq(2)
+      end
+    end
+  end
+end