mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/grid/fs_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Mongo::Grid::FS do
+
+  describe '#initialize' do
+
+    let(:fs) do
+      described_class.new(authorized_client.database)
+    end
+
+    let(:index) do
+      fs.chunks_collection.indexes.get(:files_id => 1, :n => 1)
+    end
+
+    it 'sets the files collection' do
+      expect(fs.files_collection.name).to eq('fs.files')
+    end
+
+    it 'sets the chunks collection' do
+      expect(fs.chunks_collection.name).to eq('fs.chunks')
+    end
+
+    it 'creates the index on the chunks collection' do
+      expect(index[:name]).to eq('files_id_1_n_1')
+    end
+  end
+
+  describe '#find_one' do
+
+    let(:fs) do
+      described_class.new(authorized_client.database)
+    end
+
+    let(:file) do
+      Mongo::Grid::File.new('hello world!', :filename => 'test.txt')
+    end
+
+    before do
+      fs.insert_one(file)
+    end
+
+    after do
+      fs.files_collection.find.remove_many
+      fs.chunks_collection.find.remove_many
+    end
+
+    let(:from_db) do
+      fs.find_one(:filename => 'test.txt')
+    end
+
+    it 'returns the assembled file from the db' do
+      expect(from_db.filename).to eq(file.metadata.filename)
+    end
+  end
+
+  describe '#insert_one' do
+
+    let(:fs) do
+      described_class.new(authorized_client.database)
+    end
+
+    let(:file) do
+      Mongo::Grid::File.new('Hello!', :filename => 'test.txt')
+    end
+
+    context 'when inserting the file once' do
+
+      before do
+        fs.insert_one(file)
+      end
+
+      after do
+        fs.files_collection.find.remove_many
+        fs.chunks_collection.find.remove_many
+      end
+
+      let(:from_db) do
+        fs.find_one(:filename => 'test.txt')
+      end
+
+      it 'inserts the file into the database' do
+        expect(from_db.filename).to eq(file.metadata.filename)
+      end
+
+      it 'includes the chunks and data with the file' do
+        expect(from_db.data).to eq('Hello!')
+      end
+    end
+
+    context 'when inserting the file more than once' do
+
+      after do
+        fs.files_collection.find.remove_many
+        fs.chunks_collection.find.remove_many
+      end
+
+      it 'raises an error' do
+        expect {
+          fs.insert_one(file)
+          fs.insert_one(file)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  describe '#remove_one' do
+
+    let(:fs) do
+      described_class.new(authorized_client.database)
+    end
+
+    let(:file) do
+      Mongo::Grid::File.new('Hello!', :filename => 'test.txt')
+    end
+
+    before do
+      fs.insert_one(file)
+      fs.remove_one(file)
+    end
+
+    let(:from_db) do
+      fs.find_one(:filename => 'test.txt')
+    end
+
+    it 'removes the file from the db' do
+      expect(from_db).to be_nil
+    end
+  end
+end

data/spec/mongo/index/view_spec.rb

@@ -0,0 +1,226 @@
+require 'spec_helper'
+
+describe Mongo::Index::View do
+
+  let(:view) do
+    described_class.new(authorized_collection)
+  end
+
+  describe '#drop' do
+
+    let(:spec) do
+      { another: -1 }
+    end
+
+    before do
+      view.create(spec, unique: true)
+    end
+
+    context 'when providing an index spec' do
+
+      context 'when the index exists' do
+
+        let(:result) do
+          view.drop(spec)
+        end
+
+        it 'drops the index' do
+          expect(result).to be_successful
+        end
+      end
+    end
+
+    context 'when providing an index name' do
+
+      context 'when the index exists' do
+
+        let(:result) do
+          view.drop('another_-1')
+        end
+
+        it 'drops the index' do
+          expect(result).to be_successful
+        end
+      end
+    end
+  end
+
+  describe '#drop_all' do
+
+    let(:spec) do
+      { another: -1 }
+    end
+
+    before do
+      view.create(spec, unique: true)
+    end
+
+    context 'when indexes exists' do
+
+      let(:result) do
+        view.drop_all
+      end
+
+      it 'drops the index' do
+        expect(result).to be_successful
+      end
+    end
+  end
+
+  describe '#create' do
+
+    context 'when the index is created' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let(:result) do
+        view.create(spec, unique: true)
+      end
+
+      after do
+        view.drop(spec)
+      end
+
+      it 'returns ok' do
+        expect(result).to be_successful
+      end
+    end
+
+    context 'when index creation fails' do
+
+      let(:spec) do
+        { name: 1 }
+      end
+
+      before do
+        view.create(spec, unique: true)
+      end
+
+      after do
+        view.drop(spec)
+      end
+
+      it 'raises an exception', if: write_command_enabled? do
+        expect {
+          view.create(spec, unique: false)
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+
+      it 'does not raise an exception', unless: write_command_enabled? do
+        expect(view.create(spec, unique: false)).to be_successful
+      end
+    end
+
+    context 'when providing an index name' do
+
+      let(:spec) do
+        { random: 1 }
+      end
+
+      let!(:result) do
+        view.create(spec, unique: true, name: 'random_name')
+      end
+
+      after do
+        view.drop('random_name')
+      end
+
+      it 'returns ok' do
+        expect(result).to be_successful
+      end
+
+      it 'defines the index with the provided name' do
+        expect(view.get('random_name')).to_not be_nil
+      end
+    end
+  end
+
+  describe '#get' do
+
+    let(:spec) do
+      { random: 1 }
+    end
+
+    let!(:result) do
+      view.create(spec, unique: true, name: 'random_name')
+    end
+
+    after do
+      view.drop('random_name')
+    end
+
+    context 'when providing a name' do
+
+      let(:index) do
+        view.get('random_name')
+      end
+
+      it 'returns the index' do
+        expect(index['name']).to eq('random_name')
+      end
+    end
+
+    context 'when providing a spec' do
+
+      let(:index) do
+        view.get(random: 1)
+      end
+
+      it 'returns the index' do
+        expect(index['name']).to eq('random_name')
+      end
+    end
+
+    context 'when the index does not exist' do
+
+      it 'returns nil' do
+        expect(view.get(other: 1)).to be_nil
+      end
+    end
+  end
+
+  describe '#each' do
+
+    context 'when the collection exists' do
+
+      let(:spec) do
+        { name: 1 }
+      end
+
+      before do
+        view.create(spec, unique: true)
+      end
+
+      after do
+        view.drop(spec)
+      end
+
+      let(:indexes) do
+        view.each
+      end
+
+      it 'returns all the indexes for the database' do
+        expect(indexes.to_a.count).to eq(2)
+      end
+    end
+
+    context 'when the collection does not exist' do
+
+      let(:nonexistant_collection) do
+        authorized_client[:not_a_collection]
+      end
+
+      let(:nonexistant_view) do
+        described_class.new(nonexistant_collection)
+      end
+
+      it 'raises a nonexistant collection error', if: list_command_enabled? do
+        expect {
+          nonexistant_view.each.to_a
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

data/spec/mongo/loggable_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Mongo::Loggable do
+
+  let(:operation) do
+    Class.new do
+      def log_message
+        'test'
+      end
+    end.new
+  end
+
+  describe '#log' do
+
+    let(:loggable) do
+      Class.new do
+        include Mongo::Loggable
+      end.new
+    end
+
+    let(:operation) do
+      double('operation')
+    end
+
+    before do
+      expect(operation).to receive(:log_message).and_return('test')
+      expect(Mongo::Logger).to receive(:debug).with('MONGO', 'test', anything())
+    end
+
+    context 'when a block is provided' do
+
+      context 'when an exception occurs' do
+
+        it 'logs the message' do
+          expect {
+            loggable.log(:debug, 'MONGO', [ operation ]) do
+              raise RuntimeError
+            end
+          }.to raise_error(RuntimeError)
+        end
+      end
+
+      context 'when no exception occurs' do
+
+        it 'executes the block and logs the message' do
+          expect(
+            loggable.log(:debug, 'MONGO', [ operation ]) do
+              'testing'
+            end
+          ).to eq('testing')
+        end
+      end
+    end
+
+    context 'when no block is provided' do
+
+      it 'logs the message' do
+        expect(loggable.log(:debug, 'MONGO', [ operation ])).to be_nil
+      end
+    end
+  end
+end

data/spec/mongo/logger_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Mongo::Logger do
+
+  let(:logger) do
+    described_class.logger
+  end
+
+  describe '.debug' do
+
+    it 'logs a debug message' do
+      expect(logger).to receive(:debug).with("mongo.query | message | runtime: 10ms")
+      described_class.debug('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.error' do
+
+    it 'logs a error message' do
+      expect(logger).to receive(:error).with("mongo.query | message | runtime: 10ms")
+      described_class.error('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.fatal' do
+
+    it 'logs a fatal message' do
+      expect(logger).to receive(:fatal).with("mongo.query | message | runtime: 10ms")
+      described_class.fatal('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.info' do
+
+    it 'logs a info message' do
+      expect(logger).to receive(:info).with("mongo.query | message | runtime: 10ms")
+      described_class.info('mongo.query', 'message', '10ms')
+    end
+  end
+
+  describe '.logger' do
+
+    context 'when no logger has been set' do
+
+      let(:test_logger) do
+        Mongo::Logger.logger
+      end
+
+      before do
+        Mongo::Logger.logger = nil
+      end
+
+      after do
+        Mongo::Logger.logger = test_logger
+      end
+
+      it 'returns the default logger' do
+        expect(logger.level).to eq(Logger::DEBUG)
+      end
+    end
+
+    context 'when a logger has been set' do
+
+      let(:info) do
+        Logger.new($stdout).tap do |log|
+          log.level = Logger::INFO
+        end
+      end
+
+      let(:debug) do
+        Logger.new($stdout).tap do |log|
+          log.level = Logger::DEBUG
+        end
+      end
+
+      before do
+        described_class.logger = debug
+      end
+
+      after do
+        described_class.logger = info
+      end
+
+      it 'returns the provided logger' do
+        expect(logger.level).to eq(Logger::DEBUG)
+      end
+    end
+  end
+
+  describe '.warn' do
+
+    it 'logs a warn message' do
+      expect(logger).to receive(:warn).with("mongo.query | message | runtime: 10ms")
+      described_class.warn('mongo.query', 'message', '10ms')
+    end
+  end
+end