bullet 4.0.0 → 4.13.1

data/spec/integration/counter_cache_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+if !mongoid? && active_record?
+  describe Bullet::Detector::CounterCache do
+    before(:each) do
+      Bullet.start_request
+    end
+
+    after(:each) do
+      Bullet.end_request
+    end
+
+    it "should need counter cache with all cities" do
+      Country.all.each do |country|
+        country.cities.size
+      end
+      expect(Bullet.collected_counter_cache_notifications).not_to be_empty
+    end
+
+    it "should not need counter cache if already define counter_cache" do
+      Person.all.each do |person|
+        person.pets.size
+      end
+      expect(Bullet.collected_counter_cache_notifications).to be_empty
+    end
+
+    it "should not need counter cache with only one object" do
+      Country.first.cities.size
+      expect(Bullet.collected_counter_cache_notifications).to be_empty
+    end
+
+    it "should not need counter cache with part of cities" do
+      Country.all.each do |country|
+        country.cities.where(:name => 'first').size
+      end
+      expect(Bullet.collected_counter_cache_notifications).to be_empty
+    end
+
+    context "disable" do
+      before { Bullet.counter_cache_enable = false }
+      after { Bullet.counter_cache_enable = true }
+
+      it "should not detect counter cache" do
+        Country.all.each do |country|
+          country.cities.size
+        end
+        expect(Bullet.collected_counter_cache_notifications).to be_empty
+      end
+    end
+
+    context "whitelist" do
+      before { Bullet.add_whitelist :type => :counter_cache, :class_name => "Country", :association => :cities }
+      after { Bullet.reset_whitelist }
+
+      it "should not detect counter cache" do
+        Country.all.each do |country|
+          country.cities.size
+        end
+        expect(Bullet.collected_counter_cache_notifications).to be_empty
+      end
+    end
+  end
+end

data/spec/integration/mongoid/association_spec.rb

@@ -1,276 +1,258 @@
 require 'spec_helper'
 
-begin
-  require 'mongoid'
-  describe Bullet::Detector::Association, 'has_many' do
-    before(:each) do
-      Bullet.clear
-      Bullet.start_request
-    end
-    after(:each) do
-      Bullet.end_request
+if mongoid?
+  describe Bullet::Detector::Association do
+    context 'embeds_many' do
+      context "posts => users" do
+        it "should detect nothing" do
+          Mongoid::Post.all.each do |post|
+            post.users.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
+      end
     end
 
-    context "posts => comments" do
-      it "should detect non preload posts => comments" do
-        Mongoid::Post.all.each do |post|
-          post.comments.map(&:name)
+    context 'has_many' do
+      context "posts => comments" do
+        it "should detect non preload posts => comments" do
+          Mongoid::Post.all.each do |post|
+            post.comments.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+          expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Post, :comments)
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Post, :comments)
-      end
+        it "should detect preload post => comments" do
+          Mongoid::Post.includes(:comments).each do |post|
+            post.comments.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload post => comments" do
-        Mongoid::Post.includes(:comments).each do |post|
-          post.comments.map(&:name)
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
-
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
 
