bson 4.1.1 → 5.2.0

data/spec/bson/string_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.
@@ -51,7 +51,7 @@ describe String do
       it "raises an exception" do
         expect {
           "test".to_bson_object_id
-        }.to raise_error(BSON::ObjectId::Invalid)
+        }.to raise_error(BSON::Error::InvalidObjectId)
       end
     end
   end
@@ -90,44 +90,37 @@ describe String do
 
   describe "#to_bson_key" do
 
-    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
+    let(:string) do
+      "$testing.testing"
+    end
 
-        let(:validated) do
-          string.to_bson_key
-        end
+    it "allows dots/dollars keys" do
+      expect(string.to_bson_key).to eq(string)
+    end
+  end
 
-        it_behaves_like "a validated BSON key"
+  describe '#to_bson' do
+    context 'when string is not valid utf-8' do
+      let(:string) do
+        "\xfe\x00\xff".force_encoding('BINARY')
       end
 
-      context "when validating locally" do
-
-        let(:validated) do
-          string.to_bson_key(true)
-        end
+      let(:expected_message) do
+        /from ASCII-8BIT to UTF-8/
+      end
 
-        it_behaves_like "a validated BSON key"
+      it 'raises EncodingError' do
+        expect do
+          string.to_bson
+        end.to raise_error(EncodingError, expected_message)
       end
     end
+  end
 
-    context "when allowing invalid keys" do
-
-      let(:string) do
-        "$testing.testing"
-      end
+  describe '#as_extended_json' do
+    let(:object) { 'Hello world!' }
 
-      it "allows invalid keys" do
-        expect(string.to_bson_key).to eq(string)
-      end
-    end
+    it_behaves_like '#as_extended_json returns self'
+    it_behaves_like 'an Extended JSON serializable object'
   end
 end

data/spec/bson/symbol_raw_spec.rb

@@ -0,0 +1,70 @@
+# 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::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
+
+  describe '#as_json' do
+    let(:object) do
+      described_class.new(:foobar)
+    end
+
+    it 'returns a string' do
+      expect(object.as_json).to eq('foobar')
+    end
+
+    it_behaves_like 'a JSON serializable object'
+  end
+
+  describe '#as_extended_json' do
+    let(:object) do
+      described_class.new(:foobar)
+    end
+
+    it 'returns the binary data plus type' do
+      expect(object.as_extended_json).to eq({ '$symbol' => 'foobar' })
+    end
+
+    it_behaves_like 'an Extended JSON serializable object'
+  end
+end

data/spec/bson/symbol_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.
@@ -32,12 +33,72 @@ 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
 
     let(:symbol) { :test }
-    let(:encoded) { symbol.to_s }
+    let(:encoded) { symbol }
 
     it "returns the encoded string" do
       expect(symbol.to_bson_key).to eq(encoded)
@@ -46,28 +107,24 @@ describe Symbol do
 
   describe "#to_bson_key" do
 
-    context "when validating keys" do
-
-      let(:symbol) do
-        :'$testing.testing'
-      end
-
-      it "raises an exception" do
-        expect {
-          symbol.to_bson_key(true)
-        }.to raise_error(BSON::String::IllegalKey)
-      end
+    let(:symbol) do
+      :'$testing.testing'
     end
 
-    context "when not validating keys" do
+    it "returns the key" do
+      expect(symbol.to_bson_key).to eq(symbol)
+    end
+  end
 
-      let(:symbol) do
-        :'$testing.testing'
-      end
+  describe '#as_extended_json' do
+    let(:object) do
+      :foobar
+    end
 
-      it "allows invalid keys" do
-        expect(symbol.to_bson_key).to eq(symbol.to_s)
-      end
+    it 'returns the binary data plus type' do
+      expect(object.as_extended_json).to eq({ '$symbol' => 'foobar' })
     end
+
+    it_behaves_like 'an Extended JSON serializable object'
   end
 end

data/spec/bson/time_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.
@@ -43,7 +44,7 @@ describe Time do
       end
     end
 
-    context "when the time is pre epoch" do
+    context "when the time precedes epoch" do
 
       let(:obj)  { Time.utc(1969, 1, 1, 0, 0, 0) }
       let(:bson) { [ (obj.to_f * 1000).to_i ].pack(BSON::Int64::PACK) }
@@ -51,5 +52,208 @@ describe Time do
       it_behaves_like "a serializable bson element"
       it_behaves_like "a deserializable bson element"
     end
