activerecord_authorails 1.0.0

data/test/schema_authorization_test_postgresql.rb

@@ -0,0 +1,75 @@
+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/test/schema_dumper_test.rb

@@ -0,0 +1,96 @@
+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 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 test_arguments_line_up
+      output  = standard_dump
+      output.scan(/^( *)create_table.*?\n(.*?)^\1end/m).map{ |m| m.last.split(/\n/) }.each do |column_set|
+        assert_line_up(column_set, /:(?:integer|decimal|float|datetime|timestamp|time|date|text|binary|string|boolean)/, true)
+        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
+
+    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/test/schema_test_postgresql.rb

@@ -0,0 +1,64 @@
+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/test/synonym_test_oracle.rb

@@ -0,0 +1,17 @@
+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/test/table_name_test_sqlserver.rb

@@ -0,0 +1,23 @@
+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/test/threaded_connections_test.rb

@@ -0,0 +1,48 @@
+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/test/transactions_test.rb

@@ -0,0 +1,230 @@
+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_failing_with_object_rollback
+    assert !@first.approved?, "First should be unapproved initially"
+
+    begin
+      assert_deprecated /Object transactions/ do
+        Topic.transaction(@first, @second) do
+          @first.approved  = true
+          @second.approved = false
+          @first.save
+          @second.save
+          raise "Bad things!"
+        end
+      end
+    rescue
+      # caught it
+    end
+    
+    assert !@first.approved?, "First shouldn't have been approved"
+    assert @second.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_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
+
+  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
+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