simply_stated 0.0.3 → 0.0.4

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/pooled_connections_test.rb

@@ -0,0 +1,103 @@
+require "cases/helper"
+
+class PooledConnectionsTest < ActiveRecord::TestCase
+  def setup
+    super
+    @connection = ActiveRecord::Base.remove_connection
+  end
+
+  def teardown
+    ActiveRecord::Base.clear_all_connections!
+    ActiveRecord::Base.establish_connection(@connection)
+    super
+  end
+
+  def checkout_connections
+    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 2, :wait_timeout => 0.3}))
+    @connections = []
+    @timed_out = 0
+
+    4.times do
+      Thread.new do
+        begin
+          @connections << ActiveRecord::Base.connection_pool.checkout
+        rescue ActiveRecord::ConnectionTimeoutError
+          @timed_out += 1
+        end
+      end.join
+    end
+  end
+
+  # Will deadlock due to lack of Monitor timeouts in 1.9
+  if RUBY_VERSION < '1.9'
+    def test_pooled_connection_checkout
+      checkout_connections
+      assert_equal @connections.length, 2
+      assert_equal @timed_out, 2
+    end
+  end
+
+  def checkout_checkin_connections(pool_size, threads)
+    ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :wait_timeout => 0.5}))
+    @connection_count = 0
+    @timed_out = 0
+    threads.times do
+      Thread.new do
+        begin
+          conn = ActiveRecord::Base.connection_pool.checkout
+          sleep 0.1
+          ActiveRecord::Base.connection_pool.checkin conn
+          @connection_count += 1
+        rescue ActiveRecord::ConnectionTimeoutError
+          @timed_out += 1
+        end
+      end.join
+    end
+  end
+
+  def test_pooled_connection_checkin_one
+    checkout_checkin_connections 1, 2
+    assert_equal 2, @connection_count
+    assert_equal 0, @timed_out
+  end
+
+  def test_pooled_connection_checkin_two
+    checkout_checkin_connections 2, 3
+    assert_equal 3, @connection_count
+    assert_equal 0, @timed_out
+  end
+
+  def test_pooled_connection_checkout_existing_first
+    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 1}))
+    conn_pool = ActiveRecord::Base.connection_pool
+    conn = conn_pool.checkout
+    conn_pool.checkin(conn)
+    conn = conn_pool.checkout
+    assert ActiveRecord::ConnectionAdapters::AbstractAdapter === conn
+    conn_pool.checkin(conn)
+  end
+
+  def test_not_connected_defined_connection_returns_false
+    ActiveRecord::Base.establish_connection(@connection)
+    assert ! ActiveRecord::Base.connected?
+  end
+
+  def test_undefined_connection_returns_false
+    old_handler = ActiveRecord::Base.connection_handler
+    ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
+    assert_equal false, ActiveRecord::Base.connected?
+  ensure
+    ActiveRecord::Base.connection_handler = old_handler
+  end
+end unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
+
+class AllowConcurrencyDeprecatedTest < ActiveRecord::TestCase
+  def test_allow_concurrency_is_deprecated
+    assert_deprecated('ActiveRecord::Base.allow_concurrency') do
+      ActiveRecord::Base.allow_concurrency
+    end
+    assert_deprecated('ActiveRecord::Base.allow_concurrency=') do
+      ActiveRecord::Base.allow_concurrency = true
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/query_cache_test.rb

