ibm_db 3.0.3 → 5.0.3

data/test/cases/associations/left_outer_join_association_test.rb

@@ -0,0 +1,88 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+require 'models/author'
+require 'models/essay'
+require 'models/categorization'
+require 'models/person'
+
+class LeftOuterJoinAssociationTest < ActiveRecord::TestCase
+  fixtures :authors, :essays, :posts, :comments, :categorizations, :people
+
+  def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
+    result = Author.left_outer_joins(:thinking_posts, :welcome_posts).to_a
+    assert_equal authors(:david), result.first
+  end
+
+  def test_construct_finder_sql_does_not_table_name_collide_on_duplicate_associations
+    assert_nothing_raised do
+      queries = capture_sql do
+        Person.left_outer_joins(:agents => {:agents => :agents})
+              .left_outer_joins(:agents => {:agents => {:primary_contact => :agents}}).to_a
+      end
+      assert queries.any? { |sql| /agents_people_4/i =~ sql }
+    end
+  end
+
+  def test_left_outer_joins_count_is_same_as_size_of_loaded_results
+    assert_equal 17, Post.left_outer_joins(:comments).to_a.size
+    assert_equal 17, Post.left_outer_joins(:comments).count
+  end
+
+  def test_left_joins_aliases_left_outer_joins
+    assert_equal Post.left_outer_joins(:comments).to_sql, Post.left_joins(:comments).to_sql
+  end
+
+  def test_left_outer_joins_return_has_value_for_every_comment
+    all_post_ids = Post.pluck(:id)
+    assert_equal all_post_ids, all_post_ids & Post.left_outer_joins(:comments).pluck(:id)
+  end
+
+  def test_left_outer_joins_actually_does_a_left_outer_join
+    queries = capture_sql { Author.left_outer_joins(:posts).to_a }
+    assert queries.any? { |sql| /LEFT OUTER JOIN/i =~ sql }
+  end
+
+  def test_construct_finder_sql_ignores_empty_left_outer_joins_hash
+    queries = capture_sql { Author.left_outer_joins({}).to_a }
+    assert queries.none? { |sql| /LEFT OUTER JOIN/i =~ sql }
+  end
+
+  def test_construct_finder_sql_ignores_empty_left_outer_joins_array
+    queries = capture_sql { Author.left_outer_joins([]).to_a }
+    assert queries.none? { |sql| /LEFT OUTER JOIN/i =~ sql }
+  end
+
+  def test_left_outer_joins_forbids_to_use_string_as_argument
+    assert_raise(ArgumentError){ Author.left_outer_joins('LEFT OUTER JOIN "posts" ON "posts"."user_id" = "users"."id"').to_a }
+  end
+
+  def test_join_conditions_added_to_join_clause
+    queries = capture_sql { Author.left_outer_joins(:essays).to_a }
+    assert queries.any? { |sql| /writer_type.*?=.*?(Author|\?|\$1)/i =~ sql }
+    assert queries.none? { |sql| /WHERE/i =~ sql }
+  end
+
+  def test_find_with_sti_join
+    scope = Post.left_outer_joins(:special_comments).where(:id => posts(:sti_comments).id)
+
+    # The join should match SpecialComment and its subclasses only
+    assert scope.where("comments.type" => "Comment").empty?
+    assert !scope.where("comments.type" => "SpecialComment").empty?
+    assert !scope.where("comments.type" => "SubSpecialComment").empty?
+  end
+
+  def test_does_not_override_select
+    authors = Author.select("authors.name, #{%{(authors.author_address_id || ' ' || authors.author_address_extra_id) as addr_id}}").left_outer_joins(:posts)
+    assert authors.any?
+    assert authors.first.respond_to?(:addr_id)
+  end
+
+  test "the default scope of the target is applied when joining associations" do
+    author = Author.create! name: "Jon"
+    author.categorizations.create!
+    author.categorizations.create! special: true
+
+    assert_equal [author], Author.where(id: author).left_outer_joins(:special_categorizations)
+  end
+end

