mongoid-history 0.6.1 → 0.8.3

data/lib/mongoid/history/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module History
-    VERSION = '0.6.1'
+    VERSION = '0.8.3'.freeze
   end
 end

data/mongoid-history.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'easy_diff'
   s.add_runtime_dependency 'mongoid', '>= 3.0'
-  s.add_runtime_dependency 'mongoid-compatibility'
+  s.add_runtime_dependency 'mongoid-compatibility', '>= 0.5.1'
   s.add_runtime_dependency 'activesupport'
 end

data/perf/benchmark_modified_attributes_for_create.rb

@@ -0,0 +1,65 @@
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+
+require 'mongoid'
+require 'mongoid/history'
+
+require 'benchmark/ips'
+require './perf/gc_suite'
+
+Mongoid.connect_to('mongoid_history_perf_test')
+Mongo::Logger.logger.level = ::Logger::FATAL
+Mongoid.purge!
+
+Attributes = Mongoid::History::Attributes
+
+module ZeroPointEight
+  class Create < Attributes::Create
+    def attributes
+      @attributes = {}
+      trackable.attributes.each do |k, v|
+        next unless trackable_class.tracked_field?(k, :create)
+        modified = if changes[k]
+                     changes[k].class == Array ? changes[k].last : changes[k]
+                   else
+                     v
+                   end
+        @attributes[k] = [nil, format_field(k, modified)]
+      end
+      insert_embeds_one_changes
+      insert_embeds_many_changes
+      @attributes
+    end
+  end
+end
+
+class Person
+  include Mongoid::Document
+  include Mongoid::History::Trackable
+
+  field :first_name, type: String
+  field :last_name, type: String
+  field :birth_date, type: Date
+  field :title, type: String
+
+  track_history on: %i[first_name last_name birth_date]
+end
+
+new_person = Person.new(first_name: 'Eliot', last_name: 'Horowitz', birth_date: '1981-05-01', title: 'CTO')
+
+Benchmark.ips do |bm|
+  bm.config(suite: GCSuite.new)
+
+  bm.report('HEAD') do
+    Attributes::Create.new(new_person).attributes
+  end
+
+  bm.report('v0.8.2') do
+    ZeroPointEight::Create.new(new_person).attributes
+  end
+
+  bm.report('v0.5.0') do
+    new_person.attributes.each_with_object({}) { |(k, v), h| h[k] = [nil, v] }.select { |k, _| new_person.class.tracked_field?(k, :create) }
+  end
+
+  bm.compare!
+end

data/perf/gc_suite.rb

@@ -0,0 +1,21 @@
+class GCSuite
+  def warming(*)
+    run_gc
+  end
+
+  def running(*)
+    run_gc
+  end
+
+  def warmup_stats(*); end
+
+  def add_report(*); end
+
+  private
+
+  def run_gc
+    GC.enable
+    GC.start
+    GC.disable
+  end
+end

data/spec/integration/embedded_in_polymorphic_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mongoid::History::Tracker do
-  before :all do
+  before :each do
     class RealState
       include Mongoid::Document
       include Mongoid::History::Trackable
@@ -9,14 +9,9 @@ describe Mongoid::History::Tracker do
       field :name, type: String
       belongs_to :user
       embeds_one :address, class_name: 'Contact', as: :contactable
-      embeds_one :embone,  as: :embedable
-
-      track_history on: :all, # track title and body fields only, default is :all
-                    modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    track_create: true, # track document creation, default is false
-                    track_update: true,     # track document updates, default is true
-                    track_destroy: false    # track document destruction, default is false
+      embeds_one :embone, as: :embedable
+
+      track_history
     end
 
     class Company
@@ -29,12 +24,7 @@ describe Mongoid::History::Tracker do
       embeds_one :second_address, class_name: 'Contact', as: :contactable
       embeds_one :embone, as: :embedable
 
-      track_history on: :all, # track title and body fields only, default is :all
-                    modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    track_create: true, # track document creation, default is false
-                    track_update: true, # track document updates, default is true
-                    track_destroy: false # track document destruction, default is false
+      track_history
     end
 
     class Embone
@@ -44,13 +34,7 @@ describe Mongoid::History::Tracker do
       field :name
       embedded_in :embedable, polymorphic: true
 
-      track_history on: :all, # track title and body fields only, default is :all
-                    modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    track_create: true, # track document creation, default is false
-                    track_update: true, # track document updates, default is true
-                    track_destroy: false, # track document destruction, default is false
-                    scope: :embedable
+      track_history scope: :embedable
     end
 
     class Contact
