mongo 2.0.6 → 2.1.0

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,115 @@
+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
+
+        module Mongo
+          class Address
+
+            private
+
+            alias :original_initialize_resolver! :initialize_resolver!
+            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 Server
+
+            # The constructor keeps the same API, but does not instantiate a
+            # monitor and run it.
+            alias :original_initialize :initialize
+            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.
+            alias :original_disconnect! :disconnect!
+            def disconnect!; true; end
+          end
+        end
+      end
+
+      after(:all) do
+
+        module Mongo
+          # Return the implementations to their originals for the other
+          # tests in the suite.
+          class Address
+            alias :initialize_resolver! :original_initialize_resolver!
+            remove_method(:original_initialize_resolver!)
+          end
+
+          class Server
+            alias :initialize :original_initialize
+            remove_method(:original_initialize)
+
+            alias :disconnect! :original_disconnect!
+            remove_method(:original_disconnect!)
+          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/crud_spec.rb

@@ -13,11 +13,11 @@ describe 'CRUD' do
         context(test.description) do
 
           before(:each) do
-            authorized_collection.find.delete_many
+            authorized_collection.delete_many
           end
 
           after(:each) do
-            authorized_collection.find.delete_many
+            authorized_collection.delete_many
           end
 
           let(:results) do

data/spec/mongo/cursor_spec.rb

@@ -33,7 +33,7 @@ describe Mongo::Cursor do
         end
 
         after do
-          authorized_collection.find.delete_many
+          authorized_collection.delete_many
         end
 
         it 'returns the correct amount' do
@@ -58,7 +58,7 @@ describe Mongo::Cursor do
         end
 
         after do
-          authorized_collection.find.delete_many
+          authorized_collection.delete_many
         end
 
         it 'returns the correct amount' do
@@ -84,7 +84,7 @@ describe Mongo::Cursor do
       end
 
       after do
-        authorized_collection.find.delete_many
+        authorized_collection.delete_many
       end
 
       context 'when a limit is provided' do

data/spec/mongo/database_spec.rb

@@ -93,6 +93,26 @@ describe Mongo::Database do
         expect(database.collection_names(batch_size: 1).to_a).to include('users')
       end
     end
+
+    context 'when there are more collections than the initial batch size' do
+
+      before do
+        200.times do |i|
+          database["#{i}_dalmatians"].create
+        end
+      end
+
+      after do
+        200.times do |i|
+          database["#{i}_dalmatians"].drop
+        end
+      end
+
+      it 'returns all collections' do
+        expect(database.collection_names.select { |c| c =~ /dalmatians/}.size).to eq(200)
+      end
+
+    end
   end
 
   describe '#list_collections' do
@@ -195,7 +215,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 +298,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 +312,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 +321,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 +337,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/dbref_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+require 'json'
+
+describe Mongo::DBRef do
+
+  let(:object_id) do
+    BSON::ObjectId.new
+  end
+
+  describe '#as_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.as_json).to eq({ '$ref' => 'users', '$id' => object_id })
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.as_json).to eq({
+          '$ref' => 'users',
+          '$id' => object_id,
+          '$db' => 'database'
+        })
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:dbref) do
+      described_class.new('users', object_id)
+    end
+
+    it 'sets the collection' do
+      expect(dbref.collection).to eq('users')
+    end
+
+    it 'sets the id' do
+      expect(dbref.id).to eq(object_id)
+    end
+
+    context 'when a database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'db')
+      end
+
+      it 'sets the database' do
+        expect(dbref.database).to eq('db')
+      end
+    end
+  end
+
+  describe '#to_bson' do
+
+    let(:dbref) do
+      described_class.new('users', object_id, 'database')
+    end
+
+    it 'converts the underlying document to bson' do
+      expect(dbref.to_bson).to eq(dbref.as_json.to_bson)
+    end
+  end
+
+  describe '#to_json' do
+
+    context 'when the database is not provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'returns the json document without database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json}}")
+      end
+    end
+
+    context 'when the database is provided' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'returns the json document with database' do
+        expect(dbref.to_json).to eq("{\"$ref\":\"users\",\"$id\":#{object_id.to_json},\"$db\":\"database\"}")
+      end
+    end
+  end
+
+  describe '#from_bson' do
+
+    let(:bson) do
+      StringIO.new(dbref.to_bson)
+    end
+
+    let(:decoded) do
+      BSON::Document.from_bson(bson)
+    end
+
+    context 'when a database exists' do
+
+      let(:dbref) do
+        described_class.new('users', object_id, 'database')
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'decodes the database' do
+        expect(decoded.database).to eq('database')
+      end
+    end
+
+    context 'when no database exists' do
+
+      let(:dbref) do
+        described_class.new('users', object_id)
+      end
+
+      it 'decodes the ref' do
+        expect(decoded.collection).to eq('users')
+      end
+
+      it 'decodes the id' do
+        expect(decoded.id).to eq(object_id)
+      end
+
+      it 'sets the database to nil' do
+        expect(decoded.database).to be_nil
+      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