mongo 2.8.0 → 2.9.0.rc0

data/spec/support/crud/outcome.rb

@@ -0,0 +1,53 @@
+# 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
+    class Outcome
+      def initialize(spec)
+        if spec.nil?
+          raise ArgumentError, 'Outcome specification cannot be nil'
+        end
+        @result = spec['result']
+        @collection = spec['collection']
+        @error = spec['error']
+      end
+
+      def error?
+        !!@error
+      end
+
+      def collection_data?
+        !!collection_data
+      end
+
+      # The expected data in the collection as an outcome after running an
+      # operation.
+      #
+      # @return [ Array<Hash> ] The list of documents expected to be in the collection.
+      def collection_data
+        @collection && @collection['data']
+      end
+
+      def collection_name
+        @collection && @collection['name']
+      end
+
+      # The expected result of running an operation.
+      #
+      # @return [ Array<Hash> ] The expected result.
+      attr_reader :result
+    end
+  end
+end

data/spec/support/crud/read.rb

@@ -42,23 +42,45 @@ module Mongo
                                 'nearest' => :nearest
                               }.freeze
 
-        # The operation name.
-        #
-        # @return [ String ] name The operation name.
-        #
-        # @since 2.0.0
-        attr_reader :name
-
         # Instantiate the operation.
         #
         # @return [ Hash ] spec The operation spec.
         #
         # @since 2.0.0
-        def initialize(spec)
+        def initialize(spec, outcome_spec = nil)
           @spec = spec
+          @outcome = Outcome.new(outcome_spec || spec)
           @name = spec['name']
         end
 
+        # The operation name.
+        #
+        # @return [ String ] name The operation name.
+        #
+        # @since 2.0.0
+        attr_reader :name
+
+        attr_reader :outcome
+
+        def object
+          @spec['object'] || 'collection'
+        end
+
+        # Which collection to verify results from.
+        # Returns the collection name specified on the operation, or
+        # the collection name for the entire spec file.
+        def verify_collection_name
+          if outcome && outcome.collection_name
+            outcome.collection_name
+          else
+            spec.collection_name.tap do |cn|
+              if cn.nil?
+                raise "Collection name cannot be nil"
+              end
+            end
+          end
+        end
+
         # Execute the operation.
         #
         # @example Execute the operation.
@@ -69,11 +91,17 @@ module Mongo
         # @return [ Result, Array<Hash> ] The result of executing the operation.
         #
         # @since 2.0.0
-        def execute(collection)
-          send(camel_to_snake(name), collection)
+        def execute(target)
+          op_name = Utils.underscore(name)
+          if target.is_a?(Mongo::Database)
+            op_name = "db_#{op_name}"
+          elsif target.is_a?(Mongo::Client)
+            op_name= "client_#{op_name}"
+          end
+          send(op_name, target)
         end
 
-        # Whether the operation is expected to have restuls.
+        # Whether the operation is expected to have results.
         #
         # @example Whether the operation is expected to have results.
         #   operation.has_results?
@@ -105,8 +133,10 @@ module Mongo
         end
 
         def estimated_document_count(collection)
+          # estimated_document_count defaults options to {}
+          args = arguments || {}
           options = ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
-            opts.merge!(key => arguments[value]) if arguments[value]
+            opts.merge!(key => args[value]) if args[value]
             opts
           end
           collection.estimated_document_count(options)
@@ -125,6 +155,66 @@ module Mongo
           (read_preference ? collection.with(read: read_preference) : collection).find(filter, opts).to_a
         end
 
