bson 4.1.1 → 5.2.0

data/spec/bson/byte_buffer_write_spec.rb

@@ -0,0 +1,855 @@
+# rubocop:todo all
+require 'spec_helper'
+
+describe BSON::ByteBuffer do
+
+  let(:buffer) do
+    described_class.new
+  end
+
+  shared_examples_for 'does not write' do
+    it 'raises ArgumentError' do
+      expect do
+        modified
+      end.to raise_error(ArgumentError)
+    end
+
+    it 'does not change write position' do
+      expect do
+        modified
+      end.to raise_error(ArgumentError)
+
+      expect(buffer.write_position).to eq(0)
+    end
+  end
+
+  describe '#put_byte' do
+
+    let(:modified) do
+      buffer.put_byte(BSON::Int32::BSON_TYPE)
+    end
+
+    it 'appends the byte to the byte buffer' do
+      expect(modified.to_s).to eq(BSON::Int32::BSON_TYPE.chr)
+    end
+
+    it 'increments the write position by 1' do
+      expect(modified.write_position).to eq(1)
+    end
+
+    context 'when it receives a numeric value' do
+      it 'raises the ArgumentError exception' do
+        expect{buffer.put_byte(1)}.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when it receives a nil value' do
+      it 'raises the ArgumentError exception' do
+        expect{buffer.put_byte(nil)}.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when given a string of length > 1' do
+
+      let(:modified) do
+        buffer.put_byte('xx')
+      end
+
+      it_behaves_like 'does not write'
+    end
+
+    context 'when given a string of length 0' do
+
+      let(:modified) do
+        buffer.put_byte('')
+      end
+
+      it_behaves_like 'does not write'
+    end
+
+    context 'when byte is not valid utf-8' do
+      let(:string) do
+        Utils.make_byte_string([254]).freeze
+      end
+
+      let(:modified) do
+        buffer.put_byte(string)
+      end
+
+      it 'writes the byte' do
+        expect(modified.to_s).to eq(string)
+      end
+    end
+  end
+
+  describe '#put_bytes' do
+
+    let(:modified) do
+      buffer.put_bytes(BSON::Int32::BSON_TYPE)
+      buffer
+    end
+
+    it 'increments the write position by 1' do
+      expect(modified.write_position).to eq(1)
+    end
+
+    context 'when it receives a numeric value' do
+      it 'raises the ArgumentError exception' do
+        expect{buffer.put_bytes(1)}.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when it receives a nil value' do
+      it 'raises the ArgumentError exception' do
+        expect{buffer.put_bytes(nil)}.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when given a string with null bytes' do
+      let(:byte_str) { [0, 239, 254, 0].map(&:chr).join }
+
+      let(:modified) do
+        buffer.put_bytes(byte_str)
+      end
+
+      before do
+        expect(buffer.write_position).to eq(0)
+        expect(byte_str.length).to eq(4)
+      end
+
+      it 'writes the string' do
+        expect(modified.write_position).to eq(4)
+      end
+    end
+
+    context 'when bytes are not valid utf-8' do
+      let(:string) do
+        Utils.make_byte_string([254, 0, 255]).freeze
+      end
+
+      let(:modified) do
+        buffer.put_bytes(string)
+      end
+
+      it 'writes the bytes' do
+        expect(modified.to_s).to eq(string)
+      end
+    end
+  end
+
+  shared_examples_for 'bson string writer' do
+
+    context 'given empty string' do
+      let(:modified) do
+        buffer.put_string('')
+      end
+
+      it 'writes length and null terminator' do
+        expect(modified.write_position).to eq(5)
+      end
+    end
+
+    context 'when string is not valid utf-8 in utf-8 encoding' do
+      let(:string) do
+        Utils.make_byte_string([254, 253, 255], 'utf-8')
+      end
+
+      before do
+        expect(string.encoding.name).to eq('UTF-8')
+      end
+
+      it 'raises EncodingError' do
+        # Precise exception classes and messages differ between MRI and JRuby
+        expect do
+          modified
+        end.to raise_error(EncodingError)
+      end
+    end
+
+    context 'when string is in binary encoding and cannot be encoded in utf-8' do
+      let(:string) do
+        Utils.make_byte_string([254, 253, 255], 'binary')
+      end
+
+      before do
+        expect(string.encoding.name).to eq('ASCII-8BIT')
+      end
+
+      it 'raises Encoding::UndefinedConversionError' do
+        expect do
+          modified
+        end.to raise_error(Encoding::UndefinedConversionError, /from ASCII-8BIT to UTF-8/)
+      end
+    end
+  end
+
+  describe '#put_string' do
+
+    let(:modified) do
+      buffer.put_string(string)
+    end
+
+    it_behaves_like 'bson string writer'
+
+    context 'when the buffer does not need to be expanded' do
+
+      context 'when the string is UTF-8' do
+
+        let!(:modified) do
+          buffer.put_string('testing')
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq("#{8.to_bson.to_s}testing#{BSON::NULL_BYTE}")
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(12)
+        end
+      end
+    end
+
+    context 'when the buffer needs to be expanded' do
+
+      let(:string) do
+        300.times.inject(""){ |s, i| s << "#{i}" }
+      end
+
+      context 'when no bytes exist in the buffer' do
+
+        let!(:modified) do
+          buffer.put_string(string)
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq("#{(string.bytesize + 1).to_bson.to_s}#{string}#{BSON::NULL_BYTE}")
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(string.bytesize + 5)
+        end
+      end
+
+      context 'when bytes exist in the buffer' do
+
+        let!(:modified) do
+          buffer.put_int32(4).put_string(string)
+        end
+
+        it 'appends the string to the byte buffer' do
+          expect(modified.to_s).to eq(
+            "#{[ 4 ].pack(BSON::Int32::PACK)}#{(string.bytesize + 1).to_bson.to_s}#{string}#{BSON::NULL_BYTE}"
+          )
+        end
+
+        it 'increments the write position by length + 5' do
+          expect(modified.write_position).to eq(string.bytesize + 9)
+        end
+      end
+    end
+
+    context 'when string is in an encoding other than utf-8' do
+      let(:string) do
+        # "\xfe"
+        Utils.make_byte_string([254], 'iso-8859-1')
+      end
+
+      let(:expected) do
+        # \xc3\xbe == \u00fe
+        Utils.make_byte_string([3, 0, 0, 0, 0xc3, 0xbe, 0])
+      end
+
+      it 'is written as utf-8' do
+        expect(modified.to_s).to eq(expected)
+      end
+    end
+  end
+
+  describe '#put_cstring' do
+
+    let(:modified) do
+      buffer.put_cstring(string)
+    end
+
+    it_behaves_like 'bson string writer'
+
+    context 'when argument is a string' do
+      context 'when the string is valid' do
+
+        let!(:modified) do
+          buffer.put_cstring('testing')
+        end
+
+        it 'appends the string plus null byte to the byte buffer' do
+          expect(modified.to_s).to eq("testing#{BSON::NULL_BYTE}")
+        end
+
+        it 'increments the write position by the length + 1' do
+          expect(modified.write_position).to eq(8)
+        end
+
+        it 'mutates receiver' do
+          modified
+          expect(buffer.write_position).to eq(8)
+        end
+      end
+
+      context "when the string contains a null byte" do
+
+        let(:string) do
+          "test#{BSON::NULL_BYTE}ing"
+        end
+
+        it 'raises ArgumentError' do
+          expect {
+            modified
+          }.to raise_error(ArgumentError, /String .* contains null bytes/)
+        end
+      end
+
+      context 'when string is in an encoding other than utf-8' do
+        let(:string) do
+          # "\xfe"
+          Utils.make_byte_string([254], 'iso-8859-1')
+        end
+
+        let(:expected) do
+          # \xc3\xbe == \u00fe
+          # No length prefix
+          Utils.make_byte_string([0xc3, 0xbe, 0])
+        end
+
+        it 'is written as utf-8' do
+          expect(modified.to_s).to eq(expected)
+        end
+      end
+    end
+
+    context 'when argument is a symbol' do
+      let(:modified) do
+        buffer.put_cstring(:testing)
+      end
+
+      it 'writes' do
+        expect(modified.to_s).to eq("testing#{BSON::NULL_BYTE}")
+      end
+
+      it 'increments the write position by the length + 1' do
+        expect(modified.write_position).to eq(8)
+      end
+
+      it 'mutates receiver' do
+        modified
+        expect(buffer.write_position).to eq(8)
+      end
+
+      context 'when symbol includes a null byte' do
+        let(:modified) do
+          buffer.put_cstring(:"tes\x00ing")
+        end
+
+        it 'raises ArgumentError' do
+          expect {
+            modified
+          }.to raise_error(ArgumentError, /String .* contains null bytes/)
+        end
+
+        it 'does not change write position' do
+          begin
+            buffer.put_cstring(:"tes\x00ing")
+          rescue ArgumentError
+          end
+
+          expect(buffer.write_position).to eq(0)
+        end
+      end
+    end
+
+    context 'when argument is a Fixnum' do
+      let(:modified) do
+        buffer.put_cstring(1234)
+      end
+
+      it 'writes' do
+        expect(modified.to_s).to eq("1234#{BSON::NULL_BYTE}")
+      end
+
+      it 'increments the write position by the length + 1' do
+        expect(modified.write_position).to eq(5)
+      end
+    end
+
+    context 'when argument is of an unsupported type' do
+      let(:modified) do
+        buffer.put_cstring(1234.0)
+      end
+
+      it 'raises TypeError' do
+        expect do
+          modified
+        end.to raise_error(TypeError, /Invalid type for put_cstring/)
+      end
+
+      it 'does not change write position' do
+        begin
+          buffer.put_cstring(1234.0)
+        rescue TypeError
+        end
+
+        expect(buffer.write_position).to eq(0)
+      end
+    end
+  end
+
+  describe '#put_symbol' do
+    context 'normal symbol' do
+      let(:modified) do
+        buffer.put_symbol(:hello)
+      end
+
+      it 'writes the symbol as string' do
+        expect(modified.to_s).to eq("\x06\x00\x00\x00hello\x00")
+      end
+
+      it 'advances write position' do
+        # 4 byte length + 5 byte string + null byte
+        expect(modified.write_position).to eq(10)
+      end
+    end
+
+    context 'symbol with null byte' do
+      let(:modified) do
+        buffer.put_symbol(:"he\x00lo")
+      end
+
+      it 'writes the symbol as string' do
+        expect(modified.to_s).to eq("\x06\x00\x00\x00he\x00lo\x00")
+      end
+
+      it 'advances write position' do
+        # 4 byte length + 5 byte string + null byte
+        expect(modified.write_position).to eq(10)
+      end
+    end
+
+    context 'when symbol is not valid utf-8' do
+      let(:symbol) do
+        Utils.make_byte_string([254, 0, 255]).to_sym
+      end
+
+      let(:modified) do
+        buffer.put_symbol(symbol)
+      end
+
+      it 'raises EncodingError' do
+        # Precise exception classes and messages differ between MRI and JRuby
+        expect do
+          modified
+        end.to raise_error(EncodingError)
+      end
+    end
+  end
+
+  describe '#put_double' do
+
+    let(:modified) do
+      buffer.put_double(1.2332)
+    end
+
+    it 'appends the double to the buffer' do
+      expect(modified.to_s).to eq([ 1.2332 ].pack(Float::PACK))
+    end
+
+    it 'increments the write position by 8' do
+      expect(modified.write_position).to eq(8)
+    end
+
+    context 'when argument is an integer' do
+
+      let(:modified) do
+        buffer.put_double(3)
+      end
+
+      it 'writes a double' do
+        expect(modified.to_s).to eq([ 3 ].pack(Float::PACK))
+      end
+
+      it 'increments the write position by 8' do
+        expect(modified.write_position).to eq(8)
+      end
+    end
+
+    context 'when argument is a BigNum' do
+      let(:value) { 123456789012345678901234567890 }
+
+      let(:modified) do
+        buffer.put_double(value)
+      end
+
+      let(:actual) do
+        described_class.new(modified.to_s).get_double
+      end
+
+      it 'writes a double' do
+        expect(actual).to be_within(1).of(value)
+      end
+
+      it 'increments the write position by 8' do
+        expect(modified.write_position).to eq(8)
+      end
+    end
+
+    context 'when argument is a string' do
+
+      let(:modified) do
+        buffer.put_double("hello")
+      end
+
+      it 'raises TypeError' do
+        expect do
+          modified
+        end.to raise_error(TypeError, /no implicit conversion to float from string|ClassCastException:.*RubyString cannot be cast to.*RubyFloat/)
+        expect(buffer.write_position).to eq(0)
+      end
+    end
+  end
+
+  describe '#put_int32' do
+
+    context 'when the integer is 32 bit' do
+
+      context 'when the integer is positive' do
+
+        let!(:modified) do
+          buffer.put_int32(Integer::MAX_32BIT - 1)
+        end
+
+        let(:expected) do
+          [ Integer::MAX_32BIT - 1 ].pack(BSON::Int32::PACK)
+        end
+
+        it 'appends the int32 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 4' do
+          expect(modified.write_position).to eq(4)
+        end
+      end
+
+      context 'when the integer is negative' do
+
+        let!(:modified) do
+          buffer.put_int32(Integer::MIN_32BIT + 1)
+        end
+
+        let(:expected) do
+          [ Integer::MIN_32BIT + 1 ].pack(BSON::Int32::PACK)
+        end
+
+        it 'appends the int32 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 4' do
+          expect(modified.write_position).to eq(4)
+        end
+      end
+
+      context 'when the integer is not 32 bit' do
+
+        it 'raises an exception' do
+          expect {
+            buffer.put_int32(Integer::MAX_64BIT - 1)
+          }.to raise_error(RangeError)
+        end
+      end
+    end
+
+    context 'when argument is a float' do
+
+      let(:modified) do
+        buffer.put_int32(4.934)
+      end
+
+        let(:expected) do
+          [ 4 ].pack(BSON::Int32::PACK)
+        end
+
+      it 'appends the int32 to the byte buffer' do
+        expect(modified.to_s).to eq(expected)
+      end
+
+      it 'increments the write position by 4' do
+        expect(modified.write_position).to eq(4)
+      end
+    end
+  end
+
+  describe '#put_uint32' do
+    context 'when argument is a float' do
+      it 'raises an Argument Error' do
+        expect{ buffer.put_uint32(4.934) }.to raise_error(ArgumentError, "put_uint32: incorrect type: float, expected: integer")
+      end
+    end
+    
+    context 'when number is in range' do 
+      let(:modified) do
+        buffer.put_uint32(5)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(5)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 0' do 
+      let(:modified) do
+        buffer.put_uint32(0)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(0)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number doesn\'t fit in signed int32' do 
+      let(:modified) do
+        buffer.put_uint32(4294967295)
+      end
+
+      let(:expected) do
+        [ 4294967295 ].pack(BSON::Int32::PACK)
+      end
+
+      it 'appends the int32 to the byte buffer' do
+        expect(modified.to_s).to eq(expected)
+      end
+
+      it 'get returns correct number' do
+        expect(modified.get_uint32).to eq(4294967295)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 2^31' do 
+      let(:modified) do
+        buffer.put_uint32(2147483648)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(2147483648)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is 2^31-1' do 
+      let(:modified) do
+        buffer.put_uint32(2147483647)
+      end
+
+      it 'returns gets the correct number from the buffer' do
+        expect(modified.get_uint32).to eq(2147483647)
+      end
+
+      it 'returns the length of the buffer' do
+        expect(modified.length).to eq(4)
+      end
+    end
+
+    context 'when number is not in range' do 
+      it 'raises error on out of top range' do
+        expect{ buffer.put_uint32(4294967296) }.to raise_error(RangeError, "Number 4294967296 is out of range [0, 2^32)")
+      end
+
+      it 'raises error on out of bottom range' do
+        expect{ buffer.put_uint32(-1) }.to raise_error(RangeError, "Number -1 is out of range [0, 2^32)")
+      end
+    end
+  end
+
+  describe '#put_int64' do
+
+    context 'when the integer is 64 bit' do
+
+      context 'when the integer is positive' do
+
+        let!(:modified) do
+          buffer.put_int64(Integer::MAX_64BIT - 1)
+        end
+
+        let(:expected) do
+          [ Integer::MAX_64BIT - 1 ].pack(BSON::Int64::PACK)
+        end
+
+        it 'appends the int64 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 8' do
+          expect(modified.write_position).to eq(8)
+        end
+      end
+
+      context 'when the integer is negative' do
+
+        let!(:modified) do
+          buffer.put_int64(Integer::MIN_64BIT + 1)
+        end
+
+        let(:expected) do
+          [ Integer::MIN_64BIT + 1 ].pack(BSON::Int64::PACK)
+        end
+
+        it 'appends the int64 to the byte buffer' do
+          expect(modified.to_s).to eq(expected)
+        end
+
+        it 'increments the write position by 8' do
+          expect(modified.write_position).to eq(8)
+        end
+      end
+
+      context 'when the integer is larger than 64 bit' do
+
+        it 'raises an exception' do
+          expect {
+            buffer.put_int64(Integer::MAX_64BIT + 1)
+          }.to raise_error(RangeError)
+        end
+      end
+    end
+
+    context 'when integer fits in 32 bits' do
+      let(:modified) do
+        buffer.put_int64(1)
+      end
+
+      it 'increments the write position by 8' do
+        expect(modified.write_position).to eq(8)
+      end
+    end
+
+    context 'when argument is a float' do
+
+      let(:modified) do
+        buffer.put_int64(4.934)
+      end
+
+        let(:expected) do
+          [ 4 ].pack(BSON::Int64::PACK)
+        end
+
+      it 'appends the int64 to the byte buffer' do
+        expect(modified.to_s).to eq(expected)
+      end
+
+      it 'increments the write position by 8' do
+        expect(modified.write_position).to eq(8)
+      end
+    end
+  end
+
+  describe '#replace_int32' do
+
+    let(:exp_0) do
+      [ 0 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:exp_first) do
+      [ 5 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:exp_second) do
+      [ 4 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:exp_42) do
+      [ 42 ].pack(BSON::Int32::PACK)
+    end
+
+    let(:modified) do
+      buffer.replace_int32(0, 5)
+    end
+
+    context 'when there is sufficient data in buffer' do
+
+      before do
+        buffer.put_int32(0).put_int32(4)
+      end
+
+      it 'replaces the int32 at the location' do
+        expect(modified.to_s).to eq("#{exp_first}#{exp_second}")
+      end
+
+      context 'when the position is negative' do
+
+        let(:modified) do
+          buffer.replace_int32(-1, 5)
+        end
+
+        it 'raises ArgumentError' do
+          expect do
+            modified
+          end.to raise_error(ArgumentError, /Position.*cannot be negative/)
+        end
+      end
+
+      context 'when the position is 4 bytes prior to write position' do
+
+        let(:modified) do
+          buffer.replace_int32(4, 42)
+        end
+
+        it 'replaces the int32 at the location' do
+          expect(modified.to_s).to eq("#{exp_0}#{exp_42}")
+        end
+      end
+
+      context 'when the position exceeds allowed range' do
+
+        let(:modified) do
+          # Buffer has 8 bytes but we can only write up to position 4
+          buffer.replace_int32(5, 42)
+        end
+
+        it 'raises ArgumentError' do
+          expect do
+            modified
+          end.to raise_error(ArgumentError, /Position.*is out of bounds/)
+        end
+      end
+    end
+
+    context 'when there is insufficient data in buffer' do
+
+      before do
+        buffer.put_bytes("aa")
+      end
+
+      let(:modified) do
+        buffer.replace_int32(1, 42)
+      end
+
+      it 'raises ArgumentError' do
+        expect do
+          modified
+        end.to raise_error(ArgumentError, /Buffer does not have enough data/)
+      end
+    end
+  end
+end