mongoid 3.1.6 → 4.0.2

data/spec/app/models/preference.rb

@@ -5,5 +5,5 @@ class Preference
   field :ranking, type: Integer
   has_and_belongs_to_many :people, validate: false
   validates_length_of :name, minimum: 2, allow_nil: true
-  scope :posting, where(:value.in => [ "Posting" ])
+  scope :posting, ->{ where(:value.in => [ "Posting" ]) }
 end

data/spec/app/models/quiz.rb

@@ -4,7 +4,4 @@ class Quiz
   field :name, type: String
   field :topic, type: String
   embeds_many :pages
-
-  attr_accessible :topic, as: [ :default, :admin ]
-  attr_accessible :name, as: :default
 end

data/spec/app/models/record.rb

@@ -2,11 +2,11 @@ class Record
   include Mongoid::Document
   field :name, type: String
 
-  field :before_create_called, type: Boolean, default: false
-  field :before_save_called, type: Boolean, default: false
-  field :before_update_called, type: Boolean, default: false
-  field :before_validation_called, type: Boolean, default: false
-  field :before_destroy_called, type: Boolean, default: false
+  field :before_create_called, type: Mongoid::Boolean, default: false
+  field :before_save_called, type: Mongoid::Boolean, default: false
+  field :before_update_called, type: Mongoid::Boolean, default: false
+  field :before_validation_called, type: Mongoid::Boolean, default: false
+  field :before_destroy_called, type: Mongoid::Boolean, default: false
 
   embedded_in :band
   embeds_many :tracks, cascade_callbacks: true
@@ -43,4 +43,9 @@ class Record
   def access_band
     band.name
   end
+
+  def dont_call_me_twice
+  end
+
+  validate { dont_call_me_twice }
 end

data/spec/app/models/registry.rb

@@ -1,4 +1,4 @@
 class Registry
   include Mongoid::Document
-  field :data, type: Moped::BSON::Binary
+  field :data, type: BSON::Binary
 end

data/spec/app/models/server.rb

@@ -1,7 +1,7 @@
 class Server
   include Mongoid::Document
   field :name, type: String
-  field :after, type: Boolean, default: false
+  field :after, type: Mongoid::Boolean, default: false
   belongs_to :node
   embeds_many :filesystems, validate: false
   accepts_nested_attributes_for :filesystems

data/spec/app/models/service.rb

@@ -1,9 +1,9 @@
 class Service
   include Mongoid::Document
   field :sid
-  field :before_destroy_called, type: Boolean, default: false
-  field :after_destroy_called, type: Boolean, default: false
-  field :after_initialize_called, type: Boolean, default: false
+  field :before_destroy_called, type: Mongoid::Boolean, default: false
+  field :after_destroy_called, type: Mongoid::Boolean, default: false
+  field :after_initialize_called, type: Mongoid::Boolean, default: false
   embedded_in :person
   belongs_to :target, class_name: "User"
   validates_numericality_of :sid

data/spec/app/models/sound.rb

@@ -0,0 +1,5 @@
+class Sound
+  include Mongoid::Document
+  field :active, type: Mongoid::Boolean
+  default_scope ->{ where(active: true) }
+end

data/spec/app/models/symptom.rb

@@ -2,5 +2,5 @@ class Symptom
   include Mongoid::Document
   field :name, type: String
   embedded_in :person
-  default_scope asc(:name)
+  default_scope ->{ asc(:name) }
 end

data/spec/app/models/template.rb

@@ -1,5 +1,5 @@
 class Template
   include Mongoid::Document
-  field :active, type: Boolean, default: false
+  field :active, type: Mongoid::Boolean, default: false
   validates :active, presence: true
 end

data/spec/app/models/title.rb

@@ -1,4 +1,3 @@
 class Title
   include Mongoid::Document
-  belongs_to :paranoid_post
 end

data/spec/app/models/track.rb

@@ -2,11 +2,11 @@ class Track
   include Mongoid::Document
   field :name, type: String
 
-  field :before_create_called, type: Boolean, default: false
-  field :before_save_called, type: Boolean, default: false
-  field :before_update_called, type: Boolean, default: false
-  field :before_validation_called, type: Boolean, default: false
-  field :before_destroy_called, type: Boolean, default: false
+  field :before_create_called, type: Mongoid::Boolean, default: false
+  field :before_save_called, type: Mongoid::Boolean, default: false
+  field :before_update_called, type: Mongoid::Boolean, default: false
+  field :before_validation_called, type: Mongoid::Boolean, default: false
+  field :before_destroy_called, type: Mongoid::Boolean, default: false
 
   embedded_in :record
 

