RubyGems - backlog - Versions diffs - 0.0.2 → 0.0.3 - Mend

backlog 0.0.2 → 0.0.3

Files changed (1451) hide show

data/vendor/rails/activerecord/test/datatype_test_postgresql.rb DELETED Viewed

@@ -1,52 +0,0 @@
-require 'abstract_unit'
-class PostgresqlDatatype < ActiveRecord::Base
-end
-class PGDataTypeTest < Test::Unit::TestCase
-  self.use_transactional_fixtures = false
-  TABLE_NAME = 'postgresql_datatypes'
-  COLUMNS = [
-    'id SERIAL PRIMARY KEY',
-    'commission_by_quarter INTEGER[]',
-    'nicknames TEXT[]'
-  ]
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "INSERT INTO #{TABLE_NAME} (commission_by_quarter, nicknames) VALUES ( '{35000,21000,18000,17000}', '{foo,bar,baz}' )"
-    @first = PostgresqlDatatype.find( 1 )
-  end
-  def teardown
-    @connection.execute "DROP TABLE #{TABLE_NAME}"
-  end
-  def test_data_type_of_array_types
-    assert_equal :string, @first.column_for_attribute("commission_by_quarter").type
-    assert_equal :string, @first.column_for_attribute("nicknames").type
-  end
-  def test_array_values
-    assert_equal '{35000,21000,18000,17000}', @first.commission_by_quarter
-    assert_equal '{foo,bar,baz}', @first.nicknames
-  end
-  def test_update_integer_array
-    new_value = '{32800,95000,29350,17000}'
-    assert @first.commission_by_quarter = new_value
-    assert @first.save
-    assert @first.reload
-    assert_equal @first.commission_by_quarter, new_value
-  end
-  def test_update_text_array
-    new_value = '{robby,robert,rob,robbie}'
-    assert @first.nicknames = new_value
-    assert @first.save
-    assert @first.reload
-    assert_equal @first.nicknames, new_value
-  end
-end

data/vendor/rails/activerecord/test/default_test_firebird.rb DELETED Viewed

@@ -1,16 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/default'
-class DefaultTest < Test::Unit::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/rails/activerecord/test/defaults_test.rb DELETED Viewed

