factorylabs-castronaut 0.7.5

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

@@ -0,0 +1,62 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+
+require 'config'
+require 'test/unit'
+
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_record/test_case'
+require 'connection'
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+# Quote "type" if it's a reserved word for the current connection.
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
+
+def current_adapter?(*types)
+  types.any? do |type|
+    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
+  end
+end
+
+def uses_mocha(description)
+  require 'rubygems'
+  require 'mocha'
+  yield
+rescue LoadError
+  $stderr.puts "Skipping #{description} tests. `gem install mocha` and try again."
+end
+
+ActiveRecord::Base.connection.class.class_eval do
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/]
+
+  def execute_with_query_record(sql, name = nil, &block)
+    $queries_executed ||= []
+    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_query_record(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :query_record
+end
+
+# Make with_scope public for tests
+class << ActiveRecord::Base
+  public :with_scope, :with_exclusive_scope
+end
+
+unless ENV['FIXTURE_DEBUG']
+  module Test #:nodoc:
+    module Unit #:nodoc:
+      class << TestCase #:nodoc:
+        def try_to_load_dependency_with_silence(*args)
+          ActiveRecord::Base.logger.silence { try_to_load_dependency_without_silence(*args)}
+        end
+
+        alias_method_chain :try_to_load_dependency, :silence
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
+
+class ActiveRecordI18nTests < Test::Unit::TestCase
+
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+  end
+  
+  def test_translated_model_attributes
+    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
+    assert_equal 'topic title attribute', Topic.human_attribute_name('title')
+  end
+
+  def test_translated_model_attributes_with_sti
+    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:reply => {:title => 'reply title attribute'} } }
+    assert_equal 'reply title attribute', Reply.human_attribute_name('title')
+  end
+
+  def test_translated_model_attributes_with_sti_fallback
+    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
+    assert_equal 'topic title attribute', Reply.human_attribute_name('title')
+  end
+
+  def test_translated_model_names
+    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
+    assert_equal 'topic model', Topic.human_name
+  end
+
+  def test_translated_model_names_with_sti
+    I18n.backend.store_translations 'en', :activerecord => {:models => {:reply => 'reply model'} }
+    assert_equal 'reply model', Reply.human_name
+  end
+
+  def test_translated_model_names_with_sti_fallback
+    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
+    assert_equal 'topic model', Reply.human_name
+  end
+end
+

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