data/spec/app/models/tree.rb

@@ -2,8 +2,8 @@ class Tree
   include Mongoid::Document
 
   field :name
-  field :evergreen, type: Boolean
+  field :evergreen, type: Mongoid::Boolean
 
-  scope :verdant, where(evergreen: true)
-  default_scope asc(:name)
+  scope :verdant, ->{ where(evergreen: true) }
+  default_scope ->{ asc(:name) }
 end

data/spec/app/models/video.rb

@@ -9,9 +9,5 @@ class Video
   belongs_to :post
   belongs_to :game
 
-  default_scope asc(:title)
-
-  attr_accessible :title, as: [ :default, :admin ]
-  attr_accessible :year, as: [ :default ]
-  attr_accessible :person_attributes, as: [ :default ]
+  default_scope ->{ asc(:title) }
 end

data/spec/app/models/wiki_page.rb

@@ -1,16 +1,13 @@
 class WikiPage
   include Mongoid::Document
   include Mongoid::Timestamps
-  include Mongoid::Versioning
 
   field :title, type: String
-  field :transient_property, type: String, versioned: false
+  field :transient_property, type: String
   field :author, type: String
   field :description, type: String, localize: true
-  max_versions 5
-
-  attr_protected :author
 
+  embeds_many :edits, validate: false
   has_many :comments, dependent: :destroy, validate: false
   has_many :child_pages, class_name: "WikiPage", dependent: :delete, inverse_of: :parent_pages
   belongs_to :parent_pages, class_name: "WikiPage", inverse_of: :child_pages

data/spec/app/models/word.rb

@@ -1,6 +1,7 @@
 class Word
   include Mongoid::Document
   field :name, type: String
+  field :origin, type: String
 
   belongs_to :dictionary
 
@@ -9,4 +10,6 @@ class Word
   embeds_one :pronunciation, validate: false
 
   accepts_nested_attributes_for :definitions, allow_destroy: true
+
+  index({ name: "text" }, default_language: "english")
 end

data/spec/app/models/word_origin.rb

@@ -1,7 +1,7 @@
 class WordOrigin
   include Mongoid::Document
 
-  field :_id, type: Integer, default: ->{ origin_id }
+  field :_id, type: Integer, overwrite: true, default: ->{ origin_id }
 
   field :origin_id, type: Integer
   field :country, type: String

data/spec/config/mongoid.yml

@@ -5,7 +5,7 @@ test:
       hosts:
         - <%=ENV["MONGOID_SPEC_HOST"]%>:<%=ENV["MONGOID_SPEC_PORT"]%>
       options:
-        consistency: :strong
+        read: primary
     mongohq_single:
       database: <%=ENV["MONGOHQ_SINGLE_NAME"]%>
       username: <%=ENV["MONGOHQ_SINGLE_USER"]%>
@@ -13,8 +13,9 @@ test:
       hosts:
         - <%=ENV["MONGOHQ_SINGLE_URL"]%>
       options:
-        safe: true
-        consistency: :strong
+        write:
+          w: 1
+        read: primary
     mongohq_repl:
       database: <%=ENV["MONGOHQ_REPL_NAME"]%>
       username: <%=ENV["MONGOHQ_REPL_USER"]%>
@@ -23,18 +24,16 @@ test:
         - <%=ENV["MONGOHQ_REPL_1_URL"]%>
         - <%=ENV["MONGOHQ_REPL_2_URL"]%>
       options:
-        consistency: :strong
-        safe: true
+        read: primary
+        write:
+          w: majority
     mongohq_repl_uri:
       uri: <%= ENV["MONGOHQ_REPL_URI"]%>
   options:
-    allow_dynamic_fields: true
-    identity_map_enabled: false
     include_root_in_json: false
     include_type_for_serialization: false
     preload_models: false
     scope_overwrite_exception: false
     raise_not_found_error: true
-    skip_version_check: true
     use_activesupport_time_zone: true
     use_utc: false

data/spec/helpers.rb

@@ -0,0 +1,18 @@
+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#

@@ -0,0 +1,365 @@
+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