@@ -62,13 +46,7 @@ describe Mongoid::History::Tracker do
       field :state
       embedded_in :contactable, polymorphic: true
 
-      track_history on: :all, # track title and body fields only, default is :all
-                    modifier_field: :modifier, # adds "referenced_in :modifier" to track who made the change, default is :modifier
-                    version_field: :version,   # adds "field :version, :type => Integer" to track current version, default is :version
-                    track_create: true, # track document creation, default is false
-                    track_update: true, # track document updates, default is true
-                    track_destroy: false, # track document destruction, default is false
-                    scope: [:real_state, :company]
+      track_history scope: %i[real_state company]
     end
 
     class User
@@ -78,58 +56,57 @@ describe Mongoid::History::Tracker do
     end
   end
 
-  it 'tracks history for nested embedded documents with polymorphic relations' do
-    user = User.new
-    user.save!
+  after :each do
+    Object.send(:remove_const, :RealState)
+    Object.send(:remove_const, :Company)
+    Object.send(:remove_const, :Embone)
+    Object.send(:remove_const, :Contact)
+    Object.send(:remove_const, :User)
+  end
 
-    real_state = user.real_states.build(name: 'rs_name')
+  let!(:user) { User.create! }
+
+  it 'tracks history for nested embedded documents with polymorphic relations' do
+    real_state = user.real_states.build(name: 'rs_name', modifier: user)
     real_state.save!
-    real_state.build_address(address: 'Main Street #123', city: 'Highland Park', state: 'IL').save!
+    real_state.build_address(address: 'Main Street #123', city: 'Highland Park', state: 'IL', modifier: user).save!
     expect(real_state.history_tracks.count).to eq(2)
     expect(real_state.address.history_tracks.count).to eq(1)
 
     real_state.reload
-    real_state.address.update_attribute(:address, 'Second Street')
+    real_state.address.update_attributes!(address: 'Second Street', modifier: user)
     expect(real_state.history_tracks.count).to eq(3)
     expect(real_state.address.history_tracks.count).to eq(2)
     expect(real_state.history_tracks.last.action).to eq('update')
 
-    real_state.build_embone(name: 'Lorem ipsum').save!
+    real_state.build_embone(name: 'Lorem ipsum', modifier: user).save!
     expect(real_state.history_tracks.count).to eq(4)
     expect(real_state.embone.history_tracks.count).to eq(1)
     expect(real_state.embone.history_tracks.last.action).to eq('create')
     expect(real_state.embone.history_tracks.last.association_chain.last['name']).to eq('embone')
 
-    company = user.companies.build(name: 'co_name')
+    company = user.companies.build(name: 'co_name', modifier: user)
     company.save!
-    company.build_address(address: 'Main Street #456', city: 'Evanston', state: 'IL').save!
+    company.build_address(address: 'Main Street #456', city: 'Evanston', state: 'IL', modifier: user).save!
     expect(company.history_tracks.count).to eq(2)
     expect(company.address.history_tracks.count).to eq(1)
 
     company.reload
-    company.address.update_attribute(:address, 'Second Street')
+    company.address.update_attributes!(address: 'Second Street', modifier: user)
     expect(company.history_tracks.count).to eq(3)
     expect(company.address.history_tracks.count).to eq(2)
     expect(company.history_tracks.last.action).to eq('update')
 
-    company.build_second_address(address: 'Main Street #789', city: 'Highland Park', state: 'IL').save!
+    company.build_second_address(address: 'Main Street #789', city: 'Highland Park', state: 'IL', modifier: user).save!
     expect(company.history_tracks.count).to eq(4)
     expect(company.second_address.history_tracks.count).to eq(1)
     expect(company.second_address.history_tracks.last.action).to eq('create')
     expect(company.second_address.history_tracks.last.association_chain.last['name']).to eq('second_address')
 
-    company.build_embone(name: 'Lorem ipsum').save!
+    company.build_embone(name: 'Lorem ipsum', modifier: user).save!
     expect(company.history_tracks.count).to eq(5)
     expect(company.embone.history_tracks.count).to eq(1)
     expect(company.embone.history_tracks.last.action).to eq('create')
     expect(company.embone.history_tracks.last.association_chain.last['name']).to eq('embone')
   end
-
-  after :all do
-    Object.send(:remove_const, :RealState)
-    Object.send(:remove_const, :Company)
-    Object.send(:remove_const, :Embone)
-    Object.send(:remove_const, :Contact)
-    Object.send(:remove_const, :User)
-  end
 end

data/spec/integration/integration_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mongoid::History do
-  before :all do
+  before :each do
     class Post
       include Mongoid::Document
       include Mongoid::Timestamps
