bson 4.2.2 → 4.12.1

data/spec/bson/ext_json_parse_spec.rb

@@ -0,0 +1,308 @@
+# Copyright (C) 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "spec_helper"
+
+describe "BSON::ExtJSON.parse" do
+
+  let(:parsed) { BSON::ExtJSON.parse_obj(input) }
+
+  context 'when input is true' do
+    let(:input) { true }
+
+    it 'returns true' do
+      parsed.should == true
+    end
+  end
+
+  context 'when input is false' do
+    let(:input) { false }
+
+    it 'returns false' do
+      parsed.should == false
+    end
+  end
+
+  context 'when input is nil' do
+    let(:input) { nil }
+
+    it 'returns nil' do
+      parsed.should be nil
+    end
+  end
+
+  context 'when input is a string' do
+    let(:input) { 'hello' }
+
+    it 'returns the string' do
+      parsed.should == 'hello'
+    end
+  end
+
+  context 'when input is a BSON timestamp' do
+    let(:input) { {'$timestamp' => {'t' => 12345, 'i' => 42}} }
+
+    it 'returns a BSON::Timestamp instance' do
+      parsed.should == BSON::Timestamp.new(12345, 42)
+    end
+  end
+
+  context 'when input is an ISO time' do
+    let(:input) { {'$date' => '1970-01-01T00:00:04Z'} }
+
+    it 'returns a Time instance ' do
+      parsed.should be_a(Time)
+    end
+
+    it 'returns a Time instance with correct value' do
+      parsed.should == Time.at(4)
+    end
+
+    it 'returns a Time instance in UTC' do
+      parsed.zone.should == 'UTC'
+    end
+  end
+
+  context 'when input is a Unix timestamp' do
+    let(:input) { {'$date' => {'$numberLong' => '4000'}} }
+
+    it 'returns a Time instance ' do
+      parsed.should be_a(Time)
+    end
+
+    it 'returns a Time instance with correct value' do
+      parsed.should == Time.at(4)
+    end
+
+    it 'returns a Time instance in UTC' do
+      parsed.zone.should == 'UTC'
+    end
+  end
+
+  context 'when input is an int32' do
+    let(:input) do
+      {'$numberInt' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+  end
+
+  context 'when input is an int64' do
+    let(:input) do
+      {'$numberLong' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Int64 instance' do
+        parsed.should be_a(BSON::Int64)
+        parsed.value.should == 42
+      end
+    end
+  end
+
+  context 'when input is a hash' do
+    let(:input) do
+      {}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when mode is invalid' do
+      let(:mode) { :foo }
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(ArgumentError, /Invalid value for :mode option/)
+      end
+    end
+  end
+
+  context 'when input is a binary' do
+    let(:data) do
+      Base64.decode64("//8=")
+    end
+
+    context 'in current format' do
+      let(:input) do
+        { "$binary" => { "base64"=>"//8=", "subType"=>"00" } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$binary"=>"//8=", "$type"=>"00" }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+  end
+
+  context 'when input is a regex' do
+    let(:pattern) { 'abc' }
+    let(:options) { 'im' }
+
+    context 'in current format' do
+      let(:input) do
+        { "$regularExpression" => { "pattern" => pattern, "options" => options } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$regex" => pattern, "$options" => options }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'when $regularExpression is nested in $regex' do
+      context 'with options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+            "$options" => "ix",
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'), '$options' => 'ix'
+          }
+        end
+      end
+
+      context 'without options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'),
+          }
+        end
+      end
+    end
+  end
+end

data/spec/bson/false_class_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/float_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.
@@ -26,4 +26,40 @@ describe Float do
     it_behaves_like "a serializable bson element"
     it_behaves_like "a deserializable bson element"
   end
+
+  describe '#to_json' do
+    it 'returns float' do
+      42.0.to_json.should == '42.0'
+    end
+  end
+
+  describe '#as_extended_json' do
+    context 'canonical mode' do
+      it 'returns $numberDouble' do
+        42.0.as_extended_json.should == {'$numberDouble' => '42.0'}
+      end
+    end
+
+    context 'relaxed mode' do
+      let(:serialized) do
+        42.0.as_extended_json(mode: :relaxed)
+      end
+
+      it 'returns float' do
+        serialized.should be_a(Float)
+        serialized.should be_within(0.00001).of(42)
+      end
+    end
+
+    context 'legacy mode' do
+      let(:serialized) do
+        42.0.as_extended_json(mode: :legacy)
+      end
+
+      it 'returns float' do
+        serialized.should be_a(Float)
+        serialized.should be_within(0.00001).of(42)
+      end
+    end
+  end
 end

data/spec/bson/hash_as_spec.rb

@@ -0,0 +1,57 @@
+# Copyright (C) 2021 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require "spec_helper"
+
+describe 'Hash ActiveSupport extensions' do
+  require_active_support
+
+  describe '#symbolize_keys' do
+    let(:symbolized) { hash.symbolize_keys }
+
+    shared_examples 'works correctly' do
+      it 'returns a hash' do
+        symbolized.class.should be Hash
+      end
+
+      it 'works correctly' do
+        hash.symbolize_keys.should == {foo: 'bar'}
+      end
+    end
+
+    context 'string keys' do
+      let(:hash) do
+        {'foo' => 'bar'}
+      end
+
+      include_examples 'works correctly'
+    end
+
+    context 'symbol keys' do
+      let(:hash) do
+        {foo: 'bar'}
+      end
+
+      include_examples 'works correctly'
+    end
+
+    context 'both string and symbol keys' do
+      let(:hash) do
+        {'foo' => 42, foo: 'bar'}
+      end
+
+      include_examples 'works correctly'
+    end
+  end
+end

data/spec/bson/hash_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.
@@ -157,5 +157,213 @@ describe Hash do
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
+
+    context 'with symbol values' do
+      let(:value) { :foo }
+
+      let(:serialized) do
+        {foo: value}.to_bson.to_s
+      end
+
+      def perform_test(bson_type_to_use)
+        Symbol.class_eval do
+          alias_method :bson_type_orig, :bson_type
+          define_method(:bson_type) do
+            bson_type_to_use
+          end
+        end
+
+        begin
+          yield
+        ensure
+          Symbol.class_eval do
+            alias_method :bson_type, :bson_type_orig
+            remove_method :bson_type_orig
+          end
+        end
+      end
+
+      let(:bson_with_symbol) do
+        "\x12\x00\x00\x00\x0Efoo\x00\x04\x00\x00\x00bar\x00\x00".force_encoding('binary')
+      end
+
+      let(:deserialized) do
+        Hash.from_bson(BSON::ByteBuffer.new(bson_with_symbol))
+      end
+
+      context 'when Symbol#bson_type is set to symbol' do
+        let(:bson_type_to_use) { BSON::Symbol::BSON_TYPE }
+
+        let(:expected) do
+          "\x12\x00\x00\x00\x0Efoo\x00\x04\x00\x00\x00foo\x00\x00".force_encoding('binary')
+        end
+
+        it 'serializes to BSON symbol' do
+          perform_test(bson_type_to_use) do
+            serialized
+          end.should == expected
+        end
+
+        it 'deserializes to Symbol' do
+          deserialized.should == {'foo' => :bar}
+        end
+      end
+
+      context 'when Symbol#bson_type is set to string' do
+        let(:bson_type_to_use) { BSON::String::BSON_TYPE }
+
+        let(:expected) do
+          "\x12\x00\x00\x00\x02foo\x00\x04\x00\x00\x00foo\x00\x00".force_encoding('binary')
+        end
+
+        it 'serializes to BSON string' do
+          perform_test(bson_type_to_use) do
+            serialized
+          end.should == expected
+        end
+
+        it 'deserializes to Symbol' do
+          deserialized.should == {'foo' => :bar}
+        end
+      end
+    end
+
+    context 'when hash contains value of an unserializable class' do
+      class HashSpecUnserializableClass
+      end
+
+      let(:obj) do
+        {foo: HashSpecUnserializableClass.new}
+      end
+
+      it 'raises UnserializableClass' do
+        lambda do
+          obj.to_bson
+        end.should raise_error(BSON::Error::UnserializableClass,
+          # C extension does not provide hash key in the exception message.
+          /(Hash value for key 'foo'|Value) does not define its BSON serialized type:.*HashSpecUnserializableClass/)
+      end
+    end
+
+    context 'when reading from a byte buffer that was previously written to' do
+      let(:buffer) do
+        {foo: 42}.to_bson
+      end
+
+      it 'returns the original hash' do
+        expect(Hash.from_bson(buffer)).to eq('foo' => 42)
+      end
+    end
+  end
+
+  describe '#to_bson' do
+    context 'when a key is not valid utf-8' do
+      let(:key) { Utils.make_byte_string([254, 253, 255]) }
+      let(:hash) do
+        {key => 'foo'}
+      end
+
+      let(:expected_message) do
+        if BSON::Environment.jruby?
+          # Uses JRE conversion to another encoding
+          /Error serializing key.*Encoding::UndefinedConversionError/
+        else
+          # Uses our validator
+          /Key.*is not valid UTF-8/
+        end
+      end
+
+      it 'raises EncodingError' do
+        expect do
+          hash.to_bson
+        end.to raise_error(EncodingError, expected_message)
+      end
+    end
+
+    context 'when a key contains null bytes' do
+      let(:hash) do
+        {"\x00".force_encoding('BINARY') => 'foo'}
+      end
+
+      it 'raises ArgumentError' do
+        expect do
+          hash.to_bson
+        end.to raise_error(ArgumentError, /[Kk]ey.*contains null bytes/)
+      end
+    end
+
+    context 'when a value is not valid utf-8' do
+      let(:hash) do
+        {'foo' => [254, 253, 255].map(&:chr).join.force_encoding('BINARY')}
+      end
+
+      let(:expected_message) do
+        /from ASCII-8BIT to UTF-8/
+      end
+
+      it 'raises EncodingError' do
+        expect do
+          hash.to_bson
+        end.to raise_error(EncodingError, expected_message)
+      end
+    end
+
+    context 'when a value contains null bytes' do
+      let(:hash) do
+        {'foo' => "\x00".force_encoding('BINARY')}
+      end
+
+      it 'works' do
+        expect do
+          hash.to_bson
+        end.not_to raise_error
+      end
+    end
+  end
+
+  describe '#from_bson' do
+    context 'when bson document has duplicate keys' do
+      let(:buf) do
+        buf = BSON::ByteBuffer.new
+        buf.put_int32(37)
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('overwrite')
+        buf.put_byte("\x00")
+
+        BSON::ByteBuffer.new(buf.to_s)
+      end
+
+      let(:doc) { Hash.from_bson(buf) }
+
+      it 'overwrites first value with second value' do
+        doc.should == {'foo' => 'overwrite'}
+      end
+    end
+
+    context 'when bson document has string and symbol keys of the same name' do
+      let(:buf) do
+        buf = BSON::ByteBuffer.new
+        buf.put_int32(31)
+        buf.put_byte("\x02")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x0e")
+        buf.put_cstring('foo')
+        buf.put_string('bar')
+        buf.put_byte("\x00")
+
+        BSON::ByteBuffer.new(buf.to_s)
+      end
+
+      let(:doc) { Hash.from_bson(buf) }
+
+      it 'overwrites first value with second value' do
+        doc.should == {'foo' => :bar}
+      end
+    end
   end
 end