mongoid 4.0.2 → 5.0.0.beta

data/spec/helpers.rb

@@ -1,18 +0,0 @@
-require 'mongoid/support/query_counter'
-
-module Mongoid
-  module SpecHelpers
-    def expect_query(number, &block)
-      query_counter = Mongoid::QueryCounter.new
-      query_counter.instrument(&block)
-      expect(query_counter.events.size).to(eq(number), %[
-Expected to receive #{number} queries, it received #{query_counter.events.size}
-#{query_counter.inspect}
-])
-    end
-
-    def expect_no_queries(&block)
-      expect_query(0, &block)
-    end
-  end
-end

data/spec/mongoid/#atomic_spec.rb#

@@ -1,365 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Atomic do
-
-  describe "#add_atomic_pull" do
-
-    let!(:person) do
-      Person.create
-    end
-
-    let(:address) do
-      person.addresses.create
-    end
-
-    let(:location) do
-      address.locations.create
-    end
-
-    before do
-      person.add_atomic_pull(address)
-    end
-
-    it "adds the document to the delayed atomic pulls" do
-      expect(person.delayed_atomic_pulls["addresses"]).to eq([ address ])
-    end
-
-    it "flags the document for destruction" do
-      expect(address).to be_flagged_for_destroy
-    end
-  end
-
-  describe "#add_atomic_unset" do
-
-    let!(:person) do
-      Person.new
-    end
-
-    let(:name) do
-      person.build_name
-    end
-
-    before do
-      person.add_atomic_unset(name)
-    end
-
-    it "adds the document to the delayed atomic unsets" do
-      expect(person.delayed_atomic_unsets["name"]).to eq([ name ])
-    end
-
-    it "flags the document for destruction" do
-      expect(name).to be_flagged_for_destroy
-    end
-  end
-
-  describe "#atomic_updates" do
-
-    context "when the document is persisted" do
-
-      let(:person) do
-        Person.create
-      end
-
-      context "when the document is modified" do
-
-        before do
-          person.title = "Sir"
-        end
-
-        it "returns the atomic updates" do
-          expect(person.atomic_updates).to eq({ "$set" => { "title" => "Sir" }})
-        end
-
-        context "when an embeds many child is added" do
-
-          let!(:address) do
-            person.addresses.build(street: "Oxford St")
-          end
-
-          it "returns a $set and $pushAll for modifications" do
-            expect(person.atomic_updates).to eq(
-              {
-                "$set" => { "title" => "Sir" },
-                "$pushAll" => { "addresses" => [
-                    { "_id" => "oxford-st", "street" => "Oxford St" }
-                  ]}
-              }
-            )
-          end
-        end
-
-        context "when an embeds one child is added" do
-
-          let!(:name) do
-            person.build_name(first_name: "Lionel")
-          end
-
-          it "returns a $set for modifications" do
-            expect(person.atomic_updates).to eq(
-              {
-                "$set" => {
-                  "title" => "Sir",
-                  "name" => { "_id" => "Lionel-", "first_name" => "Lionel" }
-                }
-              }
-            )
-          end
-        end
-
-        context "when an existing embeds many gets modified" do
-
-          let!(:address) do
-            person.addresses.create(street: "Oxford St")
-          end
-
-          before do
-            address.street = "Bond St"
-          end
-
-          context "when asking for the updates from the root" do
-
-            it "returns the $set with correct position and modifications" do
-              expect(person.atomic_updates).to eq(
-                { "$set" => { "title" => "Sir", "addresses.0.street" => "Bond St" }}
-              )
-            end
-          end
-
-          context "when asking for the updates from the child" do
-
-            it "returns the $set with correct position and modifications" do
-              expect(address.atomic_updates).to eq(
-                { "$set" => { "addresses.0.street" => "Bond St" }}
-              )
-            end
-          end
-
-          context "when an existing 2nd level embedded child gets modified" do
-
-            let!(:location) do
-              address.locations.create(name: "Home")
-            end
-
-            before do
-              location.name = "Work"
-            end
-
-            context "when asking for the updates from the root" do
-
-              it "returns the $set with correct positions and modifications" do
-                expect(person.atomic_updates).to eq(
-                  { "$set" => {
-                    "title" => "Sir",
-                    "addresses.0.street" => "Bond St",
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
-                )
-              end
-            end
-
-            context "when asking for the updates from the 1st level child" do
-
-              it "returns the $set with correct positions and modifications" do
-                expect(address.atomic_updates).to eq(
-                  { "$set" => {
-                    "addresses.0.street" => "Bond St",
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
-                )
-              end
-            end
-
-            context "when asking for the updates from the 2nd level child" do
-
-              it "returns the $set with correct positions and modifications" do
-                expect(location.atomic_updates).to eq(
-                  { "$set" => {
-                    "addresses.0.locations.0.name" => "Work" }
-                  }
-                )
-              end
-            end
-          end
-
-          context "when a 2nd level embedded child gets added" do
-
-            let!(:location) do
-              address.locations.build(name: "Home")
-            end
-
-            context "when asking for the updates from the root" do
-
-              it "returns the $set with correct positions and modifications" do
-                expect(person.atomic_updates).to eq(
-                  {
-                    "$set" => {
-                      "title" => "Sir",
-                      "addresses.0.street" => "Bond St"
-                    },
-                    conflicts: {
-                      "$pushAll" => {
-                        "addresses.0.locations" => [{ "_id" => location.id, "name" => "Home" }]
-                      }
-                    }
-                  }
-                )
-              end
-            end
-
-            context "when asking for the updates from the 1st level child" do
-
-              it "returns the $set with correct positions and modifications" do
-                expect(address.atomic_updates).to eq(
-                  {
-                    "$set" => {
-                      "addresses.0.street" => "Bond St"
-                    },
-                    conflicts: {
-                      "$pushAll" => {
-                        "addresses.0.locations" => [{ "_id" => location.id, "name" => "Home" }]
-                      }
-                    }
-                  }
-                )
-              end
-            end
-          end
-
-          context "when an embedded child gets unset" do
-
-            before do
-              person.attributes = { addresses: nil }
-            end
-
-            let(:updates) do
-              person.atomic_updates
-            end
-
-            it "returns the $set for the first level and $unset for other." do
-              expect(updates).to eq({
-                "$unset" => { "addresses" => true },
-                "$set" => { "title" => "Sir" }
-              })
-            end
-          end
-
-          context "when adding a new second level child" do
-
-            let!(:new_address) do
-              person.addresses.build(street: "Another")
-            end
-
-            let!(:location) do
-              new_address.locations.build(name: "Home")
-            end
-
-            context "when asking for the updates from the root document" do
-
-              it "returns the $set for 1st level and other for the 2nd level" do
-                expect(person.atomic_updates).to eq(
-                  {
-                    "$set" => {
-                      "title" => "Sir",
-                      "addresses.0.street" => "Bond St"
-                    },
-                    conflicts: {
-                      "$pushAll" => {
-                        "addresses" => [{
-                          "_id" => new_address.id,
-                          "street" => "Another",
-                          "locations" => [
-                            "_id" => location.id,
-                            "name" => "Home"
-                          ]
-                        }]
-                      }
-                    }
-                  }
-                )
-              end
-            end
-
-            context "when asking for the updates from the 1st level document" do
-
-              it "returns the $set for 1st level and other for the 2nd level" do
-                expect(address.atomic_updates).to eq(
-                  { "$set" => { "addresses.0.street" => "Bond St" }}
-                )
-              end
-            end
-          end
-
-          context "when adding a new child beetween two existing and updating one of them" do
-
-            let!(:new_address) do
-              person.addresses.build(street: "Ipanema")
-            end
-
-            let!(:location) do
-              new_address.locations.build(name: "Home")
-            end
-
-            before do
-              person.addresses[0] = new_address
-              person.addresses[1] = address
-            end
-
-            it "returns the $set for 1st and 2nd level and other for the 3nd level" do
-              expect(person.atomic_updates).to eq(
-                {
-                  "$set" => {
-                    "title" => "Sir"
-                  },
-                  "$pushAll" => {
-                    "addresses" => [{
-                      "_id" => new_address.id,
-                      "street" => "Ipanema",
-                      "locations" => [
-                        "_id" => location.id,
-                        "name" => "Home"
-                      ]
-                    }]
-                  },
-                  conflicts: {
-                    "$set" => { "addresses.0.street"=>"Bond St" }
-                  }
-                }
-              )
-            end
-          end
-        end
-
-        context "when adding new embedded docs at multiple levels" do
-
-          let!(:address) do
-            person.addresses.build(street: "Another")
-          end
-
-          let!(:location) do
-            address.locations.build(name: "Home")
-          end
-
-          it "returns the proper $sets and $pushAlls for all levels" do
-            expect(person.atomic_updates).to eq(
-              {
-                "$set" => {
-                  "title" => "Sir",
-                },
-                "$pushAll" => {
-                  "addresses" => [{
-                    "_id" => address.id,
-                    "street" => "Another",
-                    "locations" => [
-                      "_id" => location.id,
-                      "name" => "Home"
-                    ]
-                  }]
-                }
-              }
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/contextual/find_and_modify_spec.rb

@@ -1,220 +0,0 @@
-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
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to 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
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.created).to 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
-          expect(result["name"]).to eq("Tool")
-        end
-
-        it "updates the document in the database" do
-          expect(tool.reload.likes).to 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
-          expect(result["_id"]).to eq(depeche.id)
-        end
-
-        it "limits the returned fields" do
-          expect(result["name"]).to be_nil
-        end
-
-        it "updates the document in the database" do
-          expect(depeche.reload.likes).to 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
-          expect(result["name"]).to eq("Depeche Mode")
-        end
-
-        it "returns the updated document" do
-          expect(result["likes"]).to 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
-          expect(result["name"]).to 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}
-
-          expect(the_mars_volta.reload.likes).to 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
-        expect(result).to be_nil
-      end
-    end
-  end
-end