data/test/cases/associations/nested_through_associations_test.rb

@@ -27,7 +27,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :authors, :books, :posts, :subscriptions, :subscribers, :tags, :taggings,
            :people, :readers, :references, :jobs, :ratings, :comments, :members, :member_details,
            :member_types, :sponsors, :clubs, :organizations, :categories, :categories_posts,
-           :categorizations, :memberships, :essays, :author_addresses
+           :categorizations, :memberships, :essays
 
   # Through associations can either use the has_many or has_one macros.
   #
@@ -495,7 +495,7 @@ class NestedThroughAssociationsTest < ActiveRecord::TestCase
     groucho = members(:groucho)
     founding = member_types(:founding)
 
-    assert_raises(ActiveRecord::HasManyThroughNestedAssociationsAreReadonly) do
+    assert_raises(ActiveRecord::HasOneThroughNestedAssociationsAreReadonly) do
       groucho.nested_member_type = founding
     end
   end

data/test/cases/associations/required_test.rb

@@ -1,7 +1,7 @@
 require "cases/helper"
 
 class RequiredAssociationsTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   class Parent < ActiveRecord::Base
   end
@@ -18,8 +18,8 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table 'parents' if @connection.table_exists? 'parents'
-    @connection.drop_table 'children' if @connection.table_exists? 'children'
+    @connection.drop_table 'parents', if_exists: true
+    @connection.drop_table 'children', if_exists: true
   end
 
   test "belongs_to associations are not required by default" do
@@ -40,7 +40,7 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
 
     record = model.new
     assert_not record.save
-    assert_equal ["Parent can't be blank"], record.errors.full_messages
+    assert_equal ["Parent must exist"], record.errors.full_messages
 
     record.parent = Parent.new
     assert record.save
@@ -64,12 +64,32 @@ class RequiredAssociationsTest < ActiveRecord::TestCase
 
     record = model.new
     assert_not record.save
-    assert_equal ["Child can't be blank"], record.errors.full_messages
+    assert_equal ["Child must exist"], record.errors.full_messages
 
     record.child = Child.new
     assert record.save
   end
 
+  test "required has_one associations have a correct error message" do
+    model = subclass_of(Parent) do
+      has_one :child, required: true, inverse_of: false,
+      class_name: "RequiredAssociationsTest::Child"
+    end
+
+    record = model.create
+    assert_equal ["Child must exist"], record.errors.full_messages
+  end
+
+  test "required belongs_to associations have a correct error message" do
+    model = subclass_of(Child) do
+      belongs_to :parent, required: true, inverse_of: false,
+      class_name: "RequiredAssociationsTest::Parent"
+    end
+
+    record = model.create
+    assert_equal ["Parent must exist"], record.errors.full_messages
+  end
+
   private
 
   def subclass_of(klass, &block)

data/test/cases/associations_test.rb

@@ -1,7 +1,6 @@
 require "cases/helper"
 require 'models/computer'
 require 'models/developer'
-require 'models/computer'
 require 'models/project'
 require 'models/company'
 require 'models/categorization'
@@ -13,7 +12,6 @@ require 'models/tag'
 require 'models/tagging'
 require 'models/person'
 require 'models/reader'
-require 'models/parrot'
 require 'models/ship_part'
 require 'models/ship'
 require 'models/liquid'
@@ -24,7 +22,7 @@ require 'models/interest'
 
 class AssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :developers_projects,
-           :computers, :people, :readers, :authors, :author_favorites, :author_addresses
+           :computers, :people, :readers, :authors, :author_favorites
 
   def test_eager_loading_should_not_change_count_of_children
     liquid = Liquid.create(:name => 'salty')
@@ -43,28 +41,6 @@ class AssociationsTest < ActiveRecord::TestCase
     assert_equal favs, fav2
   end
 
