mongo 2.0.0.rc → 2.0.0

data/spec/mongo/operation/write/update_spec.rb

@@ -92,7 +92,7 @@ describe Mongo::Operation::Write::Update do
         })
       end
 
-      context 'when the update passes' do
+      context 'when the update succeeds' do
 
         let(:document) do
           { q: { name: 'test' }, u: { '$set' => { field: 'blah' }}, limit: 1 }
@@ -105,6 +105,18 @@ describe Mongo::Operation::Write::Update do
         it 'updates the document' do
           expect(result.written_count).to eq(1)
         end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(1)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(1)
+        end
+
+        it 'reports the upserted id as nil' do
+          expect(result.upserted_id).to eq(nil)
+        end
       end
 
       context 'when the update fails' do
@@ -145,6 +157,18 @@ describe Mongo::Operation::Write::Update do
         it 'updates the documents' do
           expect(result.written_count).to eq(2)
         end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(2)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(2)
+        end
+
+        it 'reports the upserted id as nil' do
+          expect(result.upserted_id).to eq(nil)
+        end
       end
 
       context 'when an update fails' do
@@ -172,6 +196,33 @@ describe Mongo::Operation::Write::Update do
           }.to raise_error(Mongo::Error::MaxBSONSize)
         end
       end
+
+      context 'when upsert is true' do
+
+        let(:document) do
+          { q: { field: 'non-existent' }, u: { '$set' => { other: 'blah' }}, upsert: true }
+        end
+
+        let(:result) do
+          update.execute(authorized_primary.context)
+        end
+
+        it 'inserts the document' do
+          expect(result.written_count).to eq(1)
+        end
+
+        it 'reports the modified count' do
+          expect(result.modified_count).to eq(0)
+        end
+
+        it 'reports the matched count' do
+          expect(result.matched_count).to eq(0)
+        end
+
+        it 'retruns the upserted id' do
+          expect(result.upserted_id).to be_a(BSON::ObjectId)
+        end
+      end
     end
   end
 end

data/spec/mongo/server/connection_spec.rb

@@ -154,19 +154,14 @@ describe Mongo::Server::Connection do
       Mongo::Protocol::Query.new(TEST_DB, TEST_COLL, { 'name' => 'testing' })
     end
 
-    let(:delete) do
-      Mongo::Protocol::Delete.new(TEST_DB, TEST_COLL, {})
-    end
-
     context 'when providing a single message' do
 
       let(:reply) do
         connection.dispatch([ insert, query ])
       end
 
-      # @todo: Can remove this once we have more implemented with global hooks.
       after do
-        connection.dispatch([ delete ])
+        authorized_collection.find.delete_many
       end
 
       it 'it dispatchs the message to the socket' do
@@ -188,9 +183,8 @@ describe Mongo::Server::Connection do
         connection.dispatch([ insert, command ])
       end
 
-      # @todo: Can remove this once we have more implemented with global hooks.
       after do
-        connection.dispatch([ delete ])
+        authorized_collection.find.delete_many
       end
 
       it 'it dispatchs the message to the socket' do
@@ -216,6 +210,31 @@ describe Mongo::Server::Connection do
         expect(connection).to_not be_connected
       end
     end
+
+    context 'when the process is forked' do
+
+      let(:insert) do
+        Mongo::Protocol::Insert.new(TEST_DB, TEST_COLL, documents)
+      end
+
+      before do
+        expect(Process).to receive(:pid).at_least(:once).and_return(1)
+      end
+
+      after do
+        authorized_collection.find.delete_many
+      end
+
+      it 'disconnects the connection' do
+        expect(connection).to receive(:disconnect!).and_call_original
+        connection.dispatch([ insert ])
+      end
+
+      it 'sets a new pid' do
+        connection.dispatch([ insert ])
+        expect(connection.pid).to eq(1)
+      end
+    end
   end
 
   describe '#initialize' do
@@ -252,12 +271,16 @@ describe Mongo::Server::Connection do
 
     context 'when ssl options are provided' do
 
+      let(:ssl_options) do
+        { :ssl => true, :ssl_key => 'file', :ssl_key_pass_phrase => 'iamaphrase' }
+      end
+
       let(:connection) do
-        described_class.new(server, :ssl => true)
+        described_class.new(server, ssl_options)
       end
 
       it 'sets the ssl options' do
-        expect(connection.send(:ssl_options)).to eq(:ssl => true)
+        expect(connection.send(:ssl_options)).to eq(ssl_options)
       end
     end
 

data/spec/mongo/server/monitor_spec.rb

@@ -12,6 +12,20 @@ describe Mongo::Server::Monitor do
 
   describe '#scan!' do
 
