mongo 2.4.1 → 2.14.0

data/spec/mongo/grid/stream/read_spec.rb

@@ -2,6 +2,15 @@ require 'spec_helper'
 
 describe Mongo::Grid::FSBucket::Stream::Read do
 
+  let(:support_fs) do
+    authorized_client.database.fs(fs_options)
+  end
+
+  before do
+    support_fs.files_collection.drop rescue nil
+    support_fs.chunks_collection.drop rescue nil
+  end
+
   let(:fs_options) do
     { }
   end
@@ -22,11 +31,6 @@ describe Mongo::Grid::FSBucket::Stream::Read do
     fs.upload_from_stream(filename, File.open(__FILE__))
   end
 
-  after do
-    fs.files_collection.delete_many
-    fs.chunks_collection.delete_many
-  end
-
   let(:stream) do
     described_class.new(fs, options)
   end
@@ -68,11 +72,11 @@ describe Mongo::Grid::FSBucket::Stream::Read do
         end
 
         it 'sets the read preference' do
-          expect(stream.read_preference).to eq(Mongo::ServerSelector.get(options[:read]))
+          expect(stream.read_preference).to eq(options[:read])
         end
 
         it 'sets the read preference on the view' do
-          expect(stream.send(:view).read).to eq(Mongo::ServerSelector.get(options[:read]))
+          expect(stream.send(:view).read).to eq(BSON::Document.new(options[:read]))
         end
       end
 
@@ -95,11 +99,6 @@ describe Mongo::Grid::FSBucket::Stream::Read do
       fs.upload_from_stream(filename, File.open(__FILE__))
     end
 
-    after do
-      fs.files_collection.delete_many
-      fs.chunks_collection.delete_many
-    end
-
     let(:fs_options) do
       { chunk_size: 5 }
     end
@@ -195,11 +194,6 @@ describe Mongo::Grid::FSBucket::Stream::Read do
       fs.upload_from_stream(filename, file)
     end
 
-    after do
-      fs.files_collection.delete_many
-      fs.chunks_collection.delete_many
-    end
-
     it 'returns a string of all data' do
       expect(stream.read.size).to eq(file.size)
     end
@@ -244,10 +238,10 @@ describe Mongo::Grid::FSBucket::Stream::Read do
         stream.close
       end
 
-      it 'raises an exception' do
+      it 'does not raise an exception' do
         expect {
           stream.close
-        }.to raise_error(Mongo::Error::ClosedStream)
+        }.not_to raise_error
       end
     end
   end

data/spec/mongo/grid/stream/write_spec.rb

@@ -2,6 +2,15 @@ require 'spec_helper'
 
 describe Mongo::Grid::FSBucket::Stream::Write do
 
+  let(:support_fs) do
+    authorized_client.database.fs(fs_options)
+  end
+
+  before do
+    support_fs.files_collection.drop rescue nil
+    support_fs.chunks_collection.drop rescue nil
+  end
+
   let(:file) do
     File.open(__FILE__)
   end
@@ -27,12 +36,7 @@ describe Mongo::Grid::FSBucket::Stream::Write do
   end
 
   let(:options) do
-    { filename: filename }.merge(extra_options)
-  end
-
-  after do
-    fs.files_collection.delete_many
-    fs.chunks_collection.delete_many
+    { filename: filename }.merge(extra_options).merge(fs.options)
   end
 
   let(:stream) do
@@ -53,10 +57,50 @@ describe Mongo::Grid::FSBucket::Stream::Write do
       expect(stream.close).to be_a(BSON::ObjectId)
     end
 
-    context 'when the fs has a write concern', if: standalone? do
+    context 'when the fs does not have disable_md5 specified' do
+
+      it 'sets an md5 for the file' do
+        stream.send(:file_info).to_bson
+        expect(stream.send(:file_info).document[:md5].size).to eq(32)
+      end
+    end
+
+    context 'when the fs has disable_md5 specified' do
+
+      before do
+        stream.send(:file_info).to_bson
+      end
+
+      context 'when disable_md5 is true' do
+
+        let(:fs_options) do
+          { disable_md5: true }
+        end
+
+        it 'does not set an md5 for the file' do
+          expect(stream.send(:file_info).document.has_key?(:md5)). to be(false)
+          expect(stream.send(:file_info).document[:md5]). to be_nil
+        end
+      end
+
+      context 'when disabled_md5 is false' do
+
+        let(:fs_options) do
+          { disable_md5: false }
+        end
+
+        it 'sets an md5 for the file' do
+          stream.send(:file_info).to_bson
+          expect(stream.send(:file_info).document[:md5].size).to eq(32)
+        end
+      end
+    end
+
+    context 'when the fs has a write concern' do
+      require_topology :single
 
       let(:fs_options) do