-  def test_clear_association_cache_stored
-    firm = Firm.find(1)
-    assert_kind_of Firm, firm
-
-    firm.clear_association_cache
-    assert_equal Firm.find(1).clients.collect{ |x| x.name }.sort, firm.clients.collect{ |x| x.name }.sort
-  end
-
-  def test_clear_association_cache_new_record
-     firm            = Firm.new
-     client_stored   = Client.find(3)
-     client_new      = Client.new
-     client_new.name = "The Joneses"
-     clients         = [ client_stored, client_new ]
-
-     firm.clients    << clients
-     assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
-
-     firm.clear_association_cache
-     assert_equal clients.map(&:name).to_set, firm.clients.map(&:name).to_set
-  end
-
   def test_loading_the_association_target_should_keep_child_records_marked_for_destruction
     ship = Ship.create!(:name => "The good ship Dollypop")
     part = ship.parts.create!(:name => "Mast")
@@ -115,8 +91,10 @@ class AssociationsTest < ActiveRecord::TestCase
     assert firm.clients.empty?, "New firm should have cached no client objects"
     assert_equal 0, firm.clients.size, "New firm should have cached 0 clients count"
 
-    assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
-    assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
+    ActiveSupport::Deprecation.silence do
+      assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
+      assert_equal 1, firm.clients(true).size, "New firm should have reloaded clients count"
+    end
   end
 
   def test_using_limitable_reflections_helper
@@ -132,16 +110,19 @@ class AssociationsTest < ActiveRecord::TestCase
   def test_force_reload_is_uncached
     firm = Firm.create!("name" => "A New Firm, Inc")
     Client.create!("name" => "TheClient.com", :firm => firm)
-    ActiveRecord::Base.cache do
-      firm.clients.each {}
-      assert_queries(0) { assert_not_nil firm.clients.each {} }
-      assert_queries(1) { assert_not_nil firm.clients(true).each {} }
+
+    ActiveSupport::Deprecation.silence do
+      ActiveRecord::Base.cache do
+        firm.clients.each {}
+        assert_queries(0) { assert_not_nil firm.clients.each {} }
+        assert_queries(1) { assert_not_nil firm.clients(true).each {} }
+      end
     end
   end
 
   def test_association_with_references
     firm = companies(:first_firm)
-    assert_equal ['foo'], firm.association_with_references.references_values
+    assert_includes firm.association_with_references.references_values, 'foo'
   end
 
 end
@@ -202,6 +183,14 @@ class AssociationProxyTest < ActiveRecord::TestCase
     assert !david.projects.loaded?
   end
 
+  def test_load_does_load_target
+    david = developers(:david)
+
+    assert !david.projects.loaded?
+    david.projects.load
+    assert david.projects.loaded?
+  end
+
   def test_inspect_does_not_reload_a_not_yet_loaded_target
     andreas = Developer.new :name => 'Andreas', :log => 'new developer added'
     assert !andreas.audit_logs.loaded?
@@ -238,7 +227,7 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   def test_scoped_allows_conditions
-    assert developers(:david).projects.merge!(where: 'foo').where_values.include?('foo')
+    assert developers(:david).projects.merge(where: 'foo').to_sql.include?('foo')
   end
 
   test "getting a scope from an association" do
@@ -250,7 +239,14 @@ class AssociationProxyTest < ActiveRecord::TestCase
 
   test "proxy object is cached" do
     david = developers(:david)
-    assert david.projects.equal?(david.projects)
+    assert_same david.projects, david.projects
+  end
+
+  test "proxy object can be stubbed" do
+    david = developers(:david)
+    david.projects.define_singleton_method(:extra_method) { 42 }
+
+    assert_equal 42, david.projects.extra_method
   end
 
   test "inverses get set of subsets of the association" do
@@ -267,6 +263,15 @@ class AssociationProxyTest < ActiveRecord::TestCase
   test "first! works on loaded associations" do
     david = authors(:david)
     assert_equal david.posts.first, david.posts.reload.first!
