3mix-castronaut 0.5.0.2

data/vendor/activerecord/test/cases/datatype_test_postgresql.rb

@@ -0,0 +1,203 @@
+require "cases/helper"
+
+class PostgresqlArray < ActiveRecord::Base
+end
+
+class PostgresqlMoney < ActiveRecord::Base
+end
+
+class PostgresqlNumber < ActiveRecord::Base
+end
+
+class PostgresqlTime < ActiveRecord::Base
+end
+
+class PostgresqlNetworkAddress < ActiveRecord::Base
+end
+
+class PostgresqlBitString < ActiveRecord::Base
+end
+
+class PostgresqlOid < ActiveRecord::Base
+end
+
+class PostgresqlDataTypeTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+
+    @connection.execute("INSERT INTO postgresql_arrays (commission_by_quarter, nicknames) VALUES ( '{35000,21000,18000,17000}', '{foo,bar,baz}' )")
+    @first_array = PostgresqlArray.find(1)
+
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('567.89'::money)")
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('-567.89'::money)")
+    @first_money = PostgresqlMoney.find(1)
+    @second_money = PostgresqlMoney.find(2)
+
+    @connection.execute("INSERT INTO postgresql_numbers (single, double) VALUES (123.456, 123456.789)")
+    @first_number = PostgresqlNumber.find(1)
+
+    @connection.execute("INSERT INTO postgresql_times (time_interval) VALUES ('1 year 2 days ago')")
+    @first_time = PostgresqlTime.find(1)
+
+    @connection.execute("INSERT INTO postgresql_network_addresses (cidr_address, inet_address, mac_address) VALUES('192.168.0/24', '172.16.1.254/32', '01:23:45:67:89:0a')")
+    @first_network_address = PostgresqlNetworkAddress.find(1)
+
+    @connection.execute("INSERT INTO postgresql_bit_strings (bit_string, bit_string_varying) VALUES (B'00010101', X'15')")
+    @first_bit_string = PostgresqlBitString.find(1)
+
+    @connection.execute("INSERT INTO postgresql_oids (obj_id) VALUES (1234)")
+    @first_oid = PostgresqlOid.find(1)
+  end
+
+  def test_data_type_of_array_types
+    assert_equal :string, @first_array.column_for_attribute(:commission_by_quarter).type
+    assert_equal :string, @first_array.column_for_attribute(:nicknames).type
+  end
+
+  def test_data_type_of_money_types
+    assert_equal :decimal, @first_money.column_for_attribute(:wealth).type
+  end
+
+  def test_data_type_of_number_types
+    assert_equal :float, @first_number.column_for_attribute(:single).type
+    assert_equal :float, @first_number.column_for_attribute(:double).type
+  end
+
+  def test_data_type_of_time_types
+    assert_equal :string, @first_time.column_for_attribute(:time_interval).type
+  end
+
+  def test_data_type_of_network_address_types
+    assert_equal :string, @first_network_address.column_for_attribute(:cidr_address).type
+    assert_equal :string, @first_network_address.column_for_attribute(:inet_address).type
+    assert_equal :string, @first_network_address.column_for_attribute(:mac_address).type
+  end
+
+  def test_data_type_of_bit_string_types
+    assert_equal :string, @first_bit_string.column_for_attribute(:bit_string).type
+    assert_equal :string, @first_bit_string.column_for_attribute(:bit_string_varying).type
+  end
+
+  def test_data_type_of_oid_types
+    assert_equal :integer, @first_oid.column_for_attribute(:obj_id).type
+  end
+
+  def test_array_values
+   assert_equal '{35000,21000,18000,17000}', @first_array.commission_by_quarter
+   assert_equal '{foo,bar,baz}', @first_array.nicknames
+  end
+
+  def test_money_values
+    assert_equal 567.89, @first_money.wealth
+    assert_equal -567.89, @second_money.wealth
+  end
+
+  def test_number_values
+    assert_equal 123.456, @first_number.single
+    assert_equal 123456.789, @first_number.double
+  end
+
+  def test_time_values
+    assert_equal '-1 years -2 days', @first_time.time_interval
+  end
+
+  def test_network_address_values
+    assert_equal '192.168.0.0/24', @first_network_address.cidr_address
+    assert_equal '172.16.1.254', @first_network_address.inet_address
+    assert_equal '01:23:45:67:89:0a', @first_network_address.mac_address
+  end
+
+  def test_bit_string_values
+    assert_equal '00010101', @first_bit_string.bit_string
+    assert_equal '00010101', @first_bit_string.bit_string_varying
+  end
+
+  def test_oid_values
+    assert_equal 1234, @first_oid.obj_id
+  end
+
+  def test_update_integer_array
+    new_value = '{32800,95000,29350,17000}'
+    assert @first_array.commission_by_quarter = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.commission_by_quarter, new_value
+    assert @first_array.commission_by_quarter = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.commission_by_quarter, new_value
+  end
+
+  def test_update_text_array
+    new_value = '{robby,robert,rob,robbie}'
+    assert @first_array.nicknames = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.nicknames, new_value
+    assert @first_array.nicknames = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.nicknames, new_value
+  end
+
+  def test_update_money
+    new_value = BigDecimal.new('123.45')
+    assert @first_money.wealth = new_value
+    assert @first_money.save
+    assert @first_money.reload
+    assert_equal new_value, @first_money.wealth
+  end
+
+  def test_update_number
+    new_single = 789.012
+    new_double = 789012.345
+    assert @first_number.single = new_single
+    assert @first_number.double = new_double
+    assert @first_number.save
+    assert @first_number.reload
+    assert_equal @first_number.single, new_single
+    assert_equal @first_number.double, new_double
+  end
+
+  def test_update_time
+    assert @first_time.time_interval = '2 years 3 minutes'
+    assert @first_time.save
+    assert @first_time.reload
+    assert_equal @first_time.time_interval, '2 years 00:03:00'
+  end
+
+  def test_update_network_address
+    new_cidr_address = '10.1.2.3/32'
+    new_inet_address = '10.0.0.0/8'
+    new_mac_address = 'bc:de:f0:12:34:56'
+    assert @first_network_address.cidr_address = new_cidr_address
+    assert @first_network_address.inet_address = new_inet_address
+    assert @first_network_address.mac_address = new_mac_address
+    assert @first_network_address.save
+    assert @first_network_address.reload
+    assert_equal @first_network_address.cidr_address, new_cidr_address
+    assert_equal @first_network_address.inet_address, new_inet_address
+    assert_equal @first_network_address.mac_address, new_mac_address
+  end
+
+  def test_update_bit_string
+    new_bit_string = '11111111'
+    new_bit_string_varying = 'FF'
+    assert @first_bit_string.bit_string = new_bit_string
+    assert @first_bit_string.bit_string_varying = new_bit_string_varying
+    assert @first_bit_string.save
+    assert @first_bit_string.reload
+    assert_equal @first_bit_string.bit_string, new_bit_string
+    assert_equal @first_bit_string.bit_string, @first_bit_string.bit_string_varying
+  end
+
+  def test_update_oid
+    new_value = 567890
+    assert @first_oid.obj_id = new_value
+    assert @first_oid.save
+    assert @first_oid.reload
+    assert_equal @first_oid.obj_id, new_value
+  end
+end

