bson 4.7.1 → 4.8.0

data/spec/bson/float_spec.rb

@@ -26,4 +26,40 @@ describe Float do
     it_behaves_like "a serializable bson element"
     it_behaves_like "a deserializable bson element"
   end
+
+  describe '#to_json' do
+    it 'returns float' do
+      42.0.to_json.should == '42.0'
+    end
+  end
+
+  describe '#as_extended_json' do
+    context 'canonical mode' do
+      it 'returns $numberDouble' do
+        42.0.as_extended_json.should == {'$numberDouble' => '42.0'}
+      end
+    end
+
+    context 'relaxed mode' do
+      let(:serialized) do
+        42.0.as_extended_json(mode: :relaxed)
+      end
+
+      it 'returns float' do
+        serialized.should be_a(Float)
+        serialized.should be_within(0.00001).of(42)
+      end
+    end
+
+    context 'legacy mode' do
+      let(:serialized) do
+        42.0.as_extended_json(mode: :legacy)
+      end
+
+      it 'returns float' do
+        serialized.should be_a(Float)
+        serialized.should be_within(0.00001).of(42)
+      end
+    end
+  end
 end

data/spec/bson/hash_spec.rb

@@ -157,6 +157,76 @@ describe Hash do
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
+
+    context 'with symbol values' do
+      let(:value) { :foo }
+
+      let(:serialized) do
+        {foo: value}.to_bson.to_s
+      end
+
+      def perform_test(bson_type_to_use)
+        Symbol.class_eval do
+          alias_method :bson_type_orig, :bson_type
+          define_method(:bson_type) do
+            bson_type_to_use
+          end
+        end
+
+        begin
+          yield
+        ensure
+          Symbol.class_eval do
+            alias_method :bson_type, :bson_type_orig
+            remove_method :bson_type_orig
+          end
+        end
+      end
+
+      let(:bson_with_symbol) do
+        "\x12\x00\x00\x00\x0Efoo\x00\x04\x00\x00\x00bar\x00\x00".force_encoding('binary')
+      end
+
+      let(:deserialized) do
+        Hash.from_bson(BSON::ByteBuffer.new(bson_with_symbol))
+      end
+
+      context 'when Symbol#bson_type is set to symbol' do
+        let(:bson_type_to_use) { BSON::Symbol::BSON_TYPE }
+
+        let(:expected) do
+          "\x12\x00\x00\x00\x0Efoo\x00\x04\x00\x00\x00foo\x00\x00".force_encoding('binary')
+        end
+
+        it 'serializes to BSON symbol' do
+          perform_test(bson_type_to_use) do
+            serialized
+          end.should == expected
+        end
+
+        it 'deserializes to Symbol' do
+          deserialized.should == {'foo' => :bar}
+        end
+      end
+
+      context 'when Symbol#bson_type is set to string' do
+        let(:bson_type_to_use) { BSON::String::BSON_TYPE }
+
+        let(:expected) do
+          "\x12\x00\x00\x00\x02foo\x00\x04\x00\x00\x00foo\x00\x00".force_encoding('binary')
+        end
+
+        it 'serializes to BSON string' do
+          perform_test(bson_type_to_use) do
+            serialized
+          end.should == expected
+        end
+
+        it 'deserializes to Symbol' do
+          deserialized.should == {'foo' => :bar}
+        end
+      end
+    end
   end
 
   describe '#to_bson' do

data/spec/bson/int32_spec.rb

@@ -253,4 +253,24 @@ describe BSON::Int32 do
       expect(obj.value).to eq(12345)
     end
   end
+
+  describe '#as_extended_json' do
+    context 'canonical mode' do
+      it 'returns $numberInt' do
+        described_class.new(42).as_extended_json.should == {'$numberInt' => '42'}
+      end
+    end
+
+    context 'relaxed mode' do
+      it 'returns integer' do
+        described_class.new(42).as_extended_json(mode: :relaxed).should == 42
+      end
+    end
+
+    context 'legacy mode' do
+      it 'returns integer' do
+        described_class.new(42).as_extended_json(mode: :legacy).should be 42
+      end
+    end
+  end
 end

data/spec/bson/int64_spec.rb

@@ -71,6 +71,25 @@ describe BSON::Int64 do
     it_behaves_like "a bson element"
     it_behaves_like "a deserializable bson element"
 
+    context 'canonical deserialization' do
+      let(:integer) { 42 }
+
+      let(:bson) do
+        BSON::ByteBuffer.new(BSON::Int64.new(integer).to_bson.to_s)
+      end
+
+      let(:deserialized) do
+        described_class.from_bson(bson, mode: :bson)
+      end
+
+      it 'deserializes to BSON::Int64' do
+        deserialized.class.should be BSON::Int64
+      end
+
+      it 'has the correct value' do
+        deserialized.value.should == 42
+      end
+    end
 
     context "when the integer is within the MRI Fixnum range" do
 
