mongo 1.12.5 → 2.0.0

data/spec/support/authorization.rb

@@ -0,0 +1,247 @@
+# Copyright (C) 2009-2014 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.
+
+# The default test database for all specs.
+#
+# @since 2.0.0
+TEST_DB = 'ruby-driver'.freeze
+
+# The default test collection.
+#
+# @since 2.0.0
+TEST_COLL = 'test'.freeze
+
+# The seed addresses to be used when creating a client.
+#
+# @since 2.0.0
+ADDRESSES = ENV['MONGODB_ADDRESSES'] ? ENV['MONGODB_ADDRESSES'].split(',').freeze :
+              [ '127.0.0.1:27017' ].freeze
+
+# A default address to use in tests.
+#
+# @since 2.0.0
+DEFAULT_ADDRESS = ADDRESSES.first
+
+# The topology type.
+#
+# @since 2.0.0
+CONNECT = ENV['RS_ENABLED'] == 'true' ? :replica_set.freeze :
+            ENV['SHARDED_ENABLED'] == 'true' ? :sharded.freeze :
+            :direct.freeze
+
+# The root user name.
+#
+# @since 2.0.0
+ROOT_USER_NAME = ENV['ROOT_USER_NAME'] || 'root-user'
+
+# The root user password.
+#
+# @since 2.0.0
+ROOT_USER_PWD = ENV['ROOT_USER_PWD'] || 'password'
+
+# Gets the root system administrator user.
+#
+# @since 2.0.0
+ROOT_USER = Mongo::Auth::User.new(
+  database: Mongo::Database::ADMIN,
+  user: ROOT_USER_NAME,
+  password: ROOT_USER_PWD,
+  roles: [
+    Mongo::Auth::Roles::USER_ADMIN_ANY_DATABASE,
+    Mongo::Auth::Roles::DATABASE_ADMIN_ANY_DATABASE,
+    Mongo::Auth::Roles::READ_WRITE_ANY_DATABASE,
+    Mongo::Auth::Roles::HOST_MANAGER
+  ]
+)
+
+# Get the default test user for the suite on versions 2.6 and higher.
+#
+# @since 2.0.0
+TEST_USER = Mongo::Auth::User.new(
+  database: Mongo::Database::ADMIN,
+  user: 'test-user',
+  password: 'password',
+  roles: [
+    { role: Mongo::Auth::Roles::READ_WRITE, db: TEST_DB },
+    { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: TEST_DB },
+    { role: Mongo::Auth::Roles::READ_WRITE, db: 'invalid_database' },
+    { role: Mongo::Auth::Roles::DATABASE_ADMIN, db: 'invalid_database' }
+  ]
+)
+
+# MongoDB 2.4 and lower does not allow hashes as roles, so we need to create a
+# user on those versions for each database permission in order to ensure the
+# legacy roles work with users. The following users are those.
+
+# Gets the default test user for the suite on 2.4 and lower.
+#
+# @since 2.0.
+TEST_READ_WRITE_USER = Mongo::Auth::User.new(
+  database: TEST_DB,
+  user: 'test-user',
+  password: 'password',
+  roles: [ Mongo::Auth::Roles::READ_WRITE, Mongo::Auth::Roles::DATABASE_ADMIN ]
+)
+
+# The write concern to use in the tests.
+#
+# @since 2.0.0
+WRITE_CONCERN = (CONNECT == :replica_set) ? { w: ADDRESSES.size } : { w: 1 }
+
+# Provides an authorized mongo client on the default test database for the
+# default test user.
+#
+# @since 2.0.0
+AUTHORIZED_CLIENT = Mongo::Client.new(
+  ADDRESSES,
+  database: TEST_DB,
+  user: TEST_USER.name,
+  password: TEST_USER.password,
+  max_pool_size: 1,
+  write: WRITE_CONCERN,
+  connect: CONNECT
+)
+
+# Provides an authorized mongo client on the default test database for the
+# default root system administrator.
+#
+# @since 2.0.0
+ROOT_AUTHORIZED_CLIENT = Mongo::Client.new(
+  ADDRESSES,
+  auth_source: Mongo::Database::ADMIN,
+  database: TEST_DB,
+  user: ROOT_USER.name,
+  password: ROOT_USER.password,
+  max_pool_size: 1,
+  write: WRITE_CONCERN,
+  connect: CONNECT
+)
+
+# Provides an unauthorized mongo client on the default test database.
+#
+# @since 2.0.0
+UNAUTHORIZED_CLIENT = Mongo::Client.new(
+  ADDRESSES,
+  database: TEST_DB,
+  max_pool_size: 1,
+  write: WRITE_CONCERN,
+  connect: CONNECT
+)
+
+# Provides an unauthorized mongo client on the admin database, for use in
+# setting up the first admin root user.
+#
+# @since 2.0.0
+ADMIN_UNAUTHORIZED_CLIENT = Mongo::Client.new(
+  ADDRESSES,
+  database: Mongo::Database::ADMIN,
+  max_pool_size: 1,
+  write: WRITE_CONCERN,
+  connect: CONNECT
+)
+
+# Get an authorized client on the admin database logged in as the admin
+# root user.
+#
+# @since 2.0.0
+ADMIN_AUTHORIZED_CLIENT = ADMIN_UNAUTHORIZED_CLIENT.with(
+  user: ROOT_USER.name,
+  password: ROOT_USER.password
+)
+
+module Authorization
+
+  # On inclusion provides helpers for use with testing with and without
+  # authorization.
+  #
+  #
+  # @since 2.0.0
+  def self.included(context)
+
+    # Gets the root system administrator user.
+    #
+    # @since 2.0.0
+    context.let(:root_user) { ROOT_USER }
+
+    # Get the default test user for the suite.
+    #
+    # @since 2.0.0
+    context.let(:test_user) { TEST_USER }
+
+    # Provides an authorized mongo client on the default test database for the
+    # default test user.
+    #
+    # @since 2.0.0
+    context.let(:authorized_client) { AUTHORIZED_CLIENT }
+
+    # Provides an authorized mongo client on the default test database for the
+    # default root system administrator.
+    #
+    # @since 2.0.0
+    context.let(:root_authorized_client) { ROOT_AUTHORIZED_CLIENT }
+
+    # Provides an unauthorized mongo client on the default test database.
+    #
+    # @since 2.0.0
+    context.let!(:unauthorized_client) { UNAUTHORIZED_CLIENT }
+
+    # Provides an unauthorized mongo client on the admin database, for use in
+    # setting up the first admin root user.
+    #
+    # @since 2.0.0
+    context.let!(:admin_unauthorized_client) { ADMIN_UNAUTHORIZED_CLIENT }
+
+    # Get an authorized client on the admin database logged in as the admin
+    # root user.
+    #
+    # @since 2.0.0
+    context.let!(:admin_authorized_client) { ADMIN_AUTHORIZED_CLIENT }
+
+    # Gets the default test collection from the authorized client.
+    #
+    # @since 2.0.0
+    context.let(:authorized_collection) do
+      authorized_client[TEST_COLL]
+    end
+
+    # Gets the default test collection from the unauthorized client.
+    #
+    # @since 2.0.0
+    context.let(:unauthorized_collection) do
+      unauthorized_client[TEST_COLL]
+    end
+
+    # Gets a primary server for the default authorized client.
+    #
+    # @since 2.0.0
+    context.let(:authorized_primary) do
+      authorized_client.cluster.next_primary
+    end
+
+    # Get a primary server for the client authorized as the root system
+    # administrator.
+    #
+    # @since 2.0.0
+    context.let(:root_authorized_primary) do
+      root_authorized_client.cluster.next_primary
+    end
+
+    # Get a primary server from the unauthorized client.
+    #
+    # @since 2.0.0
+    context.let(:unauthorized_primary) do
+      authorized_client.cluster.next_primary
+    end
+  end
+end

