mongo 2.14.1 → 2.15.0.alpha

data/spec/runners/unified/test.rb

@@ -0,0 +1,393 @@
+require 'runners/crud/requirement'
+require 'runners/unified/crud_operations'
+require 'runners/unified/grid_fs_operations'
+require 'runners/unified/ddl_operations'
+require 'runners/unified/change_stream_operations'
+require 'runners/unified/support_operations'
+require 'runners/unified/assertions'
+require 'support/utils'
+
+module Unified
+
+  class Test
+    include CrudOperations
+    include GridFsOperations
+    include DdlOperations
+    include ChangeStreamOperations
+    include SupportOperations
+    include Assertions
+
+    def initialize(spec, **opts)
+      @spec = spec
+      @entities = EntityMap.new
+      @test_spec = UsingHash[@spec.fetch('test')]
+      @description = @test_spec.use('description')
+      @outcome = @test_spec.use('outcome')
+      @expected_events = @test_spec.use('expectEvents')
+      @skip_reason = @test_spec.use('skipReason')
+      if req = @test_spec.use('runOnRequirements')
+        @reqs = req.map { |r| Mongo::CRUD::Requirement.new(r) }
+      end
+      if req = @spec['group_runOnRequirements']
+        @group_reqs = req.map { |r| Mongo::CRUD::Requirement.new(r) }
+      end
+      mongoses = @spec['createEntities'].select do |spec|
+        spec['client']
+      end.map do |spec|
+        spec['client']['useMultipleMongoses']
+      end.compact.uniq
+      if mongoses.length > 1
+        raise Error::InvalidTest, "Conflicting useMultipleMongoses values"
+      end
+      @multiple_mongoses = mongoses.first
+      @test_spec.freeze
+      @subscribers = {}
+      @options = opts
+    end
+
+    attr_reader :test_spec
+    attr_reader :description
+    attr_reader :outcome
+    attr_reader :skip_reason
+    attr_reader :reqs, :group_reqs
+    attr_reader :options
+
+    def skip?
+      !!@skip_reason
+    end
+
+    def require_multiple_mongoses?
+      @multiple_mongoses == true
+    end
+
+    def require_single_mongos?
+      @multiple_mongoses == false
+    end
+
+    attr_reader :entities
+
+    def create_entities
+      @spec['createEntities'].each do |entity_spec|
+        unless entity_spec.keys.length == 1
+          raise NotImplementedError, "Entity must have exactly one key"
+        end
+
+        type, spec = entity_spec.first
+        spec = UsingHash[spec]
+        id = spec.use!('id')
+
+        entity = case type
+        when 'client'
+          # Handled earlier
+          spec.delete('useMultipleMongoses')
+
+          if smc_opts = spec.use('uriOptions')
+            opts = Mongo::URI::OptionsMapper.new.smc_to_ruby(smc_opts)
+          else
+            opts = {}
+          end
+
+          if store_events = spec.use('storeEventsAsEntities')
+            store_event_names = {}
+            store_events.each do |spec|
+              entity_name = spec['id']
+              event_names = spec['events']
+              #event_name = event_name.gsub(/Event$/, '').gsub(/[A-Z]/) { |m| "_#{m}" }.upcase
+              #event_name = event_name.gsub(/Event$/, '').sub(/./) { |m| m.upcase }
+              event_names.each do |event_name|
+                store_event_names[event_name] = entity_name
+              end
+            end
+            store_event_names.values.uniq.each do |entity_name|
+              entities.set(:event_list, entity_name, [])
+            end
+            subscriber = StoringEventSubscriber.new do |payload|
+              if entity_name = store_event_names[payload['name']]
+                entities.get(:event_list, entity_name) << payload
+              end
+            end
+            opts[:sdam_proc] = lambda do |client|
+              client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+              client.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+            end
+          end
+
+          if server_api = spec.use('serverApi')
+            server_api = ::Utils.underscore_hash(server_api)
+            opts[:server_api] = server_api
+          end
+
+          create_client(**opts).tap do |client|
+            if oe = spec.use('observeEvents')
+              oe.each do |event|
+                case event
+                when 'commandStartedEvent', 'commandSucceededEvent', 'commandFailedEvent'
+                  subscriber = (@subscribers[client] ||= EventSubscriber.new)
+                  unless client.send(:monitoring).subscribers[Mongo::Monitoring::COMMAND].include?(subscriber)
+                    client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+                  end
+                  kind = event.sub('command', '').sub('Event', '').downcase.to_sym
+                  subscriber.add_wanted_events(kind)
+                  if ignore_events = spec.use('ignoreCommandMonitoringEvents')
+                    subscriber.ignore_commands(ignore_events)
+                  end
+                else
+                  raise NotImplementedError, "Unknown event #{event}"
+                end
+              end
+            end
+          end
+        when 'database'
+          client = entities.get(:client, spec.use!('client'))
+          client.use(spec.use!('databaseName')).database
+        when 'collection'
+          database = entities.get(:database, spec.use!('database'))
+          # TODO verify
+          opts = Utils.snakeize_hash(spec.use('collectionOptions') || {})
+          database[spec.use!('collectionName'), opts]
+        when 'bucket'
+          database = entities.get(:database, spec.use!('database'))
+          database.fs
+        when 'session'
+          client = entities.get(:client, spec.use!('client'))
+
+          if smc_opts = spec.use('sessionOptions')
+            opts = ::Utils.underscore_hash(smc_opts)
+          else
+            opts = {}
+          end
+
+          client.start_session(**opts)
+        else
+          raise NotImplementedError, "Unknown type #{type}"
+        end
+        unless spec.empty?
+          raise NotImplementedError, "Unhandled spec keys: #{spec}"
+        end
+        entities.set(type.to_sym, id, entity)
+      end
+    end
+
+    def set_initial_data
+      @spec['initialData']&.each do |entity_spec|
+        spec = UsingHash[entity_spec]
+        collection = root_authorized_client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
+        collection.drop
+        docs = spec.use!('documents')
+        if docs.any?
+          collection.insert_many(docs)
+        else
+          begin
+            collection.create
+          rescue Mongo::Error => e
+            if Mongo::Error::OperationFailure === e && (
+              e.code == 48 || e.message =~ /collection already exists/
+            )
+              # Already exists
+            else
+              raise
+            end
+          end
+        end
+        unless spec.empty?
+          raise NotImplementedError, "Unhandled spec keys: #{spec}"
+        end
+      end
+    end
+
+    def run
+      kill_sessions
+
+      test_spec = UsingHash[self.test_spec]
+      ops = test_spec.use!('operations')
+      execute_operations(ops)
+      unless test_spec.empty?
+        raise NotImplementedError, "Unhandled spec keys: #{test_spec}"
+      end
+    ensure
+      disable_fail_points
+    end
+
+    def stop!
+      @stop = true
+    end
+
+    def stop?
+      !!@stop
+    end
+
+    def cleanup
+      if $kill_transactions || true
+        kill_sessions
+        $kill_transactions = nil
+      end
+
+      entities[:client]&.each do |id, client|
+        client.close
+      end
+    end
+
+    private
+
+    def execute_operations(ops)
+      ops.each do |op|
+        execute_operation(op)
+      end
+    end
+
+    def execute_operation(op)
+      use_all(op, 'operation', op) do |op|
+        name = Utils.underscore(op.use!('name'))
+        method_name = name
+        if name.to_s == 'loop'
+          method_name = "_#{name}"
+        end
+        if expected_error = op.use('expectError')
+          begin
+            send(method_name, op)
+          rescue Mongo::Error, BSON::String::IllegalKey => e
+            if expected_error.use('isClientError')
+              unless BSON::String::IllegalKey === e
+                raise Error::ErrorMismatch, "Expected client error but got #{e}"
+              end
+            end
+            if code = expected_error.use('errorCode')
+              unless e.code == code
+                raise Error::ErrorMismatch, "Expected #{code} code but had #{e.code}"
+              end
+            end
+            if code_name = expected_error.use('errorCodeName')
+              unless e.code_name == code_name
+                raise Error::ErrorMismatch, "Expected #{code_name} code name but had #{e.code_name}"
+              end
+            end
+            if text = expected_error.use('errorContains')
+              unless e.to_s.include?(text)
+                raise Error::ErrorMismatch, "Expected #{text} in the message but had #{e}"
+              end
+            end
+            if labels = expected_error.use('errorLabelsContain')
+              labels.each do |label|
+                unless e.label?(label)
+                  raise Error::ErrorMismatch, "Expected error to contain label #{label} but it did not"
+                end
+              end
+            end
+            if omit_labels = expected_error.use('errorLabelsOmit')
+              omit_labels.each do |label|
+                if e.label?(label)
+                  raise Error::ErrorMismatch, "Expected error to not contain label #{label} but it did"
+                end
+              end
+            end
+            if expected_result = expected_error.use('expectResult')
+              assert_result_matches(e.result, expected_result)
+              #expected_result.clear
+            # Important: this must be the last branch.
+            elsif expected_error.use('isError')
+              # Nothing but we consume the key.
+            end
+            unless expected_error.empty?
+              raise NotImplementedError, "Unhandled keys: #{expected_error}"
+            end
+          else
+            raise Error::ErrorMismatch, "Expected exception but none was raised"
+          end
+        else
+          result = send(method_name, op)
+          if expected_result = op.use('expectResult')
+            if result.nil? && !expected_result.empty?
+              raise Error::ResultMismatch, "Actual result nil but expected result #{expected_result}"
+            elsif Array === expected_result
+              assert_documents_match(result, expected_result)
+            else
+              assert_result_matches(result, expected_result)
+            end
+            #expected_result.clear
+          end
+          if save_entity = op.use('saveResultAsEntity')
+            entities.set(:result, save_entity, result)
+          end
+        end
+      end
+    end
+
+    def use_sub(hash, key, &block)
+      v = hash.use!(key)
+      use_all(hash, key, v, &block)
+    end
+
+    def use_all(hash, key, v)
+      orig_v = v.dup
+      (yield v).tap do
+        unless v.empty?
+          raise NotImplementedError, "Unconsumed items for #{key}: #{v}\nOriginal hash: #{orig_v}"
+        end
+      end
+    end
+
+    def use_arguments(op, &block)
+      if op.key?('arguments')
+        use_sub(op, 'arguments', &block)
+      else
+        yield UsingHash.new
+      end
+    end
+
+    def disable_fail_points
+      if $disable_fail_points
+        $disable_fail_points.each do |(fail_point_command, address)|
+          client = ClusterTools.instance.direct_client(address,
+            database: 'admin')
+          client.command(configureFailPoint: fail_point_command['configureFailPoint'],
+            mode: 'off')
+        end
+        $disable_fail_points = nil
+      end
+    end
+
+    def kill_sessions
+      if options[:kill_sessions] != false
+        begin
+          root_authorized_client.command(
+            killAllSessions: [],
+          )
+        rescue Mongo::Error::OperationFailure => e
+          if e.code == 11601
+            # operation was interrupted, ignore
+          elsif e.code == 59
+            # no such command (old server), ignore
+          else
+            raise
+          end
+        end
+      end
+    end
+
+    def root_authorized_client
+      @root_authorized_client ||= ClientRegistry.instance.global_client('root_authorized')
+    end
+
+    def create_client(**opts)
+      args = case v = options[:client_args]
+      when Array
+        unless v.length == 2
+          raise NotImplementedError, 'Client args array must have two elements'
+        end
+        [v.first, v.last.dup]
+      when String
+        [v, {}]
+      else
+        [
+          SpecConfig.instance.addresses,
+          SpecConfig.instance.all_test_options,
+        ]
+      end
+      args.last.update(
+        max_read_retries: 0,
+        max_write_retries: 0,
+      ).update(opts)
+      Mongo::Client.new(*args)
+    end
+  end
+end