@@ -299,4 +318,23 @@ describe BSON::Int64 do
     end
   end
 
+  describe '#as_extended_json' do
+    context 'canonical mode' do
+      it 'returns $numberLong' do
+        described_class.new(42).as_extended_json.should == {'$numberLong' => '42'}
+      end
+    end
+
+    context 'relaxed mode' do
+      it 'returns integer' do
+        described_class.new(42).as_extended_json(mode: :relaxed).should == 42
+      end
+    end
+
+    context 'legacy mode' do
+      it 'returns integer' do
+        described_class.new(42).as_extended_json(mode: :legacy).should be 42
+      end
+    end
+  end
 end

data/spec/bson/integer_spec.rb

@@ -68,4 +68,30 @@ describe Integer do
       expect(obj.to_bson_key).to eq(encoded)
     end
   end
+
+  describe '#to_json' do
+    it 'returns integer' do
+      42.to_json.should == '42'
+    end
+  end
+
+  describe '#as_extended_json' do
+    context 'canonical mode' do
+      it 'returns $numberInt' do
+        42.as_extended_json.should == {'$numberInt' => '42'}
+      end
+    end
+
+    context 'relaxed mode' do
+      it 'returns integer' do
+        42.as_extended_json(mode: :relaxed).should be 42
+      end
+    end
+
+    context 'legacy mode' do
+      it 'returns integer' do
+        42.as_extended_json(mode: :legacy).should be 42
+      end
+    end
+  end
 end

data/spec/bson/raw_spec.rb

@@ -12,13 +12,34 @@ describe Regexp::Raw do
       described_class.new(pattern, 'im')
     end
 
-    it "returns the regex pattern and options" do
+    it "returns the legacy serialization including regex pattern and options" do
       expect(object.as_json).to eq({ "$regex" => "\\W+", "$options" => "im" })
     end
 
     it_behaves_like "a JSON serializable object"
   end
 
+  describe '#as_extended_json' do
+
+    let(:object) do
+      described_class.new(pattern, 'im')
+    end
+
+    context 'legacy mode' do
+      it "returns the legacy serialization including regex pattern and options" do
+        expect(object.as_extended_json(mode: :legacy)).to eq({ "$regex" => "\\W+", "$options" => "im" })
+      end
+    end
+
+    context 'canonical/relaxed mode' do
+      it "returns the extended json 2.0 serialization" do
+        expect(object.as_extended_json).to eq(
+          "$regularExpression" => {'pattern' => "\\W+", "options" => "im"}
+        )
+      end
+    end
+  end
+
   describe "#to_bson/#from_bson" do
 
     let(:options) { 'ilmsux' }

data/spec/bson/symbol_raw_spec.rb

@@ -0,0 +1,45 @@
+# Copyright (C) 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.
+# 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::Symbol::Raw do
+  describe '#==' do
+    let(:one) { described_class.new('foo') }
+    let(:two) { described_class.new('foo') }
+    let(:three) { described_class.new('bar') }
+
+    it 'compares equal' do
+      one.should == two
+    end
+
+    it 'compares not equal' do
+      one.should_not == three
+    end
+  end
+
+  describe '#eql?' do
+    let(:one) { described_class.new('foo') }
+    let(:two) { described_class.new('foo') }
+    let(:three) { described_class.new('bar') }
+
+    it 'compares equal' do
+      one.should be_eql(two)
+    end
+
+    it 'compares not equal' do
+      one.should_not be_eql(three)
+    end
+  end
+end

data/spec/bson/symbol_spec.rb

@@ -32,6 +32,66 @@ describe Symbol do
     it_behaves_like "a bson element"
     it_behaves_like "a serializable bson element"
     it_behaves_like "a deserializable bson element"
+
+    context 'canonical deserialization' do
+      let(:bson) do
+        BSON::ByteBuffer.new(BSON::Symbol::Raw.new(obj).to_bson.to_s)
+      end
+
+      let(:deserialized) do
+        described_class.from_bson(bson, mode: :bson)
+      end
+
+      it 'deserializes to BSON::Symbol::Raw' do
+        deserialized.class.should be BSON::Symbol::Raw
+      end
+
+      it 'has the correct value' do
+        deserialized.to_sym.should be obj
+      end
+    end
+
+    context 'when changing bson_type' do
+      def perform_test(bson_type_to_use)
+        Symbol.class_eval do
+          alias_method :bson_type_orig, :bson_type
+          define_method(:bson_type) do
+            bson_type_to_use
+          end
+        end
+
+        begin
+          yield
+        ensure
+          Symbol.class_eval do
+            alias_method :bson_type, :bson_type_orig
+            remove_method :bson_type_orig
+          end
+        end
+      end
+
+      let(:value) { :foo }
+
+      let(:serialized) do
+        value.to_bson.to_s
+      end
+
+      context 'when bson_type is set to symbol' do
+        it 'serializes to BSON string' do
+          perform_test(BSON::Symbol::BSON_TYPE) do
+            serialized
+          end.should == "\x04\x00\x00\x00foo\x00".force_encoding('binary')
+        end
+      end
+
+      context 'when bson_type is set to string' do
+        it 'serializes to BSON string' do
+          perform_test(BSON::String::BSON_TYPE) do
+            serialized
+          end.should == "\x04\x00\x00\x00foo\x00".force_encoding('binary')
+        end
+      end
+    end
   end
 
   describe "#to_bson_key" do

