bson 5.0.1-java → 5.1.1-java

data/lib/bson.rb

@@ -95,6 +95,7 @@ require "bson/time"
 require "bson/timestamp"
 require "bson/true_class"
 require "bson/undefined"
+require "bson/vector"
 require "bson/version"
 
 # If we are using JRuby, attempt to load the Java extensions, if we are using

data/spec/bson/binary_spec.rb

@@ -20,17 +20,56 @@ describe BSON::Binary do
   let(:testing1)  { described_class.new("testing") }
   let(:testing2)  { described_class.new("testing") }
   let(:not_testing) { described_class.new("not testing") }
+  let(:testing3) { described_class.new("testing", :user) }
 
-  describe "#eql?" do
-    context "for two equal objects" do
-      it "returns true" do
-        expect(testing1).to eql(testing2)
+  describe "Comparable" do
+    describe "#eql?" do
+      context "for two equal objects" do
+        it "returns true" do
+          expect(testing1).to eql(testing2)
+        end
+      end
+
+      context "for two different objects" do
+        it "returns false" do
+          expect(testing1).not_to eql(not_testing)
+        end
+      end
+
+      context 'for objects with identical data but different types' do
+        it 'returns false' do
+          expect(testing1).not_to eql(testing3)
+        end
       end
     end
 
-    context "for two different objects" do
-      it "returns false" do
-        expect(testing1).not_to eql(not_testing)
+    describe '#<=>' do
+      context 'with a non-Binary object' do
+        it 'returns nil' do
+          expect(testing1 <=> 'bogus').to be_nil
+        end
+      end
+
+      context 'with identical type and data' do
+        it 'returns 0' do
+          expect(testing1 <=> testing2).to be == 0
+        end
+      end
+
+      context 'with mismatched type' do
+        it 'returns nil' do
+          expect(testing1 <=> testing3).to be_nil
+        end
+      end
+
+      context 'with identical type but mismatched data' do
+        it 'returns -1 when a < b' do
+          expect(not_testing <=> testing1).to be == -1
+        end
+
+        it 'returns 1 when a > b' do
+          expect(testing1 <=> not_testing).to be == 1
+        end
       end
     end
   end

data/spec/bson/document_as_spec.rb

@@ -44,4 +44,18 @@ describe BSON::Document do
       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/vector_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025-present 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::Vector do
+  it 'behaves like an Array' do
+    expect(described_class.new([ 1, 2, 3 ], :int8)).to be_a(Array)
+  end
+
+  describe '#initialize' do
+    context 'when padding is not provided' do
+      let(:vector) { described_class.new([ 1, 2, 3 ], :int8) }
+
+      it 'sets the padding to 0' do
+        expect(vector.padding).to eq(0)
+      end
+    end
+  end
+end

data/spec/runners/binary_vector.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'runners/common_driver'
+
+module BSON
+  module BinaryVector
+    class Spec < CommonDriver::Spec
+      def initialize(file)
+        super
+        @valid = @invalid = nil
+      end
+
+      def tests
+        @spec['tests'].collect do |test|
+          BSON::BinaryVector::Test.new(self, test)
+        end
+      end
+
+      def valid_tests
+        tests.select(&:valid?)
+      end
+
+      def invalid_tests
+        tests.reject(&:valid?)
+      end
+    end
+
+    class Test
+      attr_reader :canonical_bson, :description, :dtype, :padding, :vector
+
+      def initialize(spec, test)
+        @spec = spec
+        @description = test['description']
+        @valid = test['valid']
+        @vector = ExtJSON.parse_obj(test['vector'])
+        @dtype_hex = test['dtype_hex']
+        @dtype_alias = test['dtype_alias']
+        @dtype = @dtype_alias.downcase.to_sym
+        @padding = test['padding']
+        @canonical_bson = test['canonical_bson']
+      end
+
+      def valid?
+        @valid
+      end
+
+      def document_from_canonical_bson
+        bson_bytes = decode_hex(@canonical_bson)
+        buffer = BSON::ByteBuffer.new(bson_bytes)
+        BSON::Document.from_bson(buffer)
+      end
+
+      def canonical_bson_from_document(use_vector_type: false, validate_vector_data: false)
+        args = if use_vector_type
+                 [ BSON::Vector.new(@vector, @dtype, @padding) ]
+               else
+                 [ @vector, @dtype, @padding ]
+               end
+        {
+          @spec.test_key => BSON::Binary.from_vector(
+            *args,
+            validate_vector_data: validate_vector_data
+          ),
+        }.to_bson.to_s
+      end
+
+      def bson
+        decode_hex(@canonical_bson)
+      end
+
+      private
+
+      def decode_hex(obj)
+        [ obj ].pack('H*')
+      end
+    end
+  end
+end

