paper_trail_without_deprecated 3.0.0.beta1

data/test/unit/protected_attrs_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class ProtectedAttrsTest < ActiveSupport::TestCase
+  subject { ProtectedWidget.new }
+
+  if ActiveRecord::VERSION::STRING.to_f < 4.0 # these ActiveModel matchers (provided by shoulda-matchers) only work for Rails 3
+    accessible_attrs = ProtectedWidget.accessible_attributes.to_a
+    accessible_attrs.each do |attr_name|
+      should allow_mass_assignment_of(attr_name.to_sym)
+    end
+    ProtectedWidget.column_names.reject { |column_name| accessible_attrs.include?(column_name) }.each do |attr_name|
+      should_not allow_mass_assignment_of(attr_name.to_sym)
+    end
+  end
+
+  context 'A model with `attr_accessible` created' do
+    setup do
+      @widget = ProtectedWidget.create! :name => 'Henry'
+      @initial_attributes = @widget.attributes
+    end
+
+    should 'be `nil` in its previous version' do
+      assert_nil @widget.previous_version
+    end
+
+    context 'which is then updated' do
+      setup do
+        @widget.assign_attributes(:name => 'Jeff', :a_text => 'Short statement')
+        @widget.an_integer = 42
+        @widget.save!
+      end
+
+      should 'not be `nil` in its previous version' do
+        assert_not_nil @widget.previous_version
+      end
+
+      should 'the previous version should contain right attributes' do
+        # For some reason this test seems to be broken in JRuby 1.9 mode in the test env even though it works in the console. WTF?
+        unless ActiveRecord::VERSION::STRING.to_f >= 4.0 && defined?(JRUBY_VERSION) && RUBY_VERSION.to_f >= 1.9
+          assert_equal @widget.previous_version.attributes, @initial_attributes
+        end
+      end
+    end
+
+  end
+end

