mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Aggregation do
+
+  let(:pipeline) do
+    []
+  end
+
+  let(:view_options) do
+    {}
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:selector) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, selector, view_options)
+  end
+
+  let(:aggregation) do
+    described_class.new(view, pipeline, options)
+  end
+
+  describe '#allow_disk_use' do
+
+    let(:new_agg) do
+      aggregation.allow_disk_use(true)
+    end
+
+    it 'sets the value in the options' do
+      expect(new_agg.allow_disk_use).to be true
+    end
+  end
+
+  describe '#each' do
+
+     let(:documents) do
+      [
+        { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
+        { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
+        { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
+      ]
+    end
+
+    let(:pipeline) do
+      [{
+        "$group" => {
+          "_id" => "$city",
+          "totalpop" => { "$sum" => "$pop" }
+        }
+      }]
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    after do
+      authorized_collection.find.remove_many
+    end
+
+    context 'when a block is provided' do
+
+      context 'when no batch size is provided' do
+
+        it 'yields to each document' do
+          aggregation.each do |doc|
+            expect(doc[:totalpop]).to_not be_nil
+          end
+        end
+      end
+
+      context 'when a batch size of 0 is provided' do
+
+        let(:aggregation) do
+          described_class.new(view.batch_size(0), pipeline, options)
+        end
+
+        it 'yields to each document' do
+          aggregation.each do |doc|
+            expect(doc[:totalpop]).to_not be_nil
+          end
+        end
+      end
+
+      context 'when a batch size of greater than zero is provided' do
+
+        let(:aggregation) do
+          described_class.new(view.batch_size(5), pipeline, options)
+        end
+
+        it 'yields to each document' do
+          aggregation.each do |doc|
+            expect(doc[:totalpop]).to_not be_nil
+          end
+        end
+      end
+    end
+
+    context 'when no block is provided' do
+
+      it 'returns an enumerated cursor' do
+        expect(aggregation.each).to be_a(Enumerator)
+      end
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:options) do
+      { :cursor => true }
+    end
+
+    it 'sets the view' do
+      expect(aggregation.view).to eq(view)
+    end
+
+    it 'sets the pipeline' do
+      expect(aggregation.pipeline).to eq(pipeline)
+    end
+
+    it 'sets the options' do
+      expect(aggregation.options).to eq(options)
+    end
+
+    it 'dups the options' do
+      expect(aggregation.options).not_to be(options)
+    end
+  end
+end

data/spec/mongo/collection/view/explainable_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Explainable do
+
+  let(:selector) do
+    {}
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, selector, options)
+  end
+
+  after do
+    authorized_collection.find.remove_many
+  end
+
+  describe '#explain' do
+
+    let(:explain) do
+      view.explain
+    end
+
+    it 'executes an explain' do
+      expect(explain[:cursor] == 'BasicCursor' ||
+             explain[:queryPlanner]).to be_truthy
+    end
+  end
+end

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::MapReduce do
+
+  let(:map) do
+  %Q{
+  function() {
+    emit(this.name, { population: this.population });
+  }}
+  end
+
+  let(:reduce) do
+    %Q{
+    function(key, values) {
+      var result = { population: 0 };
+      values.forEach(function(value) {
+        result.population += value.population;
+      });
+      return result;
+    }}
+  end
+
+  let(:documents) do
+    [
+      { name: 'Berlin', population: 3000000 },
+      { name: 'London', population: 9000000 }
+    ]
+  end
+
+  let(:selector) do
+    {}
+  end
+
+  let(:view_options) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, selector, view_options)
+  end
+
+  let(:options) do
+    {}
+  end
+
+  before do
+    authorized_collection.insert_many(documents)
+  end
+
+  after do
+    authorized_collection.find.remove_many
+  end
+
+  let(:map_reduce) do
+    described_class.new(view, map, reduce, options)
+  end
+
+  describe '#each' do
+
+    context 'when no options are provided' do
+
+      it 'iterates over the documents in the result' do
+        map_reduce.each do |document|
+          expect(document[:value]).to_not be_nil
+        end
+      end
+    end
+
+    context 'when out is inline' do
+
+      let(:new_map_reduce) do
+        map_reduce.out(inline: 1)
+      end
+
+      it 'iterates over the documents in the result' do
+        new_map_reduce.each do |document|
+          expect(document[:value]).to_not be_nil
+        end
+      end
+    end
+
+    context 'when out is a collection' do
+
+      after do
+        authorized_client['output_collection'].find.remove_many
+      end
+
+      context 'when the option is to replace' do
+
+        let(:new_map_reduce) do
+          map_reduce.out(replace: 'output_collection')
+        end
+
+        it 'iterates over the documents in the result' do
+          new_map_reduce.each do |document|
+            expect(document[:value]).to_not be_nil
+          end
+        end
+
+        it 'fetches the results from the collection' do
+          expect(new_map_reduce.count).to eq(2)
+        end
+      end
+
+      context 'when the option is to merge' do
+
+        let(:new_map_reduce) do
+          map_reduce.out(merge: 'output_collection')
+        end
+
+        it 'iterates over the documents in the result' do
+          new_map_reduce.each do |document|
+            expect(document[:value]).to_not be_nil
+          end
+        end
+
+        it 'fetches the results from the collection' do
+          expect(new_map_reduce.count).to eq(2)
+        end
+      end
+
+      context 'when the option is to reduce' do
+
+        let(:new_map_reduce) do
+          map_reduce.out(reduce: 'output_collection')
+        end
+
+        it 'iterates over the documents in the result' do
+          new_map_reduce.each do |document|
+            expect(document[:value]).to_not be_nil
+          end
+        end
+
+        it 'fetches the results from the collection' do
+          expect(new_map_reduce.count).to eq(2)
+        end
+      end
+    end
+
+    context 'when the view has a selector' do
+
+      context 'when the selector is basic' do
+
+        let(:selector) do
+          { name: 'Berlin' }
+        end
+
+        it 'applies the selector to the map/reduce' do
+          map_reduce.each do |document|
+            expect(document[:_id]).to eq('Berlin')
+          end
+        end
+      end
+
+      context 'when the selector is advanced' do
+
+        let(:selector) do
+          { :$query => { name: 'Berlin' }}
+        end
+
+        it 'applies the selector to the map/reduce' do
+          map_reduce.each do |document|
+            expect(document[:_id]).to eq('Berlin')
+          end
+        end
+      end
+    end
+
+    context 'when the view has a limit' do
+
+      let(:view_options) do
+        { limit: 1 }
+      end
+
+      it 'applies the limit to the map/reduce' do
+        map_reduce.each do |document|
+          expect(document[:_id]).to eq('Berlin')
+        end
+      end
+    end
+  end
+
+  describe '#finalize' do
+
+    let(:finalize) do
+    %Q{
+    function(key, value) {
+      value.testing = test;
+      return value;
+    }}
+    end
+
+    let(:new_map_reduce) do
+      map_reduce.finalize(finalize)
+    end
+
+    it 'sets the finalize function' do
+      expect(new_map_reduce.finalize).to eq(finalize)
+    end
+  end
+
+  describe '#js_mode' do
+
+    let(:new_map_reduce) do
+      map_reduce.js_mode(true)
+    end
+
+    it 'sets the js mode value' do
+      expect(new_map_reduce.js_mode).to be true
+    end
+  end
+
+  describe '#out' do
+
+    let(:location) do
+      { replace: 'testing' }
+    end
+
+    let(:new_map_reduce) do
+      map_reduce.out(location)
+    end
+
+    it 'sets the out value' do
+      expect(new_map_reduce.out).to eq(location)
+    end
+  end
+
+  describe '#scope' do
+
+    let(:object) do
+      { value: 'testing' }
+    end
+
+    let(:new_map_reduce) do
+      map_reduce.scope(object)
+    end
+
+    it 'sets the scope object' do
+      expect(new_map_reduce.scope).to eq(object)
+    end
+  end
+end