data/spec/shared/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 MongoDB, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/shared/bin/get-mongodb-download-url

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+desired_version, arch = ARGV
+if arch.nil?
+  STDERR.puts "Usage: get-mongodb-download-url desired-version arch"
+  exit 1
+end
+
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'mrss/server_version_registry'
+
+begin
+  puts Mrss::ServerVersionRegistry.new(desired_version, arch).download_url
+rescue Mrss::ServerVersionRegistry::Error => exc
+  STDERR.puts "Error: #{exc}"
+  exit 2
+end

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/child_process_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+autoload :ChildProcess, 'childprocess'
+autoload :Tempfile, 'tempfile'
+
+module Mrss
+  module ChildProcessHelper
+    class SpawnError < StandardError; end
+
+    module_function def call(cmd, env: nil, cwd: nil)
+      process = ChildProcess.new(*cmd)
+      process.io.inherit!
+      if cwd
+        process.cwd = cwd
+      end
+      if env
+        env.each do |k, v|
+          process.environment[k.to_s] = v
+        end
+      end
+      process.start
+      process.wait
+      process
+    end
+
+    module_function def check_call(cmd, env: nil, cwd: nil)
+      process = call(cmd, env: env, cwd: cwd)
+      unless process.exit_code == 0
+        raise SpawnError, "Failed to execute: #{cmd}"
+      end
+    end
+
+    module_function def get_output(cmd, env: nil, cwd: nil)
+      process = ChildProcess.new(*cmd)
+      process.io.inherit!
+      if cwd
+        process.cwd = cwd
+      end
+      if env
+        env.each do |k, v|
+          process.environment[k.to_s] = v
+        end
+      end
+
+      output = ''
+      r, w = IO.pipe
+
+      begin
+        process.io.stdout = w
+        process.start
+        w.close
+
+        thread = Thread.new do
+          begin
+            loop do
+              output << r.readpartial(16384)
+            end
+          rescue EOFError
+          end
+        end
+
+        process.wait
+        thread.join
+      ensure
+        r.close
+      end
+
+      [process, output]
+    end
+
+    module_function def check_output(*args)
+      process, output = get_output(*args)
+      unless process.exit_code == 0
+        raise SpawnError,"Failed to execute: #{args}"
+      end
+      output
+    end
+  end
+end

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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# ClusterConfig requires ClientRegistry class provided by the host project.
+
+require 'singleton'
+
+module Mrss
+  class ClusterConfig
+    include Singleton
+    include RSpec::Core::Pending
+
+    def single_server?
+      determine_cluster_config
+      @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
+    end
+
+    def server_version
+      determine_cluster_config
+      @server_version
+    end
+
+    def enterprise?
+      determine_cluster_config
+      @enterprise
+    end
+
+    def short_server_version
+      server_version.split('.')[0..1].join('.')
+    end
+
+    def fcv
+      determine_cluster_config
+      @fcv
+    end
+
+    # Per https://jira.mongodb.org/browse/SERVER-39052, working with FCV
+    # in sharded topologies is annoying. Also, FCV doesn't exist in servers
+    # less than 3.4. This method returns FCV on 3.4+ servers when in single
+    # or RS topologies, and otherwise returns the major.minor server version.
+    def fcv_ish
+      if server_version.nil?
+        raise "Deployment server version not known - check that connection to deployment succeeded"
+      end
+
+      if server_version >= '3.4' && !sharded_ish?
+        fcv
+      else
+        if short_server_version == '4.1'
+          '4.2'
+        else
+          short_server_version
+        end
+      end
+    end
+
+    # @return [ Mongo::Address ] The address of the primary in the deployment.
+    def primary_address
+      determine_cluster_config
+      @primary_address
+    end
+
+    def primary_address_str
+      determine_cluster_config
+      @primary_address.seed
+    end
+
+    def primary_address_host
+      both = primary_address_str
+      both.split(':').first
+    end
+
+    def primary_address_port
+      both = primary_address_str
+      both.split(':')[1] || 27017
+    end
+
+    def primary_description
+      determine_cluster_config
+      @primary_description
+    end
+
+    def server_parameters
+      determine_cluster_config
+      @server_parameters
+    end
+
+    # Try running a command on the admin database to see if the mongod was
+    # started with auth.
+    def auth_enabled?
+      if @auth_enabled.nil?
+        @auth_enabled = begin
+          basic_client.use(:admin).command(getCmdLineOpts: 1).first["argv"].include?("--auth")
+        rescue => e
+          e.message =~ /(not authorized)|(unauthorized)|(no users authenticated)|(requires authentication)/
+        end
+      end
+      @auth_enabled
+    end
+
+    def topology
+      determine_cluster_config
+      @topology
+    end
+
+    def storage_engine
+      @storage_engine ||= begin
+        # 2.6 does not have wired tiger
+        if short_server_version == '2.6'
+          :mmapv1
+        else
+          client = ClientRegistry.instance.global_client('root_authorized')
+          if sharded_ish?
+            shards = client.use(:admin).command(listShards: 1).first
+            if shards['shards'].empty?
+              raise 'Shards are empty'
+            end
+            shard = shards['shards'].first
+            address_str = shard['host'].sub(/^.*\//, '').sub(/,.*/, '')
+            client = ClusterTools.instance.direct_client(address_str,
+              SpecConfig.instance.test_options.merge(SpecConfig.instance.auth_options).merge(connect: :direct))
+          end
+          rv = client.use(:admin).command(serverStatus: 1).first
+          rv = rv['storageEngine']['name']
+          rv_map = {
+            'wiredTiger' => :wired_tiger,
+            'mmapv1' => :mmapv1,
+          }
+          rv_map[rv] || rv
+        end
+      end
+    end
+
+    # This method returns an alternate address for connecting to the configured
+    # deployment. For example, if the replica set is configured with nodes at
+    # of localhost:27017 and so on, this method will return 127.0.0.:27017.
+    #
+    # Note that the "alternate" refers to replica set configuration, not the
+    # addresses specified in test suite configuration. If the deployment topology
+    # is not a replica set, "alternate" refers to test suite configuration as
+    # this is the only configuration available.
+    def alternate_address
+      @alternate_address ||= begin
+        address = primary_address_host
+        str = case address
+        when '127.0.0.1'
+          'localhost'
+        when /^(\d+\.){3}\d+$/
+          skip 'This test requires a hostname or 127.0.0.1 as address'
+        else
+          # We don't know if mongod is listening on ipv4 or ipv6, in principle.
+          # Our tests use ipv4, so hardcode that for now.
+          # To support both we need to try both addresses which will make this
+          # test more complicated.
+          #
+          # JRuby chokes on primary_address_port as the port (e.g. 27017).
+          # Since the port does not actually matter, use a common port like 80.
+          resolved_address = Addrinfo.getaddrinfo(address, 80, Socket::PF_INET).first.ip_address
+          if resolved_address.include?(':')
+            "[#{resolved_address}]"
+          else
+            resolved_address
+          end
+        end + ":#{primary_address_port}"
+        Mongo::Address.new(str)
+      end
+    end
+
+    private
+
+    def determine_cluster_config
+      return if @primary_address
+
+      # Run all commands to figure out the cluster configuration from the same
+      # client. This is somewhat wasteful when running a single test, but reduces
+      # test runtime for the suite overall because all commands are sent on the
+      # same connection rather than each command connecting to the cluster by
+      # itself.
+      client = ClientRegistry.instance.global_client('root_authorized')
+
+      primary = client.cluster.next_primary
+      @primary_address = primary.address
+      @primary_description = primary.description
+      @replica_set_name = client.cluster.topology.replica_set_name
+
+      @topology ||= begin
+        topology = client.cluster.topology.class.name.sub(/.*::/, '')
+        topology = topology.gsub(/([A-Z])/) { |match| '_' + match.downcase }.sub(/^_/, '')
+        if topology =~ /^replica_set/
+          topology = 'replica_set'
+        end
+        topology.to_sym
+      end
+
+      @single_server = client.cluster.servers_list.length == 1
+
+      build_info = client.database.command(buildInfo: 1).first
+
+      @server_version = build_info['version']
+      @enterprise = build_info['modules'] && build_info['modules'].include?('enterprise')
+
+      @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 !sharded_ish? && short_server_version >= '3.4'
+        rv = @server_parameters['featureCompatibilityVersion']
+        @fcv = rv['version'] || rv
+      end
+    end
+
+    def basic_client
+      # Do not cache the result here so that if the client gets closed,
+      # client registry reconnects it in subsequent tests
+      ClientRegistry.instance.global_client('basic')
+    end
+  end
+end