@@ -0,0 +1,123 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/reply'
+require 'models/task'
+require 'models/course'
+require 'models/category'
+require 'models/post'
+
+
+class QueryCacheTest < ActiveRecord::TestCase
+  fixtures :tasks, :topics, :categories, :posts, :categories_posts
+
+  def test_find_queries
+    assert_queries(2) { Task.find(1); Task.find(1) }
+  end
+
+  def test_find_queries_with_cache
+    Task.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    end
+  end
+
+  def test_count_queries_with_cache
+    Task.cache do
+      assert_queries(1) { Task.count; Task.count }
+    end
+  end
+
+  def test_query_cache_dups_results_correctly
+    Task.cache do
+      now  = Time.now.utc
+      task = Task.find 1
+      assert_not_equal now, task.starting
+      task.starting = now
+      task.reload
+      assert_not_equal now, task.starting
+    end
+  end
+
+  def test_cache_is_flat
+    Task.cache do
+      Topic.columns # don't count this query
+      assert_queries(1) { Topic.find(1); Topic.find(1); }
+    end
+
+    ActiveRecord::Base.cache do
+      assert_queries(1) { Task.find(1); Task.find(1) }
+    end
+  end
+
+  def test_cache_does_not_wrap_string_results_in_arrays
+    Task.cache do
+      assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
+    end
+  end
+end
+
+class QueryCacheExpiryTest < ActiveRecord::TestCase
+  fixtures :tasks, :posts, :categories, :categories_posts
+
+  def test_find
+    Task.connection.expects(:clear_query_cache).times(1)
+
+    assert !Task.connection.query_cache_enabled
+    Task.cache do
+      assert Task.connection.query_cache_enabled
+      Task.find(1)
+
+      Task.uncached do
+        assert !Task.connection.query_cache_enabled
+        Task.find(1)
+      end
+
+      assert Task.connection.query_cache_enabled
+    end
+    assert !Task.connection.query_cache_enabled
+  end
+
+  def test_update
+    Task.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      task = Task.find(1)
+      task.starting = Time.now.utc
+      task.save!
+    end
+  end
+
+  def test_destroy
+    Task.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      Task.find(1).destroy
+    end
+  end
+
+  def test_insert
+    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+
+    Task.cache do
+      Task.create!
+    end
+  end
+
+  def test_cache_is_expired_by_habtm_update
+    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+    ActiveRecord::Base.cache do
+      c = Category.find(:first)
+      p = Post.find(:first)
+      p.categories << c
+    end
+  end
+
+  def test_cache_is_expired_by_habtm_delete
+    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
+    ActiveRecord::Base.cache do
+      c = Category.find(1)
+      p = Post.find(1)
+      assert p.categories.any?
+      p.categories.delete_all
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/readonly_test.rb

@@ -0,0 +1,107 @@
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+require 'models/developer'
+require 'models/project'
+require 'models/reader'
+require 'models/person'
+
+# Dummy class methods to test implicit association scoping.
+def Comment.foo() find :first end
+def Project.foo() find :first end
+
+
+class ReadOnlyTest < ActiveRecord::TestCase
+  fixtures :posts, :comments, :developers, :projects, :developers_projects
+
+  def test_cant_save_readonly_record
+    dev = Developer.find(1)
+    assert !dev.readonly?
+
+    dev.readonly!
+    assert dev.readonly?
+
+    assert_nothing_raised do
+      dev.name = 'Luscious forbidden fruit.'
+      assert !dev.save
+      dev.name = 'Forbidden.'
+    end
+    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
+    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
+  end
+
+
+  def test_find_with_readonly_option
+    Developer.find(:all).each { |d| assert !d.readonly? }
+    Developer.find(:all, :readonly => false).each { |d| assert !d.readonly? }
+    Developer.find(:all, :readonly => true).each { |d| assert d.readonly? }
+  end
+
+
+  def test_find_with_joins_option_implies_readonly
+    # Blank joins don't count.
+    Developer.find(:all, :joins => '  ').each { |d| assert !d.readonly? }
+    Developer.find(:all, :joins => '  ', :readonly => false).each { |d| assert !d.readonly? }
+
+    # Others do.
+    Developer.find(:all, :joins => ', projects').each { |d| assert d.readonly? }
+    Developer.find(:all, :joins => ', projects', :readonly => false).each { |d| assert !d.readonly? }
+  end
+
+
+  def test_habtm_find_readonly
+    dev = Developer.find(1)
+    assert !dev.projects.empty?
+    assert dev.projects.all?(&:readonly?)
+    assert dev.projects.find(:all).all?(&:readonly?)
+    assert dev.projects.find(:all, :readonly => true).all?(&:readonly?)
+  end
+
+  def test_has_many_find_readonly
+    post = Post.find(1)
+    assert !post.comments.empty?
+    assert !post.comments.any?(&:readonly?)
+    assert !post.comments.find(:all).any?(&:readonly?)
+    assert post.comments.find(:all, :readonly => true).all?(&:readonly?)
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly
+    assert people = Post.find(1).people
+    assert !people.any?(&:readonly?)
+  end
+
+  def test_readonly_scoping
+    Post.with_scope(:find => { :conditions => '1=1' }) do
+      assert !Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+
+    Post.with_scope(:find => { :joins => '   ' }) do
+      assert !Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+
+    # Oracle barfs on this because the join includes unqualified and
+    # conflicting column names
+    unless current_adapter?(:OracleAdapter)
+      Post.with_scope(:find => { :joins => ', developers' }) do
+        assert Post.find(1).readonly?
+        assert Post.find(1, :readonly => true).readonly?
+        assert !Post.find(1, :readonly => false).readonly?
+      end
+    end
+
+    Post.with_scope(:find => { :readonly => true }) do
+      assert Post.find(1).readonly?
+      assert Post.find(1, :readonly => true).readonly?
+      assert !Post.find(1, :readonly => false).readonly?
+    end
+  end
+
+  def test_association_collection_method_missing_scoping_not_readonly
+    assert !Developer.find(1).projects.foo.readonly?
+    assert !Post.find(1).comments.foo.readonly?
+  end
+end

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/reflection_test.rb

