bson 4.1.1 → 5.2.0

data/spec/bson/document_as_spec.rb

@@ -0,0 +1,61 @@
+# rubocop:todo all
+# Copyright (C) 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"
+
+# BSON::Document ActiveSupport extensions
+describe BSON::Document do
+  require_active_support
+
+  describe '#symbolize_keys' do
+    context 'string keys' do
+      let(:doc) do
+        described_class.new('foo' => 'bar')
+      end
+
+      it 'works correctly' do
+        doc.symbolize_keys.should == {foo: 'bar'}
+      end
+    end
+  end
+
+  describe '#symbolize_keys!' do
+    context 'string keys' do
+      let(:doc) do
+        described_class.new('foo' => 'bar')
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          doc.symbolize_keys!
+        end.should raise_error(ArgumentError, /symbolize_keys! is not supported on BSON::Document instances/)
+      end
+    end
+  end
+
+  describe '#deep_symbolize_keys!' do
+    context 'string keys' do
+      let(:doc) do
+        described_class.new('foo' => 'bar')
+      end
+
+      it 'raises ArgumentError' do
+        expect do
+          doc.deep_symbolize_keys!
+        end.to output(/\[DEPRECATION\] `deep_symbolize_keys!` is not supported on BSON::Document instances./).to_stderr
+      end
+    end
+  end
+end

data/spec/bson/document_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# rubocop:todo all
 
-# Copyright (C) 2009-2014 MongoDB Inc.
+# 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.
@@ -49,6 +49,68 @@ describe BSON::Document do
     end
   end
 
+  describe "#fetch" do
+
+    let(:document) do
+      described_class["key", "value", "key2", "value"]
+    end
+
+    context "when provided string keys" do
+
+      it "returns the value" do
+        expect(document.fetch("key")).to eq("value")
+      end
+    end
+
+    context "when provided symbol keys" do
+
+      it "returns the value" do
+        expect(document.fetch(:key)).to eq("value")
+      end
+    end
+
+    context "when key does not exist" do
+
+      it "raises KeyError" do
+        expect do
+          document.fetch(:non_existent_key)
+        end.to raise_exception(KeyError)
+      end
+
+      context "and default value is provided" do
+
+        it "returns default value" do
+          expect(document.fetch(:non_existent_key, false)).to eq(false)
+        end
+      end
+
+      context "and block is passed" do
+
+        it "returns result of the block" do
+          expect(document.fetch(:non_existent_key, &:to_s))
+            .to eq("non_existent_key")
+        end
+      end
+    end
+
+    context "when key exists" do
+
+      context "and default value is provided" do
+
+        it "returns the value" do
+          expect(document.fetch(:key, "other")).to eq("value")
+        end
+      end
+
+      context "and block is passed" do
+
+        it "returns the value" do
+          expect(document.fetch(:key, &:to_s)).to eq("value")
+        end
+      end
+    end
+  end
+
   describe "#[]" do
 
     let(:document) do
@@ -68,6 +130,13 @@ describe BSON::Document do
         expect(document[:key]).to eq("value")
       end
     end
+
+    context "when key does not exist" do
+
+      it "returns nil" do
+        expect(document[:non_existent_key]).to be nil
+      end
+    end
   end
 
   describe "#[]=" do
@@ -94,8 +163,108 @@ describe BSON::Document do
     it "sets the value" do
       expect(doc[key]).to eq(val)
     end
+
+    context 'when value is a hash' do
+      let(:val) do
+        {'foo' => {'bar' => 'baz'}}
+      end
+
+      it 'converts value to indifferent access' do
+        expect(doc[key][:foo][:bar]).to eq('baz')
+      end
+    end
+
+    context 'when value is an array with hash element' do
+      let(:val) do
+        [42, {'foo' => {'bar' => 'baz'}}]
+      end
+
+      it 'converts hash element to indifferent access' do
+        expect(doc[key][1][:foo][:bar]).to eq('baz')
+      end
+    end
   end
 
+  if described_class.instance_methods.include?(:dig)
+    describe "#dig" do
+      let(:document) do
+        described_class.new("key1" => { :key2 => "value" })
+      end
+
+      context "when provided string keys" do
+
+        it "returns the value" do
+          expect(document.dig("key1", "key2")).to eq("value")
+        end
+      end
+
+      context "when provided symbol keys" do
+
+        it "returns the value" do
+          expect(document.dig(:key1, :key2)).to eq("value")
+        end
+      end
+    end
+  end
+
+  if described_class.instance_methods.include?(:slice)
+    describe "#slice" do
+      let(:document) do
+        described_class.new("key1" => "value1", key2: "value2")
+      end
+
+      context "when provided string keys" do
+
+        it "is a BSON Document" do
+          expect(document.slice("key1")).to be_a(BSON::Document)
+        end
+
+        it "returns the partial document" do
+          expect(document.slice("key1")).to contain_exactly(['key1', 'value1'])
+        end
+      end
+
+      context "when provided symbol keys" do
+
+        it "is a BSON Document" do
+          expect(document.slice(:key1)).to be_a(BSON::Document)
+        end
+
+        it "returns the partial document" do
+          expect(document.slice(:key1)).to contain_exactly(['key1', 'value1'])
+        end
+      end
+
+      context "when provided keys that do not exist in the document" do
+
+        it "returns only the keys that exist in the document" do
+          expect(document.slice(:key1, :key3)).to contain_exactly(['key1', 'value1'])
+        end
+      end
+    end
+  end
+
+  describe "#except" do
+    let(:document) do
+      described_class.new("key1" => "value1", key2: "value2")
+    end
+
+    context "when provided string keys" do
+
+      it "returns the partial document" do
+        expect(document.except("key1")).to contain_exactly(['key2', 'value2'])
+      end
+    end
+
+    context "when provided symbol keys" do
+
+      it "returns the partial document" do
+        expect(document.except(:key1)).to contain_exactly(['key2', 'value2'])
+      end
+    end
+  end
+
+
   describe "#delete" do
 
     shared_examples_for "a document with deletable pairs" do
