bson 4.13.0 → 4.15.0

data/spec/bson/dbref_legacy_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+require 'json'
+
+# These tests are copied from driver when the driver implemented Mongo:DBRef
+# class, and are intended to verify that the current DBRef implementation is
+# compatible with the legacy driver DBRef interface.
+
+describe BSON::DBRef do
+
+  let(:object_id) do
+    BSON::ObjectId.new
+  end
+
+  describe '#as_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.as_json).to eq({ '$ref' => 'users', '$id' => object_id })
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.as_json).to eq({
+          '$ref' => 'users',
+          '$id' => object_id,
+          '$db' => 'database'
+        })
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:dbref) do
+      described_class.new('users', object_id)
+    end
+
+    it 'sets the collection' do
+      expect(dbref.collection).to eq('users')
+    end
+
+    it 'sets the id' do
+      expect(dbref.id).to eq(object_id)
+    end
+
+    context 'when a database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'db')
+      end
+
+      it 'sets the database' do
+        expect(dbref.database).to eq('db')
+      end
+
+      context 'when id is not provided' do
+
+        let(:dbref) do
+          described_class.new('users', nil, 'db')
+        end
+
+        it 'raises ArgumentError' do
+          lambda do
+            dbref
+          end.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+
+  describe '#to_bson' do
+
+    let(:dbref) do
+      described_class.new('users', object_id, 'database')
+    end
+
+    it 'converts the underlying document to bson' do
+      expect(dbref.to_bson.to_s).to eq(dbref.as_json.to_bson.to_s)
+    end
+  end
+
+  describe '#to_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json}}")
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json},\"$db\":\"database\"}")
+      end
+    end
+  end
+
+  describe '#from_bson' do
+
+    let(:buffer) do
+      dbref.to_bson
+    end
+
+    let(:decoded) do
+      BSON::Document.from_bson(BSON::ByteBuffer.new(buffer.to_s))
+    end
+
+    context 'when a database exists' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'decodes the database' do
+        expect(decoded.database).to eq('database')
+      end
+    end
+
+    context 'when no database exists' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'sets the database to nil' do
+        expect(decoded.database).to be_nil
+      end
+    end
+  end
+end

data/spec/bson/dbref_spec.rb

@@ -73,6 +73,32 @@ describe BSON::DBRef do
       expect(dbref.id).to eq(object_id)
     end
 
+    context 'when first argument is a hash and two arguments are provided' do
+
+      let(:dbref) do
+        described_class.new({:$ref => 'users', :$id => object_id}, object_id)
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          dbref
+        end.should raise_error(ArgumentError)
+      end
+    end
+
+    context 'when first argument is a hash and three arguments are provided' do
+
+      let(:dbref) do
+        described_class.new({:$ref => 'users', :$id => object_id}, object_id, 'db')
+      end
+
+      it 'raises ArgumentError' do
+        lambda do
+          dbref
+        end.should raise_error(ArgumentError)
+      end
+    end
+
     context 'when a database is provided' do
 
       let(:hash) do

data/spec/bson/decimal128_spec.rb

@@ -309,6 +309,22 @@ describe BSON::Decimal128 do
         it_behaves_like 'an initialized BSON::Decimal128'
       end
     end
+
+    context 'when range is exceeded' do
+      it 'raises InvalidRange' do
+        lambda do
+          described_class.new('1e10000')
+        end.should raise_error(BSON::Decimal128::InvalidRange, /Value out of range/)
+      end
+    end
+
+    context 'when precision is exceeded' do
+      it 'raises UnrepresentablePrecision' do
+        lambda do
+          described_class.new('1.000000000000000000000000000000000000000000000000001')
+        end.should raise_error(BSON::Decimal128::UnrepresentablePrecision, /The value contains too much precision/)
+      end
+    end
   end
 
   context 'when deserializing' do
@@ -1586,4 +1602,219 @@ describe BSON::Decimal128 do
       expect(registered).to eq(described_class)
     end
   end