+    context 'when calling multiple times in succession' do
+
+      let(:monitor) do
+        described_class.new(address, listeners)
+      end
+
+      it 'throttles the scans to minimum 500ms' do
+        start = Time.now
+        monitor.scan!
+        monitor.scan!
+        expect(Time.now - start).to be > 0.5
+      end
+    end
+
     context 'when the ismaster command succeeds' do
 
       let(:monitor) do

data/spec/spec_helper.rb

@@ -22,10 +22,10 @@ require 'mongo'
 require 'support/travis'
 require 'support/matchers'
 require 'support/authorization'
-require 'support/mongo_orchestration'
 require 'support/server_discovery_and_monitoring'
 require 'support/server_selection_rtt'
 require 'support/server_selection'
+require 'support/crud'
 
 Mongo::Logger.logger = Logger.new($stdout)
 Mongo::Logger.logger.level = Logger::INFO
@@ -67,6 +67,7 @@ CURRENT_PATH = File.expand_path(File.dirname(__FILE__))
 SERVER_DISCOVERY_TESTS = Dir.glob("#{CURRENT_PATH}/support/sdam/**/*.yml")
 SERVER_SELECTION_RTT_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/rtt/*.yml")
 SERVER_SELECTION_TESTS = Dir.glob("#{CURRENT_PATH}/support/server_selection/selection/**/*.yml")
+CRUD_TESTS = Dir.glob("#{CURRENT_PATH}/support/crud_tests/**/*.yml")
 
 # Determine whether the test clients are connecting to a standlone.
 #
@@ -128,21 +129,5 @@ def initialize_scanned_client!
   Mongo::Client.new(ADDRESSES, database: TEST_DB, connect: CONNECT)
 end
 
-def initialize_mo_standalone!(path = nil)
-  $mongo_standalone ||= MongoOrchestration.get(:standalone, path: path)
-end
-
-def stop_mo_standalone!
-  $mongo_standalone.stop if $mongo_standalone
-end
-
-def mongo_orchestration_available?(path = nil)
-  begin
-    MongoOrchestration.get(:standalone, path: path)
-  rescue MongoOrchestration::ServiceNotAvailable
-    return false
-  end
-end
-
 # require all shared examples
 Dir['./spec/support/shared/*.rb'].sort.each { |file| require file }

data/spec/support/crud.rb

@@ -0,0 +1,203 @@
+# 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.
+
+# Matcher for determining if the results of the opeartion match the
+# test's expected results.
+#
+# @since 2.0.0
+
+# Matcher for determining if the collection's data matches the
+# test's expected collection data.
+#
+# @since 2.0.0
+RSpec::Matchers.define :match_collection_data do |test|
+
+  match do |actual|
+    test.compare_collection_data
+  end
+end
+
+require 'support/crud/read'
+require 'support/crud/write'
+
+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)
+        @spec = YAML.load(ERB.new(File.new(file).read).result)
+        @description = File.basename(file)
+        @data = @spec['data']
+        @crud_tests = @spec['tests']
+      end
+
+      # 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
+      end
+    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
+
+      # 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
+        @description = test['description']
+        @operation = Operation.get(test['operation'])
+        @outcome = test['outcome']
+      end
+
+      # 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)
+        @collection = collection
+        @collection.insert_many(@data)
+        @operation.execute(collection)
+      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
+
+      # Compare the existing collection data and the expected collection data.
+      #
+      # @example Compare the existing and expected collection data.
+      #   test.compare_collection_data
+      #
+      # @return [ true, false ] The result of comparing the existing and expected
+      #  collection data.
+      #
+      # @since 2.0.0
+      def compare_collection_data
+        actual_collection_data == outcome_collection_data
+      end
+
+      # Whether this test requires server version >= 2.6 for its results to match
+      # the expected results.
+      #
+      # @example If this test requires >= 2.6.
+      #   test.requires_2_6?(collection)
+      #
+      # @param [ true, false ] If write commands are enabled on the server.
+      # @param [ Collection ] The collection the test is run on.
+      #
+      # @return [ true, false ] Whether the test requires server >= 2.6.
+      #
+      # @since 2.0.0
+      def requires_2_6?(write_command_enabled, collection)
+        !write_command_enabled && @operation.requires_2_6?(collection)
+      end
+
+      private
+
+      def outcome_collection_data
+        @outcome['collection']['data'] if @outcome['collection']
+      end
+
+      def actual_collection_data
+        if @outcome['collection']
+          collection_name = @outcome['collection']['name'] || @collection.name
+          @collection.database[collection_name].find.to_a
+        end
+      end
+    end
+
+    # 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)
+        end
+      end
+    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