@@ -1,60 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/default'
-require 'fixtures/entrant'
-class DefaultTest < Test::Unit::TestCase
-  def test_nil_defaults_for_not_null_columns
-    column_defaults =
-      if current_adapter?(:MysqlAdapter)
-        { '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
-      assert_equal nil, 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
-end

data/vendor/rails/activerecord/test/deprecated_associations_test.rb DELETED Viewed

@@ -1,396 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/developer'
-require 'fixtures/project'
-require 'fixtures/company'
-require 'fixtures/topic'
-require 'fixtures/reply'
-# Can't declare new classes in test case methods, so tests before that
-bad_collection_keys = false
-begin
-  class Car < ActiveRecord::Base; has_many :wheels, :name => "wheels"; end
-rescue ArgumentError
-  bad_collection_keys = true
-end
-raise "ActiveRecord should have barked on bad collection keys" unless bad_collection_keys
-class DeprecatedAssociationWarningsTest < Test::Unit::TestCase
-  def test_deprecation_warnings
-    assert_deprecated('find_first') { Firm.find_first }
-    assert_deprecated('find_all') { Firm.find_all }
-    assert_deprecated('has_account?') { Firm.find(:first).has_account? }
-    assert_deprecated('has_clients?') { Firm.find(:first).has_clients? }
-  end
-end
-class DeprecatedAssociationsTest < Test::Unit::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :topics,
-           :developers_projects
-  def setup
-    @firm = companies(:first_firm)
-  end
-  def test_has_many_find
-    assert_equal 2, @firm.clients.length
-  end
-  def test_has_many_orders
-    assert_equal "Summit", @firm.clients.first.name
-  end
-  def test_has_many_class_name
-    assert_equal "Microsoft", @firm.clients_sorted_desc.first.name
-  end
-  def test_has_many_foreign_key
-    assert_equal "Microsoft", @firm.clients_of_firm.first.name
-  end
-  def test_has_many_conditions
-    assert_equal "Microsoft", @firm.clients_like_ms.first.name
-  end
-  def test_has_many_sql
-    assert_equal "Microsoft", @firm.clients_using_sql.first.name
-    assert_equal 1, @firm.clients_using_sql.count
-    assert_equal 1, @firm.clients_using_sql.count
-  end
-  def test_has_many_counter_sql
-    assert_equal 1, @firm.clients_using_counter_sql.count
-  end
-  def test_has_many_queries
-    assert !@firm.clients.loaded?
-    assert_deprecated 'has_clients?' do
-      assert_queries(1) { assert @firm.has_clients? }
-    end
-    assert !@firm.clients.loaded?
-    assert_deprecated 'clients_count' do
-      assert_queries(1) { assert_equal 2, @firm.clients_count }
-    end
-    assert !@firm.clients.loaded?
-    assert_queries(1) { @firm.clients.size }
-    assert !@firm.clients.loaded?
-    assert_queries(0) { @firm.clients }
-    assert !@firm.clients.loaded?
-    assert_queries(1) { @firm.clients.reload }
-    assert @firm.clients.loaded?
-    assert_queries(0) { @firm.clients.size }
-    assert_queries(1) { @firm.clients.count }
-  end
-  def test_has_many_dependence
-    count = Client.count
-    Firm.find(:first).destroy
-    assert_equal count - 2, Client.count
-  end
-  uses_transaction :test_has_many_dependence_with_transaction_support_on_failure
-  def test_has_many_dependence_with_transaction_support_on_failure
-    count = Client.count
-    clients = @firm.clients
-    clients.last.instance_eval { def before_destroy() raise "Trigger rollback" end }
-    @firm.destroy rescue "do nothing"
-    assert_equal count, Client.count
-  end
-  def test_has_one_dependence
-    num_accounts = Account.count
-    assert_not_nil @firm.account
-    @firm.destroy
-    assert_equal num_accounts - 1, Account.count
-  end
-  def test_has_one_dependence_with_missing_association
-    Account.destroy_all
-    assert_nil @firm.account
-    @firm.destroy
-  end
-  def test_belongs_to
-    client = companies(:second_client)
-    assert_deprecated('has_firm?') do
-      assert companies(:second_client).has_firm?, "Microsoft should have a firm"
-    end
-    assert_equal companies(:first_firm), client.firm, "Microsoft should have a firm"
-  end
-  def test_belongs_to_with_different_class_name
-    assert_equal @firm, companies(:second_client).firm_with_other_name
-  end
-  def test_belongs_to_with_condition
-    assert_equal @firm, companies(:second_client).firm_with_condition
-  end
-  def test_belongs_to_equality
-    assert_equal @firm, companies(:second_client).firm, 'Microsoft should have 37signals as firm'
-  end
-  def test_has_one
-    assert_equal accounts(:signals37), @firm.account
-    assert_deprecated 'has_account?' do
-      assert @firm.has_account?, "37signals should have an account"
-    end
-    assert_deprecated 'firm?' do
-      assert accounts(:signals37).firm?(@firm), "37signals account should be able to backtrack"
-    end
-    assert_deprecated 'has_firm?' do
-      assert accounts(:signals37).has_firm?, "37signals account should be able to backtrack"
-    end
-    assert_nil accounts(:unknown).firm, "Unknown isn't linked"
-  end
-  def test_has_many_dependence_on_account
-    num_accounts = Account.count
-    @firm.destroy
-    assert_equal num_accounts - 1, Account.count
-  end
-  def test_find_in
-    assert_deprecated 'find_in_clients' do
-      assert_equal companies(:first_client), @firm.find_in_clients(2)
-      assert_raises(ActiveRecord::RecordNotFound) { @firm.find_in_clients(6) }
-    end
-  end
-  def test_force_reload
-    ActiveSupport::Deprecation.silence do
-      firm = Firm.new("name" => "A New Firm, Inc")
-      firm.save
-      firm.clients.each {|c|} # forcing to load all clients
-      assert firm.clients.empty?, "New firm shouldn't have client objects"
-      assert !firm.has_clients?, "New firm shouldn't have clients"
-      assert_equal 0, firm.clients_count, "New firm should have 0 clients"
-      client = Client.new("name" => "TheClient.com", "firm_id" => firm.id)
-      client.save
-      assert firm.clients.empty?, "New firm should have cached no client objects"
-      assert !firm.has_clients?, "New firm should have cached a no-clients response"
-      assert_equal 0, firm.clients_count, "New firm should have cached 0 clients count"
-      assert !firm.clients(true).empty?, "New firm should have reloaded client objects"
-      assert firm.has_clients?(true), "New firm should have reloaded with a have-clients response"
-      assert_equal 1, firm.clients_count(true), "New firm should have reloaded clients count"
-    end
-  end
-  def test_included_in_collection
-    assert @firm.clients.include?(Client.find(2))
-  end
-  def test_build_to_collection
-    count = @firm.clients_of_firm.count
-    new_client = nil
-    assert_deprecated 'build_to_clients_of_firm' do
-      new_client = @firm.build_to_clients_of_firm("name" => "Another Client")
-    end
-    assert_equal "Another Client", new_client.name
-    assert new_client.save
-    assert_equal @firm, new_client.firm
-    assert_equal count + 1, @firm.clients_of_firm.count
-  end
-  def test_create_in_collection
-    assert_deprecated 'create_in_clients_of_firm' do
-      assert_equal @firm.create_in_clients_of_firm("name" => "Another Client"), @firm.clients_of_firm(true).last
-    end
-  end
-  def test_has_and_belongs_to_many
-    david = Developer.find(1)
-    assert_deprecated 'has_projects?' do
-      assert david.has_projects?
-    end
-    assert_deprecated 'projects_count' do
-      assert_equal 2, david.projects_count
-    end
-    active_record = Project.find(1)
-    assert_deprecated 'has_developers?' do
-      assert active_record.has_developers?
-    end
-    assert_deprecated 'developers_count' do
-      assert_equal 3, active_record.developers_count
-    end
-    assert active_record.developers.include?(david)
-  end
-  def test_has_and_belongs_to_many_removing
-    david = Developer.find(1)
-    active_record = Project.find(1)
-    assert_deprecated do
-      david.remove_projects(active_record)
-      assert_equal 1, david.projects_count
-      assert_equal 2, active_record.developers_count
-    end
-  end
-  def test_has_and_belongs_to_many_zero
-    david = Developer.find(1)
-    assert_deprecated do
-      david.remove_projects Project.find_all
-      assert_equal 0, david.projects_count
-      assert !david.has_projects?
-    end
-  end
-  def test_has_and_belongs_to_many_adding
-    jamis = Developer.find(2)
-    action_controller = Project.find(2)
-    assert_deprecated do
-      jamis.add_projects(action_controller)
-      assert_equal 2, jamis.projects_count
-      assert_equal 2, action_controller.developers_count
-    end
-  end
-  def test_has_and_belongs_to_many_adding_from_the_project
-    jamis = Developer.find(2)
-    action_controller = Project.find(2)
-    assert_deprecated do
-      action_controller.add_developers(jamis)
-      assert_equal 2, jamis.projects_count
-      assert_equal 2, action_controller.developers_count
-    end
-  end
-  def test_has_and_belongs_to_many_adding_a_collection
-    aredridel = Developer.new("name" => "Aredridel")
-    aredridel.save
-    assert_deprecated do
-      aredridel.add_projects([ Project.find(1), Project.find(2) ])
-      assert_equal 2, aredridel.projects_count
-    end
-  end
-  def test_belongs_to_counter
-    topic = Topic.create("title" => "Apple", "content" => "hello world")
-    assert_equal 0, topic.send(:read_attribute, "replies_count"), "No replies yet"
-    reply = assert_deprecated { topic.create_in_replies("title" => "I'm saying no!", "content" => "over here") }
-    assert_equal 1, Topic.find(topic.id).send(:read_attribute, "replies_count"), "First reply created"
-    reply.destroy
-    assert_equal 0, Topic.find(topic.id).send(:read_attribute, "replies_count"), "First reply deleted"
-  end
-  def test_natural_assignment_of_has_one
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    apple.account = citibank
-    assert_equal apple.id, citibank.firm_id
-  end
-  def test_natural_assignment_of_belongs_to
-    apple = Firm.create("name" => "Apple")
-    citibank = Account.create("credit_limit" => 10)
-    citibank.firm = apple
-    assert_equal apple.id, citibank.firm_id
-  end
-  def test_natural_assignment_of_has_many
-    apple = Firm.create("name" => "Apple")
-    natural = Client.create("name" => "Natural Company")
-    apple.clients << natural
-    assert_equal apple.id, natural.firm_id
-    assert_equal Client.find(natural.id), Firm.find(apple.id).clients.find(natural.id)
-    apple.clients.delete natural
-    assert_raises(ActiveRecord::RecordNotFound) {
-      Firm.find(apple.id).clients.find(natural.id)
-    }
-  end
-  def test_natural_adding_of_has_and_belongs_to_many
-    rails = Project.create("name" => "Rails")
-    ap = Project.create("name" => "Action Pack")
-    john = Developer.create("name" => "John")
-    mike = Developer.create("name" => "Mike")
-    rails.developers << john
-    rails.developers << mike
-    assert_equal Developer.find(john.id), Project.find(rails.id).developers.find(john.id)
-    assert_equal Developer.find(mike.id), Project.find(rails.id).developers.find(mike.id)
-    assert_equal Project.find(rails.id), Developer.find(mike.id).projects.find(rails.id)
-    assert_equal Project.find(rails.id), Developer.find(john.id).projects.find(rails.id)
-    ap.developers << john
-    assert_equal Developer.find(john.id), Project.find(ap.id).developers.find(john.id)
-    assert_equal Project.find(ap.id), Developer.find(john.id).projects.find(ap.id)
-    ap.developers.delete john
-    assert_raises(ActiveRecord::RecordNotFound) {
-      Project.find(ap.id).developers.find(john.id)
-    }
-    assert_raises(ActiveRecord::RecordNotFound) {
-      Developer.find(john.id).projects.find(ap.id)
-    }
-  end
-  def test_storing_in_pstore
-    require "pstore"
-    require "tmpdir"
-    apple = Firm.create("name" => "Apple")
-    natural = Client.new("name" => "Natural Company")
-    apple.clients << natural
-    db = PStore.new(File.join(Dir.tmpdir, "ar-pstore-association-test"))
-    db.transaction do
-      db["apple"] = apple
-    end
-    db = PStore.new(File.join(Dir.tmpdir, "ar-pstore-association-test"))
-    db.transaction do
-      assert_equal "Natural Company", db["apple"].clients.first.name
-    end
-  end
-  def test_has_many_find_all
-    assert_deprecated 'find_all_in_clients' do
-      assert_equal 2, @firm.find_all_in_clients("#{QUOTED_TYPE} = 'Client'").length
-      assert_equal 1, @firm.find_all_in_clients("name = 'Summit'").length
-    end
-  end
-  def test_has_one
-    assert_equal Account.find(1), @firm.account, "37signals should have an account"
-    assert_equal @firm, Account.find(1).firm, "37signals account should be able to backtrack"
-    assert_nil Account.find(2).firm, "Unknown isn't linked"
-  end
-  def test_has_one_build
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    assert firm.save
-    account = firm.build_account(:credit_limit => 1000)
-    assert account.save
-    assert_equal account, firm.account
-  end
-  def test_has_one_failing_build_association
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    account = firm.build_account
-    assert !account.save
-    assert_equal "can't be empty", account.errors.on("credit_limit")
-  end
-  def test_has_one_create
-    firm = Firm.new("name" => "GlobalMegaCorp")
-    firm.save
-    assert_equal firm.create_account("credit_limit" => 1000), firm.account
-  end
-end