bson 4.1.1 → 4.2.0.rc0

data/spec/bson/document_spec.rb

@@ -887,7 +887,7 @@ describe BSON::Document do
       end
     end
 
-    context "when binary strings with utf-8 values exist", if: BSON::Environment.jruby? && (JRUBY_VERSION !~ /9.0/) do
+    context "when binary strings with utf-8 values exist", if: BSON::Environment.jruby? && (JRUBY_VERSION < '9') do
 
       let(:string) { "europäisch" }
       let(:document) do

data/spec/bson/driver_bson_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe 'Driver common bson tests' do
+
+  specs = DRIVER_COMMON_BSON_TESTS.map { |file| BSON::CommonDriver::Spec.new(file) }
+
+  specs.each do |spec|
+
+    context(spec.description) do
+
+      spec.valid_tests.each do |test|
+
+        context(test.description << ' - ' << test.string) do
+
+          it 'decodes the subject and displays as the correct string' do
+            expect(test.object.to_s).to eq(test.expected_to_string)
+          end
+
+          it 'encodes the decoded object correctly (roundtrips)' do
+            expect(test.reencoded_hex).to eq(test.subject.upcase)
+          end
+
+          it 'creates the correct object from extended json', if: test.from_ext_json? do
+            expect(test.from_json_string).to eq(test.object)
+          end
+
+          it 'creates the correct extended json document from the decoded object', if: test.to_ext_json? do
+            expect(test.document_as_json).to eq(test.ext_json)
+          end
+
+          it 'parses the string value to the same value as the decoded document', if: test.from_string? do
+            expect(BSON::Decimal128.new(test.string)).to eq(test.object)
+          end
+
+          it 'parses the #to_s (match_string) value to the same value as the decoded document', if: test.match_string do
+            expect(BSON::Decimal128.new(test.match_string)).to eq(test.object)
+          end
+
+          it 'creates the correct object from a non canonical string and then prints to the correct string', if: test.match_string do
+            expect(BSON::Decimal128.new(test.string).to_s).to eq(test.match_string)
+          end
+
+          it 'can be converted to a native type' do
+            expect(test.native_type_conversion).to be_a(test.native_type)
+          end
+        end
+      end
+
+      spec.invalid_tests.each do |test|
+
+        context(test.description << " - " << test.subject ) do
+
+          let(:error) do
+            ex = nil
+            begin
+              test.parse_invalid_string
+            rescue => e
+              ex = e
+            end
+            ex
+          end
+
+          let(:valid_errors) do
+            [
+              BSON::Decimal128::InvalidString,
+              BSON::Decimal128::InvalidRange
+            ]
+          end
+
+          it 'raises an exception when parsing' do
+            expect(error.class).to satisfy { |e| valid_errors.include?(e) }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/bson/int32_spec.rb

@@ -16,6 +16,42 @@ require "spec_helper"
 
 describe BSON::Int32 do
 
+  describe "#intiialize" do
+
+    let(:obj) { described_class.new(integer) }
+
+    context "when the integer is 32-bit" do
+
+      let(:integer) { Integer::MAX_32BIT }
+
+      it "wraps the integer" do
+        expect(obj.instance_variable_get(:@integer)).to be(integer)
+      end
+    end
+
+    context "when the integer is too large" do
+
+      let(:integer) { Integer::MAX_32BIT + 1 }
+
+      it "raises an out of range error" do
+        expect {
+          obj
+        }.to raise_error(RangeError)
+      end
+    end
+
+    context "when the integer is too small" do
+
+      let(:integer) { Integer::MIN_32BIT - 1 }
+
+      it "raises an out of range error" do
+        expect {
+          obj
+        }.to raise_error(RangeError)
+      end
+    end
+  end
+
   describe "#from_bson" do
 
     let(:type) { 16.chr }
@@ -41,4 +77,26 @@ describe BSON::Int32 do
       expect(BSON::Int32.from_bson(encoded_2)).to eq(decoded_2)
     end
   end
+
+  describe "#to_bson" do
+
+    context "when the integer is 32 bit" do
+
+      let(:type) { 16.chr }
+      let(:obj)  { BSON::Int32.new(Integer::MAX_32BIT - 1) }
+      let(:bson) { [ Integer::MAX_32BIT - 1 ].pack(BSON::Int32::PACK) }
+
+      it_behaves_like "a serializable bson element"
+    end
+  end
+
+  describe "#to_bson_key" do
+
+    let(:obj)  {  BSON::Int32.new(Integer::MAX_32BIT - 1) }
+    let(:encoded) { (Integer::MAX_32BIT - 1).to_s }
+
+    it "returns the key as a string" do
+      expect(obj.to_bson_key).to eq(encoded)
+    end
+  end
 end

