bson 4.9.0 → 4.15.0

data/spec/bson/decimal128_spec.rb

@@ -309,6 +309,22 @@ describe BSON::Decimal128 do
         it_behaves_like 'an initialized BSON::Decimal128'
       end
     end
+
+    context 'when range is exceeded' do
+      it 'raises InvalidRange' do
+        lambda do
+          described_class.new('1e10000')
+        end.should raise_error(BSON::Decimal128::InvalidRange, /Value out of range/)
+      end
+    end
+
+    context 'when precision is exceeded' do
+      it 'raises UnrepresentablePrecision' do
+        lambda do
+          described_class.new('1.000000000000000000000000000000000000000000000000001')
+        end.should raise_error(BSON::Decimal128::UnrepresentablePrecision, /The value contains too much precision/)
+      end
+    end
   end
 
   context 'when deserializing' do
@@ -1586,4 +1602,219 @@ describe BSON::Decimal128 do
       expect(registered).to eq(described_class)
     end
   end
+
+  %w(== ===).each do |eq_op|
+    let(:lhs) { described_class.new('1.2e12') }
+
+    describe "##{eq_op}" do
+      context 'when rhs is equal to lhs' do
+        context 'when both are Decimal128 instances' do
+          let(:rhs) { described_class.new('1.2e12') }
+
+          it 'is true' do
+            (lhs == rhs).should be true
+          end
+        end
+
+        context 'when rhs is of a different type' do
+          [
+            1200000000000,
+            1200000000000.0,
+            BigDecimal('1.2e12'),
+          ].each do |rhs|
+            context "when rhs is #{rhs.class}" do
+              it 'is true' do
+                pending 'RUBY-2952'
+
+                (lhs == rhs).should be true
+              end
+            end
+          end
+        end
+      end
+
+      context 'when rhs is not equal to lhs' do
+        context 'when both are Decimal128 instances' do
+          let(:rhs) { described_class.new('1.21e12') }
+
+          it 'is false' do
+            (lhs == rhs).should be false
+          end
+        end
+
+        context 'when rhs is of a different type' do
+
+          [
+            1200000000001,
+            1200000000001.0,
+            BigDecimal('1.21e12'),
+          ].each do |rhs|
+            context "when rhs is #{rhs.class}" do
+              it 'is false' do
+                (lhs == rhs).should be false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#<=>" do
+
+    let(:lhs) { described_class.new('1.2e12') }
+
+    context 'when lhs is less than rhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.21e12') }
+
+        it 'is -1' do
+          (lhs <=> rhs).should be -1
+        end
+      end
+
+      context 'when rhs is of a different type' do
+        [
+          1200000000001,
+          1200000000001.0,
+          BigDecimal('1.21e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is -1' do
+              (lhs <=> rhs).should be -1
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is equal to lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.2e12') }
+
+        it 'is 0' do
+          (lhs <=> rhs).should be 0
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1200000000000,
+          1200000000000.0,
+          BigDecimal('1.2e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is 0' do
+              (lhs <=> rhs).should be 0
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is greater than lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.1e12') }
+
+        it 'is 1' do
+          (lhs <=> rhs).should be 1
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1100000000000,
+          1100000000000.0,
+          BigDecimal('1.1e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is 1' do
+              (lhs <=> rhs).should be 1
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#<" do
+
+    let(:lhs) { described_class.new('1.2e12') }
+
+    context 'when lhs is less than rhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.21e12') }
+
+        it 'is true' do
+          (lhs < rhs).should be true
+        end
+      end
+
+      context 'when rhs is of a different type' do
+        [
+          1200000000001,
+          1200000000001.0,
+          BigDecimal('1.21e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is true' do
+              (lhs < rhs).should be true
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is equal to lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.2e12') }
+
+        it 'is false' do
+          (lhs < rhs).should be false
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1200000000000,
+          1200000000000.0,
+          BigDecimal('1.2e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is false' do
+              (lhs < rhs).should be false
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is greater than lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.1e12') }
+
+        it 'is false' do
+          (lhs < rhs).should be false
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1100000000000,
+          1100000000000.0,
+          BigDecimal('1.1e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is false' do
+              (lhs < rhs).should be false
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/bson/document_as_spec.rb

@@ -0,0 +1,46 @@
+# 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"
+
+# BSON::Document ActiveSupport extensions
+describe BSON::Document do
+  require_active_support
+
+  describe '#symbolize_keys' do
+    context 'string keys' do
+      let(:doc) do
+        described_class.new('foo' => 'bar')
+      end
+
+      it 'works correctly' do
+        doc.symbolize_keys.should == {foo: 'bar'}
+      end
+    end
+  end
+
+  describe '#symbolize_keys!' do
+    context 'string keys' do
+      let(:doc) do
+        described_class.new('foo' => 'bar')
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          doc.symbolize_keys!
+        end.should raise_error(ArgumentError, /symbolize_keys! is not supported on BSON::Document instances/)
+      end
+    end
+  end
+end

data/spec/bson/document_spec.rb

@@ -215,6 +215,10 @@ describe BSON::Document do
 
       context "when provided string keys" do
 
+        it "is a BSON Document" do
+          expect(document.slice("key1")).to be_a(BSON::Document)
+        end
+
         it "returns the partial document" do
           expect(document.slice("key1")).to contain_exactly(['key1', 'value1'])
         end
@@ -222,13 +226,45 @@ describe BSON::Document do
 
       context "when provided symbol keys" do
 
+        it "is a BSON Document" do
+          expect(document.slice(:key1)).to be_a(BSON::Document)
+        end
+
         it "returns the partial document" do
           expect(document.slice(:key1)).to contain_exactly(['key1', 'value1'])
         end
       end
+
+      context "when provided keys that do not exist in the document" do
+
+        it "returns only the keys that exist in the document" do
+          expect(document.slice(:key1, :key3)).to contain_exactly(['key1', 'value1'])
+        end
+      end
+    end
+  end
+
+  describe "#except" do
+    let(:document) do
+      described_class.new("key1" => "value1", key2: "value2")
+    end
+
+    context "when provided string keys" do
+
+      it "returns the partial document" do
+        expect(document.except("key1")).to contain_exactly(['key2', 'value2'])
+      end
+    end
+
+    context "when provided symbol keys" do
+
+      it "returns the partial document" do
+        expect(document.except(:key1)).to contain_exactly(['key2', 'value2'])
+      end
     end
   end
 
+
   describe "#delete" do
 
     shared_examples_for "a document with deletable pairs" do
@@ -484,7 +520,13 @@ describe BSON::Document do
       context "when the document has been serialized" do
 
         let(:deserialized) do
-          YAML.load(YAML.dump(doc))
+          if YAML.respond_to?(:unsafe_load)
+            # In psych >= 4.0.0 `load` is basically an alias to `safe_load`,
+            # which will fail here.
+            YAML.unsafe_load(YAML.dump(doc))
+          else
+            YAML.load(YAML.dump(doc))
+          end
         end
 
         let!(:enum) do

data/spec/bson/ext_json_parse_spec.rb

@@ -148,6 +148,7 @@ describe "BSON::ExtJSON.parse" do
     end
 
     let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+    let(:mode) { :bson }
 
     context 'when mode is invalid' do
       let(:mode) { :foo }
@@ -158,6 +159,42 @@ describe "BSON::ExtJSON.parse" do
         end.should raise_error(ArgumentError, /Invalid value for :mode option/)
       end
     end
+
+    context 'when it contains a string key with a null byte' do
+      let(:input) do
+        { "key\x00" => 1 }
+      end
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(BSON::Error::ExtJSONParseError, /Hash key cannot contain a null byte/)
+      end
+    end
+
+    context 'when it contains a symbol key with a null byte' do
+      let(:input) do
+        { "key\x00".to_sym => 1 }
+      end
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(BSON::Error::ExtJSONParseError, /Hash key cannot contain a null byte/)
+      end
+    end
+
+    context 'when it contains an integer key' do
+      let(:input) do
+        { 0 => 1 }
+      end
+
+      it 'does not raises an exception' do
+        lambda do
+          parsed
+        end.should_not raise_error
+      end
+    end
   end
 
   context 'when input is a binary' do

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

@@ -227,6 +227,53 @@ describe Hash do
         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
+
+    context 'when round-tripping a BigDecimal' do
+      let(:to_bson) do
+        {"x" => BigDecimal('1')}.to_bson
+      end
+
+      let(:from_bson) do
+        Hash.from_bson(to_bson)
+      end
+
+      it 'doesn\'t raise on serialization' do
+        expect do
+          to_bson
+        end.to_not raise_error
+      end
+
+      it 'deserializes as a BSON::Decimal128' do
+        expect(from_bson).to eq({"x" => BSON::Decimal128.new('1')})
+      end
+    end
   end
 
   describe '#to_bson' do
@@ -292,5 +339,63 @@ describe Hash do
         end.not_to raise_error
       end
     end
+
+    context 'when serializing a hash with a BigDecimal' do
+      let(:hash) do
+        {'foo' => BigDecimal('1')}
+      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

data/spec/bson/int64_spec.rb

@@ -106,18 +106,8 @@ describe BSON::Int64 do
         end
       end
 
-      context "when using MRI < 2.4", if: (!BSON::Environment.jruby? && RUBY_VERSION < '2.4') do
-
-        it "deserializes to a Fixnum object" do
-          expect(described_class.from_bson(bson).class).to be(Fixnum)
-        end
-      end
-
-      context "when using MRI >= 2.4", if: (!BSON::Environment.jruby? && RUBY_VERSION >= '2.4') do
-
-        it "deserializes to an Integer object" do
-          expect(described_class.from_bson(bson).class).to be(Integer)
-        end
+      it "deserializes to an Integer object" do
+        expect(described_class.from_bson(bson).class).to be(Integer)
       end
     end
 
@@ -136,18 +126,8 @@ describe BSON::Int64 do
         end
       end
 
-      context "when using MRI < 2.4", if: (!BSON::Environment.jruby? && RUBY_VERSION < '2.4') do
-
-        it "deserializes to a Bignum object" do
-          expect(described_class.from_bson(bson).class).to be(Bignum)
-        end
-      end
-
-      context "when using MRI >= 2.4", if: (!BSON::Environment.jruby? && RUBY_VERSION >= '2.4') do
-
-        it "deserializes to an Integer object" do
-          expect(described_class.from_bson(bson).class).to be(Integer)
-        end
+      it "deserializes to an Integer object" do
+        expect(described_class.from_bson(bson).class).to be(Integer)
       end
     end
   end

data/spec/bson/raw_spec.rb

@@ -580,4 +580,21 @@ describe Regexp::Raw do
       end
     end
   end
-end
+
+  describe 'yaml loading' do
+    let(:regexp) { described_class.new('hello.world', 's') }
+
+    it 'round-trips' do
+      actual = if YAML.respond_to?(:unsafe_load)
+        # In psych >= 4.0.0 `load` is basically an alias to `safe_load`,
+        # which will fail here.
+        YAML.unsafe_load(regexp.to_yaml)
+      else
+        YAML.load(regexp.to_yaml)
+      end
+      actual.pattern.should == 'hello.world'
+      actual.options.should == 's'
+      actual.compile.should =~ "hello\nworld"
+    end
+  end
+end