@@ -351,7 +520,13 @@ describe BSON::Document do
       context "when the document has been serialized" do
 
         let(:deserialized) do
-          YAML.load(YAML.dump(doc))
+          if YAML.respond_to?(:unsafe_load)
+            # In psych >= 4.0.0 `load` is basically an alias to `safe_load`,
+            # which will fail here.
+            YAML.unsafe_load(YAML.dump(doc))
+          else
+            YAML.load(YAML.dump(doc))
+          end
         end
 
         let!(:enum) do
@@ -756,6 +931,24 @@ describe BSON::Document do
       end
     end
 
+    context "when the hash contains an array of hashes" do
+      let(:obj) do
+        described_class["key",[{"a" => 1}, {"b" => 2}]]
+      end
+
+      let(:bson) do
+        "#{45.to_bson}#{Array::BSON_TYPE}key#{BSON::NULL_BYTE}" +
+        "#{35.to_bson}"+
+        "#{BSON::Document::BSON_TYPE}0#{BSON::NULL_BYTE}#{12.to_bson}#{BSON::Int32::BSON_TYPE}a#{BSON::NULL_BYTE}#{1.to_bson}#{BSON::NULL_BYTE}" +
+        "#{BSON::Document::BSON_TYPE}1#{BSON::NULL_BYTE}#{12.to_bson}#{BSON::Int32::BSON_TYPE}b#{BSON::NULL_BYTE}#{2.to_bson}#{BSON::NULL_BYTE}" +
+        "#{BSON::NULL_BYTE}" +
+        "#{BSON::NULL_BYTE}"
+      end
+
+      it_behaves_like "a serializable bson element"
+      it_behaves_like "a deserializable bson element"
+    end
+
     context "when the hash is a single level" do
 
       let(:obj) do
@@ -867,51 +1060,31 @@ describe BSON::Document do
       it_behaves_like "a document able to handle utf-8"
     end
 
-    context "when utf-8 values exist in wrong encoding" do
+    context "given a utf-8-encodable string in another encoding" do
 
       let(:string) { "gültig" }
       let(:document) do
         described_class["type", string.encode("iso-8859-1")]
       end
 
