mongoid 3.1.4 → 3.1.5

data/spec/mongoid/contextual/find_and_modify_spec.rb

@@ -0,0 +1,220 @@
+require "spec_helper"
+
+describe Mongoid::Contextual::FindAndModify do
+
+  describe "#result" do
+
+    let!(:depeche) do
+      Band.create(name: "Depeche Mode")
+    end
+
+    let!(:tool) do
+      Band.create(name: "Tool")
+    end
+
+    let!(:collection) do
+      Band.collection
+    end
+
+    context "when the selector matches" do
+
+      context "when not providing options" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["name"].should eq("Depeche Mode")
+        end
+
+        it "updates the document in the database" do
+          depeche.reload.likes.should eq(1)
+        end
+      end
+
+      context "when providing values that needs to be cast" do
+
+        let(:date_time) do
+          DateTime.new(1978, 1, 1)
+        end
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$set" => { created: date_time }})
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["name"].should eq("Depeche Mode")
+        end
+
+        it "updates the document in the database" do
+          depeche.reload.created.should eq(date_time)
+        end
+      end
+
+      context "when sorting" do
+
+        let(:criteria) do
+          Band.desc(:name)
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["name"].should eq("Tool")
+        end
+
+        it "updates the document in the database" do
+          tool.reload.likes.should eq(1)
+        end
+      end
+
+      context "when limiting fields" do
+
+        let(:criteria) do
+          Band.only(:_id)
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["_id"].should eq(depeche.id)
+        end
+
+        it "limits the returned fields" do
+          result["name"].should be_nil
+        end
+
+        it "updates the document in the database" do
+          depeche.reload.likes.should eq(1)
+        end
+      end
+
+      context "when returning new" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$inc" => { likes: 1 }}, new: true)
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["name"].should eq("Depeche Mode")
+        end
+
+        it "returns the updated document" do
+          result["likes"].should eq(1)
+        end
+      end
+
+      context "when removing" do
+
+        let(:criteria) do
+          Band.where(name: "Depeche Mode")
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, {}, remove: true)
+        end
+
+        let!(:result) do
+          context.result
+        end
+
+        it "returns the first matching document" do
+          result["name"].should eq("Depeche Mode")
+        end
+
+        it "deletes the document from the database" do
+          expect {
+            depeche.reload
+          }.to raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+      end
+
+      context "when upserting" do
+
+        let(:criteria) do
+          Band.where(name: "The Mars Volta")
+        end
+
+        let(:context) do
+          described_class.new(collection, criteria, { "$inc" => { likes: 1 }}, upsert: true)
+        end
+
+        let(:result) do
+          context.result
+        end
+
+        it "creates the document if it does not exist" do
+          expect {
+            result
+          }.to change{Band.where(name: "The Mars Volta").count}.from(0).to(1)
+        end
+
+        it "updates the document in the database if it does exist" do
+          the_mars_volta = Band.create(name: "The Mars Volta")
+
+          expect {
+            result
+          }.to_not change{Band.where(name: "The Mars Volta").count}
+
+          the_mars_volta.reload.likes.should eq(1)
+        end
+      end
+    end
+
+    context "when the selector does not match" do
+
+      let(:criteria) do
+        Band.where(name: "Placebo")
+      end
+
+      let(:context) do
+        described_class.new(collection, criteria, { "$inc" => { likes: 1 }})
+      end
+
+      let(:result) do
+        context.result
+      end
+
+      it "returns nil" do
+        result.should be_nil
+      end
+    end
+  end
+end

data/spec/mongoid/contextual/geo_near_spec.rb