-      it "should detect unused preload post => comments" do
-        Mongoid::Post.includes(:comments).map(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Post, :comments)
+        it "should detect unused preload post => comments" do
+          Mongoid::Post.includes(:comments).map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Post, :comments)
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-      it "should not detect unused preload post => comments" do
-        Mongoid::Post.all.map(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+        it "should not detect unused preload post => comments" do
+          Mongoid::Post.all.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
       end
-    end
 
-    context "category => posts, category => entries" do
-      it "should detect non preload with category => [posts, entries]" do
-        Mongoid::Category.all.each do |category|
-          category.posts.map(&:name)
-          category.entries.map(&:name)
+      context "category => posts, category => entries" do
+        it "should detect non preload with category => [posts, entries]" do
+          Mongoid::Category.all.each do |category|
+            category.posts.map(&:name)
+            category.entries.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+          expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Category, :posts)
+          expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Category, :entries)
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Category, :posts)
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Category, :entries)
-      end
+        it "should detect preload with category => posts, but not with category => entries" do
+          Mongoid::Category.includes(:posts).each do |category|
+            category.posts.map(&:name)
+            category.entries.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload with category => posts, but not with category => entries" do
-        Mongoid::Category.includes(:posts).each do |category|
-          category.posts.collect(&:name)
-          category.entries.collect(&:name)
+          expect(Bullet::Detector::Association).not_to be_detecting_unpreloaded_association_for(Mongoid::Category, :posts)
+          expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Category, :entries)
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should_not be_detecting_unpreloaded_association_for(Mongoid::Category, :posts)
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Category, :entries)
-      end
+        it "should detect preload with category => [posts, entries]" do
+          Mongoid::Category.includes(:posts, :entries).each do |category|
+            category.posts.map(&:name)
+            category.entries.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload with category => [posts, entries]" do
-        Mongoid::Category.includes([:posts, :entries]).each do |category|
-          category.posts.map(&:name)
-          category.entries.map(&:name)
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+        it "should detect unused preload with category => [posts, entries]" do
+          Mongoid::Category.includes(:posts, :entries).map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Category, :posts)
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Category, :entries)
 
-      it "should detect unused preload with category => [posts, entries]" do
-        Mongoid::Category.includes([:posts, :entries]).map(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Category, :posts)
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Category, :entries)
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+        it "should detect unused preload with category => entries, but not with category => posts" do
+          Mongoid::Category.includes(:posts, :entries).each do |category|
+            category.posts.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_unused_preload_associations_for(Mongoid::Category, :posts)
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Category, :entries)
 
-      it "should detect unused preload with category => entries, but not with category => posts" do
-        Mongoid::Category.includes([:posts, :entries]).each do |category|
-          category.posts.map(&:name)
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_unused_preload_associations_for(Mongoid::Category, :posts)
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Category, :entries)
-
-        Bullet::Detector::Association.should be_completely_preloading_associations
       end
-    end
 
-    context "post => comment" do
-      it "should detect unused preload with post => comments" do
-        Mongoid::Post.includes(:comments).each do |post|
-          post.comments.first.name
-        end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_unused_preload_associations_for(Mongoid::Post, :comments)
+      context "post => comment" do
+        it "should detect unused preload with post => comments" do
+          Mongoid::Post.includes(:comments).each do |post|
+            post.comments.first.name
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_unused_preload_associations_for(Mongoid::Post, :comments)
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-      it "should detect preload with post => commnets" do
-        Mongoid::Post.first.comments.collect(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+        it "should detect preload with post => commnets" do
+          Mongoid::Post.first.comments.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
       end
-    end
 
-    context "scope preload_comments" do
-      it "should detect preload post => comments with scope" do
-        Mongoid::Post.preload_comments.each do |post|
-          post.comments.map(&:name)
-        end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+      context "scope preload_comments" do
+        it "should detect preload post => comments with scope" do
+          Mongoid::Post.preload_comments.each do |post|
+            post.comments.map(&:name)
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-      it "should detect unused preload with scope" do
-        Mongoid::Post.preload_comments.map(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Post, :comments)
+        it "should detect unused preload with scope" do
+          Mongoid::Post.preload_comments.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Post, :comments)
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
       end
     end
-  end
-
-  describe Bullet::Detector::Association, 'belongs_to' do
-    before(:each) do
-      Bullet.clear
-      Bullet.start_request
-    end
 
