paper_trail 4.2.0 → 7.1.3

data/test/dummy/script/rails

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
-
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
-require 'rails/commands'

data/test/functional/controller_test.rb

@@ -1,91 +0,0 @@
-require 'test_helper'
-
-class ControllerTest < ActionController::TestCase
-  tests WidgetsController
-
-  setup do
-    @request.env['REMOTE_ADDR'] = '127.0.0.1'
-  end
-
-  # Mimick what RequestStore will do outside of the test env, since it is
-  # middleware, and doesn't get executed in controller / request specs
-  teardown do
-    RequestStore.store[:paper_trail] = nil
-  end
-
-  test 'disable on create' do
-    @request.env['HTTP_USER_AGENT'] = 'Disable User-Agent'
-    post :create, :widget => { :name => 'Flugel' }
-    assert_equal 0, assigns(:widget).versions.length
-  end
-
-  test 'disable on update' do
-    @request.env['HTTP_USER_AGENT'] = 'Disable User-Agent'
-    post :create, :widget => { :name => 'Flugel' }
-    w = assigns(:widget)
-    assert_equal 0, w.versions.length
-    put :update, :id => w.id, :widget => { :name => 'Bugle' }
-    widget = assigns(:widget)
-    assert_equal 0, widget.versions.length
-  end
-
-  test 'disable on destroy' do
-    @request.env['HTTP_USER_AGENT'] = 'Disable User-Agent'
-    post :create, :widget => { :name => 'Flugel' }
-    w = assigns(:widget)
-    assert_equal 0, w.versions.length
-    delete :destroy, :id => w.id
-    widget = assigns(:widget)
-    assert_equal 0, PaperTrail::Version.with_item_keys('Widget', w.id).size
-  end
-
-  test 'create' do
-    post :create, :widget => { :name => 'Flugel' }
-    widget = assigns(:widget)
-    assert_equal 1, widget.versions.length
-    assert_equal 153, widget.versions.last.whodunnit.to_i
-    assert_equal '127.0.0.1', widget.versions.last.ip
-    assert_equal 'Rails Testing', widget.versions.last.user_agent
-  end
-
-  test 'update' do
-    w = Widget.create :name => 'Duvel'
-    assert_equal 1, w.versions.length
-    put :update, :id => w.id, :widget => { :name => 'Bugle' }
-    widget = assigns(:widget)
-    assert_equal 2, widget.versions.length
-    assert_equal 153, widget.versions.last.whodunnit.to_i
-    assert_equal '127.0.0.1', widget.versions.last.ip
-    assert_equal 'Rails Testing', widget.versions.last.user_agent
-  end
-
-  test 'destroy' do
-    w = Widget.create :name => 'Roundel'
-    assert_equal 1, w.versions.length
-    delete :destroy, :id => w.id
-    widget = assigns(:widget)
-    assert_equal 2,               widget.versions.length
-    assert_equal '127.0.0.1',     widget.versions.last.ip
-    assert_equal 'Rails Testing', widget.versions.last.user_agent
-    assert_equal 153,             widget.versions.last.whodunnit.to_i
-  end
-
-  test "controller metadata methods should get evaluated if paper trail is enabled for controller" do
-    @request.env['HTTP_USER_AGENT'] = 'User-Agent'
-    post :create, :widget => { :name => 'Flugel' }
-    assert PaperTrail.enabled_for_controller?
-    assert_equal 153, PaperTrail.whodunnit
-    assert PaperTrail.controller_info.present?
-    assert PaperTrail.controller_info.keys.include?(:ip)
-    assert PaperTrail.controller_info.keys.include?(:user_agent)
-  end
-
-  test "controller metadata methods should not get evaluated if paper trail is disabled for controller" do
-    @request.env['HTTP_USER_AGENT'] = 'Disable User-Agent'
-    post :create, :widget => { :name => 'Flugel' }
-    assert_equal 0, assigns(:widget).versions.length
-    assert !PaperTrail.enabled_for_controller?
-    assert PaperTrail.whodunnit.nil?
-    assert PaperTrail.controller_info.nil?
-  end
-end