+
+  %w(== ===).each do |eq_op|
+    let(:lhs) { described_class.new('1.2e12') }
+
+    describe "##{eq_op}" do
+      context 'when rhs is equal to lhs' do
+        context 'when both are Decimal128 instances' do
+          let(:rhs) { described_class.new('1.2e12') }
+
+          it 'is true' do
+            (lhs == rhs).should be true
+          end
+        end
+
+        context 'when rhs is of a different type' do
+          [
+            1200000000000,
+            1200000000000.0,
+            BigDecimal('1.2e12'),
+          ].each do |rhs|
+            context "when rhs is #{rhs.class}" do
+              it 'is true' do
+                pending 'RUBY-2952'
+
+                (lhs == rhs).should be true
+              end
+            end
+          end
+        end
+      end
+
+      context 'when rhs is not equal to lhs' do
+        context 'when both are Decimal128 instances' do
+          let(:rhs) { described_class.new('1.21e12') }
+
+          it 'is false' do
+            (lhs == rhs).should be false
+          end
+        end
+
+        context 'when rhs is of a different type' do
+
+          [
+            1200000000001,
+            1200000000001.0,
+            BigDecimal('1.21e12'),
+          ].each do |rhs|
+            context "when rhs is #{rhs.class}" do
+              it 'is false' do
+                (lhs == rhs).should be false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#<=>" do
+
+    let(:lhs) { described_class.new('1.2e12') }
+
+    context 'when lhs is less than rhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.21e12') }
+
+        it 'is -1' do
+          (lhs <=> rhs).should be -1
+        end
+      end
+
+      context 'when rhs is of a different type' do
+        [
+          1200000000001,
+          1200000000001.0,
+          BigDecimal('1.21e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is -1' do
+              (lhs <=> rhs).should be -1
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is equal to lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.2e12') }
+
+        it 'is 0' do
+          (lhs <=> rhs).should be 0
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1200000000000,
+          1200000000000.0,
+          BigDecimal('1.2e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is 0' do
+              (lhs <=> rhs).should be 0
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is greater than lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.1e12') }
+
+        it 'is 1' do
+          (lhs <=> rhs).should be 1
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1100000000000,
+          1100000000000.0,
+          BigDecimal('1.1e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is 1' do
+              (lhs <=> rhs).should be 1
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#<" do
+
+    let(:lhs) { described_class.new('1.2e12') }
+
+    context 'when lhs is less than rhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.21e12') }
+
+        it 'is true' do
+          (lhs < rhs).should be true
+        end
+      end
+
+      context 'when rhs is of a different type' do
+        [
+          1200000000001,
+          1200000000001.0,
+          BigDecimal('1.21e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is true' do
+              (lhs < rhs).should be true
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is equal to lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.2e12') }
+
+        it 'is false' do
+          (lhs < rhs).should be false
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1200000000000,
+          1200000000000.0,
+          BigDecimal('1.2e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is false' do
+              (lhs < rhs).should be false
+            end
+          end
+        end
+      end
+    end
+
+    context 'when rhs is greater than lhs' do
+      context 'when both are Decimal128 instances' do
+        let(:rhs) { described_class.new('1.1e12') }
+
+        it 'is false' do
+          (lhs < rhs).should be false
+        end
+      end
+
+      context 'when rhs is of a different type' do
+
+        [
+          1100000000000,
+          1100000000000.0,
+          BigDecimal('1.1e12'),
+        ].each do |rhs|
+          context "when rhs is #{rhs.class}" do
+            it 'is false' do
+              (lhs < rhs).should be false
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/bson/hash_spec.rb

@@ -254,6 +254,26 @@ describe Hash do
         expect(Hash.from_bson(buffer)).to eq('foo' => 42)
       end
     end
+
+    context 'when round-tripping a BigDecimal' do
+      let(:to_bson) do
+        {"x" => BigDecimal('1')}.to_bson
+      end
+
+      let(:from_bson) do
+        Hash.from_bson(to_bson)
+      end
+
+      it 'doesn\'t raise on serialization' do
+        expect do
+          to_bson
+        end.to_not raise_error
+      end
+
+      it 'deserializes as a BSON::Decimal128' do
+        expect(from_bson).to eq({"x" => BSON::Decimal128.new('1')})
+      end
+    end
   end
 
   describe '#to_bson' do
@@ -319,6 +339,18 @@ describe Hash do
         end.not_to raise_error
       end
     end
+
+    context 'when serializing a hash with a BigDecimal' do
+      let(:hash) do
+        {'foo' => BigDecimal('1')}
+      end
+
+      it 'works' do
+        expect do
+          hash.to_bson
+        end.not_to raise_error
+      end
+    end
   end
 
   describe '#from_bson' do

data/spec/shared/bin/s3-copy

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'aws-sdk-s3'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: s3-copy options"
+
+  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
+    options[:region] = v
+  end
+
+  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for new files") do |v|
+    options[:params] ||= {}
+    k, v = v.split('=', 2)
+    options[:params][k.to_sym] = v
+  end
+
+  opts.on("-f", "--from=BUCKET:PATH", "Bucket name and key (or path) to copy from") do |v|
+    options[:from] = v
+  end
+
+  opts.on("-t", "--to=BUCKET:PATH", "Bucket name and key (or path) to write to (may be specified more than once)") do |v|
+    options[:to] ||= []
+    options[:to] << v
+  end
+end.parse!
+
+ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
+
+bucket, key = options.fetch(:from).split(':', 2)
+
+s3 = Aws::S3::Client.new
+
+options.fetch(:to).each do |dest|
+  STDERR.puts "Copying to #{dest}"
+  dbucket, dkey = dest.split(':', 2)
+  s3.copy_object(
+    bucket: dbucket,
+    key: dkey,
+    copy_source: "/#{bucket}/#{key}",
+    **options[:params] || {},
+  )
+end

data/spec/shared/bin/s3-upload

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'aws-sdk-s3'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: s3-upload options"
+
+  opts.on("-r", "--region=REGION", "AWS region to use (default us-east-1)") do |v|
+    options[:region] = v
+  end
+
+  opts.on("-p", "--param=KEY=VALUE", "Specify parameter for S3 upload") do |v|
+    options[:params] ||= {}
+    k, v = v.split('=', 2)
+    options[:params][k.to_sym] = v
+  end
+
+  opts.on("-f", "--file=PATH", "Path to the file to upload, - to upload standard input") do |v|
+    options[:file] = v
+  end
+
+  opts.on("-w", "--write=BUCKET:PATH", "Bucket name and key (or path) to upload to") do |v|
+    options[:write] = v
+  end
+
+  opts.on("-c", "--copy=BUCKET:PATH", "Bucket name and key (or path) to copy to (may be specified more than once)") do |v|
+    options[:copy] ||= []
+    options[:copy] << v
+  end
+end.parse!
+
+ENV['AWS_REGION'] ||= options[:region] || 'us-east-1'
+
+def upload(f, options)
+  s3 = Aws::S3::Client.new
+  write = options.fetch(:write)
+  STDERR.puts "Writing #{write}"
+  bucket, key = write.split(':', 2)
+  s3.put_object(
+    body: f.read,
+    bucket: bucket,
+    key: key,
+    **options[:params] || {},
+  )
+  if copy = options[:copy]
+    copy.each do |dest|
+      STDERR.puts "Copying to #{dest}"
+      dbucket, dkey = dest.split(':', 2)
+      s3.copy_object(
+        bucket: dbucket,
+        key: dkey,
+        copy_source: "/#{bucket}/#{key}",
+        **options[:params] || {},
+      )
+    end
+  end
+end
+
+if options[:file] == '-'
+  upload(STDIN, options)
+elsif options[:file]
+  File.open(options[:file]) do |f|
+    upload(f, options)
+  end
+else
+  upload(STDIN, options)
+end

data/spec/shared/lib/mrss/cluster_config.rb

@@ -15,6 +15,11 @@ module Mrss
       @single_server
     end
 
+    def sharded_ish?
+      determine_cluster_config
+      @topology == :sharded || @topology == :load_balanced
+    end
+
     def replica_set_name
       determine_cluster_config
       @replica_set_name
@@ -48,7 +53,7 @@ module Mrss
         raise "Deployment server version not known - check that connection to deployment succeeded"
       end
 
-      if server_version >= '3.4' && topology != :sharded
+      if server_version >= '3.4' && !sharded_ish?
         fcv
       else
         if short_server_version == '4.1'
@@ -115,7 +120,7 @@ module Mrss
           :mmapv1
         else
           client = ClientRegistry.instance.global_client('root_authorized')
-          if topology == :sharded
+          if sharded_ish?
             shards = client.use(:admin).command(listShards: 1).first
             if shards['shards'].empty?
               raise 'Shards are empty'
@@ -204,9 +209,14 @@ module Mrss
       @server_version = build_info['version']
       @enterprise = build_info['modules'] && build_info['modules'].include?('enterprise')
 
-      @server_parameters = client.use(:admin).command(getParameter: '*').first
+      @server_parameters = begin
+        client.use(:admin).command(getParameter: '*').first
+      rescue => e
+        STDERR.puts("WARNING: Failed to obtain server parameters: #{e.class}: #{e.message}")
+        {}
+      end
 
-      if @topology != :sharded && short_server_version >= '3.4'
+      if !sharded_ish? && short_server_version >= '3.4'
         rv = @server_parameters['featureCompatibilityVersion']
         @fcv = rv['version'] || rv
       end