-    after(:each) do
-      Bullet.end_request
-    end
+    context 'belongs_to' do
+      context "comment => post" do
+        it "should detect non preload with comment => post" do
+          Mongoid::Comment.all.each do |comment|
+            comment.post.name
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-    context "comment => post" do
-      it "should detect non preload with comment => post" do
-        Mongoid::Comment.all.each do |comment|
-          comment.post.name
+          expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Comment, :post)
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Comment, :post)
-      end
+        it "should detect preload with one comment => post" do
+          Mongoid::Comment.first.post.name
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload with one comment => post" do
-        Mongoid::Comment.first.post.name
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+        it "should detect preload with comment => post" do
+          Mongoid::Comment.includes(:post).each do |comment|
+            comment.post.name
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload with comment => post" do
-        Mongoid::Comment.includes(:post).each do |comment|
-          comment.post.name
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
-
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
 
-      it "should not detect preload with comment => post" do
-        Mongoid::Comment.all.collect(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+        it "should not detect preload with comment => post" do
+          Mongoid::Comment.all.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-      it "should detect unused preload with comments => post" do
-        Mongoid::Comment.includes(:post).map(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Comment, :post)
+        it "should detect unused preload with comments => post" do
+          Mongoid::Comment.includes(:post).map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Comment, :post)
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
       end
     end
-  end
-
-  describe Bullet::Detector::Association, "has_one" do
-    before(:each) do
-      Bullet.clear
-      Bullet.start_request
-    end
-
-    after(:each) do
-      Bullet.end_request
-    end
 
-    context "company => address" do
-      it "should detect non preload association" do
-        Mongoid::Company.all.each do |company|
-          company.address.name
+    context "has_one" do
+      context "company => address" do
+        if Mongoid::VERSION !~ /\A3.0/
+          it "should detect non preload association" do
+            Mongoid::Company.all.each do |company|
+              company.address.name
+            end
+            Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+            expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
+
+            expect(Bullet::Detector::Association).to be_detecting_unpreloaded_association_for(Mongoid::Company, :address)
+          end
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_detecting_unpreloaded_association_for(Mongoid::Company, :address)
-      end
+        it "should detect preload association" do
+          Mongoid::Company.includes(:address).each do |company|
+            company.address.name
+          end
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      it "should detect preload association" do
-        Mongoid::Company.includes(:address).each do |company|
-          company.address.name
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
         end
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
-
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
 