data/spec/runners/unified/test_group.rb

@@ -0,0 +1,28 @@
+module Unified
+
+  class TestGroup
+    def initialize(path, **opts)
+      if String === path
+        data = YAML.load(File.read(path))
+      else
+        data = path
+      end
+      @spec = BSON::ExtJSON.parse_obj(data)
+      @options = opts
+    end
+
+    attr_reader :options
+
+    def tests
+      reqs = @spec['runOnRequirements']
+
+      @spec.fetch('tests').map do |test|
+        sub = @spec.dup
+        sub.delete('tests')
+        sub['test'] = test
+        sub['group_runOnRequirements'] = reqs
+        Test.new(sub, **options)
+      end
+    end
+  end
+end

data/spec/runners/unified/using_hash.rb

@@ -0,0 +1,31 @@
+module Unified
+
+  class UsingHash < Hash
+    def use(key)
+      wrap(self[key]).tap do
+        delete(key)
+      end
+    end
+
+    def use!(key)
+      wrap(fetch(key)).tap do
+        delete(key)
+      end
+    end
+
+    private
+
+    def wrap(v)
+      case v
+      when Hash
+        self.class[v]
+      when Array
+        v.map do |subv|
+          wrap(subv)
+        end
+      else
+        v
+      end
+    end
+  end
+end

