bson 4.1.1 → 5.2.0

data/spec/runners/corpus_legacy.rb

@@ -0,0 +1,248 @@
+# rubocop:todo all
+# Copyright (C) 2016-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 'json'
+
+module BSON
+  module CorpusLegacy
+
+    # Represents a test from the driver BSON Corpus.
+    class Spec
+
+      # The spec description.
+      #
+      # @return [ String ] The spec description.
+      attr_reader :description
+
+      # The document key of the object to test.
+      #
+      # @return [ String ] The document key.
+      attr_reader :test_key
+
+      # Instantiate the new spec.
+      #
+      # @example Create the spec.
+      #   Spec.new(file)
+      #
+      # @param [ String ] file The name of the json file.
+      def initialize(file)
+        @spec = ::JSON.parse(File.read(file))
+        @valid = @spec['valid'] || []
+        @invalid = @spec['decodeErrors'] || []
+        @description = @spec['description']
+        @test_key = @spec['test_key']
+      end
+
+      # Get a list of tests that are expected to pass.
+      #
+      # @example Get the list of valid tests.
+      #   spec.valid_tests
+      #
+      # @return [ Array<BSON::CorpusLegacy::Test> ] The list of valid Tests.
+      def valid_tests
+        @valid_tests ||=
+          @valid.collect do |test|
+            BSON::CorpusLegacy::Test.new(self, test)
+          end
+      end
+
+      # Get a list of tests that raise exceptions.
+      #
+      # @example Get the list of invalid tests.
+      #   spec.invalid_tests
+      #
+      # @return [ Array<BSON::CorpusLegacy::Test> ] The list of invalid Tests.
+      def invalid_tests
+        @invalid_tests ||=
+          @invalid.collect do |test|
+            BSON::CorpusLegacy::Test.new(self, test)
+          end
+      end
+
+      # The class of the bson object to test.
+      #
+      # @example Get the class of the object to test.
+      #   spec.klass
+      #
+      # @return [ Class ] The object class.
+      def klass
+        @klass ||= BSON.const_get(description)
+      end
+    end
+
+    # Represents a single BSON Corpus test.
+    class Test
+
+      # The test description.
+      #
+      # @return [ String ] The test description.
+      attr_reader :description
+
+      # Name of a field in a valid test case extjson document that should be
+      #   checked against the case's string field.
+      #
+      # @return [ String ] The json representation of the object.
+      attr_reader :test_key
+
+      # Instantiate the new Test.
+      #
+      # @example Create the test.
+      #   Test.new(test)
+      #
+      # @param [ Corpus::Spec ] spec The test specification.
+      # @param [ Hash ] test The test specification.
+      def initialize(spec, test)
+        @spec = spec
+        @description = test['description']
+        @canonical_bson = test['canonical_bson']
+        @extjson = ::JSON.parse(test['extjson']) if test['extjson']
+        @bson = test['bson']
+        @test_key = spec.test_key
+      end
+
+      # The correct representation of the subject as bson.
+      #
+      # @example Get the correct representation of the subject as bson.
+      #   test.correct_bson
+      #
+      # @return [ String ] The correct bson bytes.
+      def correct_bson
+        @correct_bson ||= decode_hex(@canonical_bson || @bson)
+      end
+
+      # Create a BSON::Document object from the test's bson representation
+      #
+      # @return [ BSON::Document ] The BSON::Document object
+      def document_from_bson
+        bson_bytes = decode_hex(@bson)
+        buffer = BSON::ByteBuffer.new(bson_bytes)
+        BSON::Document.from_bson(buffer)
+      end
+
+      # Create a BSON::Document object from the test's canonical bson
+      # representation
+      #
+      # @return [ BSON::Document ] The BSON::Document object
+      def document_from_canonical_bson
+        bson_bytes = decode_hex(@canonical_bson)
+        buffer = BSON::ByteBuffer.new(bson_bytes)
+        BSON::Document.from_bson(buffer)
+      end
+
+      # Given the hex representation of bson, decode it into a Document,
+      #   then reencoded it to bson.
+      #
+      # @example Decoded the bson hex representation, then reencode.
+      #   test.reencoded_bson
+      #
+      # @return [ String ] The reencoded bson bytes.
+      def reencoded_bson
+        document_from_bson.to_bson.to_s
+      end
+
+      # Given the hex representation of the canonical bson, decode it into a Document,
+      #   then reencoded it to bson.
+      #
+      # @example Decoded the canonical bson hex representation, then reencode.
+      #   test.reencoded_canonical_bson
+      #
+      # @return [ String ] The reencoded canonical bson bytes.
+      def reencoded_canonical_bson
+        document_from_canonical_bson.to_bson.to_s
+      end
+
+      # Whether the canonical bson should be tested.
+      #
+      # @example Determine if the canonical bson should be tested.
+      #   test.test_canonical_bson?
+      #
+      # @return [ true, false ] Whether the canonical bson should be tested.
+      def test_canonical_bson?
+        @canonical_bson && (@bson != @canonical_bson)
+      end
+
+      # The correct representation of the subject as extended json.
+      #
+      # @example Get the correct representation of the subject as extended json.
+      #   test.correct_extjson
+      #
+      # @return [ String ] The correct extended json representation.
+      def correct_extjson
+        @canonical_extjson || @extjson
+      end
+
+      # Whether the extended json should be tested.
+      #
+      # @example Determine if the extended json should be tested.
+      #   test.test_extjson?
+      #
+      # @return [ true, false ] Whether the extended json should be tested.
+      def test_extjson?
+        !!@extjson
+      end
+
+      # Get the extended json representation of the decoded doc from the provided
+      #   bson hex representation.
+      #
+      # @example Get the extended json representation of the decoded doc.
+      #   test.extjson_from_encoded_bson
+      #
+      # @return [ Hash ] The extended json representation.
+      def extjson_from_bson
+        as_legacy_extended_json(document_from_bson)
+      end
+
+      # Get the extended json representation of the decoded doc from the provided
+      #   canonical bson hex representation.
+      #
+      # @example Get the extended json representation of the canonical decoded doc.
+      #   test.extjson_from_canonical_bson
+      #
+      # @return [ Hash ] The extended json representation.
+      def extjson_from_canonical_bson
+        as_legacy_extended_json(document_from_canonical_bson)
+      end
+
+      # Get the extended json representation of the decoded doc from the provided
+      #   extended json representation. (Verifies roundtrip)
+      #
+      # @example Get the extended json representation of the canonical decoded doc.
+      #   test.extjson_from_encoded_extjson
+      #
+      # @return [ Hash ] The extended json representation.
+      def extjson_from_encoded_extjson
+        doc = BSON::Document.new(@extjson)
+        as_legacy_extended_json(doc)
+      end
+
+      private
+
+      def as_legacy_extended_json(object)
+        result = object.as_extended_json(mode: :legacy)
+        if object.respond_to?(:as_json)
+          old_result = object.as_json
+          unless result == old_result
+            raise "Serializing #{object} to legacy extended json did not match between new and old APIs"
+          end
+        end
+        result
+      end
+
+      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