data/vendor/activerecord/test/cases/date_time_test.rb

@@ -0,0 +1,37 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/task'
+
+class DateTimeTest < ActiveRecord::TestCase
+  def test_saves_both_date_and_time
+    time_values = [1807, 2, 10, 15, 30, 45]
+    now = DateTime.civil(*time_values)
+
+    task = Task.new
+    task.starting = now
+    task.save!
+
+    # check against Time.local_time, since some platforms will return a Time instead of a DateTime
+    assert_equal Time.local_time(*time_values), Task.find(task.id).starting
+  end
+
+  def test_assign_empty_date_time
+    task = Task.new
+    task.starting = ''
+    task.ending = nil
+    assert_nil task.starting
+    assert_nil task.ending
+  end
+
+  def test_assign_empty_date
+    topic = Topic.new
+    topic.last_read = ''
+    assert_nil topic.last_read
+  end
+
+  def test_assign_empty_time
+    topic = Topic.new
+    topic.bonus_time = ''
+    assert_nil topic.bonus_time
+  end
+end

data/vendor/activerecord/test/cases/default_test_firebird.rb

@@ -0,0 +1,16 @@
+require "cases/helper"
+require 'models/default'
+
+class DefaultTest < ActiveRecord::TestCase
+  def test_default_timestamp
+    default = Default.new
+    assert_instance_of(Time, default.default_timestamp)
+    assert_equal(:datetime, default.column_for_attribute(:default_timestamp).type)
+
+    # Variance should be small; increase if required -- e.g., if test db is on
+    # remote host and clocks aren't synchronized.
+    t1 = Time.new
+    accepted_variance = 1.0
+    assert_in_delta(t1.to_f, default.default_timestamp.to_f, accepted_variance)
+  end
+end