+        def find_one(collection)
+          find(collection).first
+        end
+
+        def client_list_databases(client)
+          client.list_databases
+        end
+
+        def client_list_database_names(client)
+          client.list_databases({}, true)
+        end
+
+        def client_list_database_objects(client)
+          client.list_mongo_databases
+        end
+
+        def db_list_collections(database)
+          database.list_collections
+        end
+
+        def db_list_collection_names(database)
+          database.collection_names
+        end
+
+        def db_list_collection_objects(database)
+          database.collections
+        end
+
+        def list_indexes(collection)
+          collection.indexes.to_a
+        end
+
+        def watch(collection)
+          collection.watch
+        end
+
+        def db_watch(database)
+          database.watch
+        end
+
+        def client_watch(client)
+          client.watch
+        end
+
+        def download(fs_bucket)
+          stream = fs_bucket.open_download_stream(BSON::ObjectId.from_string(arguments['id']['$oid']))
+          stream.read
+        end
+
+        def download_by_name(fs_bucket)
+          stream = fs_bucket.open_download_stream_by_name(arguments['filename'])
+          stream.read
+        end
+
+        def map_reduce(collection)
+          view = Mongo::Collection::View.new(collection)
+          mr = Mongo::Collection::View::MapReduce.new(view, arguments['map']['$code'], arguments['reduce']['$code'])
+          mr.to_a
+        end
+
         def options
           ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
             value = if arguments[value].is_a?(Hash) && arguments[value]['$numberLong']

data/spec/support/crud/requirement.rb

@@ -0,0 +1,69 @@
+module Mongo
+  module CRUD
+    class Requirement
+      YAML_KEYS = %w(minServerVersion maxServerVersion topology).freeze
+
+      def initialize(spec)
+        @min_server_version = spec['minServerVersion']
+        @max_server_version = spec['maxServerVersion']
+        @topologies = if topologies = spec['topology']
+          topologies.map do |topology|
+            {'replicaset' => :replica_set, 'single' => :single, 'sharded' => :sharded}[topology]
+          end
+        else
+          nil
+        end
+      end
+
+      attr_reader :min_server_version
+      attr_reader :max_server_version
+      attr_reader :topologies
+
+      def short_min_server_version
+        if min_server_version
+          min_server_version.split('.')[0..1].join('.')
+        else
+          nil
+        end
+      end
+
+      def short_max_server_version
+        if max_server_version
+          max_server_version.split('.')[0..1].join('.')
+        else
+          nil
+        end
+      end
+
+      def satisfied?
+        cc = ClusterConfig.instance
+        ok = true
+        if short_min_server_version
+          ok &&= cc.fcv_ish >= short_min_server_version
+        end
+        if max_server_version
+          ok &&= cc.server_version <= max_server_version
+        end
+        if topologies
+          ok &&= topologies.include?(cc.topology)
+        end
+        ok
+      end
+
+      def description
+        versions = [min_server_version, max_server_version].compact
+        if versions.any?
+          versions = versions.join('-')
+        else
+          versions = nil
+        end
+        topologies = if self.topologies
+          self.topologies.map(&:to_s).join(',')
+        else
+          nil
+        end
+        [versions, topologies].compact.join('/')
+      end
+    end
+  end
+end

data/spec/support/crud/spec.rb

@@ -0,0 +1,68 @@
+module Mongo
+  module CRUD
+    # Represents a CRUD specification test.
+    class Spec
+
+      # 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)
+        contents = ERB.new(File.read(file)).result
+
+        # Since Ruby driver binds a client to a database, change the
+        # database name in the spec to the one we are using
+        contents.sub!(/"retryable-reads-tests"/, '"ruby-driver"')
+        contents.sub!(/"transaction-tests"/, '"ruby-driver"')
+        contents.sub!(/"withTransaction-tests"/, '"ruby-driver"')
+
+        @spec = YAML.load(ERB.new(contents).result)
+        @description = File.basename(file)
+        @data = @spec['data']
+        @tests = @spec['tests']
+
+        @requirements = if run_on = @spec['runOn']
+          run_on.map do |spec|
+            Requirement.new(spec)
+          end
+        elsif Requirement::YAML_KEYS.any? { |key| @spec.key?(key) }
+          [Requirement.new(@spec)]
+        else
+          nil
+        end
+      end
+
+      # @return [ String ] description The spec description.
+      #
+      # @since 2.0.0
+      attr_reader :description
+
+      attr_reader :requirements
+
+      def collection_name
+        # Older spec tests do not specify a collection name, thus
+        # we provide a default here
+        @spec['collection_name'] || 'crud_spec_test'
+      end
+
+      def bucket_name
+        @spec['bucket_name']
+      end
+
+      def database_name
+        @spec['database_name']
+      end
+
+      # Get a list of Test instances, one for each test definition.
+      def tests
+        @tests.map do |test|
+          Mongo::CRUD::CRUDTest.new(@data, test)
+        end
+      end
+    end
+  end
+end

