mongoid 3.1.7 → 4.0.0

data/spec/app/models/actor_observer.rb

@@ -1,15 +0,0 @@
-class ActorObserver < Mongoid::Observer
-  attr_reader :last_after_create_record
-
-  def after_create(record)
-    @last_after_create_record = record
-  end
-
-  def after_custom(record)
-    record.after_custom_count += 1
-  end
-
-  def before_custom(record)
-    @after_custom_called = true
-  end
-end

data/spec/app/models/callback_recorder.rb

@@ -1,25 +0,0 @@
-class CallbackRecorder < Mongoid::Observer
-  observe :actor
-
-  attr_reader :last_callback, :call_count, :last_record
-
-  def initialize
-    reset
-    super
-  end
-
-  def reset
-    @last_callback = nil
-    @call_count = Hash.new(0)
-    @last_record = {}
-  end
-
-  Mongoid::Callbacks.observables.each do |callback|
-    define_method(callback) do |record, &block|
-      @last_callback = callback
-      @call_count[callback] += 1
-      @last_record[callback] = record
-      block ? block.call : true
-    end
-  end
-end

data/spec/app/models/paranoid_phone.rb

@@ -1,25 +0,0 @@
-class ParanoidPhone
-  include Mongoid::Document
-  include Mongoid::Paranoia
-
-  attr_accessor :after_destroy_called, :before_destroy_called
-
-  field :number, type: String
-
-  embedded_in :person
-
-  before_destroy :before_destroy_stub, :halt_me
-  after_destroy :after_destroy_stub
-
-  def before_destroy_stub
-    self.before_destroy_called = true
-  end
-
-  def after_destroy_stub
-    self.after_destroy_called = true
-  end
-
-  def halt_me
-    person.age == 42 ? false : true
-  end
-end

data/spec/app/models/paranoid_post.rb

@@ -1,36 +0,0 @@
-class ParanoidPost
-  include Mongoid::Document
-  include Mongoid::Versioning
-  include Mongoid::Paranoia
-
-  max_versions 2
-
-  field :title, type: String
-
-  attr_accessor :after_destroy_called, :before_destroy_called
-
-  belongs_to :person
-
-  has_and_belongs_to_many :tags
-  has_many :authors, dependent: :delete
-  has_many :titles, dependent: :restrict
-
-  scope :recent, where(created_at: { "$lt" => Time.now, "$gt" => 30.days.ago })
-
-  before_destroy :before_destroy_stub
-  after_destroy :after_destroy_stub
-
-  def before_destroy_stub
-    self.before_destroy_called = true
-  end
-
-  def after_destroy_stub
-    self.after_destroy_called = true
-  end
-
-  class << self
-    def old
-      where(created_at: { "$lt" => 30.days.ago })
-    end
-  end
-end

data/spec/app/models/phone_observer.rb

@@ -1,6 +0,0 @@
-class PhoneObserver < Mongoid::Observer
-
-  def after_save(phone)
-    phone.number_in_observer = phone.number
-  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/attributes/processing_spec.rb

@@ -1,149 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Attributes::Processing do
-
-  describe "#process_attributes" do
-
-    let(:building) do
-      Building.new
-    end
-
-    context "when setting embedded documents via the parent" do
-
-      let(:attributes) do
-        {
-          building_address: { city: "Berlin" },
-          contractors: [{ name: "Joe" }]
-        }
-      end
-
-      context "when providing a role" do
-
-        context "when creating new documents" do
-
-          before do
-            building.process_attributes(attributes, :admin, true)
-          end
-
-          let(:building_address) do
-            building.building_address
-          end
-
-          let(:contractor) do
-            building.contractors.first
-          end
-
-          context "when the child fields are accessible to the role" do
-
-            it "sets the fields on the 1-1 child" do
-              building_address.city.should eq("Berlin")
-            end
-
-            it "sets the fields on the 1-n child" do
-              contractor.name.should eq("Joe")
-            end
-          end
-
-          context "when updating the document" do
-
-            let(:updates) do
-              {
-                building_address: { city: "Kiew" },
-                contractors: [{ name: "Jim" }]
-              }
-            end
-
-            before do
-              building.process_attributes(updates, :admin, true)
-            end
-
-            it "updates the 1-1 child" do
-              building_address.city.should eq("Kiew")
-            end
-
-            it "updates the 1-n child" do
-              contractor.name.should eq("Jim")
-            end
-          end
-        end
-      end
-
-      context "when turning off mass assignment" do
-
-        context "when creating new documents" do
-
-          before do
-            building.process_attributes(attributes, :default, false)
-          end
-
-          let(:building_address) do
-            building.building_address
-          end
-
-          let(:contractor) do
-            building.contractors.first
-          end
-
-          context "when the child fields are accessible to the role" do
-
-            it "sets the fields on the 1-1 child" do
-              building_address.city.should eq("Berlin")
-            end
-
-            it "sets the fields on the 1-n child" do
-              contractor.name.should eq("Joe")
-            end
-          end
-
-          context "when updating the document" do
-
-            let(:updates) do
-              {
-                building_address: { city: "Kiew" },
-                contractors: [{ name: "Jim" }]
-              }
-            end
-
-            before do
-              building.process_attributes(updates, :default, false)
-            end
-
-            it "updates the 1-1 child" do
-              building_address.city.should eq("Kiew")
-            end
-
-            it "updates the 1-n child" do
-              contractor.name.should eq("Jim")
-            end
-
-            context "with a key that is not a valid ruby identifier" do
-              let(:dynamic_updates) do
-                {
-                  building_address: { :"postal-code" => "V8N 1A1" },
-                  contractors: [{ :"license number" => "12345" }]
-                }
-              end
-
-              before do
-                building.process_attributes(dynamic_updates, :default, false)
-              end
-
-              it "updates the 1-1 child" do
-                building_address['postal-code'].should eq("V8N 1A1")
-              end
-
-              it "updates the 1-n child" do
-                contractor['license number'].should eq("12345")
-              end
-
-              it "correctly handles a second call to #process_attributes" do
-                building.process_attributes(dynamic_updates, :default, false)
-              end
-            end
-
-          end
-        end
-      end
-    end
-  end
-end