mongo 2.8.0 → 2.9.0.rc0

data/spec/support/connection_string.rb

@@ -225,7 +225,7 @@ module Mongo
          # Write  Options
         'journal' => [:write, 'j'],
         'w' => [:write, 'w'],
-        'wtimeoutms' => [:write, 'timeout'],
+        'wtimeoutms' => [:write, 'wtimeout'],
 
         # Read Options
         'readpreference' => ['read', 'mode'],
@@ -252,7 +252,7 @@ module Mongo
 
         # Client Options
         'appname' => :app_name,
-        'readconcernlevel' => :read_concern,
+        'readconcernlevel' => [:read_concern, 'level'],
         'retrywrites' => :retry_writes,
         'zlibcompressionlevel' => :zlib_compression_level,
       }

data/spec/support/crud.rb

@@ -12,220 +12,207 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'support/gridfs'
+require 'support/crud/requirement'
+require 'support/crud/spec'
+require 'support/crud/test'
+require 'support/crud/outcome'
+require 'support/crud/operation'
 require 'support/crud/read'
 require 'support/crud/write'
 require 'support/crud/verifier'
 
-module Mongo
-  module CRUD
-
-    # Represents a CRUD specification test.
-    #
-    # @since 2.0.0
-    class Spec
-
-      # @return [ String ] description The spec description.
-      #
-      # @since 2.0.0
-      attr_reader :description
-
-      # Instantiate the new spec.
-      #
-      # @example Create the spec.
-      #   Spec.new(file)
-      #
-      # @param [ String ] file The name of the file.
-      #
-      # @since 2.0.0
-      def initialize(file)
-        file = File.new(file)
-        @spec = YAML.load(ERB.new(file.read).result)
-        file.close
-        @description = File.basename(file)
-        @data = @spec['data']
-        @crud_tests = @spec['tests']
-        @min_server_version = @spec['minServerVersion']
-        @max_server_version = @spec['maxServerVersion']
-      end
+def crud_execute_operations(spec, test, num_ops, event_subscriber, expect_error,
+  client
+)
+  cache_key = "#{test.object_id}:#{num_ops}"
+  $crud_result_cache ||= {}
+  $crud_result_cache[cache_key] ||= begin
+    if spec.bucket_name
+      client["#{spec.bucket_name}.files"].delete_many
+      client["#{spec.bucket_name}.chunks"].delete_many
+    else
+      client[spec.collection_name].delete_many
+    end
 
+    test.setup_test(spec, client)
 
-      # Whether the test can be run on a given server version.
-      #
-      # @example Can the test run on this server version?
-      #   spec.server_version_satisfied?(client)
-      #
-      # @param [ Mongo::Client ] client The client to check.
-      #
-      # @return [ true, false ] Whether the test can be run on the given
-      #   server version.
-      #
-      # @since 2.4.0
-      def server_version_satisfied?(client)
-        lower_bound_satisfied?(client) && upper_bound_satisfied?(client)
-      end
+    event_subscriber.clear_events!
 
-      # Get a list of CRUDTests for each test definition.
-      #
-      # @example Get the list of CRUDTests.
-      #   spec.tests
-      #
-      # @return [ Array<CRUDTest> ] The list of CRUDTests.
-      #
-      # @since 2.0.0
-      def tests
-        @crud_tests.collect do |test|
-          Mongo::CRUD::CRUDTest.new(@data, test)
-        end
+    result = if expect_error.nil?
+      res = nil
+      begin
+        res = test.run(spec, client, num_ops)
+      rescue => e
+        res = e
       end
-
-      private
-
-      def upper_bound_satisfied?(client)
-        return true unless @max_server_version
-        client.database.command(buildInfo: 1).first['version'] <= @max_server_version
+      res
+    elsif expect_error
+      error = nil
+      begin
+        test.run(spec, client, num_ops)
+      rescue => e
+        error = e
       end
+      error
+    else
+      test.run(spec, client, num_ops)
+    end
 