@@ -18,7 +18,7 @@ describe Mongoid::History do
 
       accepts_nested_attributes_for :tags, allow_destroy: true
 
-      track_history on: [:title, :body], track_destroy: true
+      track_history on: %i[title body], track_destroy: true
     end
 
     class Comment
@@ -29,7 +29,8 @@ describe Mongoid::History do
       field :t, as: :title
       field :body
       embedded_in :commentable, polymorphic: true
-      track_history on: [:title, :body], scope: :post, track_create: true, track_destroy: true
+      # BUG: see https://github.com/mongoid/mongoid-history/issues/223, modifier_field_optional should not be necessary
+      track_history on: %i[title body], scope: :post, track_create: true, track_destroy: true, modifier_field_optional: true
     end
 
     class Section
@@ -54,7 +55,7 @@ describe Mongoid::History do
       field :city
       field :country
       field :aliases, type: Array
-      track_history except: [:email, :updated_at]
+      track_history except: %i[email updated_at], modifier_field_optional: true
     end
 
     class Tag
@@ -70,16 +71,22 @@ describe Mongoid::History do
 
     class Foo < Comment
     end
+  end
 
-    @persisted_history_options = Mongoid::History.trackable_class_options
+  after :each do
+    Object.send(:remove_const, :Post)
+    Object.send(:remove_const, :Comment)
+    Object.send(:remove_const, :Section)
+    Object.send(:remove_const, :User)
+    Object.send(:remove_const, :Tag)
+    Object.send(:remove_const, :Foo)
   end
 
-  before(:each) { Mongoid::History.trackable_class_options = @persisted_history_options }
   let(:user) { User.create!(name: 'Aaron', email: 'aaron@randomemail.com', aliases: ['bob'], country: 'Canada', city: 'Toronto', address: '21 Jump Street') }
   let(:another_user) { User.create!(name: 'Another Guy', email: 'anotherguy@randomemail.com') }
   let(:post) { Post.create!(title: 'Test', body: 'Post', modifier: user, views: 100) }
   let(:comment) { post.comments.create!(title: 'test', body: 'comment', modifier: user) }
-  let(:tag) { Tag.create!(title: 'test') }
+  let(:tag) { Tag.create!(title: 'test', updated_by: user) }
 
   describe 'track' do
     describe 'on creation' do
@@ -96,7 +103,7 @@ describe Mongoid::History do
       end
 
       it 'should assign modifier' do
-        expect(comment.history_tracks.first.modifier).to eq(user)
+        expect(comment.history_tracks.first.modifier.id).to eq(user.id)
       end
 
       it 'should assign version' do
@@ -122,6 +129,7 @@ describe Mongoid::History do
 
     describe 'on destruction' do
       it 'should have two history track records in post' do
+        post # This will create history track records for creation
         expect do
           post.destroy
         end.to change(Tracker, :count).by(1)
@@ -147,97 +155,100 @@ describe Mongoid::History do
 
     describe 'on update non-embedded' do
       it 'should create a history track if changed attributes match tracked attributes' do
+        post # This will create history track records for creation
         expect do
-          post.update_attributes(title: 'Another Test')
+          post.update_attributes!(title: 'Another Test')
         end.to change(Tracker, :count).by(1)
       end
 
       it 'should not create a history track if changed attributes do not match tracked attributes' do
+        post # This will create history track records for creation
         expect do
-          post.update_attributes(rating: 'untracked')
+          post.update_attributes!(rating: 'untracked')
         end.to change(Tracker, :count).by(0)
       end
 
       it 'should assign modified fields' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.last.modified).to eq(
           'title' => 'Another Test'
         )
       end
 
       it 'should assign method field' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.last.action).to eq('update')
       end
 
       it 'should assign original fields' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.last.original).to eq(
           'title' => 'Test'
         )
       end
 
       it 'should assign modifier' do
-        post.update_attributes(title: 'Another Test')
-        expect(post.history_tracks.first.modifier).to eq(user)
+        post.update_attributes!(title: 'Another Test')
+        expect(post.history_tracks.first.modifier.id).to eq(user.id)
       end
 
       it 'should assign version on history tracks' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.first.version).to eq(1)
       end
 
       it 'should assign version on post' do
-        post.update_attributes(title: 'Another Test')
-        expect(post.version).to eq(1)
+        expect(post.version).to eq(1) # Created
+        post.update_attributes!(title: 'Another Test')
+        expect(post.version).to eq(2) # Updated
       end
 
       it 'should assign scope' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.first.scope).to eq('post')
       end
 
       it 'should assign association_chain' do