@@ -0,0 +1,194 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/customer'
+require 'models/company'
+require 'models/company_in_module'
+require 'models/subscriber'
+require 'models/pirate'
+
+class ReflectionTest < ActiveRecord::TestCase
+  fixtures :topics, :customers, :companies, :subscribers
+
+  def setup
+    @first = Topic.find(1)
+  end
+
+  def test_column_null_not_null
+    subscriber = Subscriber.find(:first)
+    assert subscriber.column_for_attribute("name").null
+    assert !subscriber.column_for_attribute("nick").null
+  end
+
+  def test_read_attribute_names
+    assert_equal(
+      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id parent_title type ).sort,
+      @first.attribute_names
+    )
+  end
+
+  def test_columns
+    assert_equal 13, Topic.columns.length
+  end
+
+  def test_columns_are_returned_in_the_order_they_were_declared
+    column_names = Topic.columns.map { |column| column.name }
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type), column_names
+  end
+
+  def test_content_columns
+    content_columns        = Topic.content_columns
+    content_column_names   = content_columns.map {|column| column.name}
+    assert_equal 9, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved parent_title).sort, content_column_names.sort
+  end
+
+  def test_column_string_type_and_limit
+    assert_equal :string, @first.column_for_attribute("title").type
+    assert_equal 255, @first.column_for_attribute("title").limit
+  end
+
+  def test_column_null_not_null
+    subscriber = Subscriber.find(:first)
+    assert subscriber.column_for_attribute("name").null
+    assert !subscriber.column_for_attribute("nick").null
+  end
+
+  def test_human_name_for_column
+    assert_equal "Author name", @first.column_for_attribute("author_name").human_name
+  end
+
+  def test_integer_columns
+    assert_equal :integer, @first.column_for_attribute("id").type
+  end
+
+  def test_reflection_klass_for_nested_class_name
+    reflection = ActiveRecord::Reflection::MacroReflection.new(nil, nil, { :class_name => 'MyApplication::Business::Company' }, nil)
+    assert_nothing_raised do
+      assert_equal MyApplication::Business::Company, reflection.klass
+    end
+  end
+
+  def test_aggregation_reflection
+    reflection_for_address = ActiveRecord::Reflection::AggregateReflection.new(
+      :composed_of, :address, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
+    )
+
+    reflection_for_balance = ActiveRecord::Reflection::AggregateReflection.new(
+      :composed_of, :balance, { :class_name => "Money", :mapping => %w(balance amount) }, Customer
+    )
+
+    reflection_for_gps_location = ActiveRecord::Reflection::AggregateReflection.new(
+      :composed_of, :gps_location, { }, Customer
+    )
+
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
+
+    assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
+
+    assert_equal Address, Customer.reflect_on_aggregation(:address).klass
+
+    assert_equal Money, Customer.reflect_on_aggregation(:balance).klass
+  end
+
+  def test_reflect_on_all_autosave_associations
+    expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
+    received = Pirate.reflect_on_all_autosave_associations
+
+    assert !received.empty?
+    assert_not_equal Pirate.reflect_on_all_associations.length, received.length
+    assert_equal expected, received
+  end
+
+  def test_has_many_reflection
+    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => :destroy }, Firm)
+
+    assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
+
+    assert_equal Client, Firm.reflect_on_association(:clients).klass
+    assert_equal 'companies', Firm.reflect_on_association(:clients).table_name
+
+    assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass
+    assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name
+  end
+
+  def test_has_one_reflection
+    reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => :destroy }, Firm)
+    assert_equal reflection_for_account, Firm.reflect_on_association(:account)
+
+    assert_equal Account, Firm.reflect_on_association(:account).klass
+    assert_equal 'accounts', Firm.reflect_on_association(:account).table_name
+  end
+
+  def test_belongs_to_inferred_foreign_key_from_assoc_name
+    Company.belongs_to :foo
+    assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name
+    Company.belongs_to :bar, :class_name => "Xyzzy"
+    assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name
+    Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
+    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name
+  end
+
+  def test_association_reflection_in_modules
+    assert_reflection MyApplication::Business::Firm,
+      :clients_of_firm,
+      :klass      => MyApplication::Business::Client,
+      :class_name => 'Client',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :firm,
+      :klass      => MyApplication::Business::Firm,
+      :class_name => 'MyApplication::Business::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :qualified_billing_firm,
+      :klass      => MyApplication::Billing::Firm,
+      :class_name => 'MyApplication::Billing::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :unqualified_billing_firm,
+      :klass      => MyApplication::Billing::Firm,
+      :class_name => 'Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :nested_qualified_billing_firm,
+      :klass      => MyApplication::Billing::Nested::Firm,
+      :class_name => 'MyApplication::Billing::Nested::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :nested_unqualified_billing_firm,
+      :klass      => MyApplication::Billing::Nested::Firm,
+      :class_name => 'Nested::Firm',
+      :table_name => 'companies'
+  end
+
+  def test_reflection_of_all_associations
+    # FIXME these assertions bust a lot
+    assert_equal 36, Firm.reflect_on_all_associations.size
+    assert_equal 26, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
+    assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
+  end
+
+  def test_reflection_should_not_raise_error_when_compared_to_other_object
+    assert_nothing_raised { Firm.reflections[:clients] == Object.new }
+  end
+
+  def test_has_many_through_reflection
+    assert_kind_of ActiveRecord::Reflection::ThroughReflection, Subscriber.reflect_on_association(:books)
+  end
+
+  private
+    def assert_reflection(klass, association, options)
+      assert reflection = klass.reflect_on_association(association)
+      options.each do |method, value|
+        assert_equal(value, reflection.send(method))
+      end
+    end
+end

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/reload_models_test.rb

