factorylabs-castronaut 0.7.5

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

@@ -0,0 +1,124 @@
+require "cases/helper"
+require 'models/course'
+
+class FirebirdMigrationTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    # using Course connection for tests -- need a db that doesn't already have a BOOLEAN domain
+    @connection = Course.connection
+    @fireruby_connection = @connection.instance_variable_get(:@connection)
+  end
+
+  def teardown
+    @connection.drop_table :foo rescue nil
+    @connection.execute("DROP DOMAIN D_BOOLEAN") rescue nil
+  end
+
+  def test_create_table_with_custom_sequence_name
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => 'foo_custom_seq') do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert sequence_exists?('foo_custom_seq')
+
+    assert_nothing_raised { @connection.drop_table(:foo, :sequence => 'foo_custom_seq') }
+    assert !sequence_exists?('foo_custom_seq')
+  ensure
+    FireRuby::Generator.new('foo_custom_seq', @fireruby_connection).drop rescue nil
+  end
+
+  def test_create_table_without_sequence
+    assert_nothing_raised do
+      @connection.create_table(:foo, :sequence => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+
+    assert_nothing_raised do
+      @connection.create_table(:foo, :id => false) do |f|
+        f.column :bar, :string
+      end
+    end
+    assert !sequence_exists?('foo_seq')
+    assert_nothing_raised { @connection.drop_table :foo }
+  end
+
+  def test_create_table_with_boolean_column
+    assert !boolean_domain_exists?
+    assert_nothing_raised do
+      @connection.create_table :foo do |f|
+        f.column :bar, :string
+        f.column :baz, :boolean
+      end
+    end
+    assert boolean_domain_exists?
+  end
+
+  def test_add_boolean_column
+    assert !boolean_domain_exists?
+    @connection.create_table :foo do |f|
+      f.column :bar, :string
+    end
+
+    assert_nothing_raised { @connection.add_column :foo, :baz, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "baz" }.type
+  end
+
+  def test_change_column_to_boolean
+    assert !boolean_domain_exists?
+    # Manually create table with a SMALLINT column, which can be changed to a BOOLEAN
+    @connection.execute "CREATE TABLE foo (bar SMALLINT)"
+    assert_equal :integer, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+
+    assert_nothing_raised { @connection.change_column :foo, :bar, :boolean }
+    assert boolean_domain_exists?
+    assert_equal :boolean, @connection.columns(:foo).find { |c| c.name == "bar" }.type
+  end
+
+  def test_rename_table_with_data_and_index
+    @connection.create_table :foo do |f|
+      f.column :baz, :string, :limit => 50
+    end
+    100.times { |i| @connection.execute "INSERT INTO foo VALUES (GEN_ID(foo_seq, 1), 'record #{i+1}')" }
+    @connection.add_index :foo, :baz
+
+    assert_nothing_raised { @connection.rename_table :foo, :bar }
+    assert !@connection.tables.include?("foo")
+    assert @connection.tables.include?("bar")
+    assert_equal "index_bar_on_baz", @connection.indexes("bar").first.name
+    assert_equal 100, FireRuby::Generator.new("bar_seq", @fireruby_connection).last
+    assert_equal 100, @connection.select_one("SELECT COUNT(*) FROM bar")["count"]
+  ensure
+    @connection.drop_table :bar rescue nil
+  end
+
+  def test_renaming_table_with_fk_constraint_raises_error
+    @connection.create_table :parent do |p|
+      p.column :name, :string
+    end
+    @connection.create_table :child do |c|
+      c.column :parent_id, :integer
+    end
+    @connection.execute "ALTER TABLE child ADD CONSTRAINT fk_child_parent FOREIGN KEY(parent_id) REFERENCES parent(id)"
+    assert_raise(ActiveRecord::ActiveRecordError) { @connection.rename_table :child, :descendant }
+  ensure
+    @connection.drop_table :child rescue nil
+    @connection.drop_table :descendant rescue nil
+    @connection.drop_table :parent rescue nil
+  end
+
+  private
+    def boolean_domain_exists?
+      !@connection.select_one("SELECT 1 FROM rdb$fields WHERE rdb$field_name = 'D_BOOLEAN'").nil?
+    end
+
+    def sequence_exists?(sequence_name)
+      FireRuby::Generator.exists?(sequence_name, @fireruby_connection)
+    end
+end

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

@@ -0,0 +1,96 @@
+require "cases/helper"
+
+class Mixin < ActiveRecord::Base
+end
+
+# Let us control what Time.now returns for the TouchTest suite
+class Time
+  @@forced_now_time = nil
+  cattr_accessor :forced_now_time
+
+  class << self
+    def now_with_forcing
+      if @@forced_now_time
+        @@forced_now_time
+      else
+        now_without_forcing
+      end
+    end
+    alias_method_chain :now, :forcing
+  end
+end
+
+
+class TouchTest < ActiveRecord::TestCase
+  fixtures :mixins
+
+  def setup
+    Time.forced_now_time = Time.now
+  end
+
+  def teardown
+    Time.forced_now_time = nil
+  end
+
+  def test_time_mocking
+    five_minutes_ago = 5.minutes.ago
+    Time.forced_now_time = five_minutes_ago
+    assert_equal five_minutes_ago, Time.now
+
+    Time.forced_now_time = nil
+    assert_not_equal five_minutes_ago, Time.now
+  end
+
+  def test_update
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.updated_at
+    assert_equal Time.now, stamped.created_at
+  end
+
+  def test_create
+    obj = Mixin.create
+    assert_equal Time.now, obj.updated_at
+    assert_equal Time.now, obj.created_at
+  end
+
+  def test_many_updates
+    stamped = Mixin.new
+
+    assert_nil stamped.updated_at
+    assert_nil stamped.created_at
+    stamped.save
+    assert_equal Time.now, stamped.created_at
+    assert_equal Time.now, stamped.updated_at
+
+    old_updated_at = stamped.updated_at
+
+    Time.forced_now_time = 5.minutes.from_now
+    stamped.lft_will_change!
+    stamped.save
+
+    assert_equal Time.now, stamped.updated_at
+    assert_equal old_updated_at, stamped.created_at
+  end
+
+  def test_create_turned_off
+    Mixin.record_timestamps = false
+
+    mixin = Mixin.new
+
+    assert_nil mixin.updated_at
+    mixin.save
+    assert_nil mixin.updated_at
+
+  # Make sure Mixin.record_timestamps gets reset, even if this test fails,
+  # so that other tests do not fail because Mixin.record_timestamps == false
+  rescue Exception => e
+    raise e
+  ensure
+    Mixin.record_timestamps = true
+  end
+
+end

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

@@ -0,0 +1,39 @@
+require "cases/helper"
+require 'models/company_in_module'
+
+class ModulesTest < ActiveRecord::TestCase
+  fixtures :accounts, :companies, :projects, :developers
+
+  def test_module_spanning_associations
+    firm = MyApplication::Business::Firm.find(:first)
+    assert !firm.clients.empty?, "Firm should have clients"
+    assert_nil firm.class.table_name.match('::'), "Firm shouldn't have the module appear in its table name"
+  end
+
+  def test_module_spanning_has_and_belongs_to_many_associations
+    project = MyApplication::Business::Project.find(:first)
+    project.developers << MyApplication::Business::Developer.create("name" => "John")
+    assert "John", project.developers.last.name
+  end
+
+  def test_associations_spanning_cross_modules
+    account = MyApplication::Billing::Account.find(:first, :order => 'id')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+    assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_unqualified_billing_firm
+  end
+
+  def test_find_account_and_include_company
+    account = MyApplication::Billing::Account.find(1, :include => :firm)
+    assert_kind_of MyApplication::Business::Firm, account.instance_variable_get('@firm')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+  end
+
+  def test_table_name
+    assert_equal 'accounts', MyApplication::Billing::Account.table_name, 'table_name for ActiveRecord model in module'
+    assert_equal 'companies', MyApplication::Business::Client.table_name, 'table_name for ActiveRecord model subclass'
+    assert_equal 'company_contacts', MyApplication::Business::Client::Contact.table_name, 'table_name for ActiveRecord model enclosed by another ActiveRecord model'
+  end
+end

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

@@ -0,0 +1,85 @@
+require "cases/helper"
+require 'models/entrant'
+
+# So we can test whether Course.connection survives a reload.
+require_dependency 'models/course'
+
+class MultipleDbTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  def setup
+    @courses  = create_fixtures("courses") { Course.retrieve_connection }
+    @entrants = create_fixtures("entrants")
+  end
+
+  def test_connected
+    assert_not_nil Entrant.connection
+    assert_not_nil Course.connection
+  end
+
+  def test_proper_connection
+    assert_not_equal(Entrant.connection, Course.connection)
+    assert_equal(Entrant.connection, Entrant.retrieve_connection)
+    assert_equal(Course.connection, Course.retrieve_connection)
+    assert_equal(ActiveRecord::Base.connection, Entrant.connection)
+  end
+
+  def test_find
+    c1 = Course.find(1)
+    assert_equal "Ruby Development", c1.name
+    c2 = Course.find(2)
+    assert_equal "Java Development", c2.name
+    e1 = Entrant.find(1)
+    assert_equal "Ruby Developer", e1.name
+    e2 = Entrant.find(2)
+    assert_equal "Ruby Guru", e2.name
+    e3 = Entrant.find(3)
+    assert_equal "Java Lover", e3.name
+  end
+
+  def test_associations
+    c1 = Course.find(1)
+    assert_equal 2, c1.entrants.count
+    e1 = Entrant.find(1)
+    assert_equal e1.course.id, c1.id
+    c2 = Course.find(2)
+    assert_equal 1, c2.entrants.count
+    e3 = Entrant.find(3)
+    assert_equal e3.course.id, c2.id
+  end
+
+  def test_course_connection_should_survive_dependency_reload
+    assert Course.connection
+
+    ActiveSupport::Dependencies.clear
+    Object.send(:remove_const, :Course)
+    require_dependency 'models/course'
+
+    assert Course.connection
+  end
+
+  def test_transactions_across_databases
+    c1 = Course.find(1)
+    e1 = Entrant.find(1)
+
+    begin
+      Course.transaction do
+        Entrant.transaction do
+          c1.name = "Typo"
+          e1.name = "Typo"
+          c1.save
+          e1.save
+          raise "No I messed up."
+        end
+      end
+    rescue
+      # Yup caught it
+    end
+
+    assert_equal "Typo", c1.name
+    assert_equal "Typo", e1.name
+
+    assert_equal "Ruby Development", Course.find(1).name
+    assert_equal "Ruby Developer", Entrant.find(1).name
+  end
+end

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

@@ -0,0 +1,280 @@
+require "cases/helper"
+require 'models/post'
+require 'models/topic'
+require 'models/comment'
+require 'models/reply'
+require 'models/author'
+require 'models/developer'
+
+class NamedScopeTest < ActiveRecord::TestCase
+  fixtures :posts, :authors, :topics, :comments, :author_addresses
+
+  def test_implements_enumerable
+    assert !Topic.find(:all).empty?
+
+    assert_equal Topic.find(:all),   Topic.base
+    assert_equal Topic.find(:all),   Topic.base.to_a
+    assert_equal Topic.find(:first), Topic.base.first
+    assert_equal Topic.find(:all),   Topic.base.each { |i| i }
+  end
+
+  def test_found_items_are_cached
+    Topic.columns
+    all_posts = Topic.base
+
+    assert_queries(1) do
+      all_posts.collect
+      all_posts.collect
+    end
+  end
+
+  def test_reload_expires_cache_of_found_items
+    all_posts = Topic.base
+    all_posts.inspect
+
+    new_post = Topic.create!
+    assert !all_posts.include?(new_post)
+    assert all_posts.reload.include?(new_post)
+  end
+
+  def test_delegates_finds_and_calculations_to_the_base_class
+    assert !Topic.find(:all).empty?
+
+    assert_equal Topic.find(:all),               Topic.base.find(:all)
+    assert_equal Topic.find(:first),             Topic.base.find(:first)
+    assert_equal Topic.count,                    Topic.base.count
+    assert_equal Topic.average(:replies_count), Topic.base.average(:replies_count)
+  end
+
+  def test_scope_should_respond_to_own_methods_and_methods_of_the_proxy
+    assert Topic.approved.respond_to?(:proxy_found)
+    assert Topic.approved.respond_to?(:count)
+    assert Topic.approved.respond_to?(:length)
+  end
+
+  def test_respond_to_respects_include_private_parameter
+    assert !Topic.approved.respond_to?(:load_found)
+    assert Topic.approved.respond_to?(:load_found, true)
+  end
+
+  def test_subclasses_inherit_scopes
+    assert Topic.scopes.include?(:base)
+
+    assert Reply.scopes.include?(:base)
+    assert_equal Reply.find(:all), Reply.base
+  end
+
+  def test_scopes_with_options_limit_finds_to_those_matching_the_criteria_specified
+    assert !Topic.find(:all, :conditions => {:approved => true}).empty?
+
+    assert_equal Topic.find(:all, :conditions => {:approved => true}), Topic.approved
+    assert_equal Topic.count(:conditions => {:approved => true}), Topic.approved.count
+  end
+
+  def test_scopes_with_string_name_can_be_composed
+    # NOTE that scopes defined with a string as a name worked on their own
+    # but when called on another scope the other scope was completely replaced
+    assert_equal Topic.replied.approved, Topic.replied.approved_as_string
+  end
+
+  def test_scopes_can_be_specified_with_deep_hash_conditions
+    assert_equal Topic.replied.approved, Topic.replied.approved_as_hash_condition
+  end
+
+  def test_scopes_are_composable
+    assert_equal (approved = Topic.find(:all, :conditions => {:approved => true})), Topic.approved
+    assert_equal (replied = Topic.find(:all, :conditions => 'replies_count > 0')), Topic.replied
+    assert !(approved == replied)
+    assert !(approved & replied).empty?
+
+    assert_equal approved & replied, Topic.approved.replied
+  end
+
+  def test_procedural_scopes
+    topics_written_before_the_third = Topic.find(:all, :conditions => ['written_on < ?', topics(:third).written_on])
+    topics_written_before_the_second = Topic.find(:all, :conditions => ['written_on < ?', topics(:second).written_on])
+    assert_not_equal topics_written_before_the_second, topics_written_before_the_third
+
+    assert_equal topics_written_before_the_third, Topic.written_before(topics(:third).written_on)
+    assert_equal topics_written_before_the_second, Topic.written_before(topics(:second).written_on)
+  end
+
+  def test_scopes_with_joins
+    address = author_addresses(:david_address)
+    posts_with_authors_at_address = Post.find(
+      :all, :joins => 'JOIN authors ON authors.id = posts.author_id',
+      :conditions => [ 'authors.author_address_id = ?', address.id ]
+    )
+    assert_equal posts_with_authors_at_address, Post.with_authors_at_address(address)
+  end
+
+  def test_scopes_with_joins_respects_custom_select
+    address = author_addresses(:david_address)
+    posts_with_authors_at_address_titles = Post.find(:all,
+      :select => 'title',
+      :joins => 'JOIN authors ON authors.id = posts.author_id',
+      :conditions => [ 'authors.author_address_id = ?', address.id ]
+    )
+    assert_equal posts_with_authors_at_address_titles, Post.with_authors_at_address(address).find(:all, :select => 'title')
+  end
+
+  def test_extensions
+    assert_equal 1, Topic.anonymous_extension.one
+    assert_equal 2, Topic.named_extension.two
+  end
+
+  def test_multiple_extensions
+    assert_equal 2, Topic.multiple_extensions.extension_two
+    assert_equal 1, Topic.multiple_extensions.extension_one
+  end
+
+  def test_has_many_associations_have_access_to_named_scopes
+    assert_not_equal Post.containing_the_letter_a, authors(:david).posts
+    assert !Post.containing_the_letter_a.empty?
+
+    assert_equal authors(:david).posts & Post.containing_the_letter_a, authors(:david).posts.containing_the_letter_a
+  end
+
+  def test_has_many_through_associations_have_access_to_named_scopes
+    assert_not_equal Comment.containing_the_letter_e, authors(:david).comments
+    assert !Comment.containing_the_letter_e.empty?
+
+    assert_equal authors(:david).comments & Comment.containing_the_letter_e, authors(:david).comments.containing_the_letter_e
+  end
+
+  def test_active_records_have_scope_named__all__
+    assert !Topic.find(:all).empty?
+
+    assert_equal Topic.find(:all), Topic.base
+  end
+
+  def test_active_records_have_scope_named__scoped__
+    assert !Topic.find(:all, scope = {:conditions => "content LIKE '%Have%'"}).empty?
+
+    assert_equal Topic.find(:all, scope), Topic.scoped(scope)
+  end
+
+  def test_proxy_options
+    expected_proxy_options = { :conditions => { :approved => true } }
+    assert_equal expected_proxy_options, Topic.approved.proxy_options
+  end
+
+  def test_first_and_last_should_support_find_options
+    assert_equal Topic.base.first(:order => 'title'), Topic.base.find(:first, :order => 'title')
+    assert_equal Topic.base.last(:order => 'title'), Topic.base.find(:last, :order => 'title')
+  end
+
+  def test_first_and_last_should_allow_integers_for_limit
+    assert_equal Topic.base.first(2), Topic.base.to_a.first(2)
+    assert_equal Topic.base.last(2), Topic.base.to_a.last(2)
+  end
+
+  def test_first_and_last_should_not_use_query_when_results_are_loaded
+    topics = Topic.base
+    topics.reload # force load
+    assert_no_queries do
+      topics.first
+      topics.last
+    end
+  end
+
+  def test_first_and_last_find_options_should_use_query_when_results_are_loaded
+    topics = Topic.base
+    topics.reload # force load
+    assert_queries(2) do
+      topics.first(:order => 'title')
+      topics.last(:order => 'title')
+    end
+  end
+
+  def test_empty_should_not_load_results
+    topics = Topic.base
+    assert_queries(2) do
+      topics.empty?  # use count query
+      topics.collect # force load
+      topics.empty?  # use loaded (no query)
+    end
+  end
+
+  def test_any_should_not_load_results
+    topics = Topic.base
+    assert_queries(2) do
+      topics.any?    # use count query
+      topics.collect # force load
+      topics.any?    # use loaded (no query)
+    end
+  end
+
+  def test_any_should_call_proxy_found_if_using_a_block
+    topics = Topic.base
+    assert_queries(1) do
+      topics.expects(:empty?).never
+      topics.any? { true }
+    end
+  end
+
+  def test_any_should_not_fire_query_if_named_scope_loaded
+    topics = Topic.base
+    topics.collect # force load
+    assert_no_queries { assert topics.any? }
+  end
+
+  def test_should_build_with_proxy_options
+    topic = Topic.approved.build({})
+    assert topic.approved
+  end
+
+  def test_should_build_new_with_proxy_options
+    topic = Topic.approved.new
+    assert topic.approved
+  end
+
+  def test_should_create_with_proxy_options
+    topic = Topic.approved.create({})
+    assert topic.approved
+  end
+
+  def test_should_create_with_bang_with_proxy_options
+    topic = Topic.approved.create!({})
+    assert topic.approved
+  end
+  
+  def test_should_build_with_proxy_options_chained
+    topic = Topic.approved.by_lifo.build({})
+    assert topic.approved
+    assert_equal 'lifo', topic.author_name
+  end
+
+  def test_find_all_should_behave_like_select
+    assert_equal Topic.base.select(&:approved), Topic.base.find_all(&:approved)
+  end
+
+  def test_rand_should_select_a_random_object_from_proxy
+    assert Topic.approved.rand.is_a?(Topic)
+  end
+
+  def test_should_use_where_in_query_for_named_scope
+    assert_equal Developer.find_all_by_name('Jamis'), Developer.find_all_by_id(Developer.jamises)
+  end
+
+  def test_size_should_use_count_when_results_are_not_loaded
+    topics = Topic.base
+    assert_queries(1) do
+      assert_sql(/COUNT/i) { topics.size }
+    end
+  end
+
+  def test_size_should_use_length_when_results_are_loaded
+    topics = Topic.base
+    topics.reload # force load
+    assert_no_queries do
+      topics.size # use loaded (no query)
+    end
+  end
+
+  def test_chaining_with_duplicate_joins
+    join = "INNER JOIN comments ON comments.post_id = posts.id"
+    post = Post.find(1)
+    assert_equal post.comments.size, Post.scoped(:joins => join).scoped(:joins => join, :conditions => "posts.id = #{post.id}").size
+  end
+end