paper_trail 4.2.0 → 7.1.3

data/test/unit/protected_attrs_test.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-
-class ProtectedAttrsTest < ActiveSupport::TestCase
-  subject { ProtectedWidget.new }
-
-  if ActiveRecord::VERSION::MAJOR < 4 # 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::MAJOR >= 4 && defined?(JRUBY_VERSION) && RUBY_VERSION >= '1.9'
-          assert_attributes_equal @widget.previous_version.attributes, @initial_attributes
-        end
-      end
-    end
-
-  end
-end

data/test/unit/serializer_test.rb

@@ -1,117 +0,0 @@
-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(:attributes_before_change) # 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 >= '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(:attributes_before_change) # 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 >= '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, @fluxor.id]}
-      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(:attributes_before_change).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 >= '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, @fluxor.id]}
-      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

@@ -1,88 +0,0 @@
-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
-
-  context '`where_object` class method' do
-    context "when value is a string" do
-      should 'construct correct WHERE query' do
-        matches = PaperTrail::Serializers::JSON.where_object_condition(
-          PaperTrail::Version.arel_table[:object], :arg1, "Val 1")
-
-        assert matches.instance_of?(Arel::Nodes::Matches)
-        if Arel::VERSION >= '6'
-          assert_equal matches.right.val, "%\"arg1\":\"Val 1\"%"
-        else
-          assert_equal matches.right, "%\"arg1\":\"Val 1\"%"
-        end
-      end
-    end
-
-    context "when value is `null`" do
-      should 'construct correct WHERE query' do
-        matches = PaperTrail::Serializers::JSON.where_object_condition(
-          PaperTrail::Version.arel_table[:object], :arg1, nil)
-
-        assert matches.instance_of?(Arel::Nodes::Matches)
-        if Arel::VERSION >= '6'
-          assert_equal matches.right.val, "%\"arg1\":null%"
-        else
-          assert_equal matches.right, "%\"arg1\":null%"
-        end
-      end
-    end
-
-    context "when value is a number" do
-      should 'construct correct WHERE query' do
-        grouping = PaperTrail::Serializers::JSON.where_object_condition(
-          PaperTrail::Version.arel_table[:object], :arg1, -3.5)
-
-        assert grouping.instance_of?(Arel::Nodes::Grouping)
-        matches = grouping.select { |v| v.instance_of?(Arel::Nodes::Matches) }
-        # Numeric arguments need to ensure that they match for only the number, not the beginning 
-        # of a #, so it uses an Grouping matcher (See notes on `PaperTrail::Serializers::JSON`)
-        if Arel::VERSION >= '6'
-          assert_equal matches.first.right.val, "%\"arg1\":-3.5,%"
-          assert_equal matches.last.right.val, "%\"arg1\":-3.5}%"
-        else
-          assert_equal matches.first.right, "%\"arg1\":-3.5,%"
-          assert_equal matches.last.right, "%\"arg1\":-3.5}%"
-        end
-      end
-    end
-  end
-end

data/test/unit/serializers/mixin_json_test.rb

@@ -1,36 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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
-
-  context '`where_object` class method' do
-    should 'construct correct WHERE query' do
-      matches = PaperTrail::Serializers::YAML.where_object_condition(
-        PaperTrail::Version.arel_table[:object], :arg1, "Val 1")
-      assert matches.instance_of?(Arel::Nodes::Matches)
-      if Arel::VERSION >= '6'
-        assert_equal matches.right.val, "%\narg1: Val 1\n%"
-      else
-        assert_equal matches.right, "%\narg1: Val 1\n%"
-      end
-    end
-  end
-end

data/test/unit/timestamp_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-class TimestampTest < ActiveSupport::TestCase
-
-  setup do
-    PaperTrail.timestamp_field = :custom_created_at
-    change_schema
-
-    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
-    restore_schema
-  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

@@ -1,119 +0,0 @@
-require 'test_helper'
-
-module PaperTrail
-  class VersionTest < ActiveSupport::TestCase
-    setup do
-      change_schema
-      @animal = Animal.create
-      assert Version.creates.present?
-    end
-
-    teardown do
-      restore_schema
-      Animal.connection.schema_cache.clear!
-      Animal.reset_column_information
-    end
-
-    context ".creates" do
-      should "return only create events" do
-        Version.creates.each do |version|
-          assert_equal "create", version.event
-        end
-      end
-    end
-
-    context ".updates" do
-      setup {
-        @animal.update_attributes(:name => 'Animal')
-        assert Version.updates.present?
-      }
-
-      should "return only update events" do
-        Version.updates.each do |version|
-          assert_equal "update", version.event
-        end
-      end
-    end
-
-    context ".destroys" do
-      setup {
-        @animal.destroy
-        assert Version.destroys.present?
-      }
-
-      should "return only destroy events" do
-        Version.destroys.each do |version|
-          assert_equal "destroy", version.event
-        end
-      end
-    end
-
-    context ".not_creates" do
-      setup {
-        @animal.update_attributes(:name => 'Animal')
-        @animal.destroy
-        assert Version.not_creates.present?
-      }
-
-      should "return all versions except create events" do
-        Version.not_creates.each do |version|
-          assert_not_equal "create", version.event
-        end
-      end
-    end
-
-    context ".subsequent" do
-      setup do
-        2.times do
-          @animal.update_attributes(:name => Faker::Lorem.word)
-        end
-      end
-
-      context "given a timestamp" do
-        should "return all versions that were created after the timestamp" do
-          value = Version.subsequent(1.hour.ago, true)
-          assert_equal @animal.versions.to_a, value
-          assert_match(
-            /ORDER BY #{Version.arel_table[:created_at].asc.to_sql}/,
-            value.to_sql
-          )
-        end
-      end
-
-      context "given a Version" do
-        should "grab the timestamp from the version and use that as the value" do
-          expected = @animal.versions.to_a.tap { |assoc| assoc.shift }
-          actual = Version.subsequent(@animal.versions.first)
-          assert_equal expected, actual
-        end
-      end
-    end
-
-    context ".preceding" do
-      setup do
-        2.times do
-          @animal.update_attributes(:name => Faker::Lorem.word)
-        end
-      end
-
-      context "given a timestamp" do
-        should "return all versions that were created before the timestamp" do
-          value = Version.preceding(5.seconds.from_now, true)
-          assert_equal @animal.versions.reverse, value
-          assert_match(
-            /ORDER BY #{Version.arel_table[:created_at].desc.to_sql}/,
-            value.to_sql
-          )
-        end
-      end
-
-      context "given a Version" do
-        should "grab the timestamp from the version and use that as the value" do
-          expected = @animal.versions.to_a.tap { |assoc| assoc.pop }.reverse
-          actual = Version.preceding(@animal.versions.last)
-          assert_equal expected, actual
-        end
-      end
-    end
-  end
-end