mongo 2.1.0.beta → 2.1.0.rc0

data/spec/mongo/command_monitoring_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+def runnable?(file)
+  !write_command_enabled? && (file.include?('bulkWrite') || file.include?('insert'))
+end
+
+describe 'Command Monitoring Events' do
+
+  COMMAND_MONITORING_TESTS.each do |file|
+
+    spec = Mongo::CommandMonitoring::Spec.new(file)
+
+    spec.tests.each do |test|
+
+      context(test.description) do
+
+        let(:subscriber) do
+          Mongo::CommandMonitoring::TestSubscriber.new
+        end
+
+        let(:monitoring) do
+          authorized_client.instance_variable_get(:@monitoring)
+        end
+
+        before do
+          authorized_collection.find.delete_many
+          authorized_client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        end
+
+        after do
+          monitoring.subscribers[Mongo::Monitoring::COMMAND].delete(subscriber)
+          authorized_collection.find.delete_many
+        end
+
+        test.expectations.each do |expectation|
+
+          it "generates a #{expectation.event_name} for #{expectation.command_name}", unless: runnable?(file) do
+            begin
+              test.run(authorized_collection)
+              event = subscriber.send(expectation.event_type)[expectation.command_name]
+              expect(event).to send(expectation.matcher, expectation)
+            rescue Mongo::Error::OperationFailure, Mongo::Error::BulkWriteError => e
+              event = subscriber.send(expectation.event_type)[expectation.command_name]
+              expect(event).to send(expectation.matcher, expectation)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/connection_string_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe 'ConnectionString' do
+  include Mongo::ConnectionString
+
+  CONNECTION_STRING_TESTS.each do |file|
+
+    spec = Mongo::ConnectionString::Spec.new(file)
+
+    context(spec.description) do
+
+      before(:all) do
+
+        class Mongo::Address
+
+          private
+
+          def initialize_resolver!(timeout, ssl_options)
+            family = (host == 'localhost') ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
+            info = ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM)
+            FAMILY_MAP[info.first[4]].new(info[3], port, host)
+          end
+        end
+
+        class Mongo::Server
+
+          # The constructor keeps the same API, but does not instantiate a
+          # monitor and run it.
+          def initialize(address, cluster, monitoring, event_listeners, options = {})
+            @address = address
+            @cluster = cluster
+            @monitoring = monitoring
+            @options = options.freeze
+            @monitor = Monitor.new(address, event_listeners, options)
+          end
+
+          # Disconnect simply needs to return true since we have no monitor and
+          # no connection.
+          def disconnect!; true; end
+        end
+      end
+
+      after(:all) do
+
+        # Return the server implementation to its original for the other
+        # tests in the suite.
+        class Mongo::Server
+
+          # Returns the constructor to its original implementation.
+          def initialize(address, cluster, monitoring, event_listeners, options = {})
+            @address = address
+            @cluster = cluster
+            @monitoring = monitoring
+            @options = options.freeze
+            @monitor = Monitor.new(address, event_listeners, options)
+            @monitor.scan!
+            @monitor.run!
+          end
+
+          # Returns disconnect! to its original implementation.
+          def disconnect!
+            context.with_connection do |connection|
+              connection.disconnect!
+            end
+            @monitor.stop! and true
+          end
+        end
+
+        class Mongo::Address
+
+          private
+
+          def initialize_resolver!(timeout, ssl_options)
+            family = (host == 'localhost') ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
+            error = nil
+            ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM).each do |info|
+              begin
+                res = FAMILY_MAP[info[4]].new(info[3], port, host)
+                res.socket(timeout, ssl_options).connect!.close
+                return res
+              rescue IOError, SystemCallError, Error::SocketError => e
+                error = e
+              end
+            end
+            raise error
+          end
+        end
+      end
+
+      spec.tests.each_with_index do |test, index|
+
+        context "when a #{test.description} is provided" do
+
+
+          context 'when the uri is invalid', unless: test.valid? do
+
+            it 'raises an error' do
+              expect{
+                test.uri
+              }.to raise_exception(Mongo::Error::InvalidURI)
+            end
+          end
+
+          context 'when the uri should warn', if: test.warn? do
+
+            before do
+              expect(Mongo::Logger.logger).to receive(:warn)
+            end
+
+            it 'warns' do
+              expect(test.client).to be_a(Mongo::Client)
+            end
+          end
+
+          context 'when the uri is valid', if: test.valid? do
+
+            it 'does not raise an exception' do
+              expect(test.uri).to be_a(Mongo::URI)
+            end
+
+            it 'creates a client with the correct hosts' do
+              expect(test.client).to have_hosts(test)
+            end
+
+            it 'creates a client with the correct authentication properties' do
+              expect(test.client).to match_auth(test)
+            end
+
+            it 'creates a client with the correct options' do
+              expect(test.client).to match_options(test)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/database_spec.rb

