mongo 2.14.0 → 2.15.1

data/spec/runners/unified/event_subscriber.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'support/event_subscriber'
+
+module Unified
+
+  class EventSubscriber < ::EventSubscriber
+    def ignore_commands(command_names)
+      @ignore_commands = command_names
+    end
+
+    def wanted_events(observe_sensitive = false)
+      events = all_events.select do |event|
+        kind = event.class.name.sub(/.*::/, '').sub('Command', '').gsub(/([A-Z])/) { "_#{$1}" }.sub(/^_/, '').downcase.to_sym
+        @wanted_events[kind]
+      end.select do |event|
+        if event.respond_to?(:command_name)
+          event.command_name != 'configureFailPoint' &&
+            if @ignore_commands
+              !@ignore_commands.include?(event.command_name)
+            else
+              true
+            end
+        else
+          true
+        end
+      end
+      if observe_sensitive
+        events
+      else
+        events.reject do |event|
+          event.respond_to?(:command_name) &&
+            %w(authenticate getnonce saslStart saslContinue).include?(event.command_name)
+        end
+      end
+    end
+
+    def add_wanted_events(kind)
+      @wanted_events ||= {}
+      @wanted_events[kind] = true
+    end
+  end
+
+  class StoringEventSubscriber
+    def initialize(&block)
+      @handler = block
+    end
+
+    def started(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'databaseName' => event.database_name,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+        'connectionId' => event.connection_id,
+      )
+    end
+
+    def succeeded(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'duration' => event.duration,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+      )
+    end
+
+    def failed(event)
+      @handler.call(
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'commandName' => event.command_name,
+        'duration' => event.duration,
+        'failure' => event.failure,
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+        'requestId' => event.request_id,
+        'operationId' => event.operation_id,
+      )
+    end
+
+    def published(event)
+      payload = {
+        'name' => event.class.name.sub(/.*::/, '') + 'Event',
+        'observedAt' => Time.now.to_f,
+        'address' => event.address.seed,
+      }.tap do |entry|
+        if event.respond_to?(:connection_id)
+          entry['connectionId'] = event.connection_id
+        end
+        if event.respond_to?(:reason)
+          entry['reason'] = event.reason
+        end
+      end
+      @handler.call(payload)
+    end
+  end
+end

data/spec/runners/unified/exceptions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Unified
+
+  class Error < StandardError
+  end
+
+  class ResultMismatch < Error
+  end
+
+  class ErrorMismatch < Error
+  end
+
+  class EntityMapOverwriteAttempt < Error
+  end
+
+  class EntityMissing < Error
+  end
+
+  class InvalidTest < Error
+  end
+
+end

data/spec/runners/unified/grid_fs_operations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Unified
+
+  module GridFsOperations
+
+    def delete(op)
+      bucket = entities.get(:bucket, op.use!('object'))
+      use_arguments(op) do |args|
+        bucket.delete(args.use!('id'))
+      end
+    end
+
+    def download(op)
+      bucket = entities.get(:bucket, op.use!('object'))
+      use_arguments(op) do |args|
+        stream = bucket.open_download_stream(args.use!('id'))
+        stream.read
+      end
+    end
+
+    def upload(op)
+      bucket = entities.get(:bucket, op.use!('object'))
+      use_arguments(op) do |args|
+        opts = {}
+        if chunk_size = args.use('chunkSizeBytes')
+          opts[:chunk_size] = chunk_size
+        end
+        contents = transform_contents(args.use!('source'))
+        file_id = nil
+        bucket.open_upload_stream(args.use!('filename'), **opts) do |stream|
+          stream.write(contents)
+          file_id = stream.file_id
+        end
+        file_id
+      end
+    end
+
+    private
+
+    def transform_contents(contents)
+      if Hash === contents
+        if contents.length != 1
+          raise NotImplementedError, "Wanted hash with one element"
+        end
+        if contents.keys.first != '$$hexBytes'
+          raise NotImplementedError, "$$hexBytes is the only key supported"
+        end
+
+        decode_hex_bytes(contents.values.first)
+      else
+        contents
+      end
+    end
+
+  end
+end

