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/schema_authorization_test_postgresql.rb DELETED Viewed

@@ -1,75 +0,0 @@
-require 'abstract_unit'
-class SchemaThing < ActiveRecord::Base
-end
-class SchemaAuthorizationTest < Test::Unit::TestCase
-  self.use_transactional_fixtures = false
-  TABLE_NAME = 'schema_things'
-  COLUMNS = [
-    'id serial primary key',
-    'name character varying(50)'
-  ]
-  USERS = ['rails_pg_schema_user1', 'rails_pg_schema_user2']
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.execute "SET search_path TO '$user',public"
-    set_session_auth
-    USERS.each do |u|
-      @connection.execute "CREATE ROLE #{u}"
-      @connection.execute "CREATE SCHEMA AUTHORIZATION #{u}"
-      set_session_auth u
-      @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-      @connection.execute "INSERT INTO #{TABLE_NAME} (name) VALUES ('#{u}')"
-      set_session_auth
-    end
-  end
-  def teardown
-    set_session_auth
-    @connection.execute "RESET search_path"
-    USERS.each do |u|
-      @connection.execute "DROP SCHEMA #{u} CASCADE"
-      @connection.execute "DROP ROLE #{u}"
-    end
-  end
-  def test_schema_invisible
-    assert_raise(ActiveRecord::StatementInvalid) do
-      set_session_auth
-      @connection.execute "SELECT * FROM #{TABLE_NAME}"
-    end
-  end
-  def test_schema_uniqueness
-    assert_nothing_raised do
-      set_session_auth
-      USERS.each do |u|
-        set_session_auth u
-        assert_equal u, @connection.select_value("SELECT name FROM #{TABLE_NAME} WHERE id = 1")
-        set_session_auth
-      end
-    end
-  end
-  def test_sequence_schema_caching
-    assert_nothing_raised do
-      USERS.each do |u|
-        set_session_auth u
-        st = SchemaThing.new :name => 'TEST1'
-        st.save!
-        st = SchemaThing.new :id => 5, :name => 'TEST2'
-        st.save!
-        set_session_auth
-      end
-    end
-  end
-  private
-    def set_session_auth auth = nil
-       @connection.execute "SET SESSION AUTHORIZATION #{auth || 'default'}"
-    end
-end

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