@@ -0,0 +1,405 @@
+require "spec_helper"
+
+describe Mongoid::Contextual::GeoNear do
+
+  describe "#average_distance" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    context "when results are returned" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      it "returns the average distance" do
+        geo_near.average_distance.should_not be_nil
+      end
+    end
+
+    context "when no results are returned" do
+
+      let(:criteria) do
+        Bar.where(name: "Green Door")
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      it "returns 0.0" do
+        geo_near.average_distance.should be_nil
+      end
+    end
+  end
+
+  describe "#each" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    context "when no options are provided" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.entries
+      end
+
+      it "returns all the documents" do
+        results.should eq([ bar_one, bar_two ])
+      end
+    end
+
+    context "when the criteria has a limit" do
+
+      let(:criteria) do
+        Bar.limit(1)
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.entries
+      end
+
+      it "returns the limited documents" do
+        results.should eq([ bar_one ])
+      end
+    end
+
+    context "when providing a max distance" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.max_distance(0.40).entries
+      end
+
+      it "returns the limited documents" do
+        results.should eq([ bar_one ])
+      end
+    end
+
+    context "when spcifying spherical" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.spherical.entries
+      end
+
+      it "returns the documents" do
+        results.should eq([ bar_one, bar_two ])
+      end
+    end
+
+    context "when providing a distance multiplier" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.distance_multiplier(6378.1).entries
+      end
+
+      it "returns the documents" do
+        results.should eq([ bar_one, bar_two ])
+      end
+
+      it "multiplies the distance factor" do
+        results.first.geo_near_distance.to_i.should eq(2490)
+      end
+    end
+
+    context "when unique is false" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      let(:results) do
+        geo_near.unique(false).entries
+      end
+
+      it "returns the documents" do
+        results.should eq([ bar_one, bar_two ])
+      end
+    end
+  end
+
+  describe "#empty?" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    let(:geo_near) do
+      described_class.new(collection, criteria, [ 52, 13 ])
+    end
+
+    context "when the $geoNear has results" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      it "returns false" do
+        geo_near.should_not be_empty
+      end
+    end
+
+    context "when the map/reduce has no results" do
+
+      let(:criteria) do
+        Bar.where(name: "Halo")
+      end
+
+      it "returns true" do
+        geo_near.should be_empty
+      end
+    end
+  end
+
+  describe "#execute" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    let(:criteria) do
+      Bar.all
+    end
+
+    let(:geo_near) do
+      described_class.new(collection, criteria, [ 52, 13 ])
+    end
+
+    let(:execution_results) do
+      geo_near.execute
+    end
+
+    it "returns a hash" do
+      execution_results.should be_a_kind_of(Hash)
+    end
+  end
+
+  describe "#max_distance" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    context "when results are returned" do
+
+      let(:criteria) do
+        Bar.all
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      it "returns the max distance" do
+        geo_near.max_distance.should_not be_nil
+      end
+    end
+
+    context "when no results are returned" do
+
+      let(:criteria) do
+        Bar.where(name: "Green Door")
+      end
+
+      let(:geo_near) do
+        described_class.new(collection, criteria, [ 52, 13 ])
+      end
+
+      it "returns 0.0" do
+        geo_near.max_distance.should eq(0.0)
+      end
+    end
+  end
+
+  describe "#inspect" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    let(:criteria) do
+      Bar.all
+    end
+
+    let(:geo_near) do
+      described_class.new(collection, criteria, [ 52, 13 ])
+    end
+
+    it "contains the selector" do
+      geo_near.inspect.should include("selector")
+    end
+
+    it "contains the class" do
+      geo_near.inspect.should include("class")
+    end
+
+    it "contains the near" do
+      geo_near.inspect.should include("near")
+    end
+
+    it "contains the multiplier" do
+      geo_near.inspect.should include("multiplier")
+    end
+
+    it "contains the max" do
+      geo_near.inspect.should include("max")
+    end
+
+    it "contains the unique" do
+      geo_near.inspect.should include("unique")
+    end
+
+    it "contains the spherical" do
+      geo_near.inspect.should include("spherical")
+    end
+  end
+
+  describe "#time" do
+
+    let!(:collection) do
+      Bar.collection
+    end
+
+    before do
+      Bar.create_indexes
+    end
+
+    let!(:bar_one) do
+      Bar.create(location: [ 52.30, 13.25 ])
+    end
+
+    let!(:bar_two) do
+      Bar.create(location: [ 52.30, 13.35 ])
+    end
+
+    let(:criteria) do
+      Bar.all
+    end
+
+    let(:geo_near) do
+      described_class.new(collection, criteria, [ 52, 13 ])
+    end
+
+    it "returns the execution time" do
+      geo_near.time.should_not be_nil
+    end
+  end
+end