data/test/unit/serializer_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+require 'custom_json_serializer'
+
+class SerializerTest < ActiveSupport::TestCase
+
+  context 'YAML Serializer' do
+    setup do
+      Fluxor.instance_eval <<-END
+        has_paper_trail
+      END
+
+      @fluxor = Fluxor.create :name => 'Some text.'
+      @original_fluxor_attributes = @fluxor.send(:item_before_change).attributes # this is exactly what PaperTrail serializes
+      @fluxor.update_attributes :name => 'Some more text.'
+    end
+
+    should 'work with the default yaml serializer' do
+      # Normal behaviour
+      assert_equal 2, @fluxor.versions.length
+      assert_nil @fluxor.versions[0].reify
+      assert_equal 'Some text.', @fluxor.versions[1].reify.name
+
+      # Check values are stored as YAML.
+      assert_equal @original_fluxor_attributes, YAML.load(@fluxor.versions[1].object)
+      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
+      # attributes in the YAML can't be ensured.
+      if RUBY_VERSION.to_f >= 1.9
+        assert_equal YAML.dump(@original_fluxor_attributes), @fluxor.versions[1].object
+      end
+    end
+  end
+
+  context 'JSON Serializer' do
+    setup do
+      PaperTrail.configure do |config|
+        config.serializer = PaperTrail::Serializers::Json
+      end
+
+      Fluxor.instance_eval <<-END
+        has_paper_trail
+      END
+
+      @fluxor = Fluxor.create :name => 'Some text.'
+      @original_fluxor_attributes = @fluxor.send(:item_before_change).attributes # this is exactly what PaperTrail serializes
+      @fluxor.update_attributes :name => 'Some more text.'
+    end
+
+    teardown do
+      PaperTrail.config.serializer = PaperTrail::Serializers::Yaml
+    end
+
+    should 'reify with JSON serializer' do
+      # Normal behaviour
+      assert_equal 2, @fluxor.versions.length
+      assert_nil @fluxor.versions[0].reify
+      assert_equal 'Some text.', @fluxor.versions[1].reify.name
+
+      # Check values are stored as JSON.
+      assert_equal @original_fluxor_attributes, ActiveSupport::JSON.decode(@fluxor.versions[1].object)
+      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
+      # attributes in the JSON can't be ensured.
+      if RUBY_VERSION.to_f >= 1.9
+        assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes), @fluxor.versions[1].object
+      end
+    end
+
+    should 'store object_changes' do
+      initial_changeset = {"name" => [nil, "Some text."], "id" => [nil, 1]}
+      second_changeset =  {"name"=>["Some text.", "Some more text."]}
+      assert_equal initial_changeset, @fluxor.versions[0].changeset
+      assert_equal second_changeset,  @fluxor.versions[1].changeset
+    end
+  end
+
+  context 'Custom Serializer' do
+    setup do
+      PaperTrail.configure do |config|
+        config.serializer = CustomJsonSerializer
+      end
+
+      Fluxor.instance_eval <<-END
+        has_paper_trail
+      END
+
+      @fluxor = Fluxor.create
+      @original_fluxor_attributes = @fluxor.send(:item_before_change).attributes.reject { |k,v| v.nil? } # this is exactly what PaperTrail serializes
+      @fluxor.update_attributes :name => 'Some more text.'
+    end
+
+    teardown do
+      PaperTrail.config.serializer = PaperTrail::Serializers::Yaml
+    end
+
+    should 'reify with custom serializer' do
+      # Normal behaviour
+      assert_equal 2, @fluxor.versions.length
+      assert_nil @fluxor.versions[0].reify
+      assert_nil @fluxor.versions[1].reify.name
+
+      # Check values are stored as JSON.
+      assert_equal @original_fluxor_attributes, ActiveSupport::JSON.decode(@fluxor.versions[1].object)
+      # This test can't consistently pass in Ruby1.8 because hashes do no preserve order, which means the order of the
+      # attributes in the JSON can't be ensured.
+      if RUBY_VERSION.to_f >= 1.9
+        assert_equal ActiveSupport::JSON.encode(@original_fluxor_attributes), @fluxor.versions[1].object
+      end
+    end
+
+    should 'store object_changes' do
+      initial_changeset = {"id" => [nil, 1]}
+      second_changeset =  {"name"=>[nil, "Some more text."]}
+      assert_equal initial_changeset, @fluxor.versions[0].changeset
+      assert_equal second_changeset,  @fluxor.versions[1].changeset
+    end
+  end
+
+end

data/test/unit/serializers/json_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class JsonTest < ActiveSupport::TestCase
+
+  setup do
+    # Setup a hash with random values
+    @hash = {}
+    (1..4).each do |i|
+      @hash["key#{i}"] = Faker::Lorem.word
+    end
+    @hash_as_json = @hash.to_json
+    # Setup an array of random words
+    @array = []
+    (rand(5) + 4).times { @array << Faker::Lorem.word }
+    @array_as_json = @array.to_json
+  end
+
+  context '`load` class method' do
+    should 'exist' do
+      assert PaperTrail::Serializers::Json.respond_to?(:load)
+    end
+
+    should '`deserialize` JSON to Ruby' do
+      assert_equal @hash, PaperTrail::Serializers::Json.load(@hash_as_json)
+      assert_equal @array, PaperTrail::Serializers::Json.load(@array_as_json)
+    end
+  end
+
+  context '`dump` class method' do
+    should 'exist' do
+      assert PaperTrail::Serializers::Json.respond_to?(:dump)
+    end
+
+    should '`serialize` Ruby to JSON' do
+      assert_equal @hash_as_json, PaperTrail::Serializers::Json.dump(@hash)
+      assert_equal @array_as_json, PaperTrail::Serializers::Json.dump(@array)
+    end
+  end
+
+end