data/spec/runners/unified/support_operations.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module Unified
+
+  module SupportOperations
+
+    def run_command(op)
+      database = entities.get(:database, op.use!('object'))
+
+      use_arguments(op) do |args|
+        args.use!('commandName')
+
+        cmd = args.use!('command')
+
+        database.command(cmd)
+      end
+    end
+
+    def fail_point(op)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        client = entities.get(:client, args.use!('client'))
+        client.command(args.use('failPoint'))
+      end
+    end
+
+    def targeted_fail_point(op)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        session = args.use!('session')
+        session = entities.get(:session, session)
+        unless session.pinned_server
+          raise ArgumentError, 'Targeted fail point requires session to be pinned to a server'
+        end
+
+        client = ClusterTools.instance.direct_client(session.pinned_server.address,
+          database: 'admin')
+        client.command(fp = args.use!('failPoint'))
+        args.clear
+
+        $disable_fail_points ||= []
+        $disable_fail_points << [
+          fp,
+          session.pinned_server.address,
+        ]
+      end
+    end
+
+    def end_session(op)
+      session = entities.get(:session, op.use!('object'))
+      session.end_session
+    end
+
+    def assert_session_dirty(op)
+      consume_test_runner(op)
+      # https://jira.mongodb.org/browse/RUBY-1813
+      true
+    end
+
+    def assert_session_not_dirty(op)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        session = entities.get(:session, args.use!('session'))
+        # https://jira.mongodb.org/browse/RUBY-1813
+        true
+      end
+    end
+
+    def assert_same_lsid_on_last_two_commands(op, expected: true)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        client = entities.get(:client, args.use!('client'))
+        subscriber = @subscribers.fetch(client)
+        unless subscriber.started_events.length >= 2
+          raise Error::ResultMismatch, "Must have at least 2 events, have #{subscriber.started_events.length}"
+        end
+        lsids = subscriber.started_events[-2...-1].map do |cmd|
+          cmd.command.fetch('lsid')
+        end
+        if expected
+          unless lsids.first == lsids.last
+            raise Error::ResultMismatch, "lsids differ but they were expected to be the same"
+          end
+        else
+          if lsids.first == lsids.last
+            raise Error::ResultMismatch, "lsids are the same but they were expected to be different"
+          end
+        end
+      end
+    end
+
+    def assert_different_lsid_on_last_two_commands(op)
+      assert_same_lsid_on_last_two_commands(op, expected: false)
+    end
+
+    def start_transaction(op)
+      $klil_transactions = true
+      session = entities.get(:session, op.use!('object'))
+      assert_no_arguments(op)
+      session.start_transaction
+    end
+
+    def assert_session_transaction_state(op)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        session = entities.get(:session, args.use!('session'))
+        state = args.use!('state')
+        unless session.send("#{state}_transaction?")
+          raise Error::ResultMismatch, "Expected session to have state #{state}"
+        end
+      end
+    end
+
+    def commit_transaction(op)
+      session = entities.get(:session, op.use!('object'))
+      assert_no_arguments(op)
+      session.commit_transaction
+    end
+
+    def abort_transaction(op)
+      session = entities.get(:session, op.use!('object'))
+      assert_no_arguments(op)
+      session.abort_transaction
+    end
+
+    def with_transaction(op)
+      $kill_transactions = true
+      session = entities.get(:session, op.use!('object'))
+      use_arguments(op) do |args|
+        ops = args.use!('callback')
+
+        if args.empty?
+          opts = {}
+        else
+          opts = ::Utils.underscore_hash(args)
+          if value = opts[:read_concern]&.[](:level)
+            opts[:read_concern][:level] = value.to_sym
+          end
+          args.clear
+        end
+
+        session.with_transaction(**opts) do
+          execute_operations(ops)
+        end
+      end
+    end
+
+    def assert_session_pinned(op, state = true)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        session = entities.get(:session, args.use!('session'))
+
+        if state
+          unless session.pinned_server
+            raise Error::ResultMismatch, 'Expected session to be pinned but it is not'
+          end
+        else
+          if session.pinned_server
+            raise Error::ResultMismatch, 'Expected session to be not pinned but it is'
+          end
+        end
+      end
+    end
+
+    def assert_session_unpinned(op)
+      assert_session_pinned(op, false)
+    end
+
+    def _loop(op)
+      consume_test_runner(op)
+      use_arguments(op) do |args|
+        ops = args.use!('operations')
+
+        if store_errors = args.use('storeErrorsAsEntity')
+          entities.set(:error_list, store_errors, [])
+        end
+
+        if store_failures = args.use('storeFailuresAsEntity')
+          entities.set(:failure_list, store_failures, [])
+        end
+
+        store_iterations = args.use('storeIterationsAsEntity')
+        iterations = 0
+        store_successes = args.use('storeSuccessesAsEntity')
+        successes = 0
+
+        loop do
+          break if stop?
+          begin
+            ops.map(&:dup).each do |op|
+              execute_operation(op)
+              successes += 1
+            end
+          rescue Unified::Error::ResultMismatch => e
+            if store_failures
+              STDERR.puts "Failure: #{e.class}: #{e}"
+              entities.get(:failure_list, store_failures) << {
+                error: "#{e.class}: #{e}",
+                time: Time.now.to_f,
+              }
+            elsif store_errors
+              STDERR.puts "Failure: #{e.class}: #{e} (reporting as error)"
+              entities.get(:error_list, store_errors) << {
+                error: "#{e.class}: #{e}",
+                time: Time.now.to_f,
+              }
+            else
+              raise
+            end
+          rescue => e
+            if store_errors
+              STDERR.puts "Error: #{e.class}: #{e}"
+              entities.get(:error_list, store_errors) << {
+                error: "#{e.class}: #{e}",
+                observedAt: Time.now.to_f,
+              }
+            else
+              raise
+            end
+          end
+          iterations += 1
+        end
+
+        if store_iterations
+          entities.set(:iteration_count, store_iterations, iterations)
+        end
+        if store_successes
+          entities.set(:success_count, store_successes, successes)
+        end
+      end
+    end
+
+    private
+
+    def assert_no_arguments(op)
+      if op.key?('arguments')
+        raise NotimplementedError, "Arguments are not allowed"
+      end
+    end
+
+    def consume_test_runner(op)
+      v = op.use!('object')
+      unless v == 'testRunner'
+        raise NotImplementedError, 'Expected object to be testRunner'
+      end
+    end
+
+    def decode_hex_bytes(value)
+      value.scan(/../).map { |hex| hex.to_i(16).chr }.join
+    end
+  end
+end