-      it "should not detect preload association" do
-        Mongoid::Company.all.collect(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should_not be_has_unused_preload_associations
+        it "should not detect preload association" do
+          Mongoid::Company.all.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
-      end
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
 
-      it "should detect unused preload association" do
-        Mongoid::Company.includes(:address).collect(&:name)
-        Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-        Bullet::Detector::Association.should be_unused_preload_associations_for(Mongoid::Company, :address)
+        it "should detect unused preload association" do
+          criteria = Mongoid::Company.includes(:address)
+          criteria.map(&:name)
+          Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+          expect(Bullet::Detector::Association).to be_unused_preload_associations_for(Mongoid::Company, :address)
 
-        Bullet::Detector::Association.should be_completely_preloading_associations
+          expect(Bullet::Detector::Association).to be_completely_preloading_associations
+        end
       end
     end
-  end
-
-  describe Bullet::Detector::Association, "call one association that in possible objects" do
-    before(:each) do
-      Bullet.clear
-      Bullet.start_request
-    end
 
-    after(:each) do
-      Bullet.end_request
-    end
-
-    it "should not detect preload association" do
-      Mongoid::Post.all
-      Mongoid::Post.first.comments.map(&:name)
-      Bullet::Detector::UnusedEagerAssociation.check_unused_preload_associations
-      Bullet::Detector::Association.should_not be_has_unused_preload_associations
+    context "call one association that in possible objects" do
+      it "should not detect preload association" do
+        Mongoid::Post.all
+        Mongoid::Post.first.comments.map(&:name)
+        Bullet::Detector::UnusedEagerLoading.check_unused_preload_associations
+        expect(Bullet::Detector::Association).not_to be_has_unused_preload_associations
 
-      Bullet::Detector::Association.should be_completely_preloading_associations
+        expect(Bullet::Detector::Association).to be_completely_preloading_associations
+      end
     end
   end
-rescue LoadError
 end

data/spec/models/category.rb

@@ -1,5 +1,5 @@
 class Category < ActiveRecord::Base
-  has_many :posts
+  has_many :posts, inverse_of: :category
   has_many :entries
 
   has_many :submissions

data/spec/models/client.rb

@@ -1,4 +1,4 @@
 class Client < ActiveRecord::Base
   has_many :relationships
-  has_many :firms, :through => :relationships
+  has_many :firms, through: :relationships
 end

data/spec/models/comment.rb

@@ -1,4 +1,4 @@
 class Comment < ActiveRecord::Base
-  belongs_to :post
-  belongs_to :author, :class_name => "BaseUser"
+  belongs_to :post, inverse_of: :comments
+  belongs_to :author, class_name: "BaseUser"
 end

data/spec/models/document.rb

@@ -1,5 +1,5 @@
 class Document < ActiveRecord::Base
-  has_many :children, :class_name => "Document", :foreign_key => 'parent_id'
-  belongs_to :parent, :class_name => "Document", :foreign_key => 'parent_id'
+  has_many :children, class_name: "Document", foreign_key: 'parent_id'
+  belongs_to :parent, class_name: "Document", foreign_key: 'parent_id'
   belongs_to :author
 end

data/spec/models/firm.rb

@@ -1,4 +1,4 @@
 class Firm < ActiveRecord::Base
   has_many :relationships
-  has_many :clients, :through => :relationships
+  has_many :clients, through: :relationships
 end

data/spec/models/mongoid/address.rb

@@ -1,5 +1,7 @@
 class Mongoid::Address
   include Mongoid::Document
 
+  field :name
+
   belongs_to :company, :class_name => "Mongoid::Company"
 end

data/spec/models/mongoid/category.rb

@@ -1,6 +1,8 @@
 class Mongoid::Category
   include Mongoid::Document
 
+  field :name
+
   has_many :posts, :class_name => "Mongoid::Post"
   has_many :entries, :class_name => "Mongoid::Entry"
 end

data/spec/models/mongoid/comment.rb

@@ -1,5 +1,7 @@
 class Mongoid::Comment
   include Mongoid::Document
 
+  field :name
+
   belongs_to :post, :class_name => "Mongoid::Post"
 end

data/spec/models/mongoid/company.rb

@@ -1,5 +1,7 @@
 class Mongoid::Company
   include Mongoid::Document
 
+  field :name
+
   has_one :address, :class_name => "Mongoid::Address"
 end

data/spec/models/mongoid/entry.rb

@@ -1,5 +1,7 @@
 class Mongoid::Entry
   include Mongoid::Document
 
+  field :name
+
   belongs_to :category, :class_name => "Mongoid::Category"
 end

data/spec/models/mongoid/post.rb

@@ -1,8 +1,12 @@
 class Mongoid::Post
   include Mongoid::Document
 
+  field :name
+
   has_many :comments, :class_name => "Mongoid::Comment"
   belongs_to :category, :class_name => "Mongoid::Category"
 
+  embeds_many :users, :class_name => "Mongoid::User"
+
   scope :preload_comments, lambda { includes(:comments) }
 end

data/spec/models/mongoid/user.rb

@@ -0,0 +1,5 @@
+class Mongoid::User
+  include Mongoid::Document
+
+  field :name
+end

data/spec/models/newspaper.rb

@@ -1,3 +1,3 @@
 class Newspaper < ActiveRecord::Base
-  has_many :writers, :class_name => "BaseUser"
+  has_many :writers, class_name: "BaseUser"
 end

data/spec/models/pet.rb

@@ -1,3 +1,3 @@
 class Pet < ActiveRecord::Base
-  belongs_to :person, :counter_cache => true
+  belongs_to :person, counter_cache: true
 end