-      it "raises an exception", unless: BSON::Environment.jruby? do
-        expect {
-          document.to_bson
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'converts the values', if: BSON::Environment.jruby? do
-        expect(
-          BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
-        ).to eq({ "type" => string })
-      end
-    end
-
-    context "when binary strings with utf-8 values exist", if: BSON::Environment.jruby? && (JRUBY_VERSION !~ /9.0/) do
-
-      let(:string) { "europäisch" }
-      let(:document) do
-        described_class["type", string.encode("binary")]
-      end
-
-      it "encodes and decodes the document properly" do
+      it 'converts the values to utf-8' do
         expect(
           BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
         ).to eq({ "type" => string })
       end
     end
 
-    context "when binary strings with utf-8 values exist", unless: BSON::Environment.jruby? do
+    context "given a binary string with utf-8 values" do
 
-      let(:string) { "europäisch" }
+      let(:string) { "europäisch".force_encoding('binary') }
       let(:document) do
-        described_class["type", string.encode("binary", "binary")]
+        described_class["type", string]
       end
 
-      it "encodes and decodes the document properly" do
-        expect(
-          BSON::Document.from_bson(BSON::ByteBuffer.new(document.to_bson.to_s))
-        ).to eq({ "type" => string })
+      it "raises encoding error" do
+        expect do
+          document.to_bson
+        end.to raise_error(Encoding::UndefinedConversionError, /from ASCII-8BIT to UTF-8/)
       end
     end
   end

data/spec/bson/ext_json_parse_spec.rb

@@ -0,0 +1,346 @@
+# rubocop:todo all
+# 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::ExtJSON.parse" do
+
+  let(:parsed) { BSON::ExtJSON.parse_obj(input) }
+
+  context 'when input is true' do
+    let(:input) { true }
+
+    it 'returns true' do
+      parsed.should == true
+    end
+  end
+
+  context 'when input is false' do
+    let(:input) { false }
+
+    it 'returns false' do
+      parsed.should == false
+    end
+  end
+
+  context 'when input is nil' do
+    let(:input) { nil }
+
+    it 'returns nil' do
+      parsed.should be nil
+    end
+  end
+
+  context 'when input is a string' do
+    let(:input) { 'hello' }
+
+    it 'returns the string' do
+      parsed.should == 'hello'
+    end
+  end
+
+  context 'when input is a BSON timestamp' do
+    let(:input) { {'$timestamp' => {'t' => 12345, 'i' => 42}} }
+
+    it 'returns a BSON::Timestamp instance' do
+      parsed.should == BSON::Timestamp.new(12345, 42)
+    end
+  end
+
+  context 'when input is an ISO time' do
+    let(:input) { {'$date' => '1970-01-01T00:00:04Z'} }
+
+    it 'returns a Time instance ' do
+      parsed.should be_a(Time)
+    end
+
+    it 'returns a Time instance with correct value' do
+      parsed.should == Time.at(4)
+    end
+
+    it 'returns a Time instance in UTC' do
+      parsed.zone.should == 'UTC'
+    end
+  end
+
+  context 'when input is a Unix timestamp' do
+    let(:input) { {'$date' => {'$numberLong' => '4000'}} }
+
+    it 'returns a Time instance ' do
+      parsed.should be_a(Time)
+    end
+
+    it 'returns a Time instance with correct value' do
+      parsed.should == Time.at(4)
+    end
+
+    it 'returns a Time instance in UTC' do
+      parsed.zone.should == 'UTC'
+    end
+  end
+
+  context 'when input is an int32' do
+    let(:input) do
+      {'$numberInt' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+  end
+
+  context 'when input is an int64' do
+    let(:input) do
+      {'$numberLong' => '42'}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+
+    context 'when :mode is nil' do
+      let(:mode) { nil }
+
+      it 'returns Integer instance' do
+        parsed.should be_a(Integer)
+        parsed.should == 42
+      end
+    end
+
+    context 'when :mode is :bson' do
+      let(:mode) { :bson }
+
+      it 'returns Int64 instance' do
+        parsed.should be_a(BSON::Int64)
+        parsed.value.should == 42
+      end
+    end
+  end
+
+  context 'when input is a hash' do
+    let(:input) do
+      {}
+    end
+
+    let(:parsed) { BSON::ExtJSON.parse_obj(input, mode: mode) }
+    let(:mode) { :bson }
+
+    context 'when mode is invalid' do
+      let(:mode) { :foo }
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(ArgumentError, /Invalid value for :mode option/)
+      end
+    end
+
+    context 'when it contains a string key with a null byte' do
+      let(:input) do
+        { "key\x00" => 1 }
+      end
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(BSON::Error::ExtJSONParseError, /Hash key cannot contain a null byte/)
+      end
+    end
+
+    context 'when it contains a symbol key with a null byte' do
+      let(:input) do
+        { "key\x00".to_sym => 1 }
+      end
+
+      it 'raises an exception' do
+        lambda do
+          parsed
+        end.should raise_error(BSON::Error::ExtJSONParseError, /Hash key cannot contain a null byte/)
+      end
+    end
+
+    context 'when it contains an integer key' do
+      let(:input) do
+        { 0 => 1 }
+      end
+
+      it 'does not raises an exception' do
+        lambda do
+          parsed
+        end.should_not raise_error
+      end
+    end
+  end
+
+  context 'when input is a binary' do
+    let(:data) do
+      Base64.decode64("//8=")
+    end
+
+    context 'in current format' do
+      let(:input) do
+        { "$binary" => { "base64"=>"//8=", "subType"=>"00" } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$binary"=>"//8=", "$type"=>"00" }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+
+      context 'when mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns BSON::Binary instance' do
+          parsed.should be_a(BSON::Binary)
+          parsed.data.should == data
+        end
+      end
+    end
+  end
+
+  context 'when input is a regex' do
+    let(:pattern) { 'abc' }
+    let(:options) { 'im' }
+
+    context 'in current format' do
+      let(:input) do
+        { "$regularExpression" => { "pattern" => pattern, "options" => options } }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'in legacy format' do
+      let(:input) do
+        { "$regex" => pattern, "$options" => options }
+      end
+
+      context 'when :mode is nil' do
+        let(:mode) { nil }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+
+      context 'when :mode is :bson' do
+        let(:mode) { :bson }
+
+        it 'returns a BSON::Regexp::Raw instance' do
+          parsed.should be_a(BSON::Regexp::Raw)
+          parsed.pattern.should == pattern
+          parsed.options.should == options
+        end
+      end
+    end
+
+    context 'when $regularExpression is nested in $regex' do
+      context 'with options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+            "$options" => "ix",
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'), '$options' => 'ix'
+          }
+        end
+      end
+
+      context 'without options' do
+        let(:input) do
+          {
+            "$regex" => {
+              "$regularExpression" => { "pattern" => "foo*", "options" => "" },
+            },
+          }
+        end
+
+        it 'parses' do
+          parsed.should == {
+            '$regex' => BSON::Regexp::Raw.new('foo*'),
+          }
+        end
+      end
+    end
+  end
+end