@@ -195,7 +195,7 @@ describe Mongo::Database do
       end
 
       let(:client) do
-        authorized_client.with(server_selection_timeout: 2)
+        authorized_client.with(server_selection_timeout: 0.1)
       end
 
       let(:database) do
@@ -278,7 +278,7 @@ describe Mongo::Database do
     shared_context 'a GridFS database' do
 
       it 'returns a Grid::FS for the db' do
-        expect(fs).to be_a(Mongo::Grid::FS)
+        expect(fs).to be_a(Mongo::Grid::FSBucket)
       end
 
       context 'when operating on the fs' do
@@ -292,8 +292,8 @@ describe Mongo::Database do
         end
 
         after do
-          fs.files_collection.find.delete_many
-          fs.chunks_collection.find.delete_many
+          fs.files_collection.delete_many
+          fs.chunks_collection.delete_many
         end
 
         let(:from_db) do
@@ -301,7 +301,7 @@ describe Mongo::Database do
         end
 
         it 'returns the assembled file from the db' do
-          expect(from_db.filename).to eq(file.metadata.filename)
+          expect(from_db.filename).to eq(file.info.filename)
         end
       end
     end
@@ -317,15 +317,31 @@ describe Mongo::Database do
 
     context 'when a custom prefix is provided' do
 
-      let(:fs) do
-        database.fs(:fs_name => 'grid')
-      end
+      context 'when the option is fs_name' do
+
+        let(:fs) do
+          database.fs(:fs_name => 'grid')
+        end
 
-      it 'sets the custom prefix' do
-        expect(fs.prefix).to eq('grid')
+        it 'sets the custom prefix' do
+          expect(fs.prefix).to eq('grid')
+        end
+
+        it_behaves_like 'a GridFS database'
       end
 
-      it_behaves_like 'a GridFS database'
+      context 'when the option is bucket_name' do
+
+        let(:fs) do
+          database.fs(:bucket_name => 'grid')
+        end
+
+        it 'sets the custom prefix' do
+          expect(fs.prefix).to eq('grid')
+        end
+
+        it_behaves_like 'a GridFS database'
+      end
     end
   end
 end

data/spec/mongo/grid/file/chunk_spec.rb

@@ -10,8 +10,8 @@ describe Mongo::Grid::File::Chunk do
     BSON::ObjectId.new
   end
 
-  let(:metadata) do
-    Mongo::Grid::File::Metadata.new(:files_id => file_id)
+  let(:file_info) do
+    Mongo::Grid::File::Info.new(:files_id => file_id)
   end
 
   describe '#==' do
@@ -72,7 +72,7 @@ describe Mongo::Grid::File::Chunk do
     end
 
     let(:chunks) do
-      described_class.split(raw_data, metadata)
+      described_class.split(raw_data, file_info)
     end
 
     it 'returns the chunks assembled into the raw data' do
@@ -157,7 +157,7 @@ describe Mongo::Grid::File::Chunk do
       end
 
       let(:chunks) do
-        described_class.split(raw_data, metadata)
+        described_class.split(raw_data, file_info)
       end
 
       let(:chunk) do
@@ -204,7 +204,7 @@ describe Mongo::Grid::File::Chunk do
       end
 
       let(:chunks) do
-        described_class.split(raw_data, metadata)
+        described_class.split(raw_data, file_info)
       end
 
       it 'returns the correct number of chunks' do

