bson 4.12.0 → 4.14.1

data/spec/bson/dbref_spec.rb

@@ -0,0 +1,487 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+require 'json'
+
+describe BSON::DBRef do
+
+  let(:object_id) do
+    BSON::ObjectId.new
+  end
+
+  describe '#as_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id })
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.as_json).to eq({ '$ref' => 'users', '$id' => object_id })
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id, '$db' => 'database' })
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.as_json).to eq({
+          '$ref' => 'users',
+          '$id' => object_id,
+          '$db' => 'database'
+        })
+      end
+    end
+
+    context 'when other keys are provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id, '$db' => 'database', 'x' => 'y' })
+      end
+
+      it 'returns the json document with the other keys' do
+        expect(dbref.as_json).to eq({
+          '$ref' => 'users',
+          '$id' => object_id,
+          '$db' => 'database',
+          'x' => 'y'
+        })
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:dbref) do
+      described_class.new(hash)
+    end
+
+    let(:hash) do
+      { '$ref' => 'users', '$id' => object_id }
+    end
+
+    it 'sets the collection' do
+      expect(dbref.collection).to eq('users')
+    end
+
+    it 'sets the id' do
+      expect(dbref.id).to eq(object_id)
+    end
+
+    context 'when first argument is a hash and two arguments are provided' do
+
+      let(:dbref) do
+        described_class.new({:$ref => 'users', :$id => object_id}, object_id)
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          dbref
+        end.should raise_error(ArgumentError)
+      end
+    end
+
+    context 'when first argument is a hash and three arguments are provided' do
+
+      let(:dbref) do
+        described_class.new({:$ref => 'users', :$id => object_id}, object_id, 'db')
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          dbref
+        end.should raise_error(ArgumentError)
+      end
+    end
+
+    context 'when a database is provided' do
+
+      let(:hash) do
+        { '$ref' => 'users', '$id' => object_id, '$db' => 'db' }
+      end
+
+      it 'sets the database' do
+        expect(dbref.database).to eq('db')
+      end
+    end
+
+    context 'when not providing a collection' do
+      let(:hash) do
+        { '$id' => object_id, '$db' => 'db' }
+      end
+
+      it 'raises an error' do
+        expect do
+          dbref
+        end.to raise_error(ArgumentError, /DBRef must have \$ref/)
+      end
+    end
+
+    context 'when not providing an id' do
+      let(:hash) do
+        { '$ref' => 'users', '$db' => 'db' }
+      end
+
+      it 'raises an error' do
+        expect do
+          dbref
+        end.to raise_error(ArgumentError, /DBRef must have \$id/)
+      end
+    end
+
+    context 'when providing an invalid type for ref' do
+      let(:hash) do
+        { '$ref' => 1, '$id' => object_id }
+      end
+
+      it 'raises an error' do
+        expect do
+          dbref
+        end.to raise_error(ArgumentError, /The value for key \$ref must be a string/)
+      end
+    end
+
+    context 'when providing an invalid type for database' do
+      let(:hash) do
+        { '$ref' => 'users', '$id' => object_id, '$db' => 1 }
+      end
+
+      it 'raises an error' do
+        expect do
+          dbref
+        end.to raise_error(ArgumentError, /The value for key \$db must be a string/)
+      end
+    end
+
+    context 'when providing the fieds as symbols' do
+      let(:hash) do
+        { :$ref => 'users', :$id => object_id, :$db => 'db' }
+      end
+
+      it 'does not raise an error' do
+        expect do
+          dbref
+        end.to_not raise_error
+      end
+    end
+
+    context 'when testing the ordering of the fields' do
+      context 'when the fields are in order' do
+        let(:hash) do
+          { '$ref' => 'users', '$id' => object_id, '$db' => 'db' }
+        end
+
+        it 'has the correct order' do
+          expect(dbref.keys).to eq(['$ref', '$id', '$db'])
+        end
+      end
+
+      context 'when the fields are out of order' do
+        let(:hash) do
+          { '$db' => 'db', '$id' => object_id, '$ref' => 'users' }
+        end
+
+        it 'has the correct order' do
+          expect(dbref.keys).to eq(['$ref', '$id', '$db'])
+        end
+      end
+
+      context 'when there is no db' do
+        let(:hash) do
+          { '$id' => object_id, '$ref' => 'users' }
+        end
+
+        it 'has the correct order' do
+          expect(dbref.keys).to eq(['$ref', '$id'])
+        end
+      end
+
+      context 'when the there are other fields in order' do
+        let(:hash) do
+          { '$ref' => 'users', '$id' => object_id, '$db' => 'db', 'x' => 'y', 'y' => 'z' }
+        end
+
+        it 'has the correct order' do
+          expect(dbref.keys).to eq(['$ref', '$id', '$db', 'x', 'y'])
+        end
+      end
+
+      context 'when the there are other fields out of order' do
+        let(:hash) do
+          { 'y' => 'z', '$db' => 'db', '$id' => object_id, 'x' => 'y', '$ref' => 'users' }
+        end
+
+        it 'has the correct order' do
+          expect(dbref.keys).to eq(['$ref', '$id', '$db', 'y', 'x'])
+        end
+      end
+    end
+  end
+
+  describe '#to_bson' do
+
+    let(:dbref) do
+      described_class.new({ '$ref' => 'users', '$id' => object_id, '$db' => 'database' })
+    end
+
+    it 'converts the underlying document to bson' do
+      expect(dbref.to_bson.to_s).to eq(dbref.as_json.to_bson.to_s)
+    end
+  end
+
+  describe '#to_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id })
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json}}")
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id, '$db' => 'database' })
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json},\"$db\":\"database\"}")
+      end
+    end
+
+    context 'when other keys are provided' do
+
+      let(:dbref) do
+        described_class.new({ '$ref' => 'users', '$id' => object_id, '$db' => 'database', 'x' => 'y' })
+      end
+
+      it 'returns the json document with the other keys' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json},\"$db\":\"database\",\"x\":\"y\"}")
+      end
+    end
+  end
+
+  describe '#from_bson' do
+
+    let(:buffer) do
+      hash.to_bson
+    end
+
+    let(:decoded) do
+      BSON::Document.from_bson(BSON::ByteBuffer.new(buffer.to_s))
+    end
+
+    context 'when a database exists' do
+
+      let(:hash) do
+        { '$ref' => 'users', '$id' => object_id, '$db' => 'database' }
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'decodes the database' do
+        expect(decoded.database).to eq('database')
+      end
+
+      it 'is of class DBRef' do
+        expect(decoded).to be_a described_class
+      end
+    end
+
+    context 'when no database exists' do
+
+      let(:hash) do
+        { '$ref' => 'users', '$id' => object_id }
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'sets the database to nil' do
+        expect(decoded.database).to be_nil
+      end
+
+      it 'is of class DBRef' do
+        expect(decoded).to be_a described_class
+      end
+    end
+
+    context 'when other keys exist' do
+
+      let(:hash) do
+        { '$ref' => 'users', '$id' => object_id, 'x' => 'y' }
+      end
+
+      it 'decodes the key' do
+        expect(decoded['x']).to eq('y')
+      end
+
+      it 'is of class DBRef' do
+        expect(decoded).to be_a described_class
+      end
+    end
+
+    context 'when it is an invalid dbref' do
+
+      shared_examples 'bson document' do
+        it 'should not raise' do
+          expect do
+            decoded
+          end.to_not raise_error
+        end
+
+        it 'has the correct class' do
+          expect(decoded).to be_a BSON::Document
+          expect(decoded).to_not be_a described_class
+        end
+      end
+
+      context 'when the hash has invalid collection type' do
+        let(:hash) do
+          { '$ref' => 1, '$id' => object_id }
+        end
+        include_examples 'bson document'
+      end
+
+      context 'when the hash has an invalid database type' do
+        let(:hash) do
+          { '$ref' => 'users', '$id' => object_id, '$db' => 1 }
+        end
+        include_examples 'bson document'
+      end
+
+      context 'when the hash is missing a collection' do
+        let(:hash) do
+          { '$id' => object_id }
+        end
+        include_examples 'bson document'
+      end
+
+      context 'when the hash is missing an id' do
+        let(:hash) do
+          { '$ref' => 'users' }
+        end
+        include_examples 'bson document'
+      end
+    end
+
+    context 'when nesting the dbref' do
+
+      context 'when it is a valid dbref' do
+        let(:hash) do
+          { 'dbref' => { '$ref' => 'users', '$id' => object_id } }
+        end
+
+        it 'should not raise' do
+          expect do
+            buffer
+          end.to_not raise_error
+        end
+
+        it 'has the correct class' do
+          expect(decoded['dbref']).to be_a described_class
+        end
+      end
+
+      context 'when it is an invalid dbref' do
+
+        shared_examples 'nested bson document' do
+          it 'should not raise' do
+            expect do
+              decoded
+            end.to_not raise_error
+          end
+
+          it 'has the correct class' do
+            expect(decoded['dbref']).to be_a BSON::Document
+            expect(decoded['dbref']).to_not be_a described_class
+          end
+        end
+
+        context 'when the hash has invalid collection type' do
+          let(:hash) do
+            { 'dbref' => { '$ref' => 1, '$id' => object_id } }
+          end
+          include_examples 'nested bson document'
+        end
+
+        context 'when the hash has an invalid database type' do
+          let(:hash) do
+            { 'dbref' => { '$ref' => 'users', '$id' => object_id, '$db' => 1 } }
+          end
+          include_examples 'nested bson document'
+        end
+
+        context 'when the hash is missing a collection' do
+          let(:hash) do
+            { 'dbref' => { '$id' => object_id } }
+          end
+          include_examples 'nested bson document'
+        end
+
+        context 'when the hash is missing an id' do
+          let(:hash) do
+            { 'dbref' => { '$ref' => 'users' } }
+          end
+          include_examples 'nested bson document'
+        end
+      end
+    end
+
+    context 'when nesting a dbref inside a dbref' do
+      context 'when it is a valid dbref' do
+        let(:hash) do
+          { 'dbref1' => { '$ref' => 'users', '$id' => object_id, 'dbref2' => { '$ref' => 'users', '$id' => object_id } } }
+        end
+
+        it 'should not raise' do
+          expect do
+            buffer
+          end.to_not raise_error
+        end
+
+        it 'has the correct class' do
+          expect(decoded['dbref1']).to be_a described_class
+          expect(decoded['dbref1']['dbref2']).to be_a described_class
+        end
+      end
+
+      context 'when it is an invalid dbref' do
+        let(:hash) do
+          { 'dbref' => { '$ref' => 'users', '$id' => object_id, 'dbref' => { '$ref' => 1, '$id' => object_id } } }
+        end
+
+        it 'should not raise' do
+          expect do
+            decoded
+          end.to_not raise_error
+        end
+
+        it 'has the correct class' do
+          expect(decoded['dbref']).to be_a described_class
+          expect(decoded['dbref']['dbref']).to be_a BSON::Document
+        end
+      end
+    end
+  end
+end

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

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

@@ -520,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