+    assert david.posts.loaded?
+    assert_no_queries { david.posts.first! }
+  end
+
+  def test_pluck_uses_loaded_target
+    david = authors(:david)
+    assert_equal david.posts.pluck(:title), david.posts.load.pluck(:title)
+    assert david.posts.loaded?
+    assert_no_queries { david.posts.pluck(:title) }
   end
 
   def test_reset_unloads_target

data/test/cases/attribute_decorators_test.rb

@@ -12,11 +12,11 @@ module ActiveRecord
         super(delegate)
       end
 
-      def type_cast_from_user(value)
+      def cast(value)
         "#{super} #{@decoration}"
       end
 
-      alias type_cast_from_database type_cast_from_user
+      alias deserialize cast
     end
 
     setup do
@@ -28,7 +28,8 @@ module ActiveRecord
 
     teardown do
       return unless @connection
-      @connection.drop_table 'attribute_decorators_model' if @connection.table_exists? 'attribute_decorators_model'
+      @connection.drop_table 'attribute_decorators_model'
+	  #, if_exists: true
       Model.attribute_type_decorations.clear
       Model.reset_column_information
     end
@@ -51,7 +52,7 @@ module ActiveRecord
     end
 
     test "undecorated columns are not touched" do
-      Model.attribute :another_string, Type::String.new, default: 'something or other'
+      Model.attribute :another_string, :string, default: 'something or other'
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
 
       assert_equal 'something or other', Model.new.another_string
@@ -86,7 +87,7 @@ module ActiveRecord
     end
 
     test "decorating attributes does not modify parent classes" do
-      Model.attribute :another_string, Type::String.new, default: 'whatever'
+      Model.attribute :another_string, :string, default: 'whatever'
       Model.decorate_attribute_type(:a_string, :test) { |t| StringDecorator.new(t) }
       child_class = Class.new(Model)
       child_class.decorate_attribute_type(:another_string, :test) { |t| StringDecorator.new(t) }
@@ -102,15 +103,15 @@ module ActiveRecord
     end
 
     class Multiplier < SimpleDelegator
-      def type_cast_from_user(value)
+      def cast(value)
         return if value.nil?
         value * 2
       end
-      alias type_cast_from_database type_cast_from_user
+      alias deserialize cast
     end
 
     test "decorating with a proc" do
-      Model.attribute :an_int, Type::Integer.new
+      Model.attribute :an_int, :integer
       type_is_integer = proc { |_, type| type.type == :integer }
       Model.decorate_matching_attribute_types type_is_integer, :multiplier do |type|
         Multiplier.new(type)

data/test/cases/attribute_methods/read_test.rb

@@ -17,7 +17,7 @@ module ActiveRecord
 
           include ActiveRecord::AttributeMethods
 
-          def self.column_names
+          def self.attribute_names
             %w{ one two three }
           end
 
@@ -25,11 +25,11 @@ module ActiveRecord
           end
 
           def self.columns
-            column_names.map { FakeColumn.new(name) }
+            attribute_names.map { FakeColumn.new(name) }
           end
 
           def self.columns_hash
