bson 4.12.1-java → 4.13.0-java

data/spec/bson/dbref_spec.rb

@@ -0,0 +1,461 @@
+# 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 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/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/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

@@ -585,7 +585,13 @@ describe Regexp::Raw do
     let(:regexp) { described_class.new('hello.world', 's') }
 
     it 'round-trips' do
-      actual = YAML.load(regexp.to_yaml)
+      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"

data/spec/bson/regexp_spec.rb

@@ -127,6 +127,58 @@ describe Regexp do
           expect(result).to eq(obj)
         end
       end
+
+      context "when the regexp options contains a null byte" do
+
+        let(:regexp) do
+          Regexp::Raw.new("pattern", "options\x00")
+        end
+
+        it "raises an error" do
+          expect do
+            regexp
+          end.to raise_error(BSON::Error::InvalidRegexpPattern, /Regexp options cannot contain a null byte/)
+        end
+      end
+
+      context "when the regexp options is an integer" do
+
+        let(:regexp) do
+          Regexp::Raw.new("pattern", 1)
+        end
+
+        it "doesn't raise an error" do
+          expect do
+            regexp
+          end.to_not raise_error
+        end
+      end
+
+      context "when the regexp options is an invalid type" do
+
+        let(:regexp) do
+          Regexp::Raw.new("pattern", [2])
+        end
+
+        it "raises an error" do
+          expect do
+            regexp
+          end.to raise_error(ArgumentError, /Regexp options must be a String, Symbol, or Integer/)
+        end
+      end
+    end
+
+    context "when the pattern contains a null byte" do
+
+      let(:regexp) do
+        Regexp::Raw.new("pattern\x00", "options")
+      end
+
+      it "raises an error" do
+        expect do
+          regexp
+        end.to raise_error(BSON::Error::InvalidRegexpPattern, /Regexp pattern cannot contain a null byte/)
+      end
     end
   end
 end

data/spec/runners/common_driver.rb

@@ -166,7 +166,7 @@ module BSON
       #
       # @since 4.2.0
       def reencoded_hex
-        decoded_document.to_bson.to_s.unpack("H*").first.upcase
+        decoded_document.to_bson.to_s.unpack1("H*").upcase
       end
 
       # The object tested.

data/spec/shared/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 MongoDB, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/shared/bin/get-mongodb-download-url

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+desired_version, arch = ARGV
+if arch.nil?
+  STDERR.puts "Usage: get-mongodb-download-url desired-version arch"
+  exit 1
+end
+
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'mrss/server_version_registry'
+
+begin
+  puts Mrss::ServerVersionRegistry.new(desired_version, arch).download_url
+rescue Mrss::ServerVersionRegistry::Error => exc
+  STDERR.puts "Error: #{exc}"
+  exit 2
+end