data/spec/runners/unified.rb

@@ -0,0 +1,96 @@
+require 'runners/unified/error'
+require 'runners/unified/entity_map'
+require 'runners/unified/event_subscriber'
+require 'runners/unified/test'
+require 'runners/unified/test_group'
+require 'runners/unified/using_hash'
+
+def define_unified_spec_tests(base_path, paths, expect_failure: false)
+  paths.each do |path|
+    basename = path[base_path.length+1...path.length]
+    context basename do
+      group = Unified::TestGroup.new(path)
+
+      if basename =~ /retryable|transaction/
+        require_wired_tiger
+      end
+
+      group.tests.each do |test|
+        context test.description do
+
+          if test.skip?
+            before do
+              skip test.skip_reason
+            end
+          end
+
+          before(:all) do
+            if SpecConfig.instance.retry_reads == false
+              skip "Tests are not applicable when legacy read retries are used"
+            end
+            if SpecConfig.instance.retry_writes == false
+              skip "Tests are not applicable when legacy write retries are used"
+            end
+
+            if ClusterConfig.instance.topology == :sharded
+              if test.require_multiple_mongoses? && SpecConfig.instance.addresses.length == 1
+                skip "Test requires multiple mongoses"
+              elsif test.require_single_mongos? && SpecConfig.instance.addresses.length > 1
+                # Many transaction spec tests that do not specifically deal with
+                # sharded transactions fail when run against a multi-mongos cluster
+                skip "Test requires single mongos"
+              end
+            end
+          end
+
+          if expect_failure
+            it 'fails as expected' do
+              if test.group_reqs
+                unless test.group_reqs.any? { |r| r.satisfied? }
+                  skip "Group requirements not satisfied"
+                end
+              end
+              if test.reqs
+                unless test.reqs.any? { |r| r.satisfied? }
+                  skip "Requirements not satisfied"
+                end
+              end
+              begin
+                test.create_entities
+                test.set_initial_data
+                lambda do
+                  test.run
+                  test.assert_outcome
+                  test.assert_events
+                # HACK: other errors are possible and likely will need to
+                # be added here later as the tests evolve.
+                end.should raise_error(Mongo::Error::OperationFailure)
+              ensure
+                test.cleanup
+              end
+            end
+          else
+            it 'passes' do
+              if test.group_reqs
+                unless test.group_reqs.any? { |r| r.satisfied? }
+                  skip "Group requirements not satisfied"
+                end
+              end
+              if test.reqs
+                unless test.reqs.any? { |r| r.satisfied? }
+                  skip "Requirements not satisfied"
+                end
+              end
+              test.create_entities
+              test.set_initial_data
+              test.run
+              test.assert_outcome
+              test.assert_events
+              test.cleanup
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
 # ClusterConfig requires ClientRegistry class provided by the host project.
 
 require 'singleton'

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

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
 require 'optparse'
 require 'erb'
 autoload :Dotenv, 'dotenv'

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

