bson 4.1.1 → 5.2.0

data/spec/bson/big_decimal_spec.rb

@@ -0,0 +1,328 @@
+# rubocop:todo all
+# 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 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_d)
+        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::Error::InvalidDecimal128Range)
+      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::Error::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
+
+  context "when the class is loaded" do
+
+    let(:registered) do
+      BSON::Registry.get(described_class::BSON_TYPE, 'field')
+    end
+
+    it "registers the type" do
+      expect(registered).to eq(described_class)
+    end
+  end
+end

data/spec/bson/binary_spec.rb

@@ -1,4 +1,5 @@
-# Copyright (C) 2009-2014 MongoDB Inc.
+# rubocop:todo all
+# 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.
@@ -13,22 +14,62 @@
 # limitations under the License.
 
 require "spec_helper"
+require "base64"
 
 describe BSON::Binary do
   let(:testing1)  { described_class.new("testing") }
   let(:testing2)  { described_class.new("testing") }
   let(:not_testing) { described_class.new("not testing") }
+  let(:testing3) { described_class.new("testing", :user) }
+
+  describe "Comparable" do
+    describe "#eql?" do
+      context "for two equal objects" do
+        it "returns true" do
+          expect(testing1).to eql(testing2)
+        end
+      end
 
-  describe "#eql?" do
-    context "for two equal objects" do
-      it "returns true" do
-        expect(testing1).to eql(testing2)
+      context "for two different objects" do
+        it "returns false" do
+          expect(testing1).not_to eql(not_testing)
+        end
+      end
+
+      context 'for objects with identical data but different types' do
+        it 'returns false' do
+          expect(testing1).not_to eql(testing3)
+        end
       end
     end
 
-    context "for two different objects" do
-      it "returns false" do
-        expect(testing1).not_to eql(not_testing)
+    describe '#<=>' do
+      context 'with a non-Binary object' do
+        it 'returns nil' do
+          expect(testing1 <=> 'bogus').to be_nil
+        end
+      end
+
+      context 'with identical type and data' do
+        it 'returns 0' do
+          expect(testing1 <=> testing2).to be == 0
+        end
+      end
+
+      context 'with mismatched type' do
+        it 'returns nil' do
+          expect(testing1 <=> testing3).to be_nil
+        end
+      end
+
+      context 'with identical type but mismatched data' do
+        it 'returns -1 when a < b' do
+          expect(not_testing <=> testing1).to be == -1
+        end
+
+        it 'returns 1 when a > b' do
+          expect(testing1 <=> not_testing).to be == 1
+        end
       end
     end
   end
@@ -54,34 +95,52 @@ describe BSON::Binary do
     expect(hash[not_testing]).to be_nil
   end
 
-  describe "#as_json" do
+  describe "#as_extended_json" do
 
     let(:object) do
       described_class.new("testing", :user)
     end
 
     it "returns the binary data plus type" do
-      expect(object.as_json).to eq(
-        { "$binary" => "testing", "$type" => :user }
+      expect(object.as_extended_json).to eq(
+        { "$binary" => {'base64' => Base64.encode64("testing").strip, "subType" => '80' }}
       )
     end
 
-    it_behaves_like "a JSON serializable object"
+    it_behaves_like 'an Extended JSON serializable object'
+    it_behaves_like '#as_json calls #as_extended_json'
   end
 
   describe "#initialize" do
 
-    context "when he type is invalid" do
+    context 'when type is not given' do
+      let(:obj) { described_class.new('foo') }
+
+      it 'defaults to generic type' do
+        expect(obj.type).to eq(:generic)
+      end
+    end
+
+    context "when the type is invalid" do
 
       it "raises an error" do
         expect {
           described_class.new("testing", :error)
         }.to raise_error { |error|
-          expect(error).to be_a(BSON::Binary::InvalidType)
+          expect(error).to be_a(BSON::Error::InvalidBinaryType)
           expect(error.message).to match /is not a valid binary type/
         }
       end
     end
+
+    context 'when initialized via legacy YAML' do
+      let(:yaml) { "--- !ruby/object:BSON::Binary\ndata: hello\ntype: :generic\n" }
+      let(:deserialized) { YAML.safe_load(yaml, permitted_classes: [ Symbol, BSON::Binary ]) }
+
+      it 'correctly sets the raw_type' do
+        expect(deserialized.raw_type).to be == BSON::Binary::SUBTYPES[:generic]
+      end
+    end
   end
 
   describe '#inspect' do
@@ -104,7 +163,11 @@ describe BSON::Binary do
         expect(object.inspect).to eq("<BSON::Binary:0x#{object.object_id} type=user data=0x1f8b08000c787055...>")
       end
 
-      it 'is not different from default encoding' do
+      it 'is not binary' do
+        # As long as the default Ruby encoding is not binary, the inspected
+        # string should also not be in the binary encoding (it should be
+        # in one of the text encodings, but which one could depend on
+        # the Ruby runtime environment).
         expect(object.inspect.encoding).not_to eq(Encoding::BINARY)
       end
 
@@ -112,73 +175,156 @@ describe BSON::Binary do
 
   end
 
-  describe "#to_bson/#from_bson" do
-
-    let(:type) { 5.chr }
+  describe '#from_bson' do
+    let(:buffer) { BSON::ByteBuffer.new(bson) }
+    let(:obj) { described_class.from_bson(buffer) }
 
-    it_behaves_like "a bson element"
+    let(:bson) { "#{5.to_bson}#{0.chr}hello".force_encoding('BINARY') }
 
-    context "when the type is :generic" do
+    it 'sets data encoding to binary' do
+      expect(obj.data.encoding).to eq(Encoding.find('BINARY'))
+    end
 
-      let(:obj)  { described_class.new("testing") }
-      let(:bson) { "#{7.to_bson}#{0.chr}testing" }
+    context 'when binary subtype is supported' do
+      let(:bson) { [3, 0, 0, 0, 1].map(&:chr).join.force_encoding('BINARY') + 'foo' }
 
-      it_behaves_like "a serializable bson element"
-      it_behaves_like "a deserializable bson element"
+      it 'works' do
+        obj.should be_a(described_class)
+        obj.type.should be :function
+      end
     end
 
-    context "when the type is :function" do
-
-      let(:obj)  { described_class.new("testing", :function) }
-      let(:bson) { "#{7.to_bson}#{1.chr}testing" }
+    context 'when binary subtype is not supported' do
+      let(:bson) { [3, 0, 0, 0, 16].map(&:chr).join.force_encoding('BINARY') + 'foo' }
 
-      it_behaves_like "a serializable bson element"
-      it_behaves_like "a deserializable bson element"
+      it 'raises an exception' do
+        lambda do
+          obj
+        end.should raise_error(BSON::Error::UnsupportedBinarySubtype,
+          /BSON data contains unsupported binary subtype 0x10/)
+      end
     end
+  end
 
-    context "when the type is :old" do
+  describe "#to_bson/#from_bson" do
 
-      let(:obj)  { described_class.new("testing", :old) }
-      let(:bson) { "#{11.to_bson}#{2.chr}#{7.to_bson}testing" }
+    let(:type) { 5.chr }
 
-      it_behaves_like "a serializable bson element"
-      it_behaves_like "a deserializable bson element"
-    end
+    it_behaves_like "a bson element"
 
-    context "when the type is :uuid_old" do
+    [
+      {
+        types: [ nil, 0, 0.chr, :generic, 'generic' ],
+        bson: "#{7.to_bson}#{0.chr}testing",
+        type: :generic,
+      },
+      {
+        types: [ 1, 1.chr, :function, 'function' ],
+        bson: "#{7.to_bson}#{1.chr}testing",
+        type: :function,
+      },
+      {
+        types: [ 2, 2.chr, :old, 'old' ],
+        bson: "#{11.to_bson}#{2.chr}#{7.to_bson}testing",
+        type: :old,
+      },
+      {
+        types: [ 3, 3.chr, :uuid_old, 'uuid_old' ],
+        bson: "#{7.to_bson}#{3.chr}testing",
+        type: :uuid_old,
+      },
+      {
+        types: [ 4, 4.chr, :uuid, 'uuid' ],
+        bson: "#{7.to_bson}#{4.chr}testing",
+        type: :uuid,
+      },
+      {
+        types: [ 5, 5.chr, :md5, 'md5' ],
+        bson: "#{7.to_bson}#{5.chr}testing",
+        type: :md5,
+      },
+      {
+        types: [ 6, 6.chr, :ciphertext, 'ciphertext' ],
+        bson: "#{7.to_bson}#{6.chr}testing",
+        type: :ciphertext,
+      },
+      {
+        types: [ 0x80, 0x80.chr, :user, 'user' ],
+        bson: "#{7.to_bson}#{128.chr}testing",
+        type: :user,
+      },
+      {
+        types: [ 0xFF, 0xFF.chr ],
+        bson: "#{7.to_bson}#{0xFF.chr}testing",
+        type: :user,
+      },
+    ].each do |defn|
+      defn[:types].each do |type|
+        context "when the type is #{type ? type.inspect : 'not provided'}" do
+          let(:obj) do
+            if type
+              described_class.new("testing", type)
+            else
+              described_class.new("testing")
+            end
+          end
+
+          let(:bson) { defn[:bson] }
+
+          it_behaves_like "a serializable bson element"
+          it_behaves_like "a deserializable bson element"
+
+          it "reports its type as #{defn[:type].inspect}" do
+            expect(obj.type).to be == defn[:type]
+          end
+        end
+      end
+    end
 
-      let(:obj)  { described_class.new("testing", :uuid_old) }
-      let(:bson) { "#{7.to_bson}#{3.chr}testing" }
+    context 'when given binary string' do
+      let(:obj) { described_class.new("\x00\xfe\xff".force_encoding('BINARY')) }
+      let(:bson) { "#{3.to_bson}#{0.chr}\x00\xfe\xff".force_encoding('BINARY') }
 
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
 
-    context "when the type is :uuid" do
-
-      let(:obj)  { described_class.new("testing", :uuid) }
-      let(:bson) { "#{7.to_bson}#{4.chr}testing" }
+    context 'when given a frozen string' do
+      let(:str) { "\x00\xfe\xff".force_encoding('BINARY').freeze }
+      let(:obj) { described_class.new(str) }
+      let(:bson) { "#{3.to_bson}#{0.chr}\x00\xfe\xff".force_encoding('BINARY') }
 
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
+  end
 
-    context "when the type is :md5" do
+  describe '#to_uuid' do
+    let(:obj) { described_class.new("\x00" * 16, :uuid) }
 
-      let(:obj)  { described_class.new("testing", :md5) }
-      let(:bson) { "#{7.to_bson}#{5.chr}testing" }
+    it 'accepts symbol representation' do
+      expect(obj.to_uuid(:standard)).to eq('00000000-0000-0000-0000-000000000000')
+    end
 
-      it_behaves_like "a serializable bson element"
-      it_behaves_like "a deserializable bson element"
+    it 'rejects string representation' do
+      expect do
+        obj.to_uuid('standard')
+      end.to raise_error(ArgumentError, /Representation must be given as a symbol/)
     end
+  end
 
-    context "when the type is :user" do
+  describe '#from_uuid' do
+    let(:uuid) { '00000000-0000-0000-0000000000000000' }
 
-      let(:obj)  { described_class.new("testing", :user) }
-      let(:bson) { "#{7.to_bson}#{128.chr}testing" }
+    it 'accepts symbol representation' do
+      obj = described_class.from_uuid(uuid, :standard)
+      expect(obj.data).to eq("\x00" * 16)
+    end
 
-      it_behaves_like "a serializable bson element"
-      it_behaves_like "a deserializable bson element"
+    it 'rejects string representation' do
+      expect do
+        described_class.from_uuid(uuid, 'standard')
+      end.to raise_error(ArgumentError, /Representation must be given as a symbol/)
     end
   end
 end