data/vendor/activerecord/test/cases/defaults_test.rb

@@ -0,0 +1,69 @@
+require "cases/helper"
+require 'models/default'
+require 'models/entrant'
+
+class DefaultTest < ActiveRecord::TestCase
+  def test_nil_defaults_for_not_null_columns
+    column_defaults =
+      if current_adapter?(:MysqlAdapter) && (Mysql.client_version < 50051 || (50100..50122).include?(Mysql.client_version))
+        { 'id' => nil, 'name' => '',  'course_id' => nil }
+      else
+        { 'id' => nil, 'name' => nil, 'course_id' => nil }
+      end
+
+    column_defaults.each do |name, default|
+      column = Entrant.columns_hash[name]
+      assert !column.null, "#{name} column should be NOT NULL"
+      assert_equal default, column.default, "#{name} column should be DEFAULT #{default.inspect}"
+    end
+  end
+
+  if current_adapter?(:MysqlAdapter)
+    # MySQL uses an implicit default 0 rather than NULL unless in strict mode.
+    # We use an implicit NULL so schema.rb is compatible with other databases.
+    def test_mysql_integer_not_null_defaults
+      klass = Class.new(ActiveRecord::Base)
+      klass.table_name = 'test_integer_not_null_default_zero'
+      klass.connection.create_table klass.table_name do |t|
+        t.column :zero, :integer, :null => false, :default => 0
+        t.column :omit, :integer, :null => false
+      end
+
+      assert_equal 0, klass.columns_hash['zero'].default
+      assert !klass.columns_hash['zero'].null
+      # 0 in MySQL 4, nil in 5.
+      assert [0, nil].include?(klass.columns_hash['omit'].default)
+      assert !klass.columns_hash['omit'].null
+
+      assert_raise(ActiveRecord::StatementInvalid) { klass.create! }
+
+      assert_nothing_raised do
+        instance = klass.create!(:omit => 1)
+        assert_equal 0, instance.zero
+        assert_equal 1, instance.omit
+      end
+    ensure
+      klass.connection.drop_table(klass.table_name) rescue nil
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter, :SQLServerAdapter, :FirebirdAdapter, :OpenBaseAdapter, :OracleAdapter)
+    def test_default_integers
+      default = Default.new
+      assert_instance_of Fixnum, default.positive_integer
+      assert_equal 1, default.positive_integer
+      assert_instance_of Fixnum, default.negative_integer
+      assert_equal -1, default.negative_integer
+      assert_instance_of BigDecimal, default.decimal_number
+      assert_equal BigDecimal.new("2.78"), default.decimal_number
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_multiline_default_text
+      # older postgres versions represent the default with escapes ("\\012" for a newline)
+      assert ( "--- []\n\n" == Default.columns_hash['multiline_default'].default ||
+               "--- []\\012\\012" == Default.columns_hash['multiline_default'].default)
+    end
+  end
+end

data/vendor/activerecord/test/cases/deprecated_finder_test.rb