data/test/functional/enabled_for_controller_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class EnabledForControllerTest < ActionController::TestCase
-  tests ArticlesController
-
-  context "`PaperTrail.enabled? == true`" do
-    should 'enabled_for_controller?.should == true' do
-      assert PaperTrail.enabled?
-      post :create, :article => { :title => 'Doh', :content => Faker::Lorem.sentence }
-      assert_not_nil assigns(:article)
-      assert PaperTrail.enabled_for_controller?
-      assert_equal 1, assigns(:article).versions.length
-    end
-  end
-
-  context "`PaperTrail.enabled? == false`" do
-    setup { PaperTrail.enabled = false }
-    
-    should 'enabled_for_controller?.should == false' do
-      assert !PaperTrail.enabled?
-      post :create, :article => { :title => 'Doh', :content => Faker::Lorem.sentence }
-      assert !PaperTrail.enabled_for_controller?
-      assert_equal 0, assigns(:article).versions.length
-    end
-
-    teardown { PaperTrail.enabled = true }
-  end
-
-end

data/test/functional/modular_sinatra_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-require 'sinatra/base'
-
-# --- Tests for modular `Sinatra::Base` style ----
-class BaseApp < Sinatra::Base
-  configs = YAML.load_file(File.expand_path('../../dummy/config/database.yml', __FILE__))
-  ActiveRecord::Base.configurations = configs
-  ActiveRecord::Base.establish_connection(:test)
-  register PaperTrail::Sinatra
-
-  get '/test' do
-    Widget.create!(:name => 'foo')
-    'Hello'
-  end
-
-  def current_user
-    @current_user ||= OpenStruct.new(:id => 'foobar').tap do |obj|
-      # Invoking `id` returns the `object_id` value in Ruby18 unless specifically overwritten
-      def obj.id; 'foobar'; end if RUBY_VERSION < '1.9'
-    end
-  end
-end
-
-class ModularSinatraTest < ActionDispatch::IntegrationTest
-  include Rack::Test::Methods
-
-  def app
-    @app ||= BaseApp
-  end
-
-  test 'baseline' do
-    assert_nil Widget.create.versions.first.whodunnit
-  end
-
-  context "`PaperTrail::Sinatra` in a `Sinatra::Base` application" do
-  
-    should "sets the `user_for_paper_trail` from the `current_user` method" do
-      get '/test'
-      assert_equal 'Hello', last_response.body
-      widget = Widget.last
-      assert_not_nil widget
-      assert_equal 'foo', widget.name
-      assert_equal 1, widget.versions.size
-      assert_equal 'foobar', widget.versions.first.whodunnit
-    end
-
-  end
-end

data/test/functional/sinatra_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-# require 'sinatra/main'
-
-# --- Tests for non-modular `Sinatra::Application` style ----
-class Sinatra::Application
-  configs = YAML.load_file(File.expand_path('../../dummy/config/database.yml', __FILE__))
-  ActiveRecord::Base.configurations = configs
-  ActiveRecord::Base.establish_connection(:test)
-  register PaperTrail::Sinatra # we shouldn't actually need this line if I'm not mistaken but the tests seem to fail without it ATM
-
-  get '/test' do
-    Widget.create!(:name => 'bar')
-    'Hai'
-  end
-
-  def current_user
-    @current_user ||= OpenStruct.new(:id => 'raboof').tap do |obj|
-      # Invoking `id` returns the `object_id` value in Ruby18 unless specifically overwritten
-      def obj.id; 'raboof'; end if RUBY_VERSION < '1.9'
-    end
-  end
-
-end
-
-class SinatraTest < ActionDispatch::IntegrationTest
-  include Rack::Test::Methods
-
-  def app
-    @app ||= Sinatra::Application
-  end
-
-  test 'baseline' do
-    assert_nil Widget.create.versions.first.whodunnit
-  end
-
-  context "`PaperTrail::Sinatra` in a `Sinatra::Application` application" do
-
-    should "sets the `user_for_paper_trail` from the `current_user` method" do
-      get '/test'
-      assert_equal 'Hai', last_response.body
-      widget = Widget.last
-      assert_not_nil widget
-      assert_equal 'bar', widget.name
-      assert_equal 1, widget.versions.size
-      assert_equal 'raboof', widget.versions.first.whodunnit
-    end
-
-  end
-end