-            Hash[column_names.map { |name|
+            Hash[attribute_names.map { |name|
               [name, FakeColumn.new(name)]
             }]
           end
@@ -39,13 +39,13 @@ module ActiveRecord
       def test_define_attribute_methods
         instance = @klass.new
 
-        @klass.column_names.each do |name|
+        @klass.attribute_names.each do |name|
           assert !instance.methods.map(&:to_s).include?(name)
         end
 
         @klass.define_attribute_methods
 
-        @klass.column_names.each do |name|
+        @klass.attribute_names.each do |name|
           assert instance.methods.map(&:to_s).include?(name), "#{name} is not defined"
         end
       end

data/test/cases/attribute_methods_test.rb

@@ -1,7 +1,6 @@
 require "cases/helper"
 require 'models/minimalistic'
 require 'models/developer'
-require 'models/computer'
 require 'models/auto_id'
 require 'models/boolean'
 require 'models/computer'
@@ -28,14 +27,33 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
   end
 
-  def test_attribute_for_inspect
+  def test_attribute_for_inspect_string
     t = topics(:first)
     t.title = "The First Topic Now Has A Title With\nNewlines And More Than 50 Characters"
 
-    assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
     assert_equal '"The First Topic Now Has A Title With\nNewlines And ..."', t.attribute_for_inspect(:title)
   end
 
+  def test_attribute_for_inspect_date
+    t = topics(:first)
+
+    assert_equal %("#{t.written_on.to_s(:db)}"), t.attribute_for_inspect(:written_on)
+  end
+
+  def test_attribute_for_inspect_array
+    t = topics(:first)
+    t.content = [Object.new]
+
+    assert_match %r(\[#<Object:0x[0-9a-f]+>\]), t.attribute_for_inspect(:content)
+  end
+
+  def test_attribute_for_inspect_long_array
+    t = topics(:first)
+    t.content = (1..11).to_a
+
+    assert_equal "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]", t.attribute_for_inspect(:content)
+  end
+
   def test_attribute_present
     t = Topic.new
     t.title = "hello there!"
@@ -67,8 +85,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   def test_caching_nil_primary_key
     klass = Class.new(Minimalistic)
-    klass.expects(:reset_primary_key).returns(nil).once
-    2.times { klass.primary_key }
+    assert_called(klass, :reset_primary_key, returns: nil) do
+      2.times { klass.primary_key }
+    end
   end
 
   def test_attribute_keys_on_new_instance
@@ -175,9 +194,9 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal category_attrs , category.attributes_before_type_cast
   end
 
-  if current_adapter?(:MysqlAdapter)
+  if current_adapter?(:Mysql2Adapter)
     def test_read_attributes_before_type_cast_on_boolean
-      bool = Boolean.create({ "value" => false })
+      bool = Boolean.create!({ "value" => false })
       if RUBY_PLATFORM =~ /java/
         # JRuby will return the value before typecast as string
         assert_equal "0", bool.reload.attributes_before_type_cast["value"]
@@ -253,7 +272,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
   def test_case_sensitive_attributes_hash
     # DB2 is not case-sensitive
-    return true if current_adapter?(:DB2Adapter) || current_adapter?(:IBM_DBAdapter)
+    return true if current_adapter?(:DB2Adapter)
 
     assert_equal @loaded_fixtures['computers']['workstation'].to_hash, Computer.first.attributes
   end
@@ -502,7 +521,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_typecast_attribute_from_select_to_false
     Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter) || current_adapter?(:IBM_DBAdapter)
+    if current_adapter?(:OracleAdapter, :FbAdapter)
       topic = Topic.all.merge!(:select => "topics.*, 0 as is_test").first
     else
       topic = Topic.all.merge!(:select => "topics.*, 1=2 as is_test").first
@@ -513,7 +532,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_typecast_attribute_from_select_to_true
     Topic.create(:title => 'Budget')
     # Oracle does not support boolean expressions in SELECT
-    if current_adapter?(:OracleAdapter) || current_adapter?(:IBM_DBAdapter)
+    if current_adapter?(:OracleAdapter, :FbAdapter)
       topic = Topic.all.merge!(:select => "topics.*, 1 as is_test").first
     else
       topic = Topic.all.merge!(:select => "topics.*, 2=2 as is_test").first
@@ -531,20 +550,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_deprecated_cache_attributes
-    assert_deprecated do
-      Topic.cache_attributes :replies_count
-    end
-
-    assert_deprecated do
-      Topic.cached_attributes
-    end
-
-    assert_deprecated do
-      Topic.cache_attribute? :replies_count
-    end
-  end
-
   def test_converted_values_are_returned_after_assignment
     developer = Developer.new(name: 1337, salary: "50000")
 
@@ -556,9 +561,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
 
     developer.save!
 
-    assert_equal "50000", developer.salary_before_type_cast
-    assert_equal 1337, developer.name_before_type_cast
-
     assert_equal 50000, developer.salary
     assert_equal "1337", developer.name
   end
@@ -671,7 +673,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
-  def test_setting_time_zone_aware_attribute_in_current_time_zone
+  def test_setting_time_zone_aware_datetime_in_current_time_zone
     utc_time = Time.utc(2008, 1, 1)
     in_time_zone "Pacific Time (US & Canada)" do
       record   = @target.new
@@ -690,6 +692,54 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_setting_time_zone_aware_time_in_current_time_zone
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new
+      time_string = "10:00:00"
+      expected_time = Time.zone.parse("2000-01-01 #{time_string}")
+
+      record.bonus_time = time_string
+      assert_equal expected_time, record.bonus_time
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
+
+      record.bonus_time = ''
+      assert_nil record.bonus_time
+    end
+  end
+
+  def test_setting_time_zone_aware_time_with_dst
+    in_time_zone "Pacific Time (US & Canada)" do
+      current_time = Time.zone.local(2014, 06, 15, 10)
+      record = @target.new(bonus_time: current_time)
+      time_before_save = record.bonus_time
+
+      record.save
+      record.reload
+
+      assert_equal time_before_save, record.bonus_time
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record.bonus_time.time_zone
+    end
+  end
+
+  def test_removing_time_zone_aware_types
+    with_time_zone_aware_types(:datetime) do
+      in_time_zone "Pacific Time (US & Canada)" do
+        record = @target.new(bonus_time: "10:00:00")
+        expected_time = Time.utc(2000, 01, 01, 10)
+
+        assert_equal expected_time, record.bonus_time
+        assert record.bonus_time.utc?
+      end
+    end
+  end
+
+  def test_time_zone_aware_attributes_dont_recurse_infinitely_on_invalid_values
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.new(bonus_time: [])
+      assert_equal nil, record.bonus_time
+    end
+  end
+
   def test_setting_time_zone_conversion_for_attributes_should_write_value_on_class_variable
     Topic.skip_time_zone_conversion_for_attributes = [:field_a]
     Minimalistic.skip_time_zone_conversion_for_attributes = [:field_b]
@@ -744,17 +794,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal "unknown attribute 'hello' for Topic.", error.message
   end
 
-  # This test is related to a bug in Ruby 2.2.1.
-  # It can be safely removed once that bug is fixed.
-  #
-  # xref: https://bugs.ruby-lang.org/issues/10969
-  def test_bulk_does_not_raise_name_error
-    nope rescue nil # necessary to trigger the bug
-    assert_raises(ActiveRecord::UnknownAttributeError) {
-      Topic.new(hello: "world")
-    }
-  end
-
   def test_methods_override_in_multi_level_subclass
     klass = Class.new(Developer) do
       def name
@@ -778,7 +817,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_nil computer.system
   end
 
-  def test_global_methods_are_overwritte_when_subclassing
+  def test_global_methods_are_overwritten_when_subclassing
     klass = Class.new(ActiveRecord::Base) { self.abstract_class = true }
 
     subklass = Class.new(klass) do
@@ -921,6 +960,16 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert model.id_came_from_user?
   end
 
+  def test_accessed_fields
+    model = @target.first
+
+    assert_equal [], model.accessed_fields
+
+    model.title
+
+    assert_equal ["title"], model.accessed_fields
+  end
+
   private
 
   def new_topic_like_ar_class(&block)
@@ -933,6 +982,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     klass
   end
 
+  def with_time_zone_aware_types(*types)
+    old_types = ActiveRecord::Base.time_zone_aware_types
+    ActiveRecord::Base.time_zone_aware_types = types
+    yield
+  ensure
+    ActiveRecord::Base.time_zone_aware_types = old_types
+  end
+
   def cached_columns
     Topic.columns.map(&:name)
   end