-      def lower_bound_satisfied?(client)
-        return true unless @min_server_version
-        #@min_server_version <= client.database.command(buildInfo: 1).first['version']
-        @min_server_version <= ClusterConfig.instance.fcv_ish
-      end
+    $crud_event_cache ||= {}
+    # It only makes sense to assert on events if all operations succeeded,
+    # but populate our cache in any event for simplicity
+    $crud_event_cache[cache_key] = event_subscriber.started_events.dup
+
+    last_op = test.operations[num_ops-1]
+    if last_op.outcome && last_op.outcome.collection_data?
+      verify_collection = client[last_op.verify_collection_name]
+      $crud_collection_data_cache ||= {}
+      $crud_collection_data_cache[cache_key] = verify_collection.find.to_a
     end
 
-    # Represents a single CRUD test.
-    #
-    # @since 2.0.0
-    class CRUDTest
-
-      # The test description.
-      #
-      # @return [ String ] description The test description.
-      #
-      # @since 2.0.0
-      attr_reader :description
-
-      # Spec tests have configureFailPoint as a string, make it a string here too
-      FAIL_POINT_BASE_COMMAND = {
-        'configureFailPoint' => "onPrimaryTransactionalWrite",
-      }.freeze
-
-      # Instantiate the new CRUDTest.
-      #
-      # @example Create the test.
-      #   CRUDTest.new(data, test)
-      #
-      # @param [ Array<Hash> ] data The documents the collection
-      # must have before the test runs.
-      # @param [ Hash ] test The test specification.
-      #
-      # @since 2.0.0
-      def initialize(data, test)
-        @data = data
-        if test['failPoint']
-          @fail_point_command = FAIL_POINT_BASE_COMMAND.merge(test['failPoint'])
-        end
-        @description = test['description']
-        @operation = Operation.get(test['operation'])
-        @outcome = test['outcome']
-      end
+    result
+  ensure
+    test.clear_fail_point(client)
+  end
+end
 
-      attr_reader :outcome
-
-      # Run the test.
-      #
-      # @example Run the test.
-      #   test.run(collection)
-      #
-      # @param [ Collection ] collection The collection the test
-      #   should be run on.
-      #
-      # @return [ Result, Array<Hash> ] The result(s) of running the test.
-      #
-      # @since 2.0.0
-      def run(collection)
-        @operation.execute(collection)
+def define_crud_spec_test_examples(spec, req = nil, &block)
+  spec.tests.each do |test|
+
+    context(test.description) do
+
+      if test.description =~ /ListIndexNames/
+        before do
+          skip "Ruby driver does not implement list_index_names"
+        end
       end
 
-      def setup_test(collection)
-        clear_fail_point(collection)
-        @collection = collection
-        collection.delete_many
-        collection.insert_many(@data)
-        set_up_fail_point(collection)
+      let(:event_subscriber) do
+        EventSubscriber.new
       end
 
-      def set_up_fail_point(collection)
-        if @fail_point_command
-          collection.client.use(:admin).command(@fail_point_command)
+      let(:verifier) { Mongo::CRUD::Verifier.new(test) }
+
+      let(:verify_collection) { client[verify_collection_name] }
+
+      instance_exec(spec, req, test, &block)
+
+      test.operations.each_with_index do |operation, index|
+
+        context "operation #{index+1}" do
+
+          let(:result) do
+            crud_execute_operations(spec, test, index+1,
+              event_subscriber, operation.outcome.error?, client)
+          end
+
+          let(:verify_collection_name) do
+            if operation.outcome && operation.outcome.collection_name
+              operation.outcome.collection_name
+            else
+              spec.collection_name
+            end
+          end
+
+          if operation.outcome.error?
+            it 'raises an error' do
+              expect(result).to be_a(Mongo::Error)
+            end
+          else
+            tested = false
+
+            if operation.outcome.result
+              tested = true
+              it 'returns the correct result' do
+                result
+                verifier.verify_operation_result(operation.outcome.result, result)
+              end
+            end
+
+            if operation.outcome.collection_data?
+              tested = true
+              it 'has the correct data in the collection' do
+                result
+                verifier.verify_collection_data(
+                  operation.outcome.collection_data,
+                  verify_collection.find.to_a)
+              end
+            end
+
+            unless tested
+              it 'succeeds' do
+                expect do
+                  result
+                end.not_to raise_error
+              end
+            end
+          end
         end
       end
 