data/spec/mongo/grid/file/{metadata_spec.rb → info_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Mongo::Grid::File::Metadata do
+describe Mongo::Grid::File::Info do
 
   describe '#==' do
 
@@ -8,23 +8,23 @@ describe Mongo::Grid::File::Metadata do
       Time.now.utc
     end
 
-    let(:metadata) do
+    let(:info) do
       described_class.new(:filename => 'test.txt', :length => 7, :uploadDate => upload_date)
     end
 
-    context 'when the other is not metadata' do
+    context 'when the other is not a file info object' do
 
       it 'returns false' do
-        expect(metadata).to_not eq('test')
+        expect(info).to_not eq('test')
       end
     end
 
-    context 'when the other object is metadata' do
+    context 'when the other object is file info object' do
 
       context 'when the documents are equal' do
 
         it 'returns true' do
-          expect(metadata).to eq(metadata)
+          expect(info).to eq(info)
         end
       end
 
@@ -35,7 +35,7 @@ describe Mongo::Grid::File::Metadata do
         end
 
         it 'returns false' do
-          expect(metadata).to_not eq(other)
+          expect(info).to_not eq(other)
         end
       end
     end
@@ -45,48 +45,60 @@ describe Mongo::Grid::File::Metadata do
 
     context 'when provided only a filename and length' do
 
-      let(:metadata) do
+      let(:info) do
         described_class.new(:filename => 'test.txt', :length => 7)
       end
 
       it 'sets the default id' do
-        expect(metadata.id).to be_a(BSON::ObjectId)
+        expect(info.id).to be_a(BSON::ObjectId)
       end
 
       it 'sets the upload date' do
-        expect(metadata.upload_date).to be_a(Time)
+        expect(info.upload_date).to be_a(Time)
       end
 
       it 'sets the chunk size' do
-        expect(metadata.chunk_size).to eq(Mongo::Grid::File::Chunk::DEFAULT_SIZE)
+        expect(info.chunk_size).to eq(Mongo::Grid::File::Chunk::DEFAULT_SIZE)
       end
 
       it 'sets the content type' do
-        expect(metadata.content_type).to eq(Mongo::Grid::File::Metadata::DEFAULT_CONTENT_TYPE)
+        expect(info.content_type).to eq(Mongo::Grid::File::Info::DEFAULT_CONTENT_TYPE)
       end
     end
   end
 
   describe '#inspect' do
 
-    let(:metadata) do
+    let(:info) do
       described_class.new(:filename => 'test.txt', :length => 7)
     end
 
     it 'includes the chunk size' do
-      expect(metadata.inspect).to include(metadata.chunk_size.to_s)
+      expect(info.inspect).to include(info.chunk_size.to_s)
     end
 
     it 'includes the filename' do
-      expect(metadata.inspect).to include(metadata.filename)
+      expect(info.inspect).to include(info.filename)
     end
 
     it 'includes the md5' do
-      expect(metadata.inspect).to include(metadata.md5.to_s)
+      expect(info.inspect).to include(info.md5.to_s)
     end
 
     it 'includes the id' do
-      expect(metadata.inspect).to include(metadata.id.to_s)
+      expect(info.inspect).to include(info.id.to_s)
+    end
+  end
+
+  context 'when there are extra options' do
+
+    let(:info) do
+      described_class.new(:filename => 'test.txt', :extra_field => 'extra')
+    end
+
+    it 'does not include them in the document written to the database' do
+      expect(info.document['extra_field']).to be_nil
+      expect(info.document[:extra_field]).to be_nil
     end
   end
 end

data/spec/mongo/grid/file_spec.rb

@@ -51,7 +51,7 @@ describe Mongo::Grid::File do
       (1..data_size).each{ |i| data << '1' }
     end
 
-    context 'when provided data and metadata' do
+    context 'when provided data and file information' do
 
       let(:file) do
         described_class.new(data, :filename => 'test.txt')
@@ -118,31 +118,31 @@ describe Mongo::Grid::File do
       end
     end
 
-    context 'when provided chunks and metadata' do
+    context 'when provided chunks and file information' do
 
       let(:file_id) do
         BSON::ObjectId.new
       end
 
-      let(:metadata) do
+      let(:info) do
         BSON::Document.new(
           :_id => file_id,
           :uploadDate => Time.now.utc,
           :filename => 'test.txt',
           :chunkSize => Mongo::Grid::File::Chunk::DEFAULT_SIZE,
           :length => data.length,
-          :contentType => Mongo::Grid::File::Metadata::DEFAULT_CONTENT_TYPE
+          :contentType => Mongo::Grid::File::Info::DEFAULT_CONTENT_TYPE
         )
       end
 
       let(:chunks) do
         Mongo::Grid::File::Chunk.split(
-          data, Mongo::Grid::File::Metadata.new(metadata)
+          data, Mongo::Grid::File::Info.new(info)
         ).map{ |chunk| chunk.document }
       end
 
       let(:file) do
-        described_class.new(chunks, metadata)
+        described_class.new(chunks, info)
       end
 
       it 'sets the chunks' do
@@ -153,8 +153,8 @@ describe Mongo::Grid::File do
         expect(file.data).to eq(data)
       end
 
-      it 'sets the metadata' do
-        expect(file.metadata.id).to eq(metadata[:_id])
+      it 'sets the file information' do
+        expect(file.info.id).to eq(info[:_id])
       end
     end
   end