data/spec/support/crud/test.rb

@@ -0,0 +1,141 @@
+module Mongo
+  module CRUD
+
+    # 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 = BSON::Document.new(
+        'configureFailPoint' => "onPrimaryTransactionalWrite",
+      ).freeze
+
+      # Instantiate the new CRUDTest.
+      #
+      # data can be an array of hashes, with each hash corresponding to a
+      # document to be inserted into the collection whose name is given in
+      # collection_name as configured in the YAML file. Alternatively data
+      # can be a map of collection names to arrays of hashes.
+      #
+      # @param [ Hash | 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']
+        @client_options = Utils.convert_client_options(test['clientOptions'] || {})
+        if test['operations']
+          @operations = test['operations'].map do |op_spec|
+            Operation.get(op_spec)
+          end
+        else
+          @operations = [Operation.get(test['operation'], test['outcome'])]
+        end
+        @expectations = test['expectations']
+      end
+
+      attr_reader :client_options
+
+      # Operations to be performed by the test.
+      #
+      # For CRUD tests, there is one operation for test. For retryable writes,
+      # there are multiple operations for each test. In either case we build
+      # an array of operations.
+      attr_reader :operations
+
+      # The expected command monitoring events
+      attr_reader :expectations
+
+      # Run the test.
+      #
+      # The specified number of operations are executed, so that the
+      # test can assert on the outcome of each specified operation in turn.
+      #
+      # @param [ Client ] client The client the test
+      #   should be run with.
+      # @param [ Integer ] num_ops Number of operations to run.
+      #
+      # @return [ Result, Array<Hash> ] The result(s) of running the test.
+      #
+      # @since 2.0.0
+      def run(spec, client, num_ops)
+        result = nil
+        1.upto(num_ops) do |i|
+          operation = @operations[i-1]
+          target = case operation.object
+          when 'collection'
+            client[spec.collection_name]
+          when 'database'
+            client.database
+          when 'client'
+            client
+          when 'gridfsbucket'
+            client.database.fs
+          else
+            raise "Unknown target #{operation.object}"
+          end
+          result = operation.execute(target)
+        end
+        result
+      end
+
+      class DataConverter
+        include Mongo::GridFS::Convertible
+      end
+
+      def setup_test(spec, client)
+        clear_fail_point(client)
+        if @data.is_a?(Array)
+          collection = client[spec.collection_name]
+          collection.delete_many
+          collection.insert_many(@data)
+        elsif @data.is_a?(Hash)
+          converter = DataConverter.new
+          @data.each do |collection_name, data|
+            collection = client[collection_name]
+            collection.delete_many
+            data = converter.transform_docs(data)
+            collection.insert_many(data)
+          end
+        else
+          raise "Unknown type of data: #{@data}"
+        end
+        set_up_fail_point(client)
+      end
+
+      def set_up_fail_point(client)
+        if @fail_point_command
+          client.use(:admin).command(@fail_point_command)
+        end
+      end
+
+      def clear_fail_point(client)
+        if @fail_point_command
+          client.use(:admin).command(@fail_point_command.merge(mode: "off"))
+        end
+      end
+
+      private
+
+      def actual_collection_data
+        if expected_outcome.collection_data?
+          collection_name = expected_outcome.collection_name || @collection.name
+          @collection.database[collection_name].find.to_a
+        end
+      end
+    end
+  end
+end