@@ -0,0 +1,22 @@
+require "cases/helper"
+require 'models/owner'
+require 'models/pet'
+
+class ReloadModelsTest < ActiveRecord::TestCase
+  fixtures :pets
+
+  def test_has_one_with_reload
+    pet = Pet.find_by_name('parrot')
+    pet.owner = Owner.find_by_name('ashley')
+
+    # Reload the class Owner, simulating auto-reloading of model classes in a
+    # development environment. Note that meanwhile the class Pet is not
+    # reloaded, simulating a class that is present in a plugin.
+    Object.class_eval { remove_const :Owner }
+    Kernel.load(File.expand_path(File.join(File.dirname(__FILE__), "../models/owner.rb")))
+
+    pet = Pet.find_by_name('parrot')
+    pet.owner = Owner.find_by_name('ashley')
+    assert_equal pet.owner, Owner.find_by_name('ashley')
+  end
+end

data/vendor/gems/ruby/1.8/gems/activerecord-2.3.5/test/cases/repair_helper.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Testing
+    module RepairHelper
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+
+      module Toolbox
+        def self.record_validations(*model_classes)
+          model_classes.inject({}) do |repair, klass|
+            repair[klass] ||= {}
+            [:validate, :validate_on_create, :validate_on_update].each do |callback|
+              the_callback = klass.instance_variable_get("@#{callback.to_s}_callbacks")
+              repair[klass][callback] = (the_callback.nil? ? nil : the_callback.dup)
+            end
+            repair
+          end
+        end
+
+        def self.reset_validations(recorded)
+          recorded.each do |klass, repairs|
+            [:validate, :validate_on_create, :validate_on_update].each do |callback|
+              klass.instance_variable_set("@#{callback.to_s}_callbacks", repairs[callback])
+            end
+          end
+        end
+      end
+
+      module ClassMethods
+        def repair_validations(*model_classes)
+          setup do
+            @validation_repairs = ActiveRecord::Testing::RepairHelper::Toolbox.record_validations(*model_classes)
+          end
+          teardown do
+            ActiveRecord::Testing::RepairHelper::Toolbox.reset_validations(@validation_repairs)
+          end
+        end
+      end
+
+      def repair_validations(*model_classes, &block)
+        validation_repairs = ActiveRecord::Testing::RepairHelper::Toolbox.record_validations(*model_classes)
+        return block.call
+      ensure
+        ActiveRecord::Testing::RepairHelper::Toolbox.reset_validations(validation_repairs)
+      end
+    end
+  end
+end