+
+    context 'when value has sub-millisecond precision' do
+      let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+      let(:expected_round_tripped_obj) do
+        Time.utc(2012, 1, 1, 0, 0, 0, 999_000)
+      end
+
+      let(:round_tripped_obj) do
+        Time.from_bson(obj.to_bson)
+      end
+
+      it 'truncates to milliseconds when round-tripping' do
+        round_tripped_obj.should == expected_round_tripped_obj
+      end
+    end
+  end
+
+  describe '#as_extended_json' do
+
+    context 'canonical mode' do
+      context 'when value has sub-millisecond precision' do
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+        let(:expected_serialization) do
+          {'$date' => {'$numberLong' => '1325376000999'}}
+        end
+
+        let(:serialization) do
+          obj.as_extended_json
+        end
+
+        shared_examples_for 'truncates to milliseconds when serializing' do
+          it 'truncates to milliseconds when serializing' do
+            serialization.should == expected_serialization
+          end
+        end
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+
+        context 'when value has sub-microsecond precision' do
+          let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999_999/1000r) }
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+
+        context "when the time precedes epoch" do
+          let(:obj)  { Time.utc(1960, 1, 1, 0, 0, 0, 999_999) }
+
+          let(:expected_serialization) do
+            {'$date' => {'$numberLong' => '-315619199001'}}
+          end
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+      end
+    end
+
+    context 'relaxed mode' do
+      context 'when value has sub-millisecond precision' do
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+        let(:expected_serialization) do
+          {'$date' => '2012-01-01T00:00:00.999Z'}
+        end
+
+        let(:serialization) do
+          obj.as_extended_json(mode: :relaxed)
+        end
+
+        shared_examples_for 'truncates to milliseconds when serializing' do
+          it 'truncates to milliseconds when serializing' do
+            serialization.should == expected_serialization
+          end
+        end
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+
+        context 'when value has sub-microsecond precision' do
+          let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999_999/1000r) }
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+
+        context "when the time precedes epoch" do
+          let(:obj)  { Time.utc(1960, 1, 1, 0, 0, 0, 999_999) }
+
+          let(:expected_serialization) do
+            {'$date' => {'$numberLong' => '-315619199001'}}
+          end
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+      end
+    end
+  end
+
+  describe '#to_extended_json' do
+
+    context 'canonical mode' do
+      context 'when value has sub-millisecond precision' do
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+        let(:expected_serialization) do
+          %q`{"$date":{"$numberLong":"1325376000999"}}`
+        end
+
+        let(:serialization) do
+          obj.to_extended_json
+        end
+
+        shared_examples_for 'truncates to milliseconds when serializing' do
+          it 'truncates to milliseconds when serializing' do
+            serialization.should == expected_serialization
+          end
+        end
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+
+        context 'when value has sub-microsecond precision' do
+          let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999_999/1000r) }
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+
+        context "when the time precedes epoch" do
+          let(:obj)  { Time.utc(1960, 1, 1, 0, 0, 0, 999_999) }
+
+          let(:expected_serialization) do
+            %q`{"$date":{"$numberLong":"-315619199001"}}`
+          end
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+      end
+    end
+
+    context 'relaxed mode' do
+      context 'when value has sub-millisecond precision' do
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+        let(:expected_serialization) do
+          %q`{"$date":"2012-01-01T00:00:00.999Z"}`
+        end
+
+        let(:serialization) do
+          obj.to_extended_json(mode: :relaxed)
+        end
+
+        shared_examples_for 'truncates to milliseconds when serializing' do
+          it 'truncates to milliseconds when serializing' do
+            serialization.should == expected_serialization
+          end
+        end
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+
+        context 'when value has sub-microsecond precision' do
+          let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999_999/1000r) }
+
+          it_behaves_like 'truncates to milliseconds when serializing'
+        end
+      end
+    end
+  end
+
+  describe '#to_json' do
+
+    context 'when value has sub-millisecond precision' do
+      let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999) }
+
+      let(:expected_serialization) do
+        %q`"2012-01-01 00:00:00 UTC"`
+      end
+
+      let(:serialization) do
+        obj.to_json
+      end
+
+      shared_examples_for 'truncates to milliseconds when serializing' do
+        it 'truncates to milliseconds when serializing' do
+          serialization.should == expected_serialization
+        end
+      end
+
+      it_behaves_like 'truncates to milliseconds when serializing'
+
+      context 'when value has sub-microsecond precision' do
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0, 999_999_999/1000r) }
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+      end
+
+      context "when the time precedes epoch" do
+        let(:obj)  { Time.utc(1960, 1, 1, 0, 0, 0, 999_999) }
+
+        let(:expected_serialization) do
+          %q`"1960-01-01 00:00:00 UTC"`
+        end
+
+        it_behaves_like 'truncates to milliseconds when serializing'
+      end
+    end
   end
 end