-        post.update_attributes(title: 'Another Test')
+        post.update_attributes!(title: 'Another Test')
         expect(post.history_tracks.last.association_chain).to eq([{ 'id' => post.id, 'name' => 'Post' }])
       end
 
       it 'should exclude defined options' do
         name = user.name
-        user.update_attributes(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
-        expect(user.history_tracks.first.original.keys).to eq(['n'])
-        expect(user.history_tracks.first.original['n']).to eq(name)
-        expect(user.history_tracks.first.modified.keys).to eq(['n'])
-        expect(user.history_tracks.first.modified['n']).to eq(user.name)
+        user.update_attributes!(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
+        expect(user.history_tracks.last.original.keys).to eq(['n'])
+        expect(user.history_tracks.last.original['n']).to eq(name)
+        expect(user.history_tracks.last.modified.keys).to eq(['n'])
+        expect(user.history_tracks.last.modified['n']).to eq(user.name)
       end
 
       it 'should undo field changes' do
         name = user.name
-        user.update_attributes(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
-        user.history_tracks.first.undo! nil
+        user.update_attributes!(name: 'Aaron2', email: 'aaronsnewemail@randomemail.com')
+        user.history_tracks.last.undo! nil
         expect(user.reload.name).to eq(name)
       end
 
       it 'should undo non-existing field changes' do
         post = Post.create!(modifier: user, views: 100)
         expect(post.reload.title).to be_nil
-        post.update_attributes(title: 'Aaron2')
+        post.update_attributes!(title: 'Aaron2')
         expect(post.reload.title).to eq('Aaron2')
-        post.history_tracks.first.undo! nil
+        post.history_tracks.last.undo! user
         expect(post.reload.title).to be_nil
       end
 
       it 'should track array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
-        expect(user.history_tracks.first.original['aliases']).to eq(aliases)
-        expect(user.history_tracks.first.modified['aliases']).to eq(user.aliases)
+        user.update_attributes!(aliases: %w[bob joe])
+        expect(user.history_tracks.last.original['aliases']).to eq(aliases)
+        expect(user.history_tracks.last.modified['aliases']).to eq(user.aliases)
       end
 
       it 'should undo array changes' do
         aliases = user.aliases
-        user.update_attributes(aliases: %w(bob joe))
-        user.history_tracks.first.undo! nil
+        user.update_attributes!(aliases: %w[bob joe])
+        user.history_tracks.last.undo! nil
         expect(user.reload.aliases).to eq(aliases)
       end
     end
@@ -259,9 +270,9 @@ describe Mongoid::History do
         end
       end
       context 'update action' do
-        subject { user.history_tracks.first.tracked_changes }
+        subject { user.history_tracks.last.tracked_changes }
         before do
-          user.update_attributes(name: 'Aaron2', email: nil, country: '',  city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
+          user.update_attributes!(name: 'Aaron2', email: nil, country: '',  city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
         end
         it { is_expected.to be_a HashWithIndifferentAccess }
         it 'should track changed field' do
@@ -305,9 +316,9 @@ describe Mongoid::History do
         end
       end
       context 'update action' do
-        subject { user.history_tracks.first.tracked_edits }
+        subject { user.history_tracks.last.tracked_edits }
         before do
-          user.update_attributes(name: 'Aaron2', email: nil, country: '', city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
+          user.update_attributes!(name: 'Aaron2', email: nil, country: '', city: nil, phone: '867-5309', aliases: ['', 'bill', 'james'])
         end
         it { is_expected.to be_a HashWithIndifferentAccess }
         it 'should track changed field' do
@@ -323,12 +334,12 @@ describe Mongoid::History do
           expect(subject[:array]).to eq({ aliases: { remove: ['bob'], add: ['', 'bill', 'james'] } }.with_indifferent_access)
         end
         it 'should not track unmodified field' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:address]).to be_nil
           end
         end
         it 'should not track untracked fields' do
-          %w(add modify remove array).each do |edit|
+          %w[add modify remove array].each do |edit|
             expect(subject[edit][:email]).to be_nil
           end
         end
@@ -348,73 +359,75 @@ describe Mongoid::History do
 
     describe 'on update non-embedded twice' do
       it 'should assign version on post' do
-        post.update_attributes(title: 'Test2')
-        post.update_attributes(title: 'Test3')
-        expect(post.version).to eq(2)
+        expect(post.version).to eq(1)
+        post.update_attributes!(title: 'Test2')
+        post.update_attributes!(title: 'Test3')
+        expect(post.version).to eq(3)
       end
 
       it 'should create a history track if changed attributes match tracked attributes' do
+        post # Created
         expect do
-          post.update_attributes(title: 'Test2')
-          post.update_attributes(title: 'Test3')
+          post.update_attributes!(title: 'Test2')
+          post.update_attributes!(title: 'Test3')
         end.to change(Tracker, :count).by(2)
       end
 
       it 'should create a history track of version 2' do
-        post.update_attributes(title: 'Test2')
-        post.update_attributes(title: 'Test3')
+        post.update_attributes!(title: 'Test2')
+        post.update_attributes!(title: 'Test3')
         expect(post.history_tracks.where(version: 2).first).not_to be_nil
       end
 
       it 'should assign modified fields' do
-        post.update_attributes(title: 'Test2')
-        post.update_attributes(title: 'Test3')
-        expect(post.history_tracks.where(version: 2).first.modified).to eq(
+        post.update_attributes!(title: 'Test2')
+        post.update_attributes!(title: 'Test3')
+        expect(post.history_tracks.where(version: 3).first.modified).to eq(
           'title' => 'Test3'
         )
       end
 
       it 'should assign original fields' do
-        post.update_attributes(title: 'Test2')
-        post.update_attributes(title: 'Test3')
-        expect(post.history_tracks.where(version: 2).first.original).to eq(
+        post.update_attributes!(title: 'Test2')
+        post.update_attributes!(title: 'Test3')
+        expect(post.history_tracks.where(version: 3).first.original).to eq(
           'title' => 'Test2'
         )
       end
 
       it 'should assign modifier' do
-        post.update_attributes(title: 'Another Test', modifier: another_user)
-        expect(post.history_tracks.last.modifier).to eq(another_user)
+        post.update_attributes!(title: 'Another Test', modifier: another_user)
+        expect(post.history_tracks.last.modifier.id).to eq(another_user.id)
       end
     end
 
     describe 'on update embedded 1..N (embeds_many)' do
       it 'should assign version on comment' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         expect(comment.version).to eq(2) # first track generated on creation
       end
 
       it 'should create a history track of version 2' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         expect(comment.history_tracks.where(version: 2).first).not_to be_nil
       end
 
       it 'should assign modified fields' do
-        comment.update_attributes(t: 'Test2')
+        comment.update_attributes!(t: 'Test2')
         expect(comment.history_tracks.where(version: 2).first.modified).to eq(
           't' => 'Test2'
         )
       end
 
       it 'should assign original fields' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         expect(comment.history_tracks.where(version: 2).first.original).to eq(
           't' => 'test'
         )
       end
 
       it 'should be possible to undo from parent' do
-        comment.update_attributes(title: 'Test 2')
+        comment.update_attributes!(title: 'Test 2')
         user
         post.history_tracks.last.undo!(user)
         comment.reload
@@ -422,16 +435,17 @@ describe Mongoid::History do
       end
 
       it 'should assign modifier' do
-        post.update_attributes(title: 'Another Test', modifier: another_user)
-        expect(post.history_tracks.last.modifier).to eq(another_user)
+        post.update_attributes!(title: 'Another Test', modifier: another_user)
+        expect(post.history_tracks.last.modifier.id).to eq(another_user.id)
       end
     end
 
     describe 'on update embedded 1..1 (embeds_one)' do
-      let(:section) { Section.new(title: 'Technology') }
+      let(:section) { Section.new(title: 'Technology', modifier: user) }
 
       before(:each) do
         post.section = section
+        post.modifier = user
         post.save!
         post.reload
         post.section
@@ -442,39 +456,39 @@ describe Mongoid::History do
       end
 
       it 'should assign version on section' do
-        section.update_attributes(title: 'Technology 2')
+        section.update_attributes!(title: 'Technology 2')
         expect(section.version).to eq(2) # first track generated on creation
       end
 
       it 'should create a history track of version 2' do
-        section.update_attributes(title: 'Technology 2')
+        section.update_attributes!(title: 'Technology 2')
         expect(section.history_tracks.where(version: 2).first).not_to be_nil
       end
 
       it 'should assign modified fields' do
-        section.update_attributes(title: 'Technology 2')
+        section.update_attributes!(title: 'Technology 2')
         expect(section.history_tracks.where(version: 2).first.modified).to eq(
           't' => 'Technology 2'
         )
       end
 
       it 'should assign original fields' do
-        section.update_attributes(title: 'Technology 2')
+        section.update_attributes!(title: 'Technology 2')
         expect(section.history_tracks.where(version: 2).first.original).to eq(
           't' => 'Technology'
         )
       end
 
       it 'should be possible to undo from parent' do
-        section.update_attributes(title: 'Technology 2')
+        section.update_attributes!(title: 'Technology 2')
         post.history_tracks.last.undo!(user)
         section.reload
         expect(section.title).to eq('Technology')
       end
 
       it 'should assign modifier' do
-        section.update_attributes(title: 'Business', modifier: another_user)
-        expect(post.history_tracks.last.modifier).to eq(another_user)
+        section.update_attributes!(title: 'Business', modifier: another_user)
+        expect(post.history_tracks.last.modifier.id).to eq(another_user.id)
       end
     end
 
@@ -503,28 +517,23 @@ describe Mongoid::History do
 
       it 'should be possible to create with redo after undo create embedded from parent' do
         comment # initialize
-        post.comments.create!(title: 'The second one')
-        track = post.history_tracks.last
+        post.comments.create!(title: 'The second one', modifier: user)
+        track = post.history_tracks[2]
+        expect(post.reload.comments.count).to eq 2
         track.undo!(user)
+        expect(post.reload.comments.count).to eq 1
         track.redo!(user)
-        post.reload
-        expect(post.comments.count).to eq(2)
+        expect(post.reload.comments.count).to eq 2
       end
     end
 
     describe 'embedded with cascading callbacks' do
       let(:tag_foo) { post.tags.create!(title: 'foo', updated_by: user) }
-      let(:tag_bar) { post.tags.create!(title: 'bar') }
-
-      # it "should have cascaded the creation callbacks and set timestamps" do
-      #   tag_foo; tag_bar # initialize
-      #   tag_foo.created_at.should_not be_nil
-      #   tag_foo.updated_at.should_not be_nil
-      # end
+      let(:tag_bar) { post.tags.create!(title: 'bar', updated_by: user) }
 
       it 'should allow an update through the parent model' do
         update_hash = { 'post' => { 'tags_attributes' => { '1234' => { 'id' => tag_bar.id, 'title' => 'baz' } } } }
-        post.update_attributes(update_hash['post'])
+        post.update_attributes!(update_hash['post'])
         expect(post.tags.last.title).to eq('baz')
       end
 
@@ -533,14 +542,14 @@ describe Mongoid::History do
         tag_bar # initialize
         expect(post.tags.count).to eq(2)
         update_hash = { 'post' => { 'tags_attributes' => { '1234' => { 'id' => tag_bar.id, 'title' => 'baz', '_destroy' => 'true' } } } }
-        post.update_attributes(update_hash['post'])
+        post.update_attributes!(update_hash['post'])
         expect(post.tags.count).to eq(1)
         expect(post.history_tracks.to_a.last.action).to eq('destroy')
       end
 
       it 'should write relationship name for association_chain hiearchy instead of class name when using _destroy macro' do
         update_hash = { 'tags_attributes' => { '1234' => { 'id' => tag_foo.id, '_destroy' => '1' } } }
-        post.update_attributes(update_hash)
+        post.update_attributes!(update_hash)
 
         # historically this would have evaluated to 'Tags' and an error would be thrown
         # on any call that walked up the association_chain, e.g. 'trackable'
@@ -551,35 +560,35 @@ describe Mongoid::History do
 
     describe 'non-embedded' do
       it 'should undo changes' do
-        post.update_attributes(title: 'Test2')
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.update_attributes!(title: 'Test2')
+        post.history_tracks.where(version: 2).last.undo!(user)
         post.reload
         expect(post.title).to eq('Test')
       end
 
       it 'should undo destruction' do
         post.destroy
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.history_tracks.where(version: 2).last.undo!(user)
         expect(Post.find(post.id).title).to eq('Test')
       end
 
       it 'should create a new history track after undo' do
         comment # initialize
-        post.update_attributes(title: 'Test2')
+        post.update_attributes!(title: 'Test2')
         post.history_tracks.last.undo!(user)
         post.reload
-        expect(post.history_tracks.count).to eq(3)
+        expect(post.history_tracks.count).to eq(4)
       end
 
       it 'should assign user as the modifier of the newly created history track' do
-        post.update_attributes(title: 'Test2')
-        post.history_tracks.where(version: 1).last.undo!(user)
+        post.update_attributes!(title: 'Test2')
+        post.history_tracks.where(version: 2).last.undo!(user)
         post.reload
-        expect(post.history_tracks.where(version: 2).last.modifier).to eq(user)
+        expect(post.history_tracks.where(version: 2).last.modifier.id).to eq(user.id)
       end
 
       it 'should stay the same after undo and redo' do
-        post.update_attributes(title: 'Test2')
+        post.update_attributes!(title: 'Test2')
         track = post.history_tracks.last
         track.undo!(user)
         track.redo!(user)
@@ -590,7 +599,7 @@ describe Mongoid::History do
 
       it 'should be destroyed after undo and redo' do
         post.destroy
-        track = post.history_tracks.where(version: 1).last
+        track = post.history_tracks.where(version: 2).last
         track.undo!(user)
         track.redo!(user)
         expect(Post.where(_id: post.id).first).to be_nil
@@ -599,28 +608,28 @@ describe Mongoid::History do
 
     describe 'embedded' do
       it 'should undo changes' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         comment.history_tracks.where(version: 2).first.undo!(user)
         comment.reload
         expect(comment.title).to eq('test')
       end
 
       it 'should create a new history track after undo' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         comment.history_tracks.where(version: 2).first.undo!(user)
         comment.reload
         expect(comment.history_tracks.count).to eq(3)
       end
 
       it 'should assign user as the modifier of the newly created history track' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         comment.history_tracks.where(version: 2).first.undo!(user)
         comment.reload
-        expect(comment.history_tracks.where(version: 3).first.modifier).to eq(user)
+        expect(comment.history_tracks.where(version: 3).first.modifier.id).to eq(user.id)
       end
 
       it 'should stay the same after undo and redo' do
-        comment.update_attributes(title: 'Test2')
+        comment.update_attributes!(title: 'Test2')
         track = comment.history_tracks.where(version: 2).first
         track.undo!(user)
         track.redo!(user)
@@ -639,7 +648,7 @@ describe Mongoid::History do
       describe 'undo' do
         { 'undo' => [nil], 'undo!' => [nil, :reload] }.each do |test_method, methods|
           methods.each do |method|
-            context "#{method || 'instance'}" do
+            context (method || 'instance').to_s do
               it 'recognizes :from, :to options' do
                 comment.send test_method, user, from: 4, to: 2
                 comment.send(method) if method
@@ -694,9 +703,9 @@ describe Mongoid::History do
 
       describe 'redo' do
         [nil, :reload].each do |method|
-          context "#{method || 'instance'}" do
+          context (method || 'instance').to_s do
             before :each do
-              comment.update_attributes(title: 'Test5')
+              comment.update_attributes!(title: 'Test5')
             end
 
             it 'should recognize :from, :to options' do
@@ -751,39 +760,8 @@ describe Mongoid::History do
       end
     end
 
-    describe 'localized fields' do
-      before :each do
-        class Sausage
-          include Mongoid::Document
-          include Mongoid::History::Trackable
-
-          field :flavour, localize: true
-          track_history on: [:flavour], track_destroy: true
-        end
-      end
-      it 'should correctly undo and redo' do
-        if Sausage.respond_to?(:localized_fields)
-          sausage = Sausage.create!(flavour_translations: { 'en' => 'Apple', 'nl' => 'Appel' })
-          sausage.update_attributes(flavour: 'Guinness')
-
-          track = sausage.history_tracks.last
-
-          track.undo! user
-          expect(sausage.reload.flavour).to eq('Apple')
-
-          track.redo! user
-          expect(sausage.reload.flavour).to eq('Guinness')
-
-          sausage.destroy
-          expect(sausage.history_tracks.last.action).to eq('destroy')
-          sausage.history_tracks.last.undo! user
-          expect(sausage.reload.flavour).to eq('Guinness')
-        end
-      end
-    end
-
     describe 'embedded with a polymorphic trackable' do
-      let(:foo) { Foo.new(title: 'a title', body: 'a body') }
+      let(:foo) { Foo.new(title: 'a title', body: 'a body', modifier: user) }
       before :each do
         post.comments << foo
         post.save!
@@ -809,7 +787,7 @@ describe Mongoid::History do
       end
       context 'an embedded model' do
         it 'should return the trackable parent class' do
-          comment.update_attributes(title: 'Foo')
+          comment.update_attributes!(title: 'Foo')
           expect(comment.history_tracks.first.trackable_parent_class).to eq(Post)
         end
         it 'should return the parent class even if the trackable is deleted' do
@@ -821,7 +799,7 @@ describe Mongoid::History do
     end
 
     describe 'when default scope is present' do
-      before do
+      before :each do
         class Post
           default_scope -> { where(title: nil) }
         end
@@ -838,7 +816,7 @@ describe Mongoid::History do
 
       describe 'post' do
         it 'should correctly undo and redo' do
-          post.update_attributes(title: 'a new title')
+          post.update_attributes!(title: 'a new title')
           track = post.history_tracks.last
           track.undo! user
           expect(post.reload.title).to eq('Test')
@@ -847,7 +825,7 @@ describe Mongoid::History do
         end
 
         it 'should stay the same after undo and redo' do
-          post.update_attributes(title: 'testing')
+          post.update_attributes!(title: 'testing')
           track = post.history_tracks.last
           track.undo! user
           track.redo! user
@@ -856,7 +834,7 @@ describe Mongoid::History do
       end
       describe 'comment' do
         it 'should correctly undo and redo' do
-          comment.update_attributes(title: 'a new title')
+          comment.update_attributes!(title: 'a new title')
           track = comment.history_tracks.last
           track.undo! user
           expect(comment.reload.title).to eq('test')
@@ -865,7 +843,7 @@ describe Mongoid::History do
         end
 
         it 'should stay the same after undo and redo' do
-          comment.update_attributes(title: 'testing')
+          comment.update_attributes!(title: 'testing')
           track = comment.history_tracks.last
           track.undo! user
           track.redo! user
@@ -874,7 +852,7 @@ describe Mongoid::History do
       end
       describe 'user' do
         it 'should correctly undo and redo' do
-          user.update_attributes(name: 'a new name')
+          user.update_attributes!(name: 'a new name')
           track = user.history_tracks.last
           track.undo! user
           expect(user.reload.name).to eq('Aaron')
@@ -883,7 +861,7 @@ describe Mongoid::History do
         end
 
         it 'should stay the same after undo and redo' do
-          user.update_attributes(name: 'testing')
+          user.update_attributes!(name: 'testing')
           track = user.history_tracks.last
           track.undo! user
           track.redo! user
@@ -892,7 +870,7 @@ describe Mongoid::History do
       end
       describe 'tag' do
         it 'should correctly undo and redo' do
-          tag.update_attributes(title: 'a new title')
+          tag.update_attributes!(title: 'a new title')
           track = tag.history_tracks.last
           track.undo! user
           expect(tag.reload.title).to eq('test')
@@ -901,7 +879,7 @@ describe Mongoid::History do
         end
 
         it 'should stay the same after undo and redo' do
-          tag.update_attributes(title: 'testing')
+          tag.update_attributes!(title: 'testing')
           track = tag.history_tracks.last
           track.undo! user
           track.redo! user
@@ -919,18 +897,80 @@ describe Mongoid::History do
           track_history on: [:foo], changes_method: :my_changes
 
           def my_changes
-            { foo: %w(bar baz) }
+            { foo: %w[bar baz] }
           end
         end
       end
 
+      after :each do
+        Object.send(:remove_const, :OverriddenChangesMethod)
+      end
+
       it 'should add foo to the changes history' do
-        o = OverriddenChangesMethod.create
+        o = OverriddenChangesMethod.create(modifier: user)
         o.save!
         track = o.history_tracks.last
         expect(track.modified).to eq('foo' => 'baz')
         expect(track.original).to eq('foo' => 'bar')
       end
     end
+
+    describe 'localized fields' do
+      before :each do
+        class Sausage
+          include Mongoid::Document
+          include Mongoid::History::Trackable
+
+          field :flavour, localize: true
+          track_history on: [:flavour], track_destroy: true, modifier_field_optional: true
+        end
+      end
+
+      after :each do
+        Object.send(:remove_const, :Sausage)
+      end
+
+      it 'should correctly undo and redo' do
+        pending unless Sausage.respond_to?(:localized_fields)
+
+        sausage = Sausage.create!(flavour_translations: { 'en' => 'Apple', 'nl' => 'Appel' }, modifier: user)
+        sausage.update_attributes!(flavour: 'Guinness')
+
+        track = sausage.history_tracks.last
+
+        track.undo! user
+        expect(sausage.reload.flavour).to eq('Apple')
+
+        track.redo! user
+        expect(sausage.reload.flavour).to eq('Guinness')
+
+        sausage.destroy
+        expect(sausage.history_tracks.last.action).to eq('destroy')
+        sausage.history_tracks.last.undo! user
+        expect(sausage.reload.flavour).to eq('Guinness')
+      end
+    end
+
+    describe 'changing collection' do
+      before :each do
+        class Fish
+          include Mongoid::Document
+          include Mongoid::History::Trackable
+
+          track_history on: [:species], modifier_field_optional: true
+          store_in collection: :animals
+
+          field :species
+        end
+      end
+
+      after :each do
+        Object.send(:remove_const, :Fish)
+      end
+
+      it 'should track history' do
+        Fish.new.save!
+      end
+    end
   end
 end