data/test/functional/thread_safety_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-class ThreadSafetyTest < ActionController::TestCase
-  test "be thread safe when using #set_paper_trail_whodunnit" do
-    blocked = true
-
-    slow_thread = Thread.new do
-      controller = TestController.new
-      controller.send :set_paper_trail_whodunnit
-      begin
-        sleep 0.001
-      end while blocked
-      PaperTrail.whodunnit
-    end
-
-    fast_thread = Thread.new do
-      controller = TestController.new
-      controller.send :set_paper_trail_whodunnit
-      who = PaperTrail.whodunnit
-      blocked = false
-      who
-    end
-
-    assert_not_equal slow_thread.value, fast_thread.value
-  end
-
-  test "be thread safe when using #without_versioning" do
-    enabled = nil
-
-    slow_thread = Thread.new do
-      Widget.new.without_versioning do
-        sleep(0.01)
-        enabled = Widget.paper_trail_enabled_for_model?
-        sleep(0.01)
-      end
-      enabled
-    end
-
-    fast_thread = Thread.new do
-      sleep(0.005)
-      Widget.paper_trail_enabled_for_model?
-    end
-
-    assert_not_equal slow_thread.value, fast_thread.value
-    assert Widget.paper_trail_enabled_for_model?
-    assert PaperTrail.enabled_for_model?(Widget)
-  end
-end

data/test/paper_trail_test.rb

@@ -1,38 +0,0 @@
-require 'test_helper'
-
-class PaperTrailTest < ActiveSupport::TestCase
-  test 'Sanity test' do
-    assert_kind_of Module, PaperTrail::Version
-  end
-
-  test 'Version Number' do
-    assert PaperTrail.const_defined?(:VERSION)
-  end
-  
-  test 'enabled is thread-safe' do
-    Thread.new do
-      PaperTrail.enabled = false
-    end.join
-    assert PaperTrail.enabled?
-  end
-
-  test 'create with plain model class' do
-    widget = Widget.create
-    assert_equal 1, widget.versions.length
-  end
-
-  test 'update with plain model class' do
-    widget = Widget.create
-    assert_equal 1, widget.versions.length
-    widget.update_attributes(:name => 'Bugle')
-    assert_equal 2, widget.versions.length
-  end
-
-  test 'destroy with plain model class' do
-    widget = Widget.create
-    assert_equal 1, widget.versions.length
-    widget.destroy
-    versions_for_widget = PaperTrail::Version.with_item_keys('Widget', widget.id)
-    assert_equal 2, versions_for_widget.length
-  end
-end

data/test/test_helper.rb

@@ -1,105 +0,0 @@
-begin
-  require 'pry-nav'
-rescue LoadError
-  # It's OK, we don't include pry in e.g. gemfiles/3.0.gemfile
-end
-
-ENV["RAILS_ENV"] = "test"
-ENV["DB"] ||= "sqlite"
-
-unless File.exists?(File.expand_path('../../test/dummy/config/database.yml', __FILE__))
-  warn "WARNING: No database.yml detected for the dummy app, please run `rake prepare` first"
-end
-
-def using_mysql?
-  @using_mysql ||= ActiveRecord::Base.connection_config[:adapter].to_sym == :mysql2
-end
-
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
-require "rails/test_help"
-require 'shoulda'
-require 'ffaker'
-require 'database_cleaner'
-
-Rails.backtrace_cleaner.remove_silencers!
-
-# Run any available migration
-ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
-
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# DatabaseCleaner is apparently necessary for doing proper transactions within MySQL (ugh)
-DatabaseCleaner.strategy = :truncation
-
-# global setup block resetting Thread.current
-class ActiveSupport::TestCase
-  if using_mysql?
-    self.use_transactional_fixtures = false
-    setup { DatabaseCleaner.start }
-  end
-
-  teardown do
-    DatabaseCleaner.clean if using_mysql?
-    Thread.current[:paper_trail] = nil
-  end
-
-  private
-
-  def assert_attributes_equal(expected, actual)
-    if using_mysql?
-      expected, actual = expected.dup, actual.dup
-
-      # Adjust timestamps for missing fractional seconds precision.
-      %w(created_at updated_at).each do |timestamp|
-        expected[timestamp] = expected[timestamp].change(:usec => 0)
-        actual[timestamp]   = actual[timestamp].change(:usec => 0)
-      end
-    end
-
-    assert_equal expected, actual
-  end
-
-  def assert_changes_equal(expected, actual)
-    if using_mysql?
-      expected, actual = expected.dup, actual.dup
-
-      # Adjust timestamps for missing fractional seconds precision.
-      %w(created_at updated_at).each do |timestamp|
-        expected[timestamp][1] = expected[timestamp][1].change(:usec => 0)
-        actual[timestamp][1]   = actual[timestamp][1].change(:usec => 0)
-      end
-    end
-
-    assert_equal expected, actual
-  end
-end
-
-#
-# Helpers
-#
-
-def change_schema
-  ActiveRecord::Migration.verbose = false
-  ActiveRecord::Schema.define do
-    remove_column :widgets, :sacrificial_column
-    add_column :versions, :custom_created_at, :datetime
-  end
-  ActiveRecord::Migration.verbose = true
-  reset_version_class_column_info!
-end
-
-def restore_schema
-  ActiveRecord::Migration.verbose = false
-  ActiveRecord::Schema.define do
-    add_column :widgets, :sacrificial_column, :string
-    remove_column :versions, :custom_created_at
-  end
-  ActiveRecord::Migration.verbose = true
-  reset_version_class_column_info!
-end
-
-def reset_version_class_column_info!
-  PaperTrail::Version.connection.schema_cache.clear!
-  PaperTrail::Version.reset_column_information
-end