-      def clear_fail_point(collection)
-        if @fail_point_command
-          collection.client.use(:admin).command(FAIL_POINT_BASE_COMMAND.merge(mode: "off"))
+      if test.expectations
+        let(:result) do
+          crud_execute_operations(spec, test, test.operations.length,
+            event_subscriber, nil, client)
         end
-      end
 
-      # The expected result of running the test.
-      #
-      # @example Get the expected result of running the test.
-      #   test.result
-      #
-      # @return [ Array<Hash> ] The expected result of running the test.
-      #
-      # @since 2.0.0
-      def result
-        @operation.has_results? ? @outcome['result'] : []
-      end
+        let(:actual_events) do
+          result
+          Utils.yamlify_command_events($crud_event_cache["#{test.object_id}:#{test.operations.length}"])
+        end
 
-      def error?
-        !!@outcome['error']
-      end
+        it 'has the correct number of command_started events' do
+          verifier.verify_command_started_event_count(test.expectations, actual_events)
+        end
 
-      # The expected data in the collection as an outcome after running this test.
-      #
-      # @example Get the outcome collection data
-      #   test.outcome_collection_data
-      #
-      # @return [ Array<Hash> ] The list of documents expected to be in the collection
-      #   after running this test.
-      #
-      # @since 2.4.0
-      def outcome_collection_data
-        @outcome['collection']['data'] if @outcome['collection']
+        test.expectations.each_with_index do |expectation, i|
+          it "has the correct command_started event #{i+1}" do
+            verifier.verify_command_started_event(
+              test.expectations, actual_events, i)
+          end
+        end
       end
+    end
+  end
+end
 
-      private
-
-      def actual_collection_data
-        if @outcome['collection']
-          collection_name = @outcome['collection']['name'] || @collection.name
-          @collection.database[collection_name].find.to_a
+def define_spec_tests_with_requirements(spec, &block)
+  if spec.requirements
+    # This block defines the same set of examples multiple times,
+    # once for each requirement specified in the YAML files.
+    # This allows detecting when any of the configurations is
+    # not tested by CI.
+    spec.requirements.each do |req|
+      context(req.description) do
+        if req.min_server_version
+          min_server_fcv req.short_min_server_version
         end
+        if req.max_server_version
+          max_server_version req.short_max_server_version
+        end
+        if req.topologies
+          require_topology *req.topologies
+        end
+
+        instance_exec(req, &block)
       end
     end
+  else
+    yield
+  end
+end
+
+def define_crud_spec_tests(description, test_paths, &block)
+  describe(description) do
+
+    test_paths.each do |path|
+
+      spec = Mongo::CRUD::Spec.new(path)
 
-    # Helper module for instantiating either a Read or Write test operation.
-    #
-    # @since 2.0.0
-    module Operation
-      extend self
-
-      # Get a new Operation.
-      #
-      # @example Get the operation.
-      #   Operation.get(spec)
-      #
-      # @param [ Hash ] spec The operation specification.
-      #
-      # @return [ Operation::Write, Operation::Read ] The Operation object.
-      #
-      # @since 2.0.0
-      def get(spec)
-        if Write::OPERATIONS.keys.include?(spec['name'])
-          Write.new(spec)
-        else
-          Read.new(spec)
+      context(spec.description) do
+        define_spec_tests_with_requirements(spec) do |req|
+          define_crud_spec_test_examples(spec, req, &block)
         end
       end
     end

data/spec/support/crud/operation.rb

@@ -0,0 +1,43 @@
+# Copyright (C) 2014-2019 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.
+
+module Mongo
+  module CRUD
+
+    # Helper module for instantiating either a Read or Write test operation.
+    #
+    # @since 2.0.0
+    module Operation
+      extend self
+
+      # Get a new Operation.
+      #
+      # @example Get the operation.
+      #   Operation.get(spec)
+      #
+      # @param [ Hash ] spec The operation specification.
+      #
+      # @return [ Operation::Write, Operation::Read ] The Operation object.
+      #
+      # @since 2.0.0
+      def get(spec, outcome_spec = nil)
+        if Write::OPERATIONS.keys.include?(spec['name'])
+          Write.new(spec, outcome_spec)
+        else
+          Read.new(spec, outcome_spec)
+        end
+      end
+    end
+  end
+end