data/test/unit/serializers/mixin_json_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'custom_json_serializer'
+
+class MixinJsonTest < ActiveSupport::TestCase
+
+  setup do
+    # Setup a hash with random values, ensuring some values are nil
+    @hash = {}
+    (1..4).each do |i|
+      @hash["key#{i}"] = [Faker::Lorem.word, nil].sample
+    end
+    @hash['tkey'] = nil
+    @hash[''] = 'foo'
+    @hash_as_json = @hash.to_json
+  end
+
+  context '`load` class method' do
+    should 'exist' do
+      assert CustomJsonSerializer.respond_to?(:load)
+    end
+
+    should '`deserialize` JSON to Ruby, removing pairs with `blank` keys or values' do
+      assert_equal @hash.reject { |k,v| k.blank? || v.blank? }, CustomJsonSerializer.load(@hash_as_json)
+    end
+  end
+
+  context '`dump` class method' do
+    should 'exist' do
+      assert CustomJsonSerializer.respond_to?(:dump)
+    end
+
+    should '`serialize` Ruby to JSON, removing pairs with `nil` values' do
+      assert_equal @hash.reject { |k,v| v.nil? }.to_json, CustomJsonSerializer.dump(@hash)
+    end
+  end
+end

data/test/unit/serializers/mixin_yaml_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module CustomYamlSerializer
+  extend PaperTrail::Serializers::Yaml
+
+  def self.load(string)
+    parsed_value = super(string)
+    parsed_value.is_a?(Hash) ? parsed_value.reject { |k,v| k.blank? || v.blank? } : parsed_value
+  end
+
+  def self.dump(object)
+    object.is_a?(Hash) ? super(object.reject { |k,v| v.nil? }) : super
+  end
+end
+
+class MixinYamlTest < ActiveSupport::TestCase
+
+  setup do
+    # Setup a hash with random values, ensuring some values are nil
+    @hash = {}
+    (1..4).each do |i|
+      @hash["key#{i}"] = [Faker::Lorem.word, nil].sample
+    end
+    @hash['tkey'] = nil
+    @hash[''] = 'foo'
+    @hash_as_yaml = @hash.to_yaml
+  end
+
+  context '`load` class method' do
+    should 'exist' do
+      assert CustomYamlSerializer.respond_to?(:load)
+    end
+
+    should '`deserialize` YAML to Ruby, removing pairs with `blank` keys or values' do
+      assert_equal @hash.reject { |k,v| k.blank? || v.blank? }, CustomYamlSerializer.load(@hash_as_yaml)
+    end
+  end
+
+  context '`dump` class method' do
+    should 'exist' do
+      assert CustomYamlSerializer.respond_to?(:dump)
+    end
+
+    should '`serialize` Ruby to YAML, removing pairs with `nil` values' do
+      assert_equal @hash.reject { |k,v| v.nil? }.to_yaml, CustomYamlSerializer.dump(@hash)
+    end
+  end
+
+end

data/test/unit/serializers/yaml_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class YamlTest < ActiveSupport::TestCase
+
+  setup do
+    # Setup a hash with random values
+    @hash = {}
+    (1..4).each do |i|
+      @hash["key#{i}".to_sym] = Faker::Lorem.word
+    end
+    @hash_as_yaml = @hash.to_yaml
+    # Setup an array of random words
+    @array = []
+    (rand(5) + 4).times { @array << Faker::Lorem.word }
+    @array_as_yaml = @array.to_yaml
+  end
+
+  context '`load` class method' do
+    should 'exist' do
+      assert PaperTrail::Serializers::Yaml.respond_to?(:load)
+    end
+
+    should '`deserialize` YAML to Ruby' do
+      assert_equal @hash, PaperTrail::Serializers::Yaml.load(@hash_as_yaml)
+      assert_equal @array, PaperTrail::Serializers::Yaml.load(@array_as_yaml)
+    end
+  end
+
+  context '`dump` class method' do
+    should 'exist' do
+      assert PaperTrail::Serializers::Yaml.respond_to?(:dump)
+    end
+
+    should '`serialize` Ruby to YAML' do
+      assert_equal @hash_as_yaml, PaperTrail::Serializers::Yaml.dump(@hash)
+      assert_equal @array_as_yaml, PaperTrail::Serializers::Yaml.dump(@array)
+    end
+  end
+
+end

