paper_trail 3.0.9 → 4.0.0.beta1

data/test/dummy/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/test/test_helper.rb

@@ -13,7 +13,7 @@ require File.expand_path("../dummy/config/environment.rb",  __FILE__)
 require "rails/test_help"
 require 'shoulda'
 require 'ffaker'
-require 'database_cleaner' if using_mysql?
+require 'database_cleaner'
 
 Rails.backtrace_cleaner.remove_silencers!
 
@@ -24,7 +24,7 @@ ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 # DatabaseCleaner is apparently necessary for doing proper transactions within MySQL (ugh)
-DatabaseCleaner.strategy = :truncation if using_mysql?
+DatabaseCleaner.strategy = :truncation
 
 # global setup block resetting Thread.current
 class ActiveSupport::TestCase

data/test/time_travel_helper.rb

@@ -0,0 +1,15 @@
+if RUBY_VERSION < "1.9.2"
+  require 'delorean'
+
+  class Timecop
+    def self.travel(t)
+      Delorean.time_travel_to t
+    end
+
+    def self.return
+      Delorean.back_to_the_present
+    end
+  end
+else
+  require 'timecop'
+end

data/test/unit/model_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'time_travel_helper'
 
 class HasPaperTrailModelTest < ActiveSupport::TestCase
 
@@ -191,9 +192,8 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
       assert @widget.live?
     end
 
-
     context 'which is then created' do
-      setup { @widget.update_attributes :name => 'Henry' }
+      setup { @widget.update_attributes :name => 'Henry', :created_at => Time.now - 1.day }
 
       should 'have one previous version' do
         assert_equal 1, @widget.versions.length
@@ -212,6 +212,10 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
         assert @widget.live?
       end
 
+      should 'use the widget created_at' do
+        assert_equal @widget.created_at.to_i, @widget.versions.first.created_at.to_i
+      end
+
       should 'have changes' do
 
         #TODO Postgres does not appear to pass back ActiveSupport::TimeWithZone, 
@@ -301,13 +305,13 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
           should 'not copy the has_one association by default when reifying' do
             reified_widget = @widget.versions.last.reify
             assert_equal @wotsit, reified_widget.wotsit  # association hasn't been affected by reifying
-            assert_equal @wotsit, @widget.wotsit  # confirm that the association is correct
+            assert_equal @wotsit, @widget.wotsit(true)  # confirm that the association is correct
           end
 
           should 'copy the has_one association when reifying with :has_one => true' do
             reified_widget = @widget.versions.last.reify(:has_one => true)
             assert_nil reified_widget.wotsit  # wotsit wasn't there at the last version
-            assert_equal @wotsit, @widget.wotsit  # wotsit came into being on the live object
+            assert_equal @wotsit, @widget.wotsit(true)  # wotsit should still exist on live object
           end
         end
 
@@ -567,9 +571,9 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
 
       should 'track who made the change' do
         assert_equal 'Alice', @version.whodunnit
-        assert_nil   @version.paper_trail_originator
+        assert_nil   @version.originator
         assert_equal 'Alice', @version.terminator
-        assert_equal 'Alice', @widget.paper_trail_originator
+        assert_equal 'Alice', @widget.originator
       end
 
       context 'when a record is updated' do
@@ -581,9 +585,9 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
 
         should 'track who made the change' do
           assert_equal 'Bob',   @version.whodunnit
-          assert_equal 'Alice', @version.paper_trail_originator
+          assert_equal 'Alice', @version.originator
           assert_equal 'Bob',   @version.terminator
-          assert_equal 'Bob',   @widget.paper_trail_originator
+          assert_equal 'Bob',   @widget.originator
         end
 
         context 'when a record is destroyed' do
@@ -595,9 +599,9 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
 
           should 'track who made the change' do
             assert_equal 'Charlie', @version.whodunnit
-            assert_equal 'Bob',     @version.paper_trail_originator
+            assert_equal 'Bob',     @version.originator
             assert_equal 'Charlie', @version.terminator
-            assert_equal 'Charlie', @widget.paper_trail_originator
+            assert_equal 'Charlie', @widget.originator
           end
         end
       end
@@ -617,17 +621,15 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
     end
 
     # Currently the gem generates a bunch of deprecation warnings about serialized attributes on AR 4.2