data/spec/mongo/collection/view/readable_spec.rb

@@ -0,0 +1,603 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Readable do
+
+  let(:selector) do
+    {}
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, selector, options)
+  end
+
+  after do
+    authorized_collection.find.remove_many
+  end
+
+  describe '#allow_partial_results' do
+
+    let(:new_view) do
+      view.allow_partial_results
+    end
+
+    it 'sets the flag' do
+      expect(new_view.send(:flags)).to include(:partial)
+    end
+
+    it 'returns a new View' do
+      expect(new_view).not_to be(view)
+    end
+  end
+
+  describe '#aggregate' do
+
+     let(:documents) do
+      [
+        { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
+        { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
+        { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
+      ]
+    end
+
+    let(:pipeline) do
+      [{
+        "$group" => {
+          "_id" => "$city",
+          "totalpop" => { "$sum" => "$pop" }
+        }
+      }]
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    let(:aggregation) do
+      view.aggregate(pipeline)
+    end
+
+    context 'when not iterating the aggregation' do
+
+      it 'returns the aggregation object' do
+        expect(aggregation).to be_a(Mongo::Collection::View::Aggregation)
+      end
+    end
+
+    context 'when iterating the aggregation' do
+
+      it 'yields to each document' do
+        aggregation.each do |doc|
+          expect(doc[:totalpop]).to_not be_nil
+        end
+      end
+    end
+  end
+
+  describe '#map_reduce' do
+
+    let(:map) do
+    %Q{
+    function() {
+      emit(this.name, { population: this.population });
+    }}
+    end
+
+    let(:reduce) do
+      %Q{
+      function(key, values) {
+        var result = { population: 0 };
+        values.forEach(function(value) {
+          result.population += value.population;
+        });
+        return result;
+      }}
+    end
+
+    let(:documents) do
+      [
+        { name: 'Berlin', population: 3000000 },
+        { name: 'London', population: 9000000 }
+      ]
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    let(:map_reduce) do
+      view.map_reduce(map, reduce)
+    end
+
+    context 'when not iterating the map/reduce' do
+
+      it 'returns the map/reduce object' do
+        expect(map_reduce).to be_a(Mongo::Collection::View::MapReduce)
+      end
+    end
+
+    context 'when iterating the map/reduce' do
+
+      it 'yields to each document' do
+        map_reduce.each do |doc|
+          expect(doc[:_id]).to_not be_nil
+        end
+      end
+    end
+  end
+
+  describe '#batch_size' do
+
+    let(:options) do
+      { :batch_size => 13 }
+    end
+
+    context 'when a batch size is specified' do
+
+      let(:new_batch_size) do
+        15
+      end
+
+      it 'sets the batch size' do
+        new_view = view.batch_size(new_batch_size)
+        expect(new_view.batch_size).to eq(new_batch_size)
+      end
+
+      it 'returns a new View' do
+        expect(view.batch_size(new_batch_size)).not_to be(view)
+      end
+    end
+
+    context 'when a batch size is not specified' do
+
+      it 'returns the batch_size' do
+        expect(view.batch_size).to eq(options[:batch_size])
+      end
+    end
+  end
+
+  describe '#comment' do
+
+    let(:options) do
+      { :comment => 'test1' }
+    end
+
+    context 'when a comment is specified' do
+
+      let(:new_comment) do
+        'test2'
+      end
+
+      it 'sets the comment' do
+        new_view = view.comment(new_comment)
+        expect(new_view.comment).to eq(new_comment)
+      end
+
+      it 'returns a new View' do
+        expect(view.comment(new_comment)).not_to be(view)
+      end
+    end
+
+    context 'when a comment is not specified' do
+
+      it 'returns the comment' do
+        expect(view.comment).to eq(options[:comment])
+      end
+    end
+  end
+
+  describe '#count' do
+
+    let(:documents) do
+      (1..10).map{ |i| { field: "test#{i}" }}
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    after do
+      authorized_collection.find.remove_many
+    end
+
+    context 'when a selector is provided' do
+
+      let(:selector) do
+        { field: 'test1' }
+      end
+
+      it 'returns the count of matching documents' do
+        expect(view.count).to eq(1)
+      end
+    end
+
+    context 'when no selector is provided' do
+
+      it 'returns the count of matching documents' do
+        expect(view.count).to eq(10)
+      end
+    end
+
+    it 'takes a read preference option' do
+      expect(view.count(read: { mode: :secondary })).to eq(10)
+    end
+  end
+
+  describe '#distinct' do
+
+    context 'when a selector is provided' do
+
+      let(:selector) do
+        { field: 'test' }
+      end
+
+      let(:documents) do
+        (1..3).map{ |i| { field: "test" }}
+      end
+
+      before do
+        authorized_collection.insert_many(documents)
+      end
+
+      context 'when the field is a symbol' do
+
+        let(:distinct) do
+          view.distinct(:field)
+        end
+
+        it 'returns the distinct values' do
+          expect(distinct).to eq([ 'test' ])
+        end
+      end
+
+      context 'when the field is a string' do
+
+        let(:distinct) do
+          view.distinct('field')
+        end
+
+        it 'returns the distinct values' do
+          expect(distinct).to eq([ 'test' ])
+        end
+      end
+
+      context 'when the field is nil' do
+
+        let(:distinct) do
+          view.distinct(nil)
+        end
+
+        it 'returns an empty array' do
+          expect(distinct).to be_empty
+        end
+      end
+    end
+
+    context 'when no selector is provided' do
+
+      let(:documents) do
+        (1..3).map{ |i| { field: "test#{i}" }}
+      end
+
+      before do
+        authorized_collection.insert_many(documents)
+      end
+
+      context 'when the field is a symbol' do
+
+        let(:distinct) do
+          view.distinct(:field)
+        end
+
+        it 'returns the distinct values' do
+          expect(distinct).to eq([ 'test1', 'test2', 'test3' ])
+        end
+      end
+
+      context 'when the field is a string' do
+
+        let(:distinct) do
+          view.distinct('field')
+        end
+
+        it 'returns the distinct values' do
+          expect(distinct).to eq([ 'test1', 'test2', 'test3' ])
+        end
+      end
+
+      context 'when the field is nil' do
+
+        let(:distinct) do
+          view.distinct(nil)
+        end
+
+        it 'returns an empty array' do
+          expect(distinct).to be_empty
+        end
+      end
+    end
+
+    context 'when a read preference is specified' do
+
+      let(:documents) do
+        (1..3).map{ |i| { field: "test#{i}" }}
+      end
+
+      before do
+        authorized_collection.insert_many(documents)
+      end
+
+      let(:distinct) do
+        view.distinct(:field, read: { mode: :secondary })
+      end
+
+      it 'returns the distinct values' do
+        expect(distinct).to eq([ 'test1', 'test2', 'test3' ])
+      end
+    end
+  end
+
+  describe '#hint' do
+
+    context 'when a hint is specified' do
+
+      let(:options) do
+        { :hint => { 'x' => Mongo::Index::ASCENDING } }
+      end
+
+      let(:new_hint) do
+        { 'x' => Mongo::Index::DESCENDING }
+      end
+
+      it 'sets the hint' do
+        new_view = view.hint(new_hint)
+        expect(new_view.hint).to eq(new_hint)
+      end
+
+      it 'returns a new View' do
+        expect(view.hint(new_hint)).not_to be(view)
+      end
+    end
+
+    context 'when a hint is not specified' do
+
+      let(:options) do
+        { :hint => 'x' }
+      end
+
+      it 'returns the hint' do
+        expect(view.hint).to eq(options[:hint])
+      end
+    end
+  end
+
+  describe '#limit' do
+
+    context 'when a limit is specified' do
+
+      let(:options) do
+        { :limit => 5 }
+      end
+
+      let(:new_limit) do
+        10
+      end
+
+      it 'sets the limit' do
+        new_view = view.limit(new_limit)
+        expect(new_view.limit).to eq(new_limit)
+      end
+
+      it 'returns a new View' do
+        expect(view.limit(new_limit)).not_to be(view)
+      end
+    end
+
+    context 'when a limit is not specified' do
+
+      let(:options) do
+        { :limit => 5 }
+      end
+
+      it 'returns the limit' do
+        expect(view.limit).to eq(options[:limit])
+      end
+    end
+  end
+
+  describe '#max_scan' do
+
+    let(:new_view) do
+      view.max_scan(10)
+    end
+
+    it 'sets the value in the options' do
+      expect(new_view.max_scan).to eq(10)
+    end
+  end
+
+  describe '#no_cursor_timeout' do
+
+    let(:new_view) do
+      view.no_cursor_timeout
+    end
+
+    it 'sets the flag' do
+      expect(new_view.send(:flags)).to include(:no_cursor_timeout)
+    end
+
+    it 'returns a new View' do
+      expect(new_view).not_to be(view)
+    end
+  end
+
+  describe '#projection' do
+
+    context 'when projection are specified' do
+
+      let(:options) do
+        { :projection => { 'x' => 1 } }
+      end
+
+      let(:new_projection) do
+        { 'y' => 1 }
+      end
+
+      it 'sets the projection' do
+        new_view = view.projection(new_projection)
+        expect(new_view.projection).to eq(new_projection)
+      end
+
+      it 'returns a new View' do
+        expect(view.projection(new_projection)).not_to be(view)
+      end
+    end
+
+    context 'when projection are not specified' do
+
+      let(:options) { { :projection => { 'x' => 1 } } }
+
+      it 'returns the projection' do
+        expect(view.projection).to eq(options[:projection])
+      end
+    end
+  end
+
+  describe '#read' do
+
+    context 'when a read pref is specified' do
+
+      let(:options) do
+        { :read => Mongo::ServerSelector.get(:mode => :secondary) }
+      end
+
+      let(:new_read) do
+        Mongo::ServerSelector.get(:mode => :secondary_preferred)
+      end
+
+      it 'sets the read preference' do
+        new_view = view.read(new_read)
+        expect(new_view.read).to eq(new_read)
+      end
+
+      it 'returns a new View' do
+        expect(view.read(new_read)).not_to be(view)
+      end
+    end
+
+    context 'when a read pref is not specified' do
+
+      let(:options) do
+        { :read =>  Mongo::ServerSelector.get(:mode => :secondary) }
+      end
+
+      it 'returns the read preference' do
+        expect(view.read).to eq(options[:read])
+      end
+
+      context 'when no read pref is set on initialization' do
+
+        let(:options) do
+          {}
+        end
+
+        it 'returns the collection read preference' do
+          expect(view.read).to eq(authorized_collection.read_preference)
+        end
+      end
+    end
+  end
+
+  describe '#show_disk_loc' do
+
+    let(:new_view) do
+      view.show_disk_loc(true)
+    end
+
+    it 'sets the value in the options' do
+      expect(new_view.show_disk_loc).to be true
+    end
+  end
+
+  describe '#skip' do
+
+    context 'when a skip is specified' do
+
+      let(:options) do
+        { :skip => 5 }
+      end
+
+      let(:new_skip) do
+        10
+      end
+
+      it 'sets the skip value' do
+        new_view = view.skip(new_skip)
+        expect(new_view.skip).to eq(new_skip)
+      end
+
+      it 'returns a new View' do
+        expect(view.skip(new_skip)).not_to be(view)
+      end
+    end
+
+    context 'when a skip is not specified' do
+
+      let(:options) do
+        { :skip => 5 }
+      end
+
+      it 'returns the skip value' do
+        expect(view.skip).to eq(options[:skip])
+      end
+    end
+  end
+
+  describe '#snapshot' do
+
+    let(:new_view) do
+      view.snapshot(true)
+    end
+
+    it 'sets the value in the options' do
+      expect(new_view.snapshot).to be true
+    end
+  end
+
+  describe '#sort' do
+
+    context 'when a sort is specified' do
+
+      let(:options) do
+        { :sort => { 'x' => Mongo::Index::ASCENDING }}
+      end
+
+      let(:new_sort) do
+        { 'x' => Mongo::Index::DESCENDING }
+      end
+
+      it 'sets the sort option' do
+        new_view = view.sort(new_sort)
+        expect(new_view.sort).to eq(new_sort)
+      end
+
+      it 'returns a new View' do
+        expect(view.sort(new_sort)).not_to be(view)
+      end
+    end
+
+    context 'when a sort is not specified' do
+
+      let(:options) do
+        { :sort => { 'x' => Mongo::Index::ASCENDING }}
+      end
+
+      it 'returns the sort' do
+        expect(view.sort).to eq(options[:sort])
+      end
+    end
+  end
+end