@@ -0,0 +1,30 @@
+require "cases/helper"
+require 'models/entrant'
+
+class DeprecatedFinderTest < ActiveRecord::TestCase
+  fixtures :entrants
+
+  def test_deprecated_find_all_was_removed
+    assert_raise(NoMethodError) { Entrant.find_all }
+  end
+
+  def test_deprecated_find_first_was_removed
+    assert_raise(NoMethodError) { Entrant.find_first }
+  end
+
+  def test_deprecated_find_on_conditions_was_removed
+    assert_raise(NoMethodError) { Entrant.find_on_conditions }
+  end
+
+  def test_count
+    assert_equal(0, Entrant.count(:conditions => "id > 3"))
+    assert_equal(1, Entrant.count(:conditions => ["id > ?", 2]))
+    assert_equal(2, Entrant.count(:conditions => ["id > ?", 1]))
+  end
+
+  def test_count_by_sql
+    assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
+    assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
+    assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1]))
+  end
+end

data/vendor/activerecord/test/cases/dirty_test.rb

@@ -0,0 +1,257 @@
+require 'cases/helper'
+require 'models/topic'    # For booleans
+require 'models/pirate'   # For timestamps
+require 'models/parrot'
+require 'models/person'   # For optimistic locking
+
+class Pirate # Just reopening it, not defining it
+  attr_accessor :detected_changes_in_after_update # Boolean for if changes are detected
+  attr_accessor :changes_detected_in_after_update # Actual changes
+
+  after_update :check_changes
+
+private
+  # after_save/update in sweepers, observers, and the model itself
+  # can end up checking dirty status and acting on the results
+  def check_changes
+    if self.changed?
+      self.detected_changes_in_after_update = true
+      self.changes_detected_in_after_update = self.changes
+    end
+  end
+end
+
+class DirtyTest < ActiveRecord::TestCase
+  def test_attribute_changes
+    # New record - no changes.
+    pirate = Pirate.new
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+
+    # Change catchphrase.
+    pirate.catchphrase = 'arrr'
+    assert pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_was
+    assert_equal [nil, 'arrr'], pirate.catchphrase_change
+
+    # Saved - no changes.
+    pirate.save!
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+
+    # Same value - no changes.
+    pirate.catchphrase = 'arrr'
+    assert !pirate.catchphrase_changed?
+    assert_nil pirate.catchphrase_change
+  end
+
+  def test_nullable_integer_not_marked_as_changed_if_new_value_is_blank
+    pirate = Pirate.new
+
+    ["", nil].each do |value|
+      pirate.parrot_id = value
+      assert !pirate.parrot_id_changed?
+      assert_nil pirate.parrot_id_change
+    end
+  end
+
+  def test_zero_to_blank_marked_as_changed
+    pirate = Pirate.new
+    pirate.catchphrase = "Yarrrr, me hearties"
+    pirate.parrot_id = 1
+    pirate.save
+
+    # check the change from 1 to ''
+    pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
+    pirate.parrot_id = ''
+    assert pirate.parrot_id_changed?
+    assert_equal([1, nil], pirate.parrot_id_change)
+    pirate.save
+
+    # check the change from nil to 0
+    pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
+    pirate.parrot_id = 0
+    assert pirate.parrot_id_changed?
+    assert_equal([nil, 0], pirate.parrot_id_change)
+    pirate.save
+
+    # check the change from 0 to ''
+    pirate = Pirate.find_by_catchphrase("Yarrrr, me hearties")
+    pirate.parrot_id = ''
+    assert pirate.parrot_id_changed?
+    assert_equal([0, nil], pirate.parrot_id_change)
+  end
+
+  def test_object_should_be_changed_if_any_attribute_is_changed
+    pirate = Pirate.new
+    assert !pirate.changed?
+    assert_equal [], pirate.changed
+    assert_equal Hash.new, pirate.changes
+
+    pirate.catchphrase = 'arrr'
+    assert pirate.changed?
+    assert_nil pirate.catchphrase_was
+    assert_equal %w(catchphrase), pirate.changed
+    assert_equal({'catchphrase' => [nil, 'arrr']}, pirate.changes)
+
+    pirate.save
+    assert !pirate.changed?
+    assert_equal [], pirate.changed
+    assert_equal Hash.new, pirate.changes
+  end
+
+  def test_attribute_will_change!
+    pirate = Pirate.create!(:catchphrase => 'arr')
+
+    pirate.catchphrase << ' matey'
+    assert !pirate.catchphrase_changed?
+
+    assert pirate.catchphrase_will_change!
+    assert pirate.catchphrase_changed?
+    assert_equal ['arr matey', 'arr matey'], pirate.catchphrase_change
+
+    pirate.catchphrase << '!'
+    assert pirate.catchphrase_changed?
+    assert_equal ['arr matey', 'arr matey!'], pirate.catchphrase_change
+  end
+
+  def test_association_assignment_changes_foreign_key
+    pirate = Pirate.create!(:catchphrase => 'jarl')
+    pirate.parrot = Parrot.create!
+    assert pirate.changed?
+    assert_equal %w(parrot_id), pirate.changed
+  end
+
+  def test_attribute_should_be_compared_with_type_cast
+    topic = Topic.new
+    assert topic.approved?
+    assert !topic.approved_changed?
+
+    # Coming from web form.
+    params = {:topic => {:approved => 1}}
+    # In the controller.
+    topic.attributes = params[:topic]
+    assert topic.approved?
+    assert !topic.approved_changed?
+  end
+
+  def test_partial_update
+    pirate = Pirate.new(:catchphrase => 'foo')
+    old_updated_on = 1.hour.ago.beginning_of_day
+
+    with_partial_updates Pirate, false do
+      assert_queries(2) { 2.times { pirate.save! } }
+      Pirate.update_all({ :updated_on => old_updated_on }, :id => pirate.id)
+    end
+
+    with_partial_updates Pirate, true do
+      assert_queries(0) { 2.times { pirate.save! } }
+      assert_equal old_updated_on, pirate.reload.updated_on
+
+      assert_queries(1) { pirate.catchphrase = 'bar'; pirate.save! }
+      assert_not_equal old_updated_on, pirate.reload.updated_on
+    end
+  end
+
+  def test_partial_update_with_optimistic_locking
+    person = Person.new(:first_name => 'foo')
+    old_lock_version = 1
+
+    with_partial_updates Person, false do
+      assert_queries(2) { 2.times { person.save! } }
+      Person.update_all({ :first_name => 'baz' }, :id => person.id)
+    end
+
+    with_partial_updates Person, true do
+      assert_queries(0) { 2.times { person.save! } }
+      assert_equal old_lock_version, person.reload.lock_version
+
+      assert_queries(1) { person.first_name = 'bar'; person.save! }
+      assert_not_equal old_lock_version, person.reload.lock_version
+    end
+  end
+
+  def test_changed_attributes_should_be_preserved_if_save_failure
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert !pirate.save
+    check_pirate_after_save_failure(pirate)
+
+    pirate = Pirate.new
+    pirate.parrot_id = 1
+    assert_raises(ActiveRecord::RecordInvalid) { pirate.save! }
+    check_pirate_after_save_failure(pirate)
+  end
+
+  def test_reload_should_clear_changed_attributes
+    pirate = Pirate.create!(:catchphrase => "shiver me timbers")
+    pirate.catchphrase = "*hic*"
+    assert pirate.changed?
+    pirate.reload
+    assert !pirate.changed?
+  end
+
+  def test_reverted_changes_are_not_dirty
+    phrase = "shiver me timbers"
+    pirate = Pirate.create!(:catchphrase => phrase)
+    pirate.catchphrase = "*hic*"
+    assert pirate.changed?
+    pirate.catchphrase = phrase
+    assert !pirate.changed?
+  end
+
+  def test_reverted_changes_are_not_dirty_after_multiple_changes
+    phrase = "shiver me timbers"
+    pirate = Pirate.create!(:catchphrase => phrase)
+    10.times do |i|
+      pirate.catchphrase = "*hic*" * i
+      assert pirate.changed?
+    end
+    assert pirate.changed?
+    pirate.catchphrase = phrase
+    assert !pirate.changed?
+  end
+
+
+  def test_reverted_changes_are_not_dirty_going_from_nil_to_value_and_back
+    pirate = Pirate.create!(:catchphrase => "Yar!")
+
+    pirate.parrot_id = 1
+    assert pirate.changed?
+    assert pirate.parrot_id_changed?
+    assert !pirate.catchphrase_changed?
+
+    pirate.parrot_id = nil
+    assert !pirate.changed?
+    assert !pirate.parrot_id_changed?
+    assert !pirate.catchphrase_changed?
+  end
+
+  def test_save_should_store_serialized_attributes_even_with_partial_updates
+    with_partial_updates(Topic) do
+      topic = Topic.create!(:content => {:a => "a"})
+      topic.content[:b] = "b"
+      #assert topic.changed? # Known bug, will fail
+      topic.save!
+      assert_equal "b", topic.content[:b]
+      topic.reload
+      assert_equal "b", topic.content[:b]
+    end
+  end
+
+  private
+    def with_partial_updates(klass, on = true)
+      old = klass.partial_updates?
+      klass.partial_updates = on
+      yield
+    ensure
+      klass.partial_updates = old
+    end
+
+    def check_pirate_after_save_failure(pirate)
+      assert pirate.changed?
+      assert pirate.parrot_id_changed?
+      assert_equal %w(parrot_id), pirate.changed
+      assert_nil pirate.parrot_id_was
+    end
+end