-    if ActiveRecord::VERSION::STRING < '4.2'
-      should 'not generate warning' do
-        # Tests that it doesn't try to write created_on as an attribute just because a created_on
-        # method exists.
-        warnings = capture(:stderr) {  # Deprecation warning in Rails 3.2
-          assert_nothing_raised {  # ActiveModel::MissingAttributeError in Rails 4
-            @wotsit.update_attributes! :name => 'changed'
-          }
+    should 'not generate warning' do
+      # Tests that it doesn't try to write created_on as an attribute just because a created_on
+      # method exists.
+      warnings = capture(:stderr) {  # Deprecation warning in Rails 3.2
+        assert_nothing_raised {  # ActiveModel::MissingAttributeError in Rails 4
+          @wotsit.update_attributes! :name => 'changed'
         }
-        assert_equal '', warnings
-      end
+      }
+      assert_equal '', warnings
     end
 
   end
@@ -649,7 +651,7 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
     should 'should return the correct originator' do
       PaperTrail.whodunnit = 'Ben'
       @foo.update_attribute(:name, 'Geoffrey')
-      assert_equal PaperTrail.whodunnit, @foo.paper_trail_originator
+      assert_equal PaperTrail.whodunnit, @foo.originator
     end
 
     context 'when destroyed' do
@@ -734,7 +736,7 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
       should 'return versions in the time period' do
         assert_equal ['Fidget'], @widget.versions_between(20.days.ago, 10.days.ago).map(&:name)
         assert_equal ['Widget', 'Fidget'], @widget.versions_between(45.days.ago, 10.days.ago).map(&:name)
-        assert_equal ['Fidget', 'Digit'], @widget.versions_between(16.days.ago, 1.minute.ago).map(&:name)
+        assert_equal ['Fidget', 'Digit', 'Digit'], @widget.versions_between(16.days.ago, 1.minute.ago).map(&:name)
         assert_equal [], @widget.versions_between(60.days.ago, 45.days.ago).map(&:name)
       end
     end
@@ -930,7 +932,7 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
       count = PaperTrail::Version.count
       @book.authors.create :name => 'Tolstoy'
       assert_equal 2, PaperTrail::Version.count - count
-      assert_same_elements [Person.last, Authorship.last], [PaperTrail::Version.all[-2].item, PaperTrail::Version.last.item]
+      assert_same_elements [Person.last, Authorship.last], [PaperTrail::Version.order(:id).to_a[-2].item, PaperTrail::Version.last.item]
     end
 
     should 'store version on join destroy' do
@@ -952,174 +954,100 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
     end
   end
 
-
-  context 'A model with a has_one association' do
-    setup { @widget = Widget.create :name => 'widget_0' }
-
-    context 'before the associated was created' do
-      setup do
-        @widget.update_attributes :name => 'widget_1'
-        @wotsit = @widget.create_wotsit :name => 'wotsit_0'
-      end
-
-      context 'when reified' do
-        setup { @widget_0 = @widget.versions.last.reify(:has_one => 1) }
-
-        should 'see the associated as it was at the time' do
-          assert_nil @widget_0.wotsit
-        end
-      end
-    end
-
-    context 'where the association is created between model versions' do
-      setup do
-        @wotsit = @widget.create_wotsit :name => 'wotsit_0'
-        make_last_version_earlier @wotsit
-
-        @widget.update_attributes :name => 'widget_1'
-      end
-
-      context 'when reified' do
-        setup { @widget_0 = @widget.versions.last.reify(:has_one => 1) }
-
-        should 'see the associated as it was at the time' do
-          assert_equal 'wotsit_0', @widget_0.wotsit.name
-        end
-      end
-
-      context 'and then the associated is updated between model versions' do
-        setup do
-          @wotsit.update_attributes :name => 'wotsit_1'
-          make_last_version_earlier @wotsit
-          @wotsit.update_attributes :name => 'wotsit_2'
-          make_last_version_earlier @wotsit
-
-          @widget.update_attributes :name => 'widget_2'
-          @wotsit.update_attributes :name => 'wotsit_3'
-        end
-
-        context 'when reified' do
-          setup { @widget_1 = @widget.versions.last.reify(:has_one => 1) }
-
-          should 'see the associated as it was at the time' do
-            assert_equal 'wotsit_2', @widget_1.wotsit.name
-          end
-        end
-
-        context 'when reified opting out of has_one reification' do
-          setup { @widget_1 = @widget.versions.last.reify(:has_one => false) }
-
-          should 'see the associated as it is live' do
-            assert_equal 'wotsit_3', @widget_1.wotsit.name
-          end
-        end
-      end
-
-      context 'and then the associated is destroyed between model versions' do
-        setup do
-          @wotsit.destroy
-          make_last_version_earlier @wotsit
-
-          @widget.update_attributes :name => 'widget_3'
-        end
-
-        context 'when reified' do
-          setup { @widget_2 = @widget.versions.last.reify(:has_one => 1) }
-
-          should 'see the associated as it was at the time' do
-            assert_nil @widget_2.wotsit
-          end
-        end
-      end
-    end
-  end
-
-  context 'When an attribute has a custom serializer' do
-    setup { @person = Person.new(:time_zone => "Samoa") }
-
-    should "be an instance of ActiveSupport::TimeZone" do
-      assert_equal ActiveSupport::TimeZone, @person.time_zone.class
-    end
-
-    context 'when the model is saved' do
+  # `serialized_attributes` is deprecated in ActiveRecord 5.0
+  if ::ActiveRecord::VERSION::MAJOR < 5
+    context 'When an attribute has a custom serializer' do
       setup do
-        @changes_before_save = @person.changes.dup
-        @person.save!
+        PaperTrail.config.serialized_attributes = true
+        @person = Person.new(:time_zone => "Samoa")
       end
 
-      # Test for serialization:
-      should 'version.object_changes should not have stored the default, ridiculously long (to_yaml) serialization of the TimeZone object' do
-        assert @person.versions.last.object_changes.length < 105, "object_changes length was #{@person.versions.last.object_changes.length}"
-      end
-      # It should store the serialized value.
-      should 'version.object_changes attribute should have stored the value returned by the attribute serializer' do
-        as_stored_in_version = HashWithIndifferentAccess[YAML::load(@person.versions.last.object_changes)]
-        assert_equal [nil, 'Samoa'], as_stored_in_version[:time_zone]
-        serialized_value = Person::TimeZoneSerializer.dump(@person.time_zone)
-        assert_equal serialized_value, as_stored_in_version[:time_zone].last
-      end
+      teardown { PaperTrail.config.serialized_attributes = false }
 
-      # Tests for unserialization:
-      should 'version.changeset should convert the attribute value back to its original, unserialized value' do
-        unserialized_value = Person::TimeZoneSerializer.load(@person.time_zone)
-        assert_equal unserialized_value, @person.versions.last.changeset[:time_zone].last
-      end
-      should "record.changes (before save) returns the original, unserialized values" do
-        assert_equal [NilClass, ActiveSupport::TimeZone], @changes_before_save[:time_zone].map(&:class)
-      end
-      should 'version.changeset should be the same as record.changes was before the save' do
-        assert_equal @changes_before_save, @person.versions.last.changeset.delete_if { |key, val| key.to_sym == :id }
-        assert_equal [NilClass, ActiveSupport::TimeZone], @person.versions.last.changeset[:time_zone].map(&:class)
+      should "be an instance of ActiveSupport::TimeZone" do
+        assert_equal ActiveSupport::TimeZone, @person.time_zone.class
       end
 
-      context 'when that attribute is updated' do
+      context 'when the model is saved' do
         setup do
-          @attribute_value_before_change = @person.time_zone
-          @person.assign_attributes({ :time_zone => 'Pacific Time (US & Canada)' })
           @changes_before_save = @person.changes.dup
           @person.save!
         end
 
-        # Tests for serialization:
-        # Before the serialized attributes fix, the object/object_changes value that was stored was ridiculously long (58723).
-        should 'version.object should not have stored the default, ridiculously long (to_yaml) serialization of the TimeZone object' do
-          assert @person.versions.last.object.length < 105, "object length was #{@person.versions.last.object.length}"
-        end
-        # Need an additional clause to detect what version of ActiveRecord is being used for this test because AR4 injects the `updated_at` column into the changeset for updates to models
+        # Test for serialization:
         should 'version.object_changes should not have stored the default, ridiculously long (to_yaml) serialization of the TimeZone object' do
-          assert @person.versions.last.object_changes.length < (ActiveRecord::VERSION::MAJOR < 4 ? 105 : 118), "object_changes length was #{@person.versions.last.object_changes.length}"
-        end
-        # But now it stores the short, serialized value.
-        should 'version.object attribute should have stored the value returned by the attribute serializer' do
-          as_stored_in_version = HashWithIndifferentAccess[YAML::load(@person.versions.last.object)]
-          assert_equal 'Samoa', as_stored_in_version[:time_zone]
-          serialized_value = Person::TimeZoneSerializer.dump(@attribute_value_before_change)
-          assert_equal serialized_value, as_stored_in_version[:time_zone]
+          assert @person.versions.last.object_changes.length < 105, "object_changes length was #{@person.versions.last.object_changes.length}"
         end
+        # It should store the serialized value.
         should 'version.object_changes attribute should have stored the value returned by the attribute serializer' do
           as_stored_in_version = HashWithIndifferentAccess[YAML::load(@person.versions.last.object_changes)]
-          assert_equal ['Samoa', 'Pacific Time (US & Canada)'], as_stored_in_version[:time_zone]
+          assert_equal [nil, 'Samoa'], as_stored_in_version[:time_zone]
           serialized_value = Person::TimeZoneSerializer.dump(@person.time_zone)
           assert_equal serialized_value, as_stored_in_version[:time_zone].last
         end
 
         # Tests for unserialization:
-        should 'version.reify should convert the attribute value back to its original, unserialized value' do
-          unserialized_value = Person::TimeZoneSerializer.load(@attribute_value_before_change)
-          assert_equal unserialized_value, @person.versions.last.reify.time_zone
-        end
         should 'version.changeset should convert the attribute value back to its original, unserialized value' do
           unserialized_value = Person::TimeZoneSerializer.load(@person.time_zone)
           assert_equal unserialized_value, @person.versions.last.changeset[:time_zone].last
         end
         should "record.changes (before save) returns the original, unserialized values" do
-          assert_equal [ActiveSupport::TimeZone, ActiveSupport::TimeZone], @changes_before_save[:time_zone].map(&:class)
+          assert_equal [NilClass, ActiveSupport::TimeZone], @changes_before_save[:time_zone].map(&:class)
         end
         should 'version.changeset should be the same as record.changes was before the save' do
-          assert_equal @changes_before_save, @person.versions.last.changeset
-          assert_equal [ActiveSupport::TimeZone, ActiveSupport::TimeZone], @person.versions.last.changeset[:time_zone].map(&:class)
+          assert_equal @changes_before_save, @person.versions.last.changeset.delete_if { |key, val| key.to_sym == :id }
+          assert_equal [NilClass, ActiveSupport::TimeZone], @person.versions.last.changeset[:time_zone].map(&:class)
         end
 
+        context 'when that attribute is updated' do
+          setup do
+            @attribute_value_before_change = @person.time_zone
+            @person.assign_attributes({ :time_zone => 'Pacific Time (US & Canada)' })
+            @changes_before_save = @person.changes.dup
+            @person.save!
+          end
+
+          # Tests for serialization:
+          # Before the serialized attributes fix, the object/object_changes value that was stored was ridiculously long (58723).
+          should 'version.object should not have stored the default, ridiculously long (to_yaml) serialization of the TimeZone object' do
+            assert @person.versions.last.object.length < 105, "object length was #{@person.versions.last.object.length}"
+          end
+          # Need an additional clause to detect what version of ActiveRecord is being used for this test because AR4 injects the `updated_at` column into the changeset for updates to models
+          should 'version.object_changes should not have stored the default, ridiculously long (to_yaml) serialization of the TimeZone object' do
+            assert @person.versions.last.object_changes.length < (ActiveRecord::VERSION::MAJOR < 4 ? 105 : 118), "object_changes length was #{@person.versions.last.object_changes.length}"
+          end
+          # But now it stores the short, serialized value.
+          should 'version.object attribute should have stored the value returned by the attribute serializer' do
+            as_stored_in_version = HashWithIndifferentAccess[YAML::load(@person.versions.last.object)]
+            assert_equal 'Samoa', as_stored_in_version[:time_zone]
+            serialized_value = Person::TimeZoneSerializer.dump(@attribute_value_before_change)
+            assert_equal serialized_value, as_stored_in_version[:time_zone]
+          end
+          should 'version.object_changes attribute should have stored the value returned by the attribute serializer' do
+            as_stored_in_version = HashWithIndifferentAccess[YAML::load(@person.versions.last.object_changes)]
+            assert_equal ['Samoa', 'Pacific Time (US & Canada)'], as_stored_in_version[:time_zone]
+            serialized_value = Person::TimeZoneSerializer.dump(@person.time_zone)
+            assert_equal serialized_value, as_stored_in_version[:time_zone].last
+          end
+
+          # Tests for unserialization:
+          should 'version.reify should convert the attribute value back to its original, unserialized value' do
+            unserialized_value = Person::TimeZoneSerializer.load(@attribute_value_before_change)
+            assert_equal unserialized_value, @person.versions.last.reify.time_zone
+          end
+          should 'version.changeset should convert the attribute value back to its original, unserialized value' do
+            unserialized_value = Person::TimeZoneSerializer.load(@person.time_zone)
+            assert_equal unserialized_value, @person.versions.last.changeset[:time_zone].last
+          end
+          should "record.changes (before save) returns the original, unserialized values" do
+            assert_equal [ActiveSupport::TimeZone, ActiveSupport::TimeZone], @changes_before_save[:time_zone].map(&:class)
+          end
+          should 'version.changeset should be the same as record.changes was before the save' do
+            assert_equal @changes_before_save, @person.versions.last.changeset
+            assert_equal [ActiveSupport::TimeZone, ActiveSupport::TimeZone], @person.versions.last.changeset[:time_zone].map(&:class)
+          end
+
+        end
       end
     end
   end
@@ -1174,21 +1102,6 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
     should 'return "overwritten" value on reified instance' do
       assert_equal 4, @song.versions.last.reify.length
     end
-
-    context 'Has a virtual attribute injected into the ActiveModel::Dirty changes' do
-      setup do
-        @song.name = 'Good Vibrations'
-        @song.save
-        @song.name = nil
-      end
-
-      should 'return persist the changes on the live instance properly' do
-        assert_equal nil, @song.name
-      end
-      should 'return "overwritten" virtual attribute on the reified instance' do
-        assert_equal 'Good Vibrations', @song.versions.last.reify.name
-      end
-    end
   end
 
 
@@ -1399,15 +1312,530 @@ class HasPaperTrailModelTest < ActiveSupport::TestCase
       assert_equal 3, @widget.versions.size
     end
   end
+end
 
-  private
 
-  # Updates `model`'s last version so it looks like the version was
-  # created 2 seconds ago.
-  def make_last_version_earlier(model)
-    PaperTrail::Version.record_timestamps = false
-    model.versions.last.update_attributes :created_at => 2.seconds.ago
-    PaperTrail::Version.record_timestamps = true
+class HasPaperTrailModelTransactionalTest < ActiveSupport::TestCase
+  # These would have been done in test_helper.rb if using_mysql? is true
+  unless using_mysql?
+    self.use_transactional_fixtures = false
+    setup { DatabaseCleaner.start }
   end
 
-end
+  teardown do
+    Timecop.return
+    # This would have been done in test_helper.rb if using_mysql? is true
+    DatabaseCleaner.clean unless using_mysql?
+  end
+
+  context 'A model with a has_one association' do
+    setup { @widget = Widget.create :name => 'widget_0' }
+
+    context 'before the associated was created' do
+      setup do
+        @widget.update_attributes :name => 'widget_1'
+        @wotsit = @widget.create_wotsit :name => 'wotsit_0'
+      end
+
+      context 'when reified' do
+        setup { @widget_0 = @widget.versions.last.reify(:has_one => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_nil @widget_0.wotsit
+        end
+
+        should 'not persist changes to the live association' do
+          assert_equal @wotsit, @widget.wotsit(true)
+        end
+      end
+    end
+
+    context 'where the association is created between model versions' do
+      setup do
+        @wotsit = @widget.create_wotsit :name => 'wotsit_0'
+        Timecop.travel 1.second.since
+        @widget.update_attributes :name => 'widget_1'
+      end
+
+      context 'when reified' do
+        setup { @widget_0 = @widget.versions.last.reify(:has_one => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal 'wotsit_0', @widget_0.wotsit.name
+        end
+
+        should 'not persist changes to the live association' do
+          assert_equal @wotsit, @widget.wotsit(true)
+        end
+      end
+
+      context 'and then the associated is updated between model versions' do
+        setup do
+          @wotsit.update_attributes :name => 'wotsit_1'
+          @wotsit.update_attributes :name => 'wotsit_2'
+          Timecop.travel 1.second.since
+          @widget.update_attributes :name => 'widget_2'
+          @wotsit.update_attributes :name => 'wotsit_3'
+        end
+
+        context 'when reified' do
+          setup { @widget_1 = @widget.versions.last.reify(:has_one => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal 'wotsit_2', @widget_1.wotsit.name
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal 'wotsit_3', @widget.wotsit(true).name
+          end
+        end
+
+        context 'when reified opting out of has_one reification' do
+          setup { @widget_1 = @widget.versions.last.reify(:has_one => false) }
+
+          should 'see the associated as it is live' do
+            assert_equal 'wotsit_3', @widget_1.wotsit.name
+          end
+        end
+      end
+
+      context 'and then the associated is destroyed' do
+        setup do
+          @wotsit.destroy
+        end
+
+        context 'when reify' do
+          setup { @widget_1 = @widget.versions.last.reify(:has_one => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal @wotsit, @widget_1.wotsit
+          end
+
+          should 'not persist changes to the live association' do
+            assert_nil @widget.wotsit(true)
+          end
+        end
+
+        context 'and then the model is updated' do
+          setup do
+            Timecop.travel 1.second.since
+            @widget.update_attributes :name => 'widget_3'
+          end
+
+          context 'when reified' do
+            setup { @widget_2 = @widget.versions.last.reify(:has_one => true) }
+
+            should 'see the associated as it was at the time' do
+              assert_nil @widget_2.wotsit
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'A model with a has_many association' do
+    setup { @customer = Customer.create :name => 'customer_0' }
+
+    context 'updated before the associated was created' do
+      setup do
+        @customer.update_attributes! :name => 'customer_1'
+        @customer.orders.create! :order_date => Date.today
+      end
+
+      context 'when reified' do
+        setup { @customer_0 = @customer.versions.last.reify(:has_many => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal [], @customer_0.orders
+        end
+
+        should 'not persist changes to the live association' do
+          assert_not_equal [], @customer.orders(true)
+        end
+      end
+
+      context 'when reified with option mark_for_destruction' do
+        setup { @customer_0 = @customer.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+        should 'mark the associated for destruction' do
+          assert_equal [true], @customer_0.orders.map(&:marked_for_destruction?)
+        end
+      end
+    end
+
+    context 'where the association is created between model versions' do
+      setup do
+        @order = @customer.orders.create! :order_date => 'order_date_0'
+        Timecop.travel 1.second.since
+        @customer.update_attributes :name => 'customer_1'
+      end
+
+      context 'when reified' do
+        setup { @customer_0 = @customer.versions.last.reify(:has_many => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal ['order_date_0'], @customer_0.orders.map(&:order_date)
+        end
+      end
+
+      context 'and then a nested has_many association is created' do
+        setup do
+          @order.line_items.create! :product => 'product_0'
+        end
+
+        context 'when reified' do
+          setup { @customer_0 = @customer.versions.last.reify(:has_many => true) }
+
+          should 'see the live version of the nested association' do
+            assert_equal ['product_0'], @customer_0.orders.first.line_items.map(&:product)
+          end
+        end
+      end
+
+      context 'and then the associated is updated between model versions' do
+        setup do
+          @order.update_attributes :order_date => 'order_date_1'
+          @order.update_attributes :order_date => 'order_date_2'
+          Timecop.travel 1.second.since
+          @customer.update_attributes :name => 'customer_2'
+          @order.update_attributes :order_date => 'order_date_3'
+        end
+
+        context 'when reified' do
+          setup { @customer_1 = @customer.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal ['order_date_2'], @customer_1.orders.map(&:order_date)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal ['order_date_3'], @customer.orders(true).map(&:order_date)
+          end
+        end
+
+        context 'when reified opting out of has_many reification' do
+          setup { @customer_1 = @customer.versions.last.reify(:has_many => false) }
+
+          should 'see the associated as it is live' do
+            assert_equal ['order_date_3'], @customer_1.orders.map(&:order_date)
+          end
+        end
+
+        context 'and then the associated is destroyed' do
+          setup do
+            @order.destroy
+          end
+
+          context 'when reified' do
+            setup { @customer_1 = @customer.versions.last.reify(:has_many => true) }
+
+            should 'see the associated as it was at the time' do
+              assert_equal ['order_date_2'], @customer_1.orders.map(&:order_date)
+            end
+
+            should 'not persist changes to the live association' do
+              assert_equal [], @customer.orders(true)
+            end
+          end
+        end
+      end
+
+      context 'and then the associated is destroyed' do
+        setup do
+          @order.destroy
+        end
+
+        context 'when reified' do
+          setup { @customer_1 = @customer.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal [@order.order_date], @customer_1.orders.map(&:order_date)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal [], @customer.orders(true)
+          end
+        end
+      end
+
+      context 'and then the associated is destroyed between model versions' do
+        setup do
+          @order.destroy
+          Timecop.travel 1.second.since
+          @customer.update_attributes :name => 'customer_2'
+        end
+
+        context 'when reified' do
+          setup { @customer_1 = @customer.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal [], @customer_1.orders
+          end
+        end
+      end
+
+      context 'and then another association is added' do
+        setup do
+          @customer.orders.create! :order_date => 'order_date_1'
+        end
+
+        context 'when reified' do
+          setup { @customer_0 = @customer.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal ['order_date_0'], @customer_0.orders.map(&:order_date)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal ['order_date_0', 'order_date_1'], @customer.orders(true).map(&:order_date).sort
+          end
+        end
+
+        context 'when reified with option mark_for_destruction' do
+          setup { @customer_0 = @customer.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+          should 'mark the newly associated for destruction' do
+            assert @customer_0.orders.detect { |o| o.order_date == 'order_date_1'}.marked_for_destruction?
+          end
+        end
+      end
+    end
+  end
+
+  context 'A model with a has_many through association' do
+    setup { @book = Book.create :title => 'book_0' }
+
+    context 'updated before the associated was created' do
+      setup do
+        @book.update_attributes! :title => 'book_1'
+        @book.authors.create! :name => 'author_0'
+      end
+
+      context 'when reified' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal [], @book_0.authors
+        end
+
+        should 'not persist changes to the live association' do
+          assert_equal ['author_0'], @book.authors(true).map(&:name)
+        end
+      end
+
+      context 'when reified with option mark_for_destruction' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+        should 'mark the associated for destruction' do
+          assert_equal [true], @book_0.authors.map(&:marked_for_destruction?)
+        end
+
+        should 'mark the associated-through for destruction' do
+          assert_equal [true], @book_0.authorships.map(&:marked_for_destruction?)
+        end
+      end
+    end
+
+    context 'updated before it is associated with an existing one' do
+      setup do
+        person_existing = Person.create(:name => 'person_existing')
+        Timecop.travel 1.second.since
+        @book.update_attributes! :title => 'book_1'
+        @book.authors << person_existing
+      end
+
+      context 'when reified' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal [], @book_0.authors
+        end
+      end
+
+      context 'when reified with option mark_for_destruction' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+        should 'not mark the associated for destruction' do
+          assert_equal [false], @book_0.authors.map(&:marked_for_destruction?)
+        end
+
+        should 'mark the associated-through for destruction' do
+          assert_equal [true], @book_0.authorships.map(&:marked_for_destruction?)
+        end
+      end
+    end
+
+    context 'where the association is created between model versions' do
+      setup do
+        @author = @book.authors.create! :name => 'author_0'
+        @person_existing = Person.create(:name => 'person_existing')
+        Timecop.travel 1.second.since
+        @book.update_attributes! :title => 'book_1'
+      end
+
+      context 'when reified' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+        should 'see the associated as it was at the time' do
+          assert_equal ['author_0'], @book_0.authors.map(&:name)
+        end
+      end
+
+      context 'and then the associated is updated between model versions' do
+        setup do
+          @author.update_attributes :name => 'author_1'
+          @author.update_attributes :name => 'author_2'
+          Timecop.travel 1.second.since
+          @book.update_attributes :title => 'book_2'
+          @author.update_attributes :name => 'author_3'
+        end
+
+        context 'when reified' do
+          setup { @book_1 = @book.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal ['author_2'], @book_1.authors.map(&:name)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal ['author_3'], @book.authors(true).map(&:name)
+          end
+        end
+
+        context 'when reified opting out of has_many reification' do
+          setup { @book_1 = @book.versions.last.reify(:has_many => false) }
+
+          should 'see the associated as it is live' do
+            assert_equal ['author_3'], @book_1.authors.map(&:name)
+          end
+        end
+      end
+
+      context 'and then the associated is destroyed' do
+        setup do
+          @author.destroy
+        end
+
+        context 'when reified' do
+          setup { @book_1 = @book.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal [@author.name], @book_1.authors.map(&:name)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal [], @book.authors(true)
+          end
+        end
+      end
+
+      context 'and then the associated is destroyed between model versions' do
+        setup do
+          @author.destroy
+          Timecop.travel 1.second.since
+          @book.update_attributes :title => 'book_2'
+        end
+
+        context 'when reified' do
+          setup { @book_1 = @book.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal [], @book_1.authors
+          end
+        end
+      end
+
+      context 'and then the associated is dissociated between model versions' do
+        setup do
+          @book.authors = []
+          Timecop.travel 1.second.since
+          @book.update_attributes :title => 'book_2'
+        end
+
+        context 'when reified' do
+          setup { @book_1 = @book.versions.last.reify(:has_many => true) }
+
+          should 'see the associated as it was at the time' do
+            assert_equal [], @book_1.authors
+          end
+        end
+      end
+
+      context 'and then another associated is created' do
+        setup do
+          @book.authors.create! :name => 'author_1'
+        end
+
+        context 'when reified' do
+          setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+          should 'only see the first associated' do
+            assert_equal ['author_0'], @book_0.authors.map(&:name)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal ['author_0', 'author_1'], @book.authors(true).map(&:name)
+          end
+        end
+
+        context 'when reified with option mark_for_destruction' do
+          setup { @book_0 = @book.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+          should 'mark the newly associated for destruction' do
+            assert @book_0.authors.detect { |a| a.name == 'author_1' }.marked_for_destruction?
+          end
+
+          should 'mark the newly associated-through for destruction' do
+            assert @book_0.authorships.detect { |as| as.person.name == 'author_1' }.marked_for_destruction?
+          end
+        end
+      end
+
+      context 'and then an existing one is associated' do
+        setup do
+          @book.authors << @person_existing
+        end
+
+        context 'when reified' do
+          setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+          should 'only see the first associated' do
+            assert_equal ['author_0'], @book_0.authors.map(&:name)
+          end
+
+          should 'not persist changes to the live association' do
+            assert_equal ['author_0', 'person_existing'], @book.authors(true).map(&:name).sort
+          end
+        end
+
+        context 'when reified with option mark_for_destruction' do
+          setup { @book_0 = @book.versions.last.reify(:has_many => true, :mark_for_destruction => true) }
+
+          should 'not mark the newly associated for destruction' do
+            assert !@book_0.authors.detect { |a| a.name == 'person_existing' }.marked_for_destruction?
+          end
+
+          should 'mark the newly associated-through for destruction' do
+            assert @book_0.authorships.detect { |as| as.person.name == 'person_existing' }.marked_for_destruction?
+          end
+        end
+      end
+    end
+
+    context 'updated before the associated without paper_trail was created' do
+      setup do
+        @book.update_attributes! :title => 'book_1'
+        @book.editors.create! :name => 'editor_0'
+      end
+
+      context 'when reified' do
+        setup { @book_0 = @book.versions.last.reify(:has_many => true) }
+
+        should 'see the live association' do
+          assert_equal ['editor_0'], @book_0.editors.map(&:name)
+        end
+      end
+    end
+  end
+end