-        { write: { w: (WRITE_CONCERN[:w] + 1) } }
+        { write: INVALID_WRITE_CONCERN }
       end
 
       it 'uses the write concern of the fs as a default' do
@@ -83,7 +127,7 @@ describe Mongo::Grid::FSBucket::Stream::Write do
 
         let(:extra_options) do
           {
-            write: { w: (WRITE_CONCERN[:w] + 1) }
+            write: INVALID_WRITE_CONCERN
           }
         end
 
@@ -192,11 +236,6 @@ describe Mongo::Grid::FSBucket::Stream::Write do
 
   describe '#write' do
 
-    after do
-      fs.files_collection.delete_many
-      fs.chunks_collection.delete_many
-    end
-
     let(:file_from_db) do
       fs.find_one(filename: filename)
     end
@@ -217,8 +256,6 @@ describe Mongo::Grid::FSBucket::Stream::Write do
       context 'when the files collection is empty' do
 
         before do
-          fs.files_collection.delete_many
-          fs.chunks_collection.delete_many
           expect(fs.files_collection).to receive(:indexes).and_call_original
           expect(fs.chunks_collection).to receive(:indexes).and_call_original
           stream.write(file)
@@ -252,20 +289,48 @@ describe Mongo::Grid::FSBucket::Stream::Write do
         end
       end
 
+      context 'when the files collection is empty but indexes already exist with double values' do
+        before do
+          fs.files_collection.indexes.create_one(
+            { filename: 1.0, uploadDate: 1.0 },
+            name: 'filename_1_uploadDate_1'
+          )
+
+          fs.chunks_collection.indexes.create_one(
+            { files_id: 1.0, n: 1.0 },
+            name: 'files_id_1_n_1',
+            unique: true
+          )
+        end
+
+        it 'does not raise an exception' do
+          expect do
+            stream.write(file)
+          end.not_to raise_error
+        end
+
+        it 'does not create new indexes' do
+          stream.write(file)
+
+          files_indexes = fs.files_collection.indexes.map { |index| index['key'] }
+          chunks_indexes = fs.chunks_collection.indexes.map { |index| index['key'] }
+
+          # Ruby parses the index keys with integer values
+          expect(files_indexes).to eq([{ '_id' => 1 }, { 'filename' => 1, 'uploadDate' => 1 }])
+          expect(chunks_indexes).to eq([{ '_id' => 1 }, { 'files_id' => 1, 'n' => 1 }])
+        end
+      end
+
       context 'when the files collection is not empty' do
 
         before do
-          fs.files_collection.insert_one(a: 1)
+          support_fs.send(:ensure_indexes!)
+          support_fs.files_collection.insert_one(a: 1)
           expect(fs.files_collection).not_to receive(:indexes)
           expect(fs.chunks_collection).not_to receive(:indexes)
           stream.write(file)
         end
 
-        after do
-          fs.files_collection.delete_many
-          fs.chunks_collection.delete_many
-        end
-
         let(:files_index) do
           fs.database[fs.files_collection.name].indexes.get(:filename => 1, :uploadDate => 1)
         end
@@ -275,19 +340,14 @@ describe Mongo::Grid::FSBucket::Stream::Write do
         end
       end
 
-      context 'when the index creation encounters an error', if: write_command_enabled? do
+      context 'when the index creation encounters an error' do
 
         before do
-          fs.chunks_collection.drop
           fs.chunks_collection.indexes.create_one(Mongo::Grid::FSBucket::CHUNKS_INDEX, :unique => false)
           expect(fs.chunks_collection).to receive(:indexes).and_call_original
           expect(fs.files_collection).not_to receive(:indexes)
         end
 
-        after do
-          fs.database[fs.chunks_collection.name].indexes.drop_one('files_id_1_n_1')
-        end
-
         it 'raises the error to the user' do
           expect {
             stream.write(file)

data/spec/mongo/id_spec.rb

@@ -0,0 +1,35 @@
+require 'lite_spec_helper'
+
+describe Mongo::Id do
+  it 'starts with ID 1' do
+    class IdA
+      include Mongo::Id
+    end
+
+    expect(IdA.next_id).to eq(1)
+  end
+
+  it 'increases each subsequent ID' do
+    class IdB
+      include Mongo::Id
+    end
+
+    expect(IdB.next_id).to eq(1)
+    expect(IdB.next_id).to eq(2)
+  end
+
+  it 'correctly generates independent IDs for separate classes' do
+    class IdC
+      include Mongo::Id
+    end
+
+    class IdD
+      include Mongo::Id
+    end
+
+    expect(IdC.next_id).to eq(1)
+    expect(IdD.next_id).to eq(1)
+    expect(IdC.next_id).to eq(2)
+    expect(IdD.next_id).to eq(2)
+  end
+end