data/test/unit/timestamp_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class TimestampTest < ActiveSupport::TestCase
+
+  setup do
+    PaperTrail.timestamp_field = :custom_created_at
+    change_schema
+    PaperTrail::Version.connection.schema_cache.clear!
+    PaperTrail::Version.reset_column_information
+
+    Fluxor.instance_eval <<-END
+      has_paper_trail
+    END
+
+    @fluxor = Fluxor.create :name => 'Some text.'
+    @fluxor.update_attributes :name => 'Some more text.'
+    @fluxor.update_attributes :name => 'Even more text.'
+  end
+
+  teardown do
+    PaperTrail.timestamp_field = :created_at
+  end
+
+  test 'versions works with custom timestamp field' do
+    # Normal behaviour
+    assert_equal 3, @fluxor.versions.length
+    assert_nil @fluxor.versions[0].reify
+    assert_equal 'Some text.', @fluxor.versions[1].reify.name
+    assert_equal 'Some more text.', @fluxor.versions[2].reify.name
+
+    # Tinker with custom timestamps.
+    now = Time.now.utc
+    @fluxor.versions.reverse.each_with_index do |version, index|
+      version.update_attribute :custom_created_at, (now + index.seconds)
+    end
+
+    # Test we are ordering by custom timestamps.
+    @fluxor.versions true  # reload association
+    assert_nil @fluxor.versions[2].reify
+    assert_equal 'Some text.', @fluxor.versions[1].reify.name
+    assert_equal 'Some more text.', @fluxor.versions[0].reify.name
+  end
+
+end

data/test/unit/version_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class PaperTrail::VersionTest < ActiveSupport::TestCase
+  setup do
+    change_schema
+    @animal = Animal.create
+    assert PaperTrail::Version.creates.present?
+  end
+
+  context "PaperTrail::Version.creates" do
+    should "return only create events" do
+      PaperTrail::Version.creates.each do |version|
+        assert_equal "create", version.event
+      end
+    end
+  end
+
+  context "PaperTrail::Version.updates" do
+    setup {
+      @animal.update_attributes(:name => 'Animal')
+      assert PaperTrail::Version.updates.present?
+    }
+
+    should "return only update events" do
+      PaperTrail::Version.updates.each do |version|
+        assert_equal "update", version.event
+      end
+    end
+  end
+
+  context "PaperTrail::Version.destroys" do
+    setup {
+      @animal.destroy
+      assert PaperTrail::Version.destroys.present?
+    }
+
+    should "return only destroy events" do
+      PaperTrail::Version.destroys.each do |version|
+        assert_equal "destroy", version.event
+      end
+    end
+  end
+
+  context "PaperTrail::Version.not_creates" do
+    setup {
+      @animal.update_attributes(:name => 'Animal')
+      @animal.destroy
+      assert PaperTrail::Version.not_creates.present?
+    }
+
+    should "return all items except create events" do
+      PaperTrail::Version.not_creates.each do |version|
+        assert_not_equal "create", version.event
+      end
+    end
+  end
+end
+
+class VersionTest < ActiveSupport::TestCase
+  # without this, it sometimes picks up the changed schema from the previous test and gets confused
+  setup { PaperTrail::Version.reset_column_information }
+
+  context "Version class" do
+    should "be a subclass of the `PaperTrail::Version` class" do
+      assert Version < PaperTrail::Version
+    end
+
+    should "act like a `PaperTrail::Version` while warning the user" do
+      widget = Widget.create! :name => Faker::Name.name
+      widget.update_attributes! :name => Faker::Name.name
+      assert_equal Version.last.reify.name, widget.versions.last.reify.name
+    end
+  end
+end