@@ -171,21 +171,5 @@ module Mrss
         end
       end
     end
-
-    def require_active_support
-      before(:all) do
-        if !SpecConfig.instance.active_support?
-          skip 'This test requires ActiveSupport; set WITH_ACTIVE_SUPPORT=1 in environment'
-        end
-      end
-    end
-
-    def no_active_support
-      before(:all) do
-        if SpecConfig.instance.active_support?
-          skip 'This test requires no ActiveSupport; unset WITH_ACTIVE_SUPPORT in environment'
-        end
-      end
-    end
   end
 end

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

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
 autoload :JSON, 'json'
 require 'open-uri'
 

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

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
 autoload :JSON, 'json'
 autoload :FileUtils, 'fileutils'
 autoload :Find, 'find'

data/spec/shared/shlib/server.sh

@@ -163,7 +163,7 @@ calculate_server_args() {
     args="$args --replicaset --name ruby-driver-rs --nodes 2 --arbiter"
     export HAVE_ARBITER=1
   elif test "$TOPOLOGY" = sharded-cluster; then
-    args="$args --replicaset --nodes 2 --sharded 1 --name ruby-driver-rs"
+    args="$args --replicaset --nodes 1 --sharded 1 --name ruby-driver-rs"
     if test -z "$SINGLE_MONGOS"; then
       args="$args --mongos 2"
     fi

data/spec/spec_helper.rb

@@ -1,10 +1,13 @@
 require 'lite_spec_helper'
 
 require 'mrss/constraints'
+require 'mrss/cluster_config'
+
+ClusterConfig = Mrss::ClusterConfig
+
 require 'support/constraints'
 require 'support/authorization'
 require 'support/primary_socket'
-require 'support/cluster_config'
 require 'support/cluster_tools'
 require 'rspec/retry'
 require 'support/monitoring_ext'

data/spec/spec_tests/crud_unified_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+require 'runners/unified'
+
+base = "#{CURRENT_PATH}/spec_tests/data/crud_unified"
+CRUD_UNIFIED_TESTS = Dir.glob("#{base}/**/*.yml").sort
+
+describe 'CRUD unified spec tests' do
+  define_unified_spec_tests(base, CRUD_UNIFIED_TESTS)
+end

data/spec/spec_tests/data/change_streams/change-streams.yml

@@ -371,7 +371,6 @@ tests:
             db: *database_name
             coll: *collection_name
           updateDescription:
-            removedFields: []
             updatedFields:
               x:
                 $numberInt: "2"