data/spec/bson/int64_spec.rb

@@ -16,6 +16,42 @@ require "spec_helper"
 
 describe BSON::Int64 do
 
+  describe "#intiialize" do
+
+    let(:obj) { described_class.new(integer) }
+
+    context "when the integer is 64-bit" do
+
+      let(:integer) { Integer::MAX_64BIT - 1 }
+
+      it "wraps the integer" do
+        expect(obj.instance_variable_get(:@integer)).to be(integer)
+      end
+    end
+
+    context "when the integer is too large" do
+
+      let(:integer) { Integer::MAX_64BIT + 1 }
+
+      it "raises an out of range error" do
+        expect {
+          obj
+        }.to raise_error(RangeError)
+      end
+    end
+
+    context "when the integer is too small" do
+
+      let(:integer) { Integer::MIN_64BIT - 1 }
+
+      it "raises an out of range error" do
+        expect {
+          obj
+        }.to raise_error(RangeError)
+      end
+    end
+  end
+
   describe "#from_bson" do
 
     let(:type) { 18.chr }
@@ -25,4 +61,26 @@ describe BSON::Int64 do
     it_behaves_like "a bson element"
     it_behaves_like "a deserializable bson element"
   end
+
+  describe "#to_bson" do
+
+    context "when the integer is 64 bit" do
+
+      let(:type) { 18.chr }
+      let(:obj)  { BSON::Int64.new(Integer::MAX_64BIT - 1) }
+      let(:bson) { [ Integer::MAX_64BIT - 1 ].pack(BSON::Int64::PACK) }
+
+      it_behaves_like "a serializable bson element"
+    end
+  end
+
+  describe "#to_bson_key" do
+
+    let(:obj)  {  BSON::Int64.new(Integer::MAX_64BIT - 1) }
+    let(:encoded) { (Integer::MAX_64BIT - 1).to_s }
+
+    it "returns the key as a string" do
+      expect(obj.to_bson_key).to eq(encoded)
+    end
+  end
 end

data/spec/bson/open_struct_spec.rb

@@ -0,0 +1,144 @@
+# Copyright (C) 2016 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 OpenStruct do
+
+  describe "#to_bson" do
+
+    let(:type) { 3.chr }
+
+    it_behaves_like "a bson element"
+
+    context "when the struct is a single level" do
+
+      let(:obj) do
+        described_class.new({"key" => "value" })
+      end
+
+      let(:bson) do
+        "#{20.to_bson.to_s}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
+        "#{6.to_bson.to_s}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
+      end
+
+      it_behaves_like "a serializable bson element"
+    end
+
+    context "when the struct has invalid keys" do
+
+      let(:obj) do
+        described_class.new({ "$testing" => "value" })
+      end
+
+      context "when validating keys" do
+
+        context "when validating globally" do
+
+          before do
+            BSON::Config.validating_keys = true
+          end
+
+          after do
+            BSON::Config.validating_keys = false
+          end
+
+          it "raises an error" do
+            expect {
+              obj.to_bson
+            }.to raise_error(BSON::String::IllegalKey)
+          end
+
+          context "when the struct contains an array of documents containing invalid keys" do
+
+            let(:obj) do
+              described_class.new({ "array" =>  [{ "$testing" => "value" }] })
+            end
+
+            it "raises an error" do
+              expect {
+                obj.to_bson
+              }.to raise_error(BSON::String::IllegalKey)
+            end
+          end
+        end
+
+        context "when validating locally" do
+
+          it "raises an error" do
+            expect {
+              obj.to_bson(BSON::ByteBuffer.new, true)
+            }.to raise_error(BSON::String::IllegalKey)
+          end
+
+          context "when the struct contains an array of documents containing invalid keys" do
+
+            let(:obj) do
+              described_class.new({ "array" =>  [{ "$testing" => "value" }] })
+            end
+
+            it "raises an error" do
+              expect {
+                obj.to_bson(BSON::ByteBuffer.new, true)
+              }.to raise_error(BSON::String::IllegalKey)
+            end
+          end
+        end
+      end
+
+      context "when not validating keys" do
+
+        let(:bson) do
+          "#{25.to_bson.to_s}#{String::BSON_TYPE}$testing#{BSON::NULL_BYTE}" +
+          "#{6.to_bson.to_s}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
+        end
+
+        it "serializes the struct" do
+          expect(obj.to_bson.to_s).to eq(bson)
+        end
+
+        context "when the struct contains an array of documents containing invalid keys" do
+
+          let(:obj) do
+            described_class.new({ "array" =>  [{ "$testing" => "value" }] })
+          end
+
+          let(:bson) do
+            "#{45.to_bson.to_s}#{Array::BSON_TYPE}array#{BSON::NULL_BYTE}" +
+              "#{[{ "$testing" => "value" }].to_bson.to_s}#{BSON::NULL_BYTE}"
+          end
+
+          it "serializes the struct" do
+            expect(obj.to_bson.to_s).to eq(bson)
+          end
+        end
+      end
+    end
+
+    context "when the struct is embedded" do
+
+      let(:obj) do
+        described_class.new({ "field" => OpenStruct.new({ "key" => "value" })})
+      end
+
+      let(:bson) do
+        "#{32.to_bson.to_s}#{Hash::BSON_TYPE}field#{BSON::NULL_BYTE}" +
+        "#{20.to_bson.to_s}#{String::BSON_TYPE}key#{BSON::NULL_BYTE}" +
+        "#{6.to_bson.to_s}value#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}#{BSON::NULL_BYTE}"
+      end
+
+      it_behaves_like "a serializable bson element"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -12,9 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
+DRIVER_COMMON_BSON_TESTS = Dir.glob("#{CURRENT_PATH}/support/driver-spec-tests/**/*.json")
+
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
+require "ostruct"
 require "bson"
 require "json"
 require "rspec"