@@ -1,124 +0,0 @@
-require 'abstract_unit'
-require "#{File.dirname(__FILE__)}/../lib/active_record/schema_dumper"
-require 'stringio'
-if ActiveRecord::Base.connection.respond_to?(:tables)
-  class SchemaDumperTest < Test::Unit::TestCase
-    def standard_dump
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = []
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      stream.string
-    end
-    def test_schema_dump
-      output = standard_dump
-      assert_match %r{create_table "accounts"}, output
-      assert_match %r{create_table "authors"}, output
-      assert_no_match %r{create_table "schema_info"}, output
-    end
-    def test_schema_dump_excludes_sqlite_sequence
-      output = standard_dump
-      assert_no_match %r{create_table "sqlite_sequence"}, output
-    end
-    def assert_line_up(lines, pattern, required = false)
-      return assert(true) if lines.empty?
-      matches = lines.map { |line| line.match(pattern) }
-      assert matches.all? if required
-      matches.compact!
-      return assert(true) if matches.empty?
-      assert_equal 1, matches.map{ |match| match.offset(0).first }.uniq.length
-    end
-    def column_definition_lines(output = standard_dump)
-      output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }
-    end
-    def test_types_line_up
-      column_definition_lines.each do |column_set|
-        next if column_set.empty?
-        lengths = column_set.map do |column|
-          if match = column.match(/t\.(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)\s+"/)
-            match[0].length
-          end
-        end
-        assert_equal 1, lengths.uniq.length
-      end
-    end
-    def test_arguments_line_up
-      column_definition_lines.each do |column_set|
-        assert_line_up(column_set, /:default => /)
-        assert_line_up(column_set, /:limit => /)
-        assert_line_up(column_set, /:null => /)
-      end
-    end
-    def test_no_dump_errors
-      output = standard_dump
-      assert_no_match %r{\# Could not dump table}, output
-    end
-    def test_schema_dump_includes_not_null_columns
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = [/^[^r]/]
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      output = stream.string
-      assert_match %r{:null => false}, output
-    end
-    def test_schema_dump_with_string_ignored_table
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = ['accounts']
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      output = stream.string
-      assert_no_match %r{create_table "accounts"}, output
-      assert_match %r{create_table "authors"}, output
-      assert_no_match %r{create_table "schema_info"}, output
-    end
-    def test_schema_dump_with_regexp_ignored_table
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = [/^account/]
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      output = stream.string
-      assert_no_match %r{create_table "accounts"}, output
-      assert_match %r{create_table "authors"}, output
-      assert_no_match %r{create_table "schema_info"}, output
-    end
-    def test_schema_dump_illegal_ignored_table_value
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = [5]
-      assert_raise(StandardError) do
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      end
-    end
-    if current_adapter?(:MysqlAdapter)
-      def test_schema_dump_should_not_add_default_value_for_mysql_text_field
-        output = standard_dump
-        assert_match %r{t.text\s+"body",\s+:null => false$}, output
-      end
-    end
-    def test_schema_dump_includes_decimal_options
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.ignore_tables = [/^[^n]/]
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      output = stream.string
-      assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 2.78}, output
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-require 'abstract_unit'
-class SchemaTest < Test::Unit::TestCase
-  self.use_transactional_fixtures = false
-  SCHEMA_NAME = 'test_schema'
-  TABLE_NAME = 'things'
-  COLUMNS = [
-    'id integer',
-    'name character varying(50)',
-    'moment timestamp without time zone default now()'
-  ]
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.execute "CREATE SCHEMA #{SCHEMA_NAME} CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-  end
-  def teardown
-    @connection.execute "DROP SCHEMA #{SCHEMA_NAME} CASCADE"
-  end
-  def test_with_schema_prefixed_table_name
-    assert_nothing_raised do
-      assert_equal COLUMNS, columns("#{SCHEMA_NAME}.#{TABLE_NAME}")
-    end
-  end
-  def test_with_schema_search_path
-    assert_nothing_raised do
-      with_schema_search_path(SCHEMA_NAME) do
-        assert_equal COLUMNS, columns(TABLE_NAME)
-      end
-    end
-  end
-  def test_raise_on_unquoted_schema_name
-    assert_raise(ActiveRecord::StatementInvalid) do
-      with_schema_search_path '$user,public'
-    end
-  end
-  def test_without_schema_search_path
-    assert_raise(ActiveRecord::StatementInvalid) { columns(TABLE_NAME) }
-  end
-  def test_ignore_nil_schema_search_path
-    assert_nothing_raised { with_schema_search_path nil }
-  end
-  private
-    def columns(table_name)
-      @connection.send(:column_definitions, table_name).map do |name, type, default|
-        "#{name} #{type}" + (default ? " default #{default}" : '')
-      end
-    end
-    def with_schema_search_path(schema_search_path)
-      @connection.schema_search_path = schema_search_path
-      yield if block_given?
-    ensure
-      @connection.schema_search_path = "'$user', public"
-    end
-end

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

@@ -1,17 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/subject'
-# confirm that synonyms work just like tables; in this case
-# the "subjects" table in Oracle (defined in oci.sql) is just
-# a synonym to the "topics" table
-class TestOracleSynonym < Test::Unit::TestCase
-  def test_oracle_synonym
-    topic = Topic.new
-    subject = Subject.new
-    assert_equal(topic.attributes, subject.attributes)
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'abstract_unit'
-require "#{File.dirname(__FILE__)}/../lib/active_record/schema"
-if ActiveRecord::Base.connection.supports_migrations?
-  class Order < ActiveRecord::Base
-    self.table_name = '[order]'
-  end
-  class TableNameTest < Test::Unit::TestCase
-    self.use_transactional_fixtures = false
-    # Ensures Model.columns works when using SQLServer escape characters.
-    # Enables legacy schemas using SQL reserved words as table names.
-    # Should work with table names with spaces as well ('table name').
-    def test_escaped_table_name
-      assert_nothing_raised do
-        ActiveRecord::Base.connection.select_all 'SELECT * FROM [order]'
-      end
-      assert_equal '[order]', Order.table_name
-      assert_equal 5, Order.columns.length
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
-unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
-  class ThreadedConnectionsTest < Test::Unit::TestCase
-    self.use_transactional_fixtures = false
-    fixtures :topics
-  def setup
-    @connection = ActiveRecord::Base.remove_connection
-    @connections = []
-    @allow_concurrency = ActiveRecord::Base.allow_concurrency
-  end
-  def teardown
-    # clear the connection cache
-    ActiveRecord::Base.send(:clear_all_cached_connections!)
-    # set allow_concurrency to saved value
-    ActiveRecord::Base.allow_concurrency = @allow_concurrency
-    # reestablish old connection
-    ActiveRecord::Base.establish_connection(@connection)
-  end
-  def gather_connections(use_threaded_connections)
-    ActiveRecord::Base.allow_concurrency = use_threaded_connections
-    ActiveRecord::Base.establish_connection(@connection)
-      5.times do
-        Thread.new do
-          Topic.find :first
-          @connections << ActiveRecord::Base.active_connections.values.first
-        end.join
-      end
-    end
-    def test_threaded_connections
-      gather_connections(true)
-      assert_equal @connections.uniq.length, 5
-    end
-    def test_unthreaded_connections
-      gather_connections(false)
-      assert_equal @connections.uniq.length, 1
-    end
-  end
-end

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

@@ -1,268 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/reply'
-require 'fixtures/developer'
-class TransactionTest < Test::Unit::TestCase
-  self.use_transactional_fixtures = false
-  fixtures :topics, :developers
-  def setup
-    @first, @second = Topic.find(1, 2).sort_by { |t| t.id }
-  end
-  def test_successful
-    Topic.transaction do
-      @first.approved  = true
-      @second.approved = false
-      @first.save
-      @second.save
-    end
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
-  end
-  def transaction_with_return
-    Topic.transaction do
-      @first.approved  = true
-      @second.approved = false
-      @first.save
-      @second.save
-      return
-    end
-  end
-  def test_successful_with_return
-    class << Topic.connection
-      alias :real_commit_db_transaction :commit_db_transaction
-      def commit_db_transaction
-        $committed = true
-        real_commit_db_transaction
-      end
-    end
-    $committed = false
-    transaction_with_return
-    assert $committed
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
-  ensure
-    class << Topic.connection
-      alias :commit_db_transaction :real_commit_db_transaction rescue nil
-    end
-  end
-  def test_successful_with_instance_method
-    @first.transaction do
-      @first.approved  = true
-      @second.approved = false
-      @first.save
-      @second.save
-    end
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
-  end
-  def test_failing_on_exception
-    begin
-      Topic.transaction do
-        @first.approved  = true
-        @second.approved = false
-        @first.save
-        @second.save
-        raise "Bad things!"
-      end
-    rescue
-      # caught it
-    end
-    assert @first.approved?, "First should still be changed in the objects"
-    assert !@second.approved?, "Second should still be changed in the objects"
-    assert !Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
-  end
-  def test_callback_rollback_in_save
-    add_exception_raising_after_save_callback_to_topic
-    begin
-      @first.approved = true
-      @first.save
-      flunk
-    rescue => e
-      assert_equal "Make the transaction rollback", e.message
-      assert !Topic.find(1).approved?
-    ensure
-      remove_exception_raising_after_save_callback_to_topic
-    end
-  end
-  def test_callback_rollback_in_create
-    new_topic = Topic.new(
-      :title => "A new topic",
-      :author_name => "Ben",
-      :author_email_address => "ben@example.com",
-      :written_on => "2003-07-16t15:28:11.2233+01:00",
-      :last_read => "2004-04-15",
-      :bonus_time => "2005-01-30t15:28:00.00+01:00",
-      :content => "Have a nice day",
-      :approved => false)
-    new_record_snapshot = new_topic.new_record?
-    id_present = new_topic.has_attribute?(Topic.primary_key)
-    id_snapshot = new_topic.id
-    # Make sure the second save gets the after_create callback called.
-    2.times do
-      begin
-        add_exception_raising_after_create_callback_to_topic
-        new_topic.approved = true
-        new_topic.save
-        flunk
-      rescue => e
-        assert_equal "Make the transaction rollback", e.message
-        assert_equal new_record_snapshot, new_topic.new_record?, "The topic should have its old new_record value"
-        assert_equal id_snapshot, new_topic.id, "The topic should have its old id"
-        assert_equal id_present, new_topic.has_attribute?(Topic.primary_key)
-      ensure
-        remove_exception_raising_after_create_callback_to_topic
-      end
-    end
-  end
-  def test_nested_explicit_transactions
-    Topic.transaction do
-      Topic.transaction do
-        @first.approved  = true
-        @second.approved = false
-        @first.save
-        @second.save
-      end
-    end
-    assert Topic.find(1).approved?, "First should have been approved"
-    assert !Topic.find(2).approved?, "Second should have been unapproved"
-  end
-  def test_manually_rolling_back_a_transaction
-    Topic.transaction do |transaction|
-      @first.approved  = true
-      @second.approved = false
-      @first.save
-      @second.save
-      transaction.rollback!
-    end
-    assert @first.approved?, "First should still be changed in the objects"
-    assert !@second.approved?, "Second should still be changed in the objects"
-    assert !Topic.find(1).approved?, "First shouldn't have been approved"
-    assert Topic.find(2).approved?, "Second should still be approved"
-  end
-  private
-    def add_exception_raising_after_save_callback_to_topic
-      Topic.class_eval { def after_save() raise "Make the transaction rollback" end }
-    end
-    def remove_exception_raising_after_save_callback_to_topic
-      Topic.class_eval { remove_method :after_save }
-    end
-    def add_exception_raising_after_create_callback_to_topic
-      Topic.class_eval { def after_create() raise "Make the transaction rollback" end }
-    end
-    def remove_exception_raising_after_create_callback_to_topic
-      Topic.class_eval { remove_method :after_create }
-    end
-end
-if current_adapter?(:PostgreSQLAdapter)
-  class ConcurrentTransactionTest < TransactionTest
-    def setup
-      @allow_concurrency = ActiveRecord::Base.allow_concurrency
-      ActiveRecord::Base.allow_concurrency = true
-      super
-    end
-    def teardown
-      super
-      ActiveRecord::Base.allow_concurrency = @allow_concurrency
-    end
-    # This will cause transactions to overlap and fail unless they are performed on
-    # separate database connections.
-    def test_transaction_per_thread
-      assert_nothing_raised do
-        threads = (1..3).map do
-          Thread.new do
-            Topic.transaction do
-              topic = Topic.find(1)
-              topic.approved = !topic.approved?
-              topic.save!
-              topic.approved = !topic.approved?
-              topic.save!
-            end
-          end
-        end
-        threads.each { |t| t.join }
-      end
-    end
-    # Test for dirty reads among simultaneous transactions.
-    def test_transaction_isolation__read_committed
-      # Should be invariant.
-      original_salary = Developer.find(1).salary
-      temporary_salary = 200000
-      assert_nothing_raised do
-        threads = (1..3).map do
-          Thread.new do
-            Developer.transaction do
-              # Expect original salary.
-              dev = Developer.find(1)
-              assert_equal original_salary, dev.salary
-              dev.salary = temporary_salary
-              dev.save!
-              # Expect temporary salary.
-              dev = Developer.find(1)
-              assert_equal temporary_salary, dev.salary
-              dev.salary = original_salary
-              dev.save!
-              # Expect original salary.
-              dev = Developer.find(1)
-              assert_equal original_salary, dev.salary
-            end
-          end
-        end
-        # Keep our eyes peeled.
-        threads << Thread.new do
-          10.times do
-            sleep 0.05
-            Developer.transaction do
-              # Always expect original salary.
-              assert_equal original_salary, Developer.find(1).salary
-            end
-          end
-        end
-        threads.each { |t| t.join }
-      end
-      assert_equal original_salary, Developer.find(1).salary
-    end
-  end
-end