data/spec/support/crud/read.rb

@@ -0,0 +1,144 @@
+# Copyright (C) 2014-2015 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
+    module Operation
+
+      # Defines common behaviour for running CRUD read operation tests
+      # on a collection.
+      #
+      # @since 2.0.0
+      class Read
+
+        # Map of method names to test operation argument names.
+        #
+        # @since 2.0.0
+        ARGUMENT_MAP = { :sort => 'sort',
+                         :skip => 'skip',
+                         :batch_size => 'batch_size',
+                         :limit => 'limit'
+                       }
+
+        # 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)
+          @spec = spec
+          @name = spec['name']
+        end
+
+        # Execute the operation.
+        #
+        # @example Execute the operation.
+        #   operation.execute
+        #
+        # @param [ Collection ] collection The collection to execute the operation on.
+        #
+        # @return [ Result, Array<Hash> ] The result of executing the operation.
+        #
+        # @since 2.0.0
+        def execute(collection)
+          send(name.to_sym, collection)
+        end
+
+        # Whether the operation is expected to have restuls.
+        #
+        # @example Whether the operation is expected to have results.
+        #   operation.has_results?
+        #
+        # @return [ true, false ] If the operation is expected to have results.
+        #
+        # @since 2.0.0
+        def has_results?
+          !(name == 'aggregate' &&
+              pipeline.find {|op| op.keys.include?('$out') })
+        end
+
+        # Whether the operation requires server version >= 2.6 for its results to
+        # match expected results.
+        #
+        # @example Whether the operation requires >= 2.6 for its results to match.
+        #   operation.requires_2_6?(collection)
+        #
+        # @param [ Collection ] collection The collection the operation is executed on.
+        #
+        # @return [ true, false ] If the operation requires 2.6 for its results to match.
+        #
+        # @since 2.0.0
+        def requires_2_6?(collection)
+          name == 'aggregate' && pipeline.find {|op| op.keys.include?('$out') }
+        end
+
+        private
+  
+        def count(collection)
+          view = collection.find(filter)
+          options = ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
+            opts.merge!(key => arguments[value]) if arguments[value]
+            opts
+          end
+          view.count(options)
+        end
+  
+        def aggregate(collection)
+          collection.find.tap do |view|
+            view = view.batch_size(batch_size) if batch_size
+          end.aggregate(pipeline).to_a
+        end
+  
+        def distinct(collection)
+          collection.find(filter).distinct(field_name)
+        end
+  
+        def find(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.to_a
+        end
+  
+        def batch_size
+          arguments['batchSize']
+        end
+
+        def filter
+          arguments['filter']
+        end
+  
+        def pipeline
+          arguments['pipeline']
+        end
+
+        def field_name
+          arguments['fieldName']
+        end
+
+        def arguments
+          @spec['arguments']
+        end
+      end
+    end
+  end
+end

data/spec/support/crud/write.rb

@@ -0,0 +1,214 @@
+# Copyright (C) 2014-2015 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
+    module Operation
+
+      # Defines common behaviour for running CRUD write operation tests on a
+      # collection.
+      #
+      # @since 2.0.0
+      class Write
+  
+        # Map of CRUD operation names to method names.
+        #
+        # @since 2.0.0
+        OPERATIONS = { 'deleteMany' => :delete_many,
+                       'deleteOne' => :delete_one,
+                       'insertMany' => :insert_many,
+                       'insertOne' => :insert_one,
+                       'replaceOne' => :replace_one,
+                       'updateMany' => :update_many,
+                       'updateOne' => :update_one,
+                       'findOneAndDelete' => :find_one_and_delete,
+                       'findOneAndReplace' => :find_one_and_replace,
+                       'findOneAndUpdate' => :find_one_and_update
+                     }
+
+        # Map of operation options to method names.
+        #
+        # @since 2.0.0
+        ARGUMENT_MAP = {
+                        :sort => 'sort',
+                        :projection => 'projection'
+                       }
+
+        # Operations that need a check if results on < 2.6 will match.
+        #
+        # @since 2.0.0
+        REQUIRES_2_6 = ['findOneAndReplace',
+                        'updateMany',
+                        'updateOne',
+                        'replaceOne']
+  
+        # The operation name.
+        #
+        # @return [ String ] name The operation name.
+        #
+        # @since 2.0.0
+        attr_reader :name
+
+        def initialize(spec)
+          @spec = spec
+          @name = spec['name']
+        end
+
+        # Whether the operation is expected to have restuls.
+        #
+        # @example Whether the operation is expected to have results.
+        #   operation.has_results?
+        #
+        # @return [ true ] If the operation is expected to have results.
+        #
+        # @since 2.0.0
+        def has_results?
+          true
+        end
+
+        # Execute the operation.
+        #
+        # @example Execute the operation.
+        #   operation.execute
+        #
+        # @param [ Collection ] collection The collection to execute
+        #   the operation on.
+        #
+        # @return [ Result, Array<Hash> ] The result of executing the operation.
+        #
+        # @since 2.0.0
+        def execute(collection)
+          send(OPERATIONS[name], collection)
+        end
+
+        # Whether this operation requires >= 2.6 to be tested.
+        #
+        # @example Determine whether this operation requires >= 2.6.
+        #   operation.requires_2_6?(collection)
+        #
+        # @param [ Collection ] collection The collection the operation
+        #   should be executed on.
+        #
+        # @return [ true, false ] Whether this operation requires 2.6
+        #   to be tested.
+        #
+        # @since 2.0.0
+        def requires_2_6?(collection)
+          REQUIRES_2_6.include?(name) && upsert
+        end
+  
+        private
+  
+        def delete_many(collection)
+          result = collection.find(filter).delete_many
+          { 'deletedCount' => result.deleted_count }
+        end
+
+        def delete_one(collection)
+          result = collection.find(filter).delete_one
+          { 'deletedCount' => result.deleted_count }
+        end
+
+        def insert_many(collection)
+          collection.insert_many(documents)
+          # returning inserted_ids is optional
+          { 'insertedIds' => documents.collect { |d| d['_id'] } }
+        end
+
+        def insert_one(collection)
+          result = collection.insert_one(document)
+          # returning inserted_id is optional
+          { 'insertedId' => document['_id'] }
+        end
+
+        def update_return_doc(result)
+          return_doc = { 'upsertedId' => result.upserted_id } if upsert
+          (return_doc || {}).merge!({ 'matchedCount' => result.matched_count,
+                                      'modifiedCount' => result.modified_count })
+        end
+
+        def replace_one(collection)
+          result = collection.find(filter).replace_one(replacement, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def update_many(collection)
+          result = collection.find(filter).update_many(update, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def update_one(collection)
+          result = collection.find(filter).update_one(update, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def find_one_and_delete(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_delete
+        end
+
+        def find_one_and_replace(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_replace(replacement, upsert: upsert, return_document: return_document)
+        end
+
+        def find_one_and_update(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_update(update, upsert: upsert, return_document: return_document)
+        end
+
+        def replacement
+          arguments['replacement']
+        end
+
+        def documents
+          arguments['documents']
+        end
+
+        def document
+          arguments['document']
+        end
+
+        def filter
+          arguments['filter']
+        end
+
+        def upsert
+          arguments['upsert']
+        end
+
+        def return_document
+          :after if arguments['returnDocument']
+        end
+
+        def update
+          arguments['update']
+        end
+
+        def arguments
+          @spec['arguments']
+        end
+      end
+    end
+  end
+end