bson 4.2.2 → 4.12.1

data/spec/bson/boolean_spec.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/spec/bson/byte_buffer_read_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe BSON::ByteBuffer do
+
+  describe '#get_byte' do
+
+    let(:buffer) do
+      described_class.new(BSON::Int32::BSON_TYPE)
+    end
+
+    let!(:byte) do
+      buffer.get_byte
+    end
+
+    it 'gets the byte from the buffer' do
+      expect(byte).to eq(BSON::Int32::BSON_TYPE)
+    end
+
+    it 'increments the read position by 1' do
+      expect(buffer.read_position).to eq(1)
+    end
+  end
+
+  describe '#get_bytes' do
+
+    let(:string) do
+      "#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}"
+    end
+
+    let(:buffer) do
+      described_class.new(string)
+    end
+
+    let!(:bytes) do
+      buffer.get_bytes(2)
+    end
+
+    it 'gets the bytes from the buffer' do
+      expect(bytes).to eq(string)
+    end
+
+    it 'increments the position by the length' do
+      expect(buffer.read_position).to eq(string.bytesize)
+    end
+  end
+
+  describe '#get_cstring' do
+
+    let(:buffer) do
+      described_class.new("testing#{BSON::NULL_BYTE}")
+    end
+
+    let!(:string) do
+      buffer.get_cstring
+    end
+
+    it 'gets the cstring from the buffer' do
+      expect(string).to eq("testing")
+    end
+
+    it 'increments the position by string length + 1' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_double' do
+
+    let(:buffer) do
+      described_class.new(12.5.to_bson.to_s)
+    end
+
+    let!(:double) do
+      buffer.get_double
+    end
+
+    it 'gets the double from the buffer' do
+      expect(double).to eq(12.5)
+    end
+
+    it 'increments the read position by 8' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_int32' do
+
+    let(:buffer) do
+      described_class.new(12.to_bson.to_s)
+    end
+
+    let!(:int32) do
+      buffer.get_int32
+    end
+
+    it 'gets the int32 from the buffer' do
+      expect(int32).to eq(12)
+    end
+
+    it 'increments the position by 4' do
+      expect(buffer.read_position).to eq(4)
+    end
+  end
+
+  describe '#get_uint32' do
+    context 'when using 2^32-1' do
+      let(:buffer) do
+        described_class.new(4294967295.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(4294967295)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+    
+    context 'when using 2^32-2' do
+      let(:buffer) do
+        described_class.new(4294967294.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(4294967294)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+
+    context 'when using 0' do
+      let(:buffer) do
+        described_class.new(0.to_bson.to_s)
+      end
+
+      let!(:int32) do
+        buffer.get_uint32
+      end
+
+      it 'gets the uint32 from the buffer' do
+        expect(int32).to eq(0)
+      end
+
+      it 'increments the position by 4' do
+        expect(buffer.read_position).to eq(4)
+      end
+    end
+  end
+
+  describe '#get_int64' do
+
+    let(:buffer) do
+      described_class.new((Integer::MAX_64BIT - 1).to_bson.to_s)
+    end
+
+    let!(:int64) do
+      buffer.get_int64
+    end
+
+    it 'gets the int64 from the buffer' do
+      expect(int64).to eq(Integer::MAX_64BIT - 1)
+    end
+
+    it 'increments the position by 8' do
+      expect(buffer.read_position).to eq(8)
+    end
+  end
+
+  describe '#get_string' do
+
+    let(:buffer) do
+      described_class.new("#{8.to_bson.to_s}testing#{BSON::NULL_BYTE}")
+    end
+
+    let!(:string) do
+      buffer.get_string
+    end
+
+    it 'gets the string from the buffer' do
+      expect(string).to eq("testing")
+    end
+
+    it 'increments the position by string length + 5' do
+      expect(buffer.read_position).to eq(12)
+    end
+  end
+end

data/spec/bson/byte_buffer_spec.rb

@@ -13,478 +13,218 @@ describe BSON::ByteBuffer do
     end
   end
 
-  describe '#get_byte' do
-
-    let(:buffer) do
-      described_class.new(BSON::Int32::BSON_TYPE)
-    end
-
-    let!(:byte) do
-      buffer.get_byte
-    end
-
-    it 'gets the byte from the buffer' do
-      expect(byte).to eq(BSON::Int32::BSON_TYPE)
-    end
-
-    it 'increments the read position by 1' do
-      expect(buffer.read_position).to eq(1)
-    end
-  end
-
-  describe '#get_bytes' do
-
-    let(:string) do
-      "#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}"
-    end
-
-    let(:buffer) do
-      described_class.new(string)
-    end
-
-    let!(:bytes) do
-      buffer.get_bytes(2)
-    end
-
-    it 'gets the bytes from the buffer' do
-      expect(bytes).to eq(string)
-    end
-
-    it 'increments the position by the length' do
-      expect(buffer.read_position).to eq(string.bytesize)
-    end
-  end
-
-  describe '#get_cstring' do
-
-    let(:buffer) do
-      described_class.new("testing#{BSON::NULL_BYTE}")
-    end
-
-    let!(:string) do
-      buffer.get_cstring
-    end
-
-    it 'gets the cstring from the buffer' do
-      expect(string).to eq("testing")
-    end
-
-    it 'increments the position by string length + 1' do
-      expect(buffer.read_position).to eq(8)
-    end
-  end
-
-  describe '#get_double' do
-
-    let(:buffer) do
-      described_class.new("#{12.5.to_bson.to_s}")
-    end
-
-    let!(:double) do
-      buffer.get_double
-    end
-
-    it 'gets the double from the buffer' do
-      expect(double).to eq(12.5)
-    end
-
-    it 'increments the read position by 8' do
-      expect(buffer.read_position).to eq(8)
-    end
-  end
-
-  describe '#get_int32' do
-
-    let(:buffer) do
-      described_class.new("#{12.to_bson.to_s}")
-    end
-
-    let!(:int32) do
-      buffer.get_int32
-    end
-
-    it 'gets the int32 from the buffer' do
-      expect(int32).to eq(12)
-    end
-
-    it 'increments the position by 4' do
-      expect(buffer.read_position).to eq(4)
-    end
-  end
-
-  describe '#get_int64' do
-
-    let(:buffer) do
-      described_class.new("#{(Integer::MAX_64BIT - 1).to_bson.to_s}")
-    end
-
-    let!(:int64) do
-      buffer.get_int64
-    end
-
-    it 'gets the int64 from the buffer' do
-      expect(int64).to eq(Integer::MAX_64BIT - 1)
-    end
-
-    it 'increments the position by 8' do
-      expect(buffer.read_position).to eq(8)
-    end
-  end
-
-  describe '#get_string' do
-
-    let(:buffer) do
-      described_class.new("#{8.to_bson.to_s}testing#{BSON::NULL_BYTE}")
-    end
-
-    let!(:string) do
-      buffer.get_string
-    end
-
-    it 'gets the string from the buffer' do
-      expect(string).to eq("testing")
-    end
-
-    it 'increments the position by string length + 5' do
-      expect(buffer.read_position).to eq(12)
-    end
-  end
-
   describe '#length' do
+    context 'empty buffer' do
 
-    let(:buffer) do
-      described_class.new
-    end
-
-    before do
-      buffer.put_int32(5)
-    end
-
-    it 'returns the length of the buffer' do
-      expect(buffer.length).to eq(4)
-    end
-  end
-
-  describe '#put_byte' do
-
-    let(:buffer) do
-      described_class.new
-    end
-
-    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
-  end
-
-  describe '#put_cstring' do
+      let(:buffer) do
+        described_class.new
+      end
 
-    let(:buffer) do
-      described_class.new
+      it 'is zero' do
+        expect(buffer.length).to eq(0)
+      end
     end
 
-    context 'when the string is valid' do
+    context 'when the byte buffer is initialized with no bytes' do
 
-      let!(:modified) do
-        buffer.put_cstring('testing')
+      let(:buffer) do
+        described_class.new
       end
 
-      it 'appends the string plus null byte to the byte buffer' do
-        expect(modified.to_s).to eq("testing#{BSON::NULL_BYTE}")
-      end
+      context '#put_int32' do
+        before do
+          buffer.put_int32(5)
+        end
 
-      it 'increments the write position by the length + 1' do
-        expect(modified.write_position).to eq(8)
+        it 'returns the length of the buffer' do
+          expect(buffer.length).to eq(4)
+        end
       end
     end
 
-    context "when the string contains a null byte" do
+    context 'when the byte buffer is initialized with some bytes' do
 
-      let(:string) do
-        "test#{BSON::NULL_BYTE}ing"
+      let(:buffer) do
+        described_class.new("#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}")
       end
 
-      it "raises an error" do
-        expect {
-          buffer.put_cstring(string)
-        }.to raise_error(ArgumentError)
+      it 'returns the length' do
+        expect(buffer.length).to eq(2)
       end
     end
-  end
-
-  describe '#put_double' do
-
-    let(:buffer) do
-      described_class.new
-    end
-
-    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
-  end
+    context 'after the byte buffer was read from' do
 
-  describe '#put_int32' do
+      let(:buffer) do
+        described_class.new({}.to_bson.to_s)
+      end
 
-    let(:buffer) do
-      described_class.new
+      it 'returns the number of bytes remaining in the buffer' do
+        expect(buffer.length).to eq(5)
+        buffer.get_int32
+        expect(buffer.length).to eq(1)
+      end
     end
 
-    context 'when the integer is 32 bit' do
-
-      context 'when the integer is positive' do
+    context 'after the byte buffer was converted to string' 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)
+      shared_examples 'returns the total buffer length' do
+        it 'returns the total buffer length' do
+          expect(buffer.length).to eq(5)
+          buffer.to_s.length.should == 5
+          expect(buffer.length).to eq(5)
         end
       end
 
-      context 'when the integer is negative' do
-
-        let!(:modified) do
-          buffer.put_int32(Integer::MIN_32BIT + 1)
-        end
+      context 'read buffer' do
 
-        let(:expected) do
-          [ Integer::MIN_32BIT + 1 ].pack(BSON::Int32::PACK)
+        let(:buffer) do
+          described_class.new({}.to_bson.to_s)
         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
+        include_examples 'returns the total buffer length'
       end
 
-      context 'when the integer is not 32 bit' do
+      context 'write buffer' do
 
-        it 'raises an exception' do
-          expect {
-            buffer.put_int32(Integer::MAX_64BIT - 1)
-          }.to raise_error(RangeError)
+        let(:buffer) do
+          described_class.new.tap do |buffer|
+            buffer.put_bytes('hello')
+          end
         end
+
+        include_examples 'returns the total buffer length'
       end
     end
   end
 
-  describe '#put_int64' do
-
-    let(:buffer) do
-      described_class.new
-    end
-
-    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
+  describe '#rewind!' do
 
-        it 'appends the int64 to the byte buffer' do
-          expect(modified.to_s).to eq(expected)
-        end
+    shared_examples_for 'a rewindable buffer' do
 
-        it 'increments the write position by 8' do
-          expect(modified.write_position).to eq(8)
-        end
+      let(:string) do
+        "#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}"
       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
+      before do
+        buffer.get_bytes(1)
+        buffer.rewind!
       end
 
-      context 'when the integer is larger than 64 bit' do
+      it 'resets the read position to 0' do
+        expect(buffer.read_position).to eq(0)
+      end
 
-        it 'raises an exception' do
-          expect {
-            buffer.put_int64(Integer::MAX_64BIT + 1)
-          }.to raise_error(RangeError)
-        end
+      it 'starts subsequent reads at position 0' do
+        expect(buffer.get_bytes(2)).to eq(string)
       end
     end
-  end
-
-  describe '#put_string' do
 
-    context 'when the buffer does not need to be expanded' do
+    context 'when the buffer is instantiated with a string' do
 
       let(:buffer) do
-        described_class.new
+        described_class.new(string)
       end
 
-      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
+      it_behaves_like 'a rewindable buffer'
     end
 
-    context 'when the buffer needs to be expanded' do
+    context 'when the buffer is instantiated with nothing' do
 
       let(:buffer) do
         described_class.new
       end
 
-      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
+      before do
+        buffer.put_byte(BSON::Int32::BSON_TYPE).put_byte(BSON::Int32::BSON_TYPE)
       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_behaves_like 'a rewindable buffer'
+    end
 
-        it 'increments the write position by length + 5' do
-          expect(modified.write_position).to eq(string.bytesize + 9)
-        end
-      end
+    it 'does not change write position' do
+      buffer = described_class.new
+      buffer.put_byte(BSON::Int32::BSON_TYPE)
+      expect(buffer.write_position).to eq(1)
+      buffer.rewind!
+      expect(buffer.write_position).to eq(1)
     end
   end
 
-  describe '#replace_int32' do
-
+  describe 'write followed by read' do
     let(:buffer) do
       described_class.new
     end
 
-    let(:exp_first) do
-      [ 5 ].pack(BSON::Int32::PACK)
+    context 'one cycle' do
+      it 'returns the written data' do
+        buffer.put_cstring('hello')
+        buffer.get_cstring.should == 'hello'
+      end
     end
 
-    let(:exp_second) do
-      [ 4 ].pack(BSON::Int32::PACK)
-    end
+    context 'two cycles' do
+      it 'returns the written data' do
+        buffer.put_cstring('hello')
+        buffer.get_cstring.should == 'hello'
 
-    let(:modified) do
-      buffer.put_int32(0).put_int32(4).replace_int32(0, 5)
+        buffer.put_cstring('world')
+        buffer.get_cstring.should == 'world'
+      end
     end
 
-    it 'replaces the int32 at the location' do
-      expect(modified.to_s).to eq("#{exp_first}#{exp_second}")
-    end
-  end
+    context 'mixed cycles' do
+      it 'returns the written data' do
+        if BSON::Environment.jruby?
+          pending 'RUBY-2334'
+        end
 
-  describe '#rewind!' do
+        buffer.put_int32(1)
+        buffer.put_int32(2)
 
-    shared_examples_for 'a rewindable buffer' do
+        buffer.get_int32.should == 1
 
-      let(:string) do
-        "#{BSON::Int32::BSON_TYPE}#{BSON::Int32::BSON_TYPE}"
-      end
+        buffer.put_int32(3)
 
-      before do
-        buffer.get_bytes(1)
-        buffer.rewind!
+        buffer.get_int32.should == 2
+        buffer.get_int32.should == 3
       end
+    end
+  end
 
-      it 'resets the read position to 0' do
-        expect(buffer.read_position).to eq(0)
+  describe '#to_s' do
+    context 'read buffer' do
+      let(:buffer) do
+        described_class.new("\x18\x00\x00\x00*\x00\x00\x00")
       end
 
-      it 'starts subsequent reads at position 0' do
-        expect(buffer.get_bytes(2)).to eq(string)
+      it 'returns the data' do
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00"
       end
-    end
-
-    context 'when the buffer is instantiated with a string' do
 
-      let(:buffer) do
-        described_class.new(string)
+      it 'returns the remaining buffer contents after a read' do
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00"
+        buffer.get_int32.should == 24
+        buffer.to_s.should == "*\x00\x00\x00"
       end
-
-      it_behaves_like 'a rewindable buffer'
     end
 
-    context 'when the buffer is instantiated with nothing' do
-
+    context 'write buffer' do
       let(:buffer) do
-        described_class.new
+        described_class.new.tap do |buffer|
+          buffer.put_int32(24)
+        end
       end
 
-      before do
-        buffer.put_byte(BSON::Int32::BSON_TYPE).put_byte(BSON::Int32::BSON_TYPE)
+      it 'returns the data' do
+        buffer.to_s.should == "\x18\x00\x00\x00".force_encoding('binary')
       end
 
-      it_behaves_like 'a rewindable buffer'
+      it 'returns the complete buffer contents after a write' do
+        buffer.to_s.should == "\x18\x00\x00\x00".force_encoding('binary')
+        buffer.put_int32(42)
+        buffer.to_s.should == "\x18\x00\x00\x00*\x00\x00\x00".force_encoding('binary')
+      end
     end
   end
 end