mongo 1.12.5 → 2.0.0

data/spec/mongo/protocol/insert_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Insert do
+
+  let(:opcode) { 2002 }
+  let(:db)     { TEST_DB }
+  let(:coll)   { TEST_COLL }
+  let(:ns)     { "#{db}.#{coll}" }
+  let(:doc1)   { { :name => 'Tyler' } }
+  let(:doc2)   { { :name => 'Brandon' } }
+  let(:docs)   { [doc1, doc2] }
+  let(:options)   { Hash.new }
+
+  let(:message) do
+    described_class.new(db, coll, docs, options)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the namepsace' do
+      expect(message.namespace).to eq(ns)
+    end
+
+    it 'sets the documents' do
+      expect(message.documents).to eq(docs)
+    end
+
+    context 'when options are provided' do
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => [:continue_on_error] } }
+
+        it 'sets the flags' do
+          expect(message.flags).to eq(options[:flags])
+        end
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is an insert' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          described_class.new(db, coll, docs, options)
+        end
+
+        it 'returns true' do
+          expect(message).to eq(other)
+        end
+      end
+
+      context 'when the database is not equal' do
+        let(:other) do
+          described_class.new('tyler', coll, docs, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the collection is not equal' do
+        let(:other) do
+          described_class.new(db, 'tyler', docs, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the documents are not equal' do
+        let(:other) do
+          described_class.new(db, coll, docs[1..1], options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the options are not equal' do
+        let(:other) do
+          described_class.new(db, coll, docs, :flags => [:continue_on_error])
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not an insert' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      message.send(:fields).map do |field|
+        message.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(message.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#replyable?' do
+
+    it 'returns false' do
+      expect(message).to_not be_replyable
+    end
+  end
+
+  describe '#serialize' do
+    let(:bytes) { message.serialize }
+
+    include_examples 'message with a header'
+
+    describe 'flags' do
+      let(:field) { bytes[16..19] }
+
+      context 'when no flags are provided' do
+        it 'does not set any bits' do
+          expect(field).to be_int32(0)
+        end
+      end
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => flags } }
+
+        context 'continue on error flag' do
+          let(:flags) { [:continue_on_error] }
+          it 'sets the first bit' do
+            expect(field).to be_int32(1)
+          end
+        end
+      end
+    end
+
+    describe 'namespace' do
+      let(:field) { bytes[20..36] }
+      it 'serializes the namespace' do
+        expect(field).to be_cstring(ns)
+      end
+    end
+
+    describe 'documents' do
+      let(:field) { bytes[37..-1] }
+      it 'serializes the documents' do
+        expect(field).to be_bson_sequence(docs)
+      end
+    end
+  end
+end

data/spec/mongo/protocol/kill_cursors_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::KillCursors do
+
+  let(:opcode)     { 2007 }
+  let(:cursor_ids) { [123, 456, 789] }
+  let(:id_count)   { cursor_ids.size }
+  let(:message) do
+    described_class.new(cursor_ids)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the cursor ids' do
+      expect(message.cursor_ids).to eq(cursor_ids)
+    end
+
+    it 'sets the count' do
+      expect(message.id_count).to eq(id_count)
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is a killcursors' do
+
+      context 'when the cursor ids are equal' do
+        let(:other) do
+          described_class.new(cursor_ids)
+        end
+
+        it 'returns true' do
+          expect(message).to eq(other)
+        end
+      end
+
+      context 'when the cursor ids are not equal' do
+        let(:other) do
+          described_class.new([123, 456])
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a killcursors' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      message.send(:fields).map do |field|
+        message.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(message.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#replyable?' do
+
+    it 'returns false' do
+      expect(message).to_not be_replyable
+    end
+  end
+
+  describe '#serialize' do
+    let(:bytes) { message.serialize }
+
+    include_examples 'message with a header'
+
+    describe 'zero' do
+      let(:field) { bytes[16..19] }
+
+      it 'serializes a zero' do
+        expect(field).to be_int32(0)
+      end
+    end
+
+    describe 'number of cursors' do
+      let(:field) { bytes[20..23] }
+      it 'serializes the cursor count' do
+        expect(field).to be_int32(id_count)
+      end
+    end
+
+    describe 'cursor ids' do
+      let(:field) { bytes[24..-1] }
+      it 'serializes the selector' do
+        expect(field).to be_int64_sequence(cursor_ids)
+      end
+    end
+  end
+end

data/spec/mongo/protocol/query_spec.rb

@@ -0,0 +1,285 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Query do
+
+  let(:opcode)   { 2004 }
+  let(:db)       { TEST_DB }
+  let(:coll)     { TEST_COLL }
+  let(:ns)       { "#{db}.#{coll}" }
+  let(:selector) { { :name => 'Tyler' } }
+  let(:options)     { Hash.new }
+
+  let(:message) do
+    described_class.new(db, coll, selector, options)
+  end
+
+  describe '#initialize' do
+
+    it 'sets the namepsace' do
+      expect(message.namespace).to eq(ns)
+    end
+
+    it 'sets the selector' do
+      expect(message.selector).to eq(selector)
+    end
+
+    context 'when options are provided' do
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => [:slave_ok] } }
+
+        it 'sets the flags' do
+          expect(message.flags).to eq(options[:flags])
+        end
+      end
+
+      context 'when a limit is provided' do
+        let(:options) { { :limit => 5 } }
+
+        it 'sets the limit' do
+          expect(message.limit).to eq(options[:limit])
+        end
+      end
+
+      context 'when a skip is provided' do
+        let(:options) { { :skip => 13 } }
+
+        it 'sets the flags' do
+          expect(message.skip).to eq(options[:skip])
+        end
+      end
+
+      context 'when a projection is provided' do
+        let(:options) { { :project => { :_id => 0 } } }
+
+        it 'sets the projection' do
+          expect(message.project).to eq(options[:project])
+        end
+      end
+    end
+  end
+
+  describe '#==' do
+
+    context 'when the other is a query' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, options)
+        end
+
+        it 'returns true' do
+          expect(message).to eq(other)
+        end
+      end
+
+      context 'when the database is not equal' do
+        let(:other) do
+          described_class.new('tyler', coll, selector, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the collection is not equal' do
+        let(:other) do
+          described_class.new(db, 'tyler', selector, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the selector is not equal' do
+        let(:other) do
+          described_class.new(db, coll, { :a => 1 }, options)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+
+      context 'when the options are not equal' do
+        let(:other) do
+          described_class.new(db, coll, selector, :skip => 2)
+        end
+
+        it 'returns false' do
+          expect(message).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a query' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      message.send(:fields).map do |field|
+        message.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(message.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#replyable?' do
+
+    it 'returns true' do
+      expect(message).to be_replyable
+    end
+  end
+
+  describe '#serialize' do
+    let(:bytes) { message.serialize }
+
+    include_examples 'message with a header'
+
+    describe 'flags' do
+      let(:field) { bytes[16..19] }
+
+      context 'when no flags are provided' do
+        it 'does not set any bits' do
+          expect(field).to be_int32(0)
+        end
+      end
+
+      context 'when flags are provided' do
+        let(:options) { { :flags => flags } }
+
+        context 'tailable cursor flag' do
+          let(:flags) { [:tailable_cursor] }
+          it 'sets the second bit' do
+            expect(field).to be_int32(2)
+          end
+        end
+
+        context 'slave ok flag' do
+          let(:flags) { [:slave_ok] }
+          it 'sets the third bit' do
+            expect(field).to be_int32(4)
+          end
+        end
+
+        context 'oplog replay flag' do
+          let(:flags) { [:oplog_replay] }
+          it 'sets the fourth bit' do
+            expect(field).to be_int32(8)
+          end
+        end
+
+        context 'no cursor timeout flag' do
+          let(:flags) { [:no_cursor_timeout] }
+          it 'sets the fifth bit' do
+            expect(field).to be_int32(16)
+          end
+        end
+
+        context 'await data flag' do
+          let(:flags) { [:await_data] }
+          it 'sets the sixth bit' do
+            expect(field).to be_int32(32)
+          end
+        end
+
+        context 'exhaust flag' do
+          let(:flags) { [:exhaust] }
+          it 'sets the seventh bit' do
+            expect(field).to be_int32(64)
+          end
+        end
+
+        context 'partial flag' do
+          let(:flags) { [:partial] }
+          it 'sets the eigth bit' do
+            expect(field).to be_int32(128)
+          end
+        end
+
+        context 'multiple flags' do
+          let(:flags) { [:await_data, :slave_ok] }
+          it 'sets the correct bits' do
+            expect(field).to be_int32(36)
+          end
+        end
+      end
+    end
+
+    describe 'namespace' do
+      let(:field) { bytes[20..36] }
+      it 'serializes the namespace' do
+        expect(field).to be_cstring(ns)
+      end
+    end
+
+    describe 'skip' do
+      let(:field) { bytes[37..40] }
+
+      context 'when no skip is provided' do
+        it 'serializes a zero' do
+          expect(field).to be_int32(0)
+        end
+      end
+
+      context 'when skip is provided' do
+        let(:options) { { :skip => 5 } }
+
+        it 'serializes the skip' do
+          expect(field).to be_int32(options[:skip])
+        end
+      end
+    end
+
+    describe 'limit' do
+      let(:field) { bytes[41..44] }
+
+      context 'when no limit is provided' do
+        it 'serializes a zero' do
+          expect(field).to be_int32(0)
+        end
+      end
+
+      context 'when limit is provided' do
+        let(:options) { { :limit => 123 } }
+        it 'serializes the limit' do
+          expect(field).to be_int32(options[:limit])
+        end
+      end
+    end
+
+    describe 'selector' do
+      let(:field) { bytes[45..65] }
+      it 'serializes the selector' do
+        expect(field).to be_bson(selector)
+      end
+    end
+
+    describe 'project' do
+      let(:field) { bytes[66..-1] }
+      context 'when no projection is provided' do
+        it 'does not serialize a projection' do
+          expect(field).to be_empty
+        end
+      end
+
+      context 'when projection is provided' do
+        let(:options) { { :project => projection } }
+        let(:projection) { { :_id => 0 } }
+
+        it 'serializes the projection' do
+          expect(field).to be_bson(projection)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/protocol/reply_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Mongo::Protocol::Reply do
+
+  let(:length)      { 78 }
+  let(:request_id)  { 0 }
+  let(:response_to) { 0 }
+  let(:op_code)     { 1 }
+  let(:flags)       { 0 }
+  let(:start)       { 0 }
+  let(:n_returned)  { 2 }
+  let(:cursor_id)   { 999_999 }
+  let(:doc)         { { 'name' => 'Tyler' } }
+  let(:documents)   { [doc] * 2 }
+
+  let(:header) do
+    [length, request_id, response_to, op_code].pack('l<l<l<l<')
+  end
+
+  let(:data) do
+    data =  [flags].pack('l<')
+    data << [cursor_id].pack('q<')
+    data << [start].pack('l<')
+    data << [n_returned].pack('l<')
+    data << documents.map(&:to_bson).join
+  end
+
+  let(:io)    { StringIO.new(header + data) }
+  let(:reply) { described_class.deserialize(io) }
+
+  describe '#==' do
+
+    context 'when the other is a reply' do
+
+      context 'when the fields are equal' do
+        let(:other) do
+          other = described_class.allocate
+          other.instance_variable_set(:@flags, [])
+          other.instance_variable_set(:@number_returned, n_returned)
+          other.instance_variable_set(:@cursor_id, cursor_id)
+          other.instance_variable_set(:@documents, documents)
+          other.instance_variable_set(:@starting_from, start)
+          other
+        end
+
+        it 'returns true' do
+          expect(reply).to eq(other)
+        end
+      end
+
+      context 'when fields are not equal' do
+        let(:other) do
+          other = described_class.allocate
+          other.instance_variable_set(:@flags, [:await_capable])
+          other.instance_variable_set(:@number_returned, n_returned)
+          other.instance_variable_set(:@cursor_id, cursor_id)
+          other.instance_variable_set(:@documents, documents)
+          other.instance_variable_set(:@starting_from, start)
+          other
+        end
+
+        it 'returns false' do
+          expect(reply).not_to eq(other)
+        end
+      end
+    end
+
+    context 'when the other is not a reply' do
+      let(:other) do
+        expect(message).not_to eq('test')
+      end
+    end
+  end
+
+  describe '#hash' do
+    let(:values) do
+      reply.send(:fields).map do |field|
+        reply.instance_variable_get(field[:name])
+      end
+    end
+
+    it 'returns a hash of the field values' do
+      expect(reply.hash).to eq(values.hash)
+    end
+  end
+
+  describe '#deserialize' do
+
+    describe 'response flags' do
+
+      context 'no flags' do
+        it 'sets no flags' do
+          expect(reply.flags).to be_empty
+        end
+      end
+
+      context 'cursor not found' do
+        let(:flags) { 1 }
+        it 'sets the cursor not found flag' do
+          expect(reply.flags).to eq([:cursor_not_found])
+        end
+      end
+
+      context 'query failure' do
+        let(:flags) { 2 }
+        it 'sets the query failure flag' do
+          expect(reply.flags).to eq([:query_failure])
+        end
+      end
+
+      context 'shard config stale' do
+        let(:flags) { 4 }
+        it 'sets the shard config stale flag' do
+          expect(reply.flags).to eq([:shard_config_stale])
+        end
+      end
+
+      context 'await capable' do
+        let(:flags) { 8 }
+        it 'sets the await capable flag' do
+          expect(reply.flags).to eq([:await_capable])
+        end
+      end
+
+      context 'multiple flags' do
+        let(:flags) { 10 }
+        it 'sets multiple flags' do
+          expect(reply.flags).to include(:query_failure, :await_capable)
+        end
+      end
+    end
+
+    describe 'cursor id' do
+      it 'sets the cursor id attribute' do
+        expect(reply.cursor_id).to eq(cursor_id)
+      end
+    end
+
+    describe 'starting from' do
+      it 'sets the starting from attribute' do
+        expect(reply.starting_from).to eq(start)
+      end
+    end
+
+    describe 'number returned' do
+      it 'sets the number returned attribute' do
+        expect(reply.number_returned).to eq(n_returned)
+      end
+    end
+
+    describe 'documents' do
+      it 'sets the documents attribute' do
+        expect(reply.documents).to eq(documents)
+      end
+    end
+  end
+end