data/spec/bson/time_with_zone_spec.rb

@@ -0,0 +1,69 @@
+# rubocop:todo all
+# Copyright (C) 2018-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"
+
+context 'when ActiveSupport support is enabled' do
+  before do
+    unless SpecConfig.instance.active_support?
+      skip "ActiveSupport support is not enabled"
+    end
+  end
+
+  describe 'ActiveSupport::TimeWithZone' do
+    let(:cls) { ActiveSupport::TimeWithZone }
+
+    it "shares BSON type with Time" do
+      # ActiveSupport::TimeWithZone#new has no 0-argument version
+      obj = Time.now.in_time_zone("UTC")
+      expect(obj.bson_type).to eq(Time::BSON_TYPE)
+    end
+
+    shared_examples_for 'deserializes as expected' do
+      it 'deserializes to UTC' do
+        # Time zone information is lost during serialization - the time
+        # is always serialized in UTC.
+        rt_obj = Time.from_bson(obj.to_bson)
+        expect(rt_obj.zone).to eq('UTC')
+      end
+
+      it 'deserializes to an equal object' do
+        rt_obj = Time.from_bson(obj.to_bson)
+        expect(rt_obj).to eq(obj)
+      end
+    end
+
+    describe "#to_bson" do
+
+      context "when the TimeWithZone is not in UTC" do
+
+        let(:obj)  { Time.utc(2012, 12, 12, 0, 0, 0).in_time_zone("Pacific Time (US & Canada)") }
+        let(:bson) { [ (obj.utc.to_f * 1000).to_i ].pack(BSON::Int64::PACK) }
+
+        it_behaves_like "a serializable bson element"
+        it_behaves_like 'deserializes as expected'
+      end
+
+      context "when the TimeWithZone is in UTC" do
+
+        let(:obj)  { Time.utc(2012, 1, 1, 0, 0, 0).in_time_zone("UTC") }
+        let(:bson) { [ (obj.utc.to_f * 1000).to_i ].pack(BSON::Int64::PACK) }
+
+        it_behaves_like "a serializable bson element"
+        it_behaves_like 'deserializes as expected'
+      end
+    end
+  end
+end

data/spec/bson/timestamp_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.
@@ -48,6 +49,61 @@ describe BSON::Timestamp do
     end
   end
 
+  describe "#<=>" do
+
+    let(:timestamp) do
+      described_class.new(1, 10)
+    end
+
+    context "when the objects are equal" do
+
+      let(:other) { described_class.new(1, 10) }
+
+      it "returns 0" do
+        expect(timestamp).to eq(other)
+        expect(timestamp < other).to be(false)
+        expect(timestamp > other).to be(false)
+        expect(timestamp >= other).to be(true)
+        expect(timestamp <= other).to be(true)
+      end
+    end
+
+    context "when the first object is less than the second" do
+
+      let(:other) { described_class.new(1, 15) }
+
+      it "returns -1" do
+        expect(timestamp <=> other).to be(-1)
+        expect(timestamp < other).to be(true)
+        expect(timestamp > other).to be(false)
+        expect(timestamp >= other).to be(false)
+        expect(timestamp <= other).to be(true)
+      end
+    end
+
+    context "when the first object is greater than the second" do
+
+      let(:other) { described_class.new(1, 5) }
+
+      it "returns 1" do
+        expect(timestamp <=> other).to be(1)
+        expect(timestamp < other).to be(false)
+        expect(timestamp > other).to be(true)
+        expect(timestamp >= other).to be(true)
+        expect(timestamp <= other).to be(false)
+      end
+    end
+
+    context "when the other object is not a timestamp" do
+
+      it "raises an ArgumentError" do
+        expect {
+          timestamp < 1
+        }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
   describe "#as_json" do
 
     let(:object) do
@@ -55,7 +111,7 @@ describe BSON::Timestamp do
     end
 
     it "returns the binary data plus type" do
-      expect(object.as_json).to eq({ "t" => 10, "i" => 50 })
+      expect(object.as_json).to eq({"$timestamp" => { "t" => 10, "i" => 50 } })
     end
 
     it_behaves_like "a JSON serializable object"

data/spec/bson/true_class_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.
@@ -25,4 +26,11 @@ describe TrueClass do
     it_behaves_like "a bson element"
     it_behaves_like "a serializable bson element"
   end
+
+  describe '#as_extended_json' do
+    let(:object) { true }
+
+    it_behaves_like '#as_extended_json returns self'
+    it_behaves_like 'an Extended JSON serializable object'
+  end
 end