data/spec/support/common_driver.rb

@@ -0,0 +1,347 @@
+# Copyright (C) 2016 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 'bigdecimal'
+
+module BSON
+  module CommonDriver
+
+    # Represents a Common Driver specification test.
+    #
+    # @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 yaml file.
+      #
+      # @since 4.2.0
+      def initialize(file)
+        @spec = ::JSON.parse(File.read(file))
+        @valid = @spec['valid'] || []
+        @invalid = @spec['parseErrors'] || []
+        @description = @spec['description']
+        @test_key = @spec['test_key']
+      end
+
+      # Get a list of tests that don't raise exceptions.
+      #
+      # @example Get the list of valid tests.
+      #   spec.valid_tests
+      #
+      # @return [ Array<BSON::CommonDriver::Test> ] The list of valid Tests.
+      #
+      # @since 4.2.0
+      def valid_tests
+        @valid_tests ||=
+          @valid.collect do |test|
+            BSON::CommonDriver::Test.new(self, test)
+          end
+      end
+
+      # Get a list of tests that raise exceptions.
+      #
+      # @example Get the list of invalid tests.
+      #   spec.invalid_tests
+      #
+      # @return [ Array<BSON::CommonDriver::Test> ] The list of invalid Tests.
+      #
+      # @since 4.2.0
+      def invalid_tests
+        @invalid_tests ||=
+          @invalid.collect do |test|
+            BSON::CommonDriver::Test.new(self, test)
+          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 CommonDriver test.
+    #
+    # @since 4.2.0
+    class Test
+
+      # The test description.
+      #
+      # @return [ String ] The test description.
+      #
+      # @since 4.2.0
+      attr_reader :description
+
+      # The test subject.
+      #
+      # @return [ String ] The test subject.
+      #
+      # @since 4.2.0
+      attr_reader :subject
+
+      # The string to use to create a Decimal128.
+      #
+      # @return [ String ] The string to use in creating a Decimal128 object.
+      #
+      # @since 4.2.0
+      attr_reader :string
+
+      # The expected string representation of the Decimal128 object.
+      #
+      # @return [ String ] The object as a string.
+      #
+      # @since 4.2.0
+      attr_reader :match_string
+
+      # The json representation of the object.
+      #
+      # @return [ Hash ] The json representation of the object.
+      #
+      # @since 4.2.0
+      attr_reader :ext_json
+
+      # Instantiate the new Test.
+      #
+      # @example Create the test.
+      #   Test.new(test)
+      #
+      # @param [ CommonDriver::Spec ] spec The test specification.
+      # @param [ Hash ] test The test specification.
+      #
+      # @since 4.2.0
+      def initialize(spec, test)
+        @spec = spec
+        @description = test['description']
+        @string = test['string']
+        @match_string = test['match_string']
+        @ext_json = ::JSON.parse(test['extjson']) if test['extjson']
+        @from_ext_json = test['from_extjson'].nil? ? true : test['from_extjson']
+        @to_ext_json = test['to_extjson'].nil? ? true : test['to_extjson']
+        @subject = test['subject']
+        @test_key = spec.test_key
+      end
+
+      # Get the reencoded document in hex format.
+      #
+      # @example Get the reencoded document as hex.
+      #   test.reencoded_hex
+      #
+      # @return [ String ] The reencoded document in hex format.
+      #
+      # @since 4.2.0
+      def reencoded_hex
+        decoded_document.to_bson.to_s.unpack("H*").first.upcase
+      end
+
+      # The object tested.
+      #
+      # @example Get the object for this test.
+      #   test.object
+      #
+      # @return [ BSON::Object ] The object.
+      #
+      # @since 4.2.0
+      def object
+        @object ||= decoded_document[@test_key]
+      end
+
+      # The object as json, in a document with the test key.
+      #
+      # @example Get a document with the object at the test key.
+      #   test.document_as_json
+      #
+      # @return [ BSON::Document ] The json document.
+      #
+      # @since 4.2.0
+      def document_as_json
+        { @test_key => object.as_json }
+      end
+
+      # Use the string in the extended json to instantiate the bson object.
+      #
+      # @example Get a bson object from the string in the extended json.
+      #   test.from_json
+      #
+      # @return [ BSON::Object ] The BSON object.
+      #
+      # @since 4.2.0
+      def from_json_string
+        klass.from_string(@ext_json[@test_key][klass::EXTENDED_JSON_KEY])
+      end
+
+      # Create an object from the given test string.
+      #
+      # @example
+      #   test.parse_string
+      #
+      # @return [ BSON::Object ] The object.
+      #
+      # @since 4.2.0
+      def parse_string
+        klass.from_string(string)
+      end
+
+      # Attempt to create an object from an invalid string.
+      #
+      # @example
+      #   test.parse_invalid_string
+      #
+      # @raise [ Error ] Parsing an invalid string will raise an error.
+      #
+      # @since 4.2.0
+      def parse_invalid_string
+        klass.from_string(subject)
+      end
+
+      # The class of the object being tested.
+      #
+      # @example
+      #   test.klass
+      #
+      # @return [ Class ] The object class.
+      #
+      # @since 4.2.0
+      def klass
+        @spec.klass
+      end
+
+      # The error class of a parse error.
+      #
+      # @example
+      #   test.parse_error
+      #
+      # @return [ Class ] The parse error class.
+      #
+      # @since 4.2.0
+      def parse_error
+        klass::InvalidRange
+      end
+
+      # Whether the object can be instantiated from extended json.
+      #
+      # @example Check if an object can be instantiated from the extended json.
+      #  test.from_ex_json?
+      #
+      # @return [ true, false ] If the object can be instantiated from
+      #   the provided extended json.
+      #
+      # @since 4.2.0
+      def from_ext_json?
+        @ext_json && @from_ext_json
+      end
+
+      # Whether the object can be represented as extended json.
+      #
+      # @example Check if an object can be represented as extended json.
+      #  test.to_ext_json?
+      #
+      # @return [ true, false ] If the object can be represented as
+      #   extended json.
+      #
+      # @since 4.2.0
+      def to_ext_json?
+        @ext_json && @to_ext_json
+      end
+
+      # Whether the object can be instantiated from a string.
+      #
+      # @example Check if an object can be instantiated from a string.
+      #  test.from_string?
+      #
+      # @return [ true, false ] If the object can be instantiated from a string.
+      #
+      # @since 4.2.0
+      def from_string?
+        @string && @from_ext_json
+      end
+
+      # The expected string representation of the test object.
+      #
+      # @example Get the expected String representation of the test object.
+      #  test.expected_to_string
+      #
+      # @return [ String ] The expected string representation.
+      #
+      # @since 4.2.0
+      def expected_to_string
+        match_string || string
+      end
+
+      # The Ruby class to which this bson object can be converted via a helper.
+      #
+      # @example Get the native type to which this object can be converted.
+      #  test.native_type
+      #
+      # @return [ Class ] The Ruby native type.
+      #
+      # @since 4.2.0
+      def native_type
+        klass::NATIVE_TYPE
+      end
+
+      # Get the object converted to an instance of the native Ruby type.
+      #
+      # @example Get a native Ruby instance.
+      #  test.native_type_conversion
+      #
+      # @return [ Object ] An instance of the Ruby native type.
+      #
+      # @since 4.2.0
+      def native_type_conversion
+        object.send("to_#{to_snake_case(native_type)}")
+      end
+
+      private
+
+      def to_snake_case(string)
+        string.to_s.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+      end
+
+      def decoded_document
+        @document ||= (data = [ @subject ].pack('H*')
+          buffer = BSON::ByteBuffer.new(data)
+          BSON::Document.from_bson(buffer))
+      end
+    end
+  end
+end