bson 4.1.1-java → 4.2.0-java

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/bson/raw_spec.rb

@@ -0,0 +1,540 @@
+require 'spec_helper'
+
+describe Regexp::Raw do
+
+  let(:pattern) { '\W+' }
+  let(:options) { '' }
+  let(:bson) { "#{pattern}#{BSON::NULL_BYTE}#{options}#{BSON::NULL_BYTE}" }
+
+  describe "#as_json" do
+
+    let(:object) do
+      described_class.new(pattern, 'im')
+    end
+
+    it "returns the 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 "#to_bson/#from_bson" do
+
+    let(:options) { 'ilmsux' }
+    let(:obj)  { described_class.new(pattern, options) }
+    let(:type) { 11.chr }
+    let(:bson) { "#{pattern}#{BSON::NULL_BYTE}#{options}#{BSON::NULL_BYTE}" }
+
+    let(:klass) { ::Regexp }
+
+    it_behaves_like "a bson element"
+    it_behaves_like "a serializable bson element"
+    it_behaves_like "a deserializable bson element"
+  end
+
+  describe "#initialize" do
+
+    let(:object) do
+      described_class.new(pattern, options)
+    end
+
+    context "when options are not passed" do
+
+      it "sets the options on the raw regex" do
+        expect(object.options). to eq(options)
+      end
+
+      context "When the raw regexp is compiled" do
+
+        let(:regexp) do
+          object.compile
+        end
+
+        it "sets the options on the compiled regexp object" do
+          expect(regexp.options).to eq(0)
+        end
+      end
+    end
+
+    context "when options are passed" do
+
+      context "when options are an Integer" do
+
+        let(:options) { ::Regexp::EXTENDED }
+
+        it "sets the options on the raw regex" do
+          expect(object.options). to eq(options)
+        end
+
+        context "When the raw regexp is compiled" do
+
+          let(:regexp) do
+            object.compile
+          end
+
+          it "sets the options on the compiled regexp object" do
+            expect(regexp.options).to eq(options)
+          end
+        end
+      end
+
+      context "when options are a String" do
+
+        let(:options) { 'x' }
+
+        it "sets the options on the raw regex" do
+          expect(object.options). to eq(options)
+        end
+
+        context "When the raw regexp is compiled" do
+
+          let(:regexp) do
+            object.compile
+          end
+
+          it "sets the options on the compiled regexp object" do
+            expect(regexp.options).to eq(::Regexp::EXTENDED)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#from_bson" do
+
+    let(:obj) { ::Regexp.from_bson(io) }
+    let(:io) { BSON::ByteBuffer.new(bson) }
+
+    it "deserializes to a Regexp::Raw object" do
+      expect(obj).to be_a(Regexp::Raw)
+    end
+
+    it "deserializes the pattern" do
+      expect(obj.pattern).to eq(pattern)
+    end
+
+    context "when there are no options" do
+
+      it "does not set any options on the raw regexp object" do
+        expect(obj.options).to eq(options)
+      end
+    end
+
+    context "when there are options" do
+
+      context "when there is the i ignorecase option" do
+
+        let(:options) { 'i' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the i option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when there is the l locale dependent option" do
+
+        let(:options) { 'l' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the l option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when there is the m multiline option" do
+
+        let(:options) { 'm' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the m option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when there is the s dotall option" do
+
+        let(:options) { 's' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the s option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when there is the u match unicode option" do
+
+        let(:options) { 'u' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the u option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when there is the x verbose option" do
+
+        let(:options) { 'x' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets the x option on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+
+      context "when all options are set" do
+
+        let(:options) { 'ilmsux' }
+
+        it "deserializes the pattern" do
+          expect(obj.pattern).to eq(pattern)
+        end
+
+        it "sets all options on the raw regexp object" do
+          expect(obj.options).to eq(options)
+        end
+      end
+    end
+  end
+
+  context "when a method is called on a Raw regexp object" do
+
+    let(:obj) { ::Regexp.from_bson(io) }
+    let(:io) { BSON::ByteBuffer.new(bson) }
+
+    it "forwards the method call on to the compiled Ruby Regexp object" do
+      expect(obj.source).to eq(pattern)
+    end
+  end
+
+  context "when respond_to? is called on the Raw Regexp object" do
+
+    let(:obj) { Regexp::Raw.new(pattern, options) }
+
+    context "when include_private is false" do
+
+      it "does not consider private methods" do
+        expect(obj.respond_to?(:initialize_copy)).to eq(false)
+      end
+    end
+
+    context "when include private is true" do
+
+      it "considers private methods" do
+        expect(obj.respond_to?(:initialize_copy, true)).to eq(true)
+      end
+    end
+
+    context "when include_private is not specified" do
+
+      it "does not consider private methods" do
+        expect(obj.respond_to?(:initialize_copy)).to eq(false)
+      end
+    end
+  end
+
+  context "#to_bson" do
+
+    let(:obj) { Regexp::Raw.new(pattern, options) }
+    let(:options) { '' }
+    let(:bson) { "#{pattern}#{BSON::NULL_BYTE}#{options}#{BSON::NULL_BYTE}" }
+    let(:serialized) { obj.to_bson.to_s }
+
+    it "serializes the pattern" do
+      expect(serialized).to eq(bson)
+    end
+
+    context "where there are no options" do
+
+      it "does not set any options on the bson regex object" do
+        expect(serialized).to eq(bson)
+      end
+    end
+
+    context "when there are options" do
+
+      context "when options are specified as an Integer" do
+
+        let(:options) { ::Regexp::EXTENDED }
+        let(:bson) { "#{pattern}#{BSON::NULL_BYTE}mx#{BSON::NULL_BYTE}" }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the i ignorecase option" do
+
+        let(:options) { 'i' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the l locale dependent option" do
+
+        let(:options) { 'l' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the m multiline option" do
+
+        let(:options) { 'm' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the s dotall option" do
+
+        let(:options) { 's' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the u match unicode option" do
+
+        let(:options) { 'u' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when there is the x verbose option" do
+
+        let(:options) { 'x' }
+
+        it "sets the option on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+      end
+
+      context "when all options are set" do
+
+        let(:options) { 'ilmsux' }
+
+        it "sets all options on the serialized bson object" do
+          expect(serialized).to eq(bson)
+        end
+
+        context "when the options are not provided in alphabetical order" do
+
+          let(:options) { 'mislxu' }
+          let(:bson) { "#{pattern}#{BSON::NULL_BYTE}ilmsux#{BSON::NULL_BYTE}" }
+
+          it "serializes the options in alphabetical order" do
+            expect(serialized).to eq(bson)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#compile" do
+
+    let(:obj) { Regexp.from_bson(io) }
+    let(:io) { BSON::ByteBuffer.new(bson) }
+    let(:ruby_regexp) { obj.compile }
+
+    it "sets the pattern on the Ruby Regexp object" do
+      expect(obj.pattern).to eq(ruby_regexp.source)
+    end
+
+    context "when there are no options set" do
+
+      it "does not set any options on the Ruby Regexp object" do
+        expect(ruby_regexp.options).to eq(0)
+      end
+    end
+
+    context "when there are options set" do
+
+      context "when there is the i ignorecase option" do
+
+        let(:options) { 'i' }
+
+        it "sets the i option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(::Regexp::IGNORECASE)
+        end
+      end
+
+      context "when there is the l locale dependent option" do
+
+        let(:options) { 'l' }
+
+        it "does not set an option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(0)
+        end
+      end
+
+      context "when there is the m multiline option" do
+
+        let(:options) { 'm' }
+
+        it "does not set an option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(0)
+        end
+      end
+
+      context "when there is the s dotall option" do
+
+        let(:options) { 's' }
+
+        # s in a bson regex maps to a Ruby Multiline Regexp option
+        it "sets the m option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(::Regexp::MULTILINE)
+        end
+      end
+
+      context "when there is the u match unicode option" do
+
+        let(:options) { 'u' }
+
+        it "does not set an option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(0)
+        end
+      end
+
+      context "when there is the x verbose option" do
+
+        let(:options) { 'x' }
+
+        it "sets the x option on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(::Regexp::EXTENDED)
+        end
+      end
+
+      context "when all options are set" do
+
+        let(:options) { 'ilmsux' }
+
+        # s in a bson regex maps to a Ruby Multiline Regexp option
+        it "sets the i, m, and x options on the Ruby Regexp object" do
+          expect(ruby_regexp.options).to eq(::Regexp::IGNORECASE | ::Regexp::MULTILINE | ::Regexp::EXTENDED)
+        end
+      end
+    end
+  end
+
+  context "when a Regexp::Raw object is roundtripped" do
+
+    let(:obj) { Regexp::Raw.new(pattern, options) }
+    let(:serialized) { obj.to_bson.to_s }
+    let(:roundtripped) { Regexp.from_bson(BSON::ByteBuffer.new(serialized)) }
+
+    it "roundtrips the pattern" do
+      expect(roundtripped.pattern).to eq(pattern)
+    end
+
+    context "when there are no options" do
+
+      let(:options) { '' }
+
+      it "does not set any options on the roundtripped Regexp::Raw object" do
+        expect(roundtripped.options).to eq(options)
+      end
+    end
+
+    context "when there are options set" do
+
+      context "when there is the i ignorecase option" do
+
+        let(:options) { 'i' }
+
+        it "sets the i option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when there is the l locale dependent option" do
+
+        let(:options) { 'l' }
+
+        it "sets the l option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when there is the m multiline option" do
+
+        let(:options) { 'm' }
+
+        it "sets the m option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when there is the s dotall option" do
+
+        let(:options) { 's' }
+
+        it "sets the s option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when there is the u match unicode option" do
+
+        let(:options) { 'u' }
+
+        it "sets the u option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when there is the x verbose option" do
+
+        let(:options) { 'x' }
+
+        it "sets the x option on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+      end
+
+      context "when all options are set" do
+
+        let(:options) { 'ilmsux' }
+
+        it "sets all the options on the roundtripped Regexp::Raw object" do
+          expect(roundtripped.options).to eq(options)
+        end
+
+        context "when the options are passed in not in alphabetical order" do
+
+          let(:options) { 'sumlxi' }
+
+          it "sets all the options on the roundtripped Regexp::Raw object in order" do
+            expect(roundtripped.options).to eq(options.chars.sort.join)
+          end
+        end
+      end
+    end
+  end
+end