data/vendor/activerecord/test/cases/finder_respond_to_test.rb

@@ -0,0 +1,76 @@
+require "cases/helper"
+require 'models/topic'
+
+class FinderRespondToTest < ActiveRecord::TestCase
+
+  fixtures :topics
+
+  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_newly_added_method
+    class << Topic; self; end.send(:define_method, :method_added_for_finder_respond_to_test) { }
+    assert Topic.respond_to?(:method_added_for_finder_respond_to_test)
+  ensure
+    class << Topic; self; end.send(:remove_method, :method_added_for_finder_respond_to_test)
+  end
+
+  def test_should_preserve_normal_respond_to_behaviour_and_respond_to_standard_object_method
+    assert Topic.respond_to?(:to_s)
+  end
+
+  def test_should_respond_to_find_by_one_attribute_before_caching
+    ensure_topic_method_is_not_cached(:find_by_title)
+    assert Topic.respond_to?(:find_by_title)
+  end
+
+  def test_should_respond_to_find_all_by_one_attribute
+    ensure_topic_method_is_not_cached(:find_all_by_title)
+    assert Topic.respond_to?(:find_all_by_title)
+  end
+
+  def test_should_respond_to_find_all_by_two_attributes
+    ensure_topic_method_is_not_cached(:find_all_by_title_and_author_name)
+    assert Topic.respond_to?(:find_all_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_by_two_attributes
+    ensure_topic_method_is_not_cached(:find_by_title_and_author_name)
+    assert Topic.respond_to?(:find_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_or_initialize_from_one_attribute
+    ensure_topic_method_is_not_cached(:find_or_initialize_by_title)
+    assert Topic.respond_to?(:find_or_initialize_by_title)
+  end
+
+  def test_should_respond_to_find_or_initialize_from_two_attributes
+    ensure_topic_method_is_not_cached(:find_or_initialize_by_title_and_author_name)
+    assert Topic.respond_to?(:find_or_initialize_by_title_and_author_name)
+  end
+
+  def test_should_respond_to_find_or_create_from_one_attribute
+    ensure_topic_method_is_not_cached(:find_or_create_by_title)
+    assert Topic.respond_to?(:find_or_create_by_title)
+  end
+
+  def test_should_respond_to_find_or_create_from_two_attributes
+    ensure_topic_method_is_not_cached(:find_or_create_by_title_and_author_name)
+    assert Topic.respond_to?(:find_or_create_by_title_and_author_name)
+  end
+
+  def test_should_not_respond_to_find_by_one_missing_attribute
+    assert !Topic.respond_to?(:find_by_undertitle)
+  end
+
+  def test_should_not_respond_to_find_by_invalid_method_syntax
+    assert !Topic.respond_to?(:fail_to_find_by_title)
+    assert !Topic.respond_to?(:find_by_title?)
+    assert !Topic.respond_to?(:fail_to_find_or_create_by_title)
+    assert !Topic.respond_to?(:find_or_create_by_title?)
+  end
+
+  private
+
+  def ensure_topic_method_is_not_cached(method_id)
+    class << Topic; self; end.send(:remove_method, method_id) if Topic.public_methods.any? { |m| m.to_s == method_id.to_s }
+  end
+
+end