data/test/time_travel_helper.rb

@@ -1,15 +0,0 @@
-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/associations_test.rb

@@ -1,726 +0,0 @@
-require 'test_helper'
-require 'time_travel_helper'
-
-class AssociationsTest < ActiveSupport::TestCase
-  CHAPTER_NAMES = [
-    "Down the Rabbit-Hole",
-    "The Pool of Tears",
-    "A Caucus-Race and a Long Tale",
-    "The Rabbit Sends in a Little Bill",
-    "Advice from a Caterpillar",
-    "Pig and Pepper",
-    "A Mad Tea-Party",
-    "The Queen's Croquet-Ground",
-    "The Mock Turtle's Story",
-    "The Lobster Quadrille",
-    "Who Stole the Tarts?",
-    "Alice's Evidence"
-  ]
-
-  # 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
-
-  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 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 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 "has_many through associations" do
-    context "Books, Authors, and Authorships" 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
-
-    context "Chapters, Sections, Paragraphs, Quotations, and Citations" do
-      setup { @chapter = Chapter.create(:name => CHAPTER_NAMES[0]) }
-
-      context "before any associations are created" do
-        setup do
-          @chapter.update_attributes(:name => CHAPTER_NAMES[1])
-        end
-
-        should "not reify any associations" do
-          chapter_v1 = @chapter.versions[1].reify(:has_many => true)
-          assert_equal CHAPTER_NAMES[0], chapter_v1.name
-          assert_equal [], chapter_v1.sections
-          assert_equal [], chapter_v1.paragraphs
-        end
-      end
-
-      context "after the first has_many through relationship is created" do
-        setup do
-          assert_equal 1, @chapter.versions.size
-          @chapter.update_attributes :name => CHAPTER_NAMES[1]
-          assert_equal 2, @chapter.versions.size
-
-          Timecop.travel 1.second.since
-          @chapter.sections.create :name => "section 1"
-          Timecop.travel 1.second.since
-          @chapter.sections.first.update_attributes :name => "section 2"
-          Timecop.travel 1.second.since
-          @chapter.update_attributes :name => CHAPTER_NAMES[2]
-          assert_equal 3, @chapter.versions.size
-
-          Timecop.travel 1.second.since
-          @chapter.sections.first.update_attributes :name => "section 3"
-        end
-
-        context "version 1" do
-          should "have no sections" do
-            chapter_v1 = @chapter.versions[1].reify(:has_many => true)
-            assert_equal [], chapter_v1.sections
-          end
-        end
-
-        context "version 2" do
-          should "have one section" do
-            chapter_v2 = @chapter.versions[2].reify(:has_many => true)
-            assert_equal 1, chapter_v2.sections.size
-
-            # Shows the value of the section as it was before
-            # the chapter was updated.
-            assert_equal ['section 2'], chapter_v2.sections.map(&:name)
-
-            # Shows the value of the chapter as it was before
-            assert_equal CHAPTER_NAMES[1], chapter_v2.name
-          end
-        end
-
-        context "version 2, before the section was destroyed" do
-          setup do
-            @chapter.update_attributes :name => CHAPTER_NAMES[2]
-            Timecop.travel 1.second.since
-            @chapter.sections.destroy_all
-            Timecop.travel 1.second.since
-          end
-
-          should "have the one section" do
-            chapter_v2 = @chapter.versions[2].reify(:has_many => true)
-            assert_equal ['section 2'], chapter_v2.sections.map(&:name)
-          end
-        end
-
-        context "version 3, after the section was destroyed" do
-          setup do
-            @chapter.sections.destroy_all
-            Timecop.travel 1.second.since
-            @chapter.update_attributes :name => CHAPTER_NAMES[3]
-            Timecop.travel 1.second.since
-          end
-
-          should "have no sections" do
-            chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-            assert_equal 0, chapter_v3.sections.size
-          end
-        end
-
-        context "after creating a paragraph" do
-          setup do
-            assert_equal 3, @chapter.versions.size
-            @section = @chapter.sections.first
-            Timecop.travel 1.second.since
-            @paragraph = @section.paragraphs.create :name => 'para1'
-          end
-
-          context "new chapter version" do
-            should "have one paragraph" do
-              initial_section_name = @section.name
-              initial_paragraph_name = @paragraph.name
-              Timecop.travel 1.second.since
-              @chapter.update_attributes :name => CHAPTER_NAMES[4]
-              assert_equal 4, @chapter.versions.size
-              Timecop.travel 1.second.since
-              @paragraph.update_attributes :name => 'para3'
-              chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-              assert_equal [initial_section_name], chapter_v3.sections.map(&:name)
-              paragraphs = chapter_v3.sections.first.paragraphs
-              assert_equal 1, paragraphs.size
-              assert_equal [initial_paragraph_name], paragraphs.map(&:name)
-            end
-          end
-
-          context "the version before a section is destroyed" do
-            should "have the section and paragraph" do
-              Timecop.travel 1.second.since
-              @chapter.update_attributes(:name => CHAPTER_NAMES[3])
-              assert_equal 4, @chapter.versions.size
-              Timecop.travel 1.second.since
-              @section.destroy
-              assert_equal 4, @chapter.versions.size
-              chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-              assert_equal CHAPTER_NAMES[2], chapter_v3.name
-              assert_equal [@section], chapter_v3.sections
-              assert_equal [@paragraph], chapter_v3.sections[0].paragraphs
-              assert_equal [@paragraph], chapter_v3.paragraphs
-            end
-          end
-
-          context "the version after a section is destroyed" do
-            should "not have any sections or paragraphs" do
-              @section.destroy
-              Timecop.travel 1.second.since
-              @chapter.update_attributes(:name => CHAPTER_NAMES[5])
-              assert_equal 4, @chapter.versions.size
-              chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-              assert_equal 0, chapter_v3.sections.size
-              assert_equal 0, chapter_v3.paragraphs.size
-            end
-          end
-
-          context "the version before a paragraph is destroyed" do
-            should "have the one paragraph" do
-              initial_paragraph_name = @section.paragraphs.first.name
-              Timecop.travel 1.second.since
-              @chapter.update_attributes(:name => CHAPTER_NAMES[5])
-              Timecop.travel 1.second.since
-              @paragraph.destroy
-              chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-              paragraphs = chapter_v3.sections.first.paragraphs
-              assert_equal 1, paragraphs.size
-              assert_equal initial_paragraph_name, paragraphs.first.name
-            end
-          end
-
-          context "the version after a paragraph is destroyed" do
-            should "have no paragraphs" do
-              @paragraph.destroy
-              Timecop.travel 1.second.since
-              @chapter.update_attributes(:name => CHAPTER_NAMES[5])
-              chapter_v3 = @chapter.versions[3].reify(:has_many => true)
-              assert_equal 0, chapter_v3.paragraphs.size
-              assert_equal [], chapter_v3.sections.first.paragraphs
-            end
-          end
-        end
-      end
-
-      context "a chapter with one paragraph and one citation" do
-        should "reify paragraphs and citations" do
-          chapter = Chapter.create(:name => CHAPTER_NAMES[0])
-          section = Section.create(:name => 'Section One', :chapter => chapter)
-          paragraph = Paragraph.create(:name => 'Paragraph One', :section => section)
-          quotation = Quotation.create(:chapter => chapter)
-          citation = Citation.create(:quotation => quotation)
-          Timecop.travel 1.second.since
-          chapter.update_attributes(:name => CHAPTER_NAMES[1])
-          assert_equal 2, chapter.versions.count
-          paragraph.destroy
-          citation.destroy
-          reified = chapter.versions[1].reify(:has_many => true)
-          assert_equal [paragraph], reified.sections.first.paragraphs
-          assert_equal [citation], reified.quotations.first.citations
-        end
-      end
-    end
-  end
-end