bson 4.12.0-java → 4.14.1-java

data/lib/bson.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Copyright (C) 2009-2020 MongoDB Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -38,22 +39,22 @@ module BSON
   # Constant for binary string encoding.
   #
   # @since 2.0.0
-  BINARY = "BINARY".freeze
+  BINARY = "BINARY"
 
   # Constant for bson types that don't actually serialize a value.
   #
   # @since 2.0.0
-  NO_VALUE = "".force_encoding(BINARY).freeze
+  NO_VALUE = ::String.new(encoding: BINARY).freeze
 
   # Constant for a null byte (0x00).
   #
   # @since 2.0.0
-  NULL_BYTE = 0.chr.force_encoding(BINARY).freeze
+  NULL_BYTE = ::String.new(0.chr, encoding: BINARY).freeze
 
   # Constant for UTF-8 string encoding.
   #
   # @since 2.0.0
-  UTF8 = "UTF-8".freeze
+  UTF8 = "UTF-8"
 end
 
 require "bson/config"
@@ -73,11 +74,13 @@ require "bson/date"
 require "bson/date_time"
 require "bson/db_pointer"
 require "bson/decimal128"
+require "bson/big_decimal"
 require "bson/document"
 require "bson/ext_json"
 require "bson/false_class"
 require "bson/float"
 require "bson/hash"
+require "bson/dbref"
 require "bson/open_struct"
 require "bson/max_key"
 require "bson/min_key"
@@ -100,7 +103,7 @@ require "bson/version"
 begin
   if BSON::Environment.jruby?
     require "bson-ruby.jar"
-    org.bson.NativeService.new.basicLoad(JRuby.runtime)
+    JRuby::Util.load_ext("org.bson.NativeService")
   else
     require "bson_native"
   end

data/spec/README.md

@@ -0,0 +1,14 @@
+# Running BSON Ruby Tests
+
+## Quick Start
+
+The test suite requires shared tooling that is stored in a separate repository
+and is referenced as a submodule. After checking out the desired bson-ruby
+branch, check out the matching submodules:
+
+    git submodule init
+    git submodule update
+
+Then, to run the test suite:
+
+    rake

data/spec/bson/big_decimal_spec.rb

@@ -0,0 +1,316 @@
+# Copyright (C) 2016-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 BSON::BigDecimal do
+
+  describe '#from_bson' do
+    shared_examples_for 'a BSON::BigDecimal deserializer' do
+
+      let(:decimal128) do
+        BSON::Decimal128.new(argument)
+      end
+
+      let(:deserialized_big_decimal) do
+        BigDecimal.from_bson(decimal128.to_bson)
+      end
+
+      let(:deserialized_decimal128) do
+        BSON::Decimal128.from_bson(decimal128.to_bson)
+      end
+
+      it 'deserializes Decimal128 encoded bson correctly' do
+        if deserialized_decimal128.to_s == "NaN"
+          expect(deserialized_big_decimal.nan?).to be true
+        else
+          expect(deserialized_big_decimal).to eq(deserialized_decimal128.to_big_decimal)
+        end
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -NaN is passed' do
+      let(:argument) { "-NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when SNaN is passed' do
+      let(:argument) { "SNaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -SNaN is passed' do
+      let(:argument) { "SNaN" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal deserializer'
+    end
+  end
+
+  describe "#to_bson" do
+    shared_examples_for 'a BSON::BigDecimal serializer' do
+
+      let(:decimal128) do
+        BSON::Decimal128.new(BigDecimal(argument).to_s)
+      end
+
+      let(:decimal_128_bson) do
+        decimal128.to_bson
+      end
+
+      let(:big_decimal_bson) do
+        BigDecimal(argument).to_bson
+      end
+
+      it 'serializes BigDecimals correctly' do
+        expect(decimal_128_bson.to_s).to eq(big_decimal_bson.to_s)
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal serializer'
+    end
+
+    context "when passing an out of range Decimal128" do
+      let(:argument) { "1E1000000" }
+
+      it "raises an error" do
+        expect do
+          BigDecimal(argument).to_bson
+        end.to raise_error(BSON::Decimal128::InvalidRange)
+      end
+    end
+
+    context "when passing a number with too much precision for Decimal128" do
+      let(:argument) { "1.000000000000000000000000000000000000000000000000001" }
+
+      it "raises an error" do
+        expect do
+          BigDecimal(argument).to_bson
+        end.to raise_error(BSON::Decimal128::UnrepresentablePrecision)
+      end
+    end
+  end
+
+  describe "#from_bson/#to_bson" do
+    shared_examples_for 'a BSON::BigDecimal round trip' do
+
+      let(:big_decimal) do
+        BigDecimal(argument)
+      end
+
+      let(:big_decimal_bson) do
+        big_decimal.to_bson
+      end
+
+      let(:deserialized_big_decimal) do
+        BigDecimal.from_bson(big_decimal_bson)
+      end
+
+      it 'serializes BigDecimals correctly' do
+        if big_decimal.nan?
+          expect(deserialized_big_decimal.nan?).to be true
+        else
+          expect(deserialized_big_decimal).to eq(big_decimal)
+        end
+      end
+    end
+
+    context 'when Infinity is passed' do
+
+      let(:argument) { "Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when -Infinity is passed' do
+
+      let(:argument) { "-Infinity" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when NaN is passed' do
+
+      let(:argument) { "NaN" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when -0 is passed' do
+      let(:argument) { "-0" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a positive integer is passed' do
+      let(:argument) { "12" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a negative integer is passed' do
+      let(:argument) { "-12" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a positive float is passed' do
+      let(:argument) { "0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a negative float is passed' do
+      let(:argument) { "-0.12345" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a large positive integer is passed' do
+      let(:argument) { "1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+
+    context 'when a large negative integer is passed' do
+      let(:argument) { "-1234567890123456789012345678901234" }
+
+      it_behaves_like 'a BSON::BigDecimal round trip'
+    end
+  end
+end

data/spec/bson/dbref_legacy_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+require 'json'
+
+# These tests are copied from driver when the driver implemented Mongo:DBRef
+# class, and are intended to verify that the current DBRef implementation is
+# compatible with the legacy driver DBRef interface.
+
+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('users', 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('users', object_id, '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
+  end
+
+  describe '#initialize' do
+
+    let(:dbref) do
+      described_class.new('users', 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(:dbref) do
+        described_class.new('users', object_id, 'db')
+      end
+
+      it 'sets the database' do
+        expect(dbref.database).to eq('db')
+      end
+
+      context 'when id is not provided' do
+
+        let(:dbref) do
+          described_class.new('users', nil, 'db')
+        end
+
+        it 'raises ArgumentError' do
+          lambda do
+            dbref
+          end.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe '#to_bson' do
+
+    let(:dbref) do
+      described_class.new('users', object_id, '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('users', 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('users', object_id, '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
+  end
+
+  describe '#from_bson' do
+
+    let(:buffer) do
+      dbref.to_bson
+    end
+
+    let(:decoded) do
+      BSON::Document.from_bson(BSON::ByteBuffer.new(buffer.to_s))
+    end
+
+    context 'when a database exists' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, '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
+    end
+
+    context 'when no database exists' do
+
+      let(:dbref) do
+        described_class.new('users', 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
+    end
+  end
+end