@@ -0,0 +1,262 @@
+require "cases/helper"
+require 'models/company'
+require 'models/project'
+require 'models/subscriber'
+
+class InheritanceTest < ActiveRecord::TestCase
+  fixtures :companies, :projects, :subscribers, :accounts
+
+  def test_class_with_store_full_sti_class_returns_full_name
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    assert_equal 'Namespaced::Company', Namespaced::Company.sti_name
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_class_without_store_full_sti_class_returns_demodulized_name
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = false
+    assert_equal 'Company', Namespaced::Company.sti_name
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = false
+    item = Namespaced::Company.new
+    assert_equal 'Company', item[:type]
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+  
+  def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    item = Namespaced::Company.new
+    assert_equal 'Namespaced::Company', item[:type]
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+  
+  def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_class_option
+    old = ActiveRecord::Base.store_full_sti_class
+    ActiveRecord::Base.store_full_sti_class = true
+    item = Namespaced::Company.create :name => "Wolverine 2"
+    assert_not_nil Company.find(item.id)
+    assert_not_nil Namespaced::Company.find(item.id)
+  ensure
+    ActiveRecord::Base.store_full_sti_class = old
+  end
+
+  def test_company_descends_from_active_record
+    assert_raise(NoMethodError) { ActiveRecord::Base.descends_from_active_record? }
+    assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'
+    assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base'
+    assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base'
+  end
+
+  def test_a_bad_type_column
+    #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
+    if current_adapter?(:SybaseAdapter)
+      Company.connection.execute "SET IDENTITY_INSERT companies ON"
+    end
+    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
+
+    #We then need to turn it back Off before continuing.
+    if current_adapter?(:SybaseAdapter)
+      Company.connection.execute "SET IDENTITY_INSERT companies OFF"
+    end
+    assert_raises(ActiveRecord::SubclassNotFound) { Company.find(100) }
+  end
+
+  def test_inheritance_find
+    assert Company.find(1).kind_of?(Firm), "37signals should be a firm"
+    assert Firm.find(1).kind_of?(Firm), "37signals should be a firm"
+    assert Company.find(2).kind_of?(Client), "Summit should be a client"
+    assert Client.find(2).kind_of?(Client), "Summit should be a client"
+  end
+
+  def test_alt_inheritance_find
+    switch_to_alt_inheritance_column
+    test_inheritance_find
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_find_all
+    companies = Company.find(:all, :order => 'id')
+    assert companies[0].kind_of?(Firm), "37signals should be a firm"
+    assert companies[1].kind_of?(Client), "Summit should be a client"
+  end
+
+  def test_alt_inheritance_find_all
+    switch_to_alt_inheritance_column
+    test_inheritance_find_all
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_save
+    firm = Firm.new
+    firm.name = "Next Angle"
+    firm.save
+
+    next_angle = Company.find(firm.id)
+    assert next_angle.kind_of?(Firm), "Next Angle should be a firm"
+  end
+
+  def test_alt_inheritance_save
+    switch_to_alt_inheritance_column
+    test_inheritance_save
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_condition
+    assert_equal 9, Company.count
+    assert_equal 2, Firm.count
+    assert_equal 3, Client.count
+  end
+
+  def test_alt_inheritance_condition
+    switch_to_alt_inheritance_column
+    test_inheritance_condition
+    switch_to_default_inheritance_column
+  end
+
+  def test_finding_incorrect_type_data
+    assert_raises(ActiveRecord::RecordNotFound) { Firm.find(2) }
+    assert_nothing_raised   { Firm.find(1) }
+  end
+
+  def test_alt_finding_incorrect_type_data
+    switch_to_alt_inheritance_column
+    test_finding_incorrect_type_data
+    switch_to_default_inheritance_column
+  end
+
+  def test_update_all_within_inheritance
+    Client.update_all "name = 'I am a client'"
+    assert_equal "I am a client", Client.find(:all).first.name
+    assert_equal "37signals", Firm.find(:all).first.name
+  end
+
+  def test_alt_update_all_within_inheritance
+    switch_to_alt_inheritance_column
+    test_update_all_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_destroy_all_within_inheritance
+    Client.destroy_all
+    assert_equal 0, Client.count
+    assert_equal 2, Firm.count
+  end
+
+  def test_alt_destroy_all_within_inheritance
+    switch_to_alt_inheritance_column
+    test_destroy_all_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_find_first_within_inheritance
+    assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'")
+    assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'")
+    assert_nil Client.find(:first, :conditions => "name = '37signals'")
+  end
+
+  def test_alt_find_first_within_inheritance
+    switch_to_alt_inheritance_column
+    test_find_first_within_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_complex_inheritance
+    very_special_client = VerySpecialClient.create("name" => "veryspecial")
+    assert_equal very_special_client, VerySpecialClient.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'")
+    assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size
+    assert_equal very_special_client, Client.find(very_special_client.id)
+  end
+
+  def test_alt_complex_inheritance
+    switch_to_alt_inheritance_column
+    test_complex_inheritance
+    switch_to_default_inheritance_column
+  end
+
+  def test_eager_load_belongs_to_something_inherited
+    account = Account.find(1, :include => :firm)
+    assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed"
+  end
+
+  def test_eager_load_belongs_to_primary_key_quoting
+    con = Account.connection
+    assert_sql(/\(#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} = 1\)/) do
+      Account.find(1, :include => :firm)
+    end
+  end
+
+  def test_alt_eager_loading
+    switch_to_alt_inheritance_column
+    test_eager_load_belongs_to_something_inherited
+    switch_to_default_inheritance_column
+  end
+
+  def test_inheritance_without_mapping
+    assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
+    assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
+  end
+
+  private
+    def switch_to_alt_inheritance_column
+      # we don't want misleading test results, so get rid of the values in the type column
+      Company.find(:all, :order => 'id').each do |c|
+        c['type'] = nil
+        c.save
+      end
+      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
+      Company.set_inheritance_column('ruby_type')
+    end
+    def switch_to_default_inheritance_column
+      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
+      Company.set_inheritance_column('type')
+    end
+end
+
+
+class InheritanceComputeTypeTest < ActiveRecord::TestCase
+  fixtures :companies
+
+  def setup
+    ActiveSupport::Dependencies.log_activity = true
+  end
+
+  def teardown
+    ActiveSupport::Dependencies.log_activity = false
+    self.class.const_remove :FirmOnTheFly rescue nil
+    Firm.const_remove :FirmOnTheFly rescue nil
+  end
+
+  def test_instantiation_doesnt_try_to_require_corresponding_file
+    foo = Firm.find(:first).clone
+    foo.ruby_type = foo.type = 'FirmOnTheFly'
+    foo.save!
+
+    # Should fail without FirmOnTheFly in the type condition.
+    assert_raise(ActiveRecord::RecordNotFound) { Firm.find(foo.id) }
+
+    # Nest FirmOnTheFly in the test case where Dependencies won't see it.
+    self.class.const_set :FirmOnTheFly, Class.new(Firm)
+    assert_raise(ActiveRecord::SubclassNotFound) { Firm.find(foo.id) }
+
+    # Nest FirmOnTheFly in Firm where Dependencies will see it.
+    # This is analogous to nesting models in a migration.
+    Firm.const_set :FirmOnTheFly, Class.new(Firm)
+
+    # And instantiate will find the existing constant rather than trying
+    # to require firm_on_the_fly.
+    assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find(foo.id) }
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'cases/helper'
+require 'models/topic'
+
+class InvalidDateTest < Test::Unit::TestCase
+  def test_assign_valid_dates
+    valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
+
+    invalid_dates = [[2007, 11, 31], [1993, 2, 29], [2007, 2, 29]]
+
+    topic = Topic.new
+
+    valid_dates.each do |date_src|
+      topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
+      assert_equal(topic.last_read, Date.new(*date_src))
+    end
+
+    invalid_dates.each do |date_src|
+      assert_nothing_raised do
+        topic = Topic.new({"last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s})
+        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behaviour of the Time object")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+require "cases/helper"
+require 'models/contact'
+require 'models/post'
+require 'models/author'
+require 'models/tagging'
+require 'models/tag'
+require 'models/comment'
+
+class JsonSerializationTest < ActiveRecord::TestCase
+  class NamespacedContact < Contact
+    column :name,        :string
+  end
+
+  def setup
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :avatar      => 'binarydata',
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+  end
+
+  def test_should_demodulize_root_in_json
+    NamespacedContact.include_root_in_json = true
+    @contact = NamespacedContact.new :name => 'whatever'
+    json = @contact.to_json
+    assert_match %r{^\{"namespaced_contact": \{}, json
+  end
+
+  def test_should_include_root_in_json
+    Contact.include_root_in_json = true
+    json = @contact.to_json
+
+    assert_match %r{^\{"contact": \{}, json
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome": true}, json
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  ensure
+    Contact.include_root_in_json = false
+  end
+
+  def test_should_encode_all_encodable_attributes
+    json = @contact.to_json
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome": true}, json
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_only
+    json = @contact.to_json(:only => [:name, :age])
+
+    assert_match %r{"name": "Konata Izumi"}, json
+    assert_match %r{"age": 16}, json
+    assert_no_match %r{"awesome": true}, json
+    assert !json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_no_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_should_allow_attribute_filtering_with_except
+    json = @contact.to_json(:except => [:name, :age])
+
+    assert_no_match %r{"name": "Konata Izumi"}, json
+    assert_no_match %r{"age": 16}, json
+    assert_match %r{"awesome": true}, json
+    assert json.include?(%("created_at": #{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"preferences": \{"shows": "anime"\}}, json
+  end
+
+  def test_methods_are_called_on_object
+    # Define methods on fixture.
+    def @contact.label; "Has cheezburger"; end
+    def @contact.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_match %r{"label": "Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{"label": "Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote": "Constraints are liberating"}, methods_json
+  end
+end
+
+class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
+  fixtures :authors, :posts, :comments, :tags, :taggings
+
+  def setup
+    @david = authors(:david)
+    @mary = authors(:mary)
+  end
+
+  def test_includes_uses_association_name
+    json = @david.to_json(:include => :posts)
+
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"id": 1}, json
+    assert_match %r{"name": "David"}, json
+
+    assert_match %r{"author_id": 1}, json
+    assert_match %r{"title": "Welcome to the weblog"}, json
+    assert_match %r{"body": "Such a lovely day"}, json
+
+    assert_match %r{"title": "So I was thinking"}, json
+    assert_match %r{"body": "Like I hopefully always am"}, json
+  end
+
+  def test_includes_uses_association_name_and_applies_attribute_filters
+    json = @david.to_json(:include => { :posts => { :only => :title } })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"title": "Welcome to the weblog"}, json
+    assert_no_match %r{"body": "Such a lovely day"}, json
+
+    assert_match %r{"title": "So I was thinking"}, json
+    assert_no_match %r{"body": "Like I hopefully always am"}, json
+  end
+
+  def test_includes_fetches_second_level_associations
+    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"comments": \[}, json
+    assert_match %r{\{"body": "Thank you again for the welcome"\}}, json
+    assert_match %r{\{"body": "Don't think too hard"\}}, json
+    assert_no_match %r{"post_id": }, json
+  end
+
+  def test_includes_fetches_nth_level_associations
+    json = @david.to_json(
+      :include => {
+        :posts => {
+          :include => {
+            :taggings => {
+              :include => {
+                :tag => { :only => :name }
+              }
+            }
+          }
+        }
+    })
+
+    assert_match %r{"name": "David"}, json
+    assert_match %r{"posts": \[}, json
+
+    assert_match %r{"taggings": \[}, json
+    assert_match %r{"tag": \{"name": "General"\}}, json
+  end
+
+  def test_should_not_call_methods_on_associations_that_dont_respond
+    def @david.favorite_quote; "Constraints are liberating"; end
+    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
+
+    assert !@david.posts.first.respond_to?(:favorite_quote)
+    assert_match %r{"favorite_quote": "Constraints are liberating"}, json
+    assert_equal %r{"favorite_quote": }.match(json).size, 1
+  end
+
+  def test_should_allow_only_option_for_list_of_authors
+    authors = [@david, @mary]
+
+    assert_equal %([{"name": "David"}, {"name": "Mary"}]), authors.to_json(:only => :name)
+  end
+
+  def test_should_allow_except_option_for_list_of_authors
+    authors = [@david, @mary]
+
+    assert_equal %([{"id": 1}, {"id": 2}]), authors.to_json(:except => [:name, :author_address_id, :author_address_extra_id])
+  end
+
+  def test_should_allow_includes_for_list_of_authors
+    authors = [@david, @mary]
+    json = authors.to_json(
+      :only => :name,
+      :include => {
+        :posts => { :only => :id }
+      }
+    )
+
+    ['"name": "David"', '"posts": [', '{"id": 1}', '{"id": 2}', '{"id": 4}',
+     '{"id": 5}', '{"id": 6}', '"name": "Mary"', '"posts": [{"id": 7}]'].each do |fragment|
+      assert json.include?(fragment), json
+     end
+  end
+
+  def test_should_allow_options_for_hash_of_authors
+    authors_hash = {
+      1 => @david,
+      2 => @mary
+    }
+
+    assert_equal %({1: {"name": "David"}}), authors_hash.to_json(:only => [1, :name])
+  end
+end