data/spec/runners/corpus.rb

@@ -0,0 +1,182 @@
+# Copyright (C) 2016-2019 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 'json'
+require 'forwardable'
+
+module BSON
+  module Corpus
+
+    # Represents a test from the driver BSON Corpus.
+    #
+    # @since 4.2.0
+    class Spec
+
+      # The spec description.
+      #
+      # @return [ String ] The spec description.
+      #
+      # @since 4.2.0
+      attr_reader :description
+
+      # The document key of the object to test.
+      #
+      # @return [ String ] The document key.
+      #
+      # @since 4.2.0
+      attr_reader :test_key
+
+      # Instantiate the new spec.
+      #
+      # @example Create the spec.
+      #   Spec.new(file)
+      #
+      # @param [ String ] file The name of the json file.
+      #
+      # @since 4.2.0
+      def initialize(file)
+        @spec = ::JSON.parse(File.read(file).force_encoding('utf-8'))
+      end
+
+      def description
+        @spec['description']
+      end
+
+      def test_key
+        @spec['test_key']
+      end
+
+      def valid_tests
+        @valid_tests ||=
+          @spec['valid']&.map do |test_spec|
+            ValidTest.new(self, test_spec)
+          end
+      end
+
+      def decode_error_tests
+        @decode_error_tests ||=
+          @spec['decodeErrors']&.map do |test_spec|
+            DecodeErrorTest.new(self, test_spec)
+          end
+      end
+
+      def parse_error_tests
+        @parse_error_tests ||=
+          @spec['parseErrors']&.map do |test_spec|
+            ParseErrorTest.new(self, test_spec)
+          end
+      end
+
+      # The class of the bson object to test.
+      #
+      # @example Get the class of the object to test.
+      #   spec.klass
+      #
+      # @return [ Class ] The object class.
+      #
+      # @since 4.2.0
+      def klass
+        @klass ||= BSON.const_get(description)
+      end
+    end
+
+    # Represents a single BSON Corpus test.
+    #
+    # @since 4.2.0
+    class ValidTest
+      extend Forwardable
+
+      # Instantiate the new Test.
+      #
+      # @example Create the test.
+      #   Test.new(test)
+      #
+      # @param [ Corpus::Spec ] spec The test specification.
+      # @param [ Hash ] test The test specification.
+      #
+      # @since 4.2.0
+      def initialize(spec, test_params)
+        @spec = spec
+        test_params = test_params.dup
+        %w(
+          description canonical_extjson relaxed_extjson
+          degenerate_extjson converted_extjson
+          lossy
+        ).each do |key|
+          instance_variable_set("@#{key}", test_params.delete(key))
+        end
+        %w(
+          canonical_bson degenerate_bson converted_bson
+          lossy
+        ).each do |key|
+          if test_params.key?(key)
+            instance_variable_set("@#{key}", decode_hex(test_params.delete(key)))
+          end
+        end
+        unless test_params.empty?
+          raise "Test params has unprocessed keys: #{test_params}"
+        end
+      end
+
+      def_delegators :@spec, :test_key
+
+      attr_reader :description,
+        :canonical_bson,
+        :degenerate_bson,
+        :converted_bson,
+        :canonical_extjson,
+        :relaxed_extjson,
+        :degenerate_extjson,
+        :converted_extjson
+
+      def lossy?
+        !!@lossy
+      end
+
+      def canonical_extjson_doc
+        ::JSON.parse(canonical_extjson)
+      end
+
+      def relaxed_extjson_doc
+        relaxed_extjson && ::JSON.parse(relaxed_extjson)
+      end
+
+      private
+
+      def decode_hex(obj)
+        [ obj ].pack('H*')
+      end
+    end
+
+    class DecodeErrorTest
+      def initialize(spec, test_params)
+        @spec = spec
+        @description = test_params['description']
+        @bson = test_params['bson']
+      end
+
+      attr_reader :description, :bson
+    end
+
+    class ParseErrorTest
+      def initialize(spec, test_params)
+        @spec = spec
+        @description = test_params['description']
+        @string = test_params['string']
+      end
+
+      attr_reader :description, :string
+    end
+  end
+end