From 26617d2e3d1b29919e830af602a41346d544d582 Mon Sep 17 00:00:00 2001 From: Blythe Dunham Date: Wed, 23 Dec 2009 19:05:19 -0800 Subject: [PATCH 1/2] update with unique patch --- activerecord/lib/active_record.rb | 1 + activerecord/lib/active_record/base.rb | 23 +++++++++ .../connection_adapters/abstract_adapter.rb | 14 +++++- .../connection_adapters/mysql_adapter.rb | 25 ++++++++++ .../connection_adapters/postgresql_adapter.rb | 18 +++++++ .../connection_adapters/sqlite_adapter.rb | 17 +++++++ activerecord/lib/active_record/locale/en.yml | 2 + .../lib/active_record/unique_constraints.rb | 24 +++++++++ activerecord/test/cases/adapter_test.rb | 50 ++++++++++++++++++++ activerecord/test/cases/unique_constraints_test.rb | 40 ++++++++++++++++ activerecord/test/models/unique_item.rb | 2 + activerecord/test/schema/schema.rb | 15 ++++++ 12 files changed, 230 insertions(+), 1 deletions(-) create mode 100644 activerecord/lib/active_record/unique_constraints.rb create mode 100644 activerecord/test/cases/unique_constraints_test.rb create mode 100644 activerecord/test/models/unique_item.rb diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb index 2f8c5c7..8469255 100644 --- a/activerecord/lib/active_record.rb +++ b/activerecord/lib/active_record.rb @@ -68,6 +68,7 @@ module ActiveRecord autoload :TestCase, 'active_record/test_case' autoload :Timestamp, 'active_record/timestamp' autoload :Transactions, 'active_record/transactions' + autoload :UniqueConstraints, 'active_record/unique_constraints' autoload :Validations, 'active_record/validations' module Locking diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb index 4929969..da9c110 100755 --- a/activerecord/lib/active_record/base.rb +++ b/activerecord/lib/active_record/base.rb @@ -55,6 +55,25 @@ module ActiveRecord #:nodoc: class StatementInvalid < ActiveRecordError end + # Parent class for all specific exceptions which wrap database driver exceptions + # provides access to the original exception also. + class WrappedDatabaseException < StatementInvalid + attr_reader :original_exception + + def initialize(message, original_exception) + super(message) + @original_exception, = original_exception + end + end + + # Raised when a record cannot be inserted because it would violate a uniqueness constraint. + class RecordNotUnique < WrappedDatabaseException + end + + # Raised when a record cannot be inserted or updated because it references a non-existent record. + class InvalidForeignKey < WrappedDatabaseException + end + # Raised when number of bind variables in statement given to :condition key (for example, when using +find+ method) # does not match number of expected variables. # @@ -3181,6 +3200,10 @@ module ActiveRecord #:nodoc: include AutosaveAssociation, NestedAttributes include Aggregations, Transactions, Reflection, Batches, Calculations, Serialization + + # UniqueConstraints needs to be included after Transactions, because we need #save_with_unique_constraints + # to rescue after the transaction has been resolved for postgres. + include UniqueConstraints end end diff --git a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb index 22871f2..6adea19 100755 --- a/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb @@ -197,6 +197,13 @@ module ActiveRecord end end + # given an ActiveRecord::RecordNotUnique exception and a table name this returns the index whose + # unique constraint was violated, or nil if it can't determine the index + def index_for_record_not_unique(not_unique_exception, table_name) #:nodoc: + # override in derived class + nil + end + protected def log(sql, name) if block_given? @@ -216,9 +223,14 @@ module ActiveRecord @last_verification = 0 message = "#{e.class.name}: #{e.message}: #{sql}" log_info(message, name, 0) - raise ActiveRecord::StatementInvalid, message + raise translate_exception(e, message) end + def translate_exception(e, message) + # override in derived class + ActiveRecord::StatementInvalid.new(message) + end + def format_log_entry(message, dump = nil) if ActiveRecord::Base.colorize_logging if @@row_even diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb index a8aa16e..658df1f 100644 --- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb @@ -586,6 +586,31 @@ module ActiveRecord where_sql end + def index_for_record_not_unique(exception, table_name) #:nodoc: + case exception.message + when /Duplicate entry.*for key (\d+)/ + index_position = $1.to_i + # minus two b/c mysql message is one-based + rails excludes primary key index from indexes list + indexes(table_name)[index_position - 2] + when /Duplicate entry.*for key '(\w+)'/ + index_name = $1 + indexes(table_name).detect { |i| i.name == index_name } + end + end + + protected + + def translate_exception(exception, message) + case exception.errno + when 1062 + RecordNotUnique.new(message, exception) + when 1452 + InvalidForeignKey.new(message, exception) + else + super + end + end + private def connect encoding = @config[:encoding] diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb index bc289ff..c313082 100644 --- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb @@ -941,6 +941,13 @@ module ActiveRecord sql.replace "SELECT * FROM (#{sql}) AS id_list ORDER BY #{order}" end + def index_for_record_not_unique(exception, table_name) #:nodoc: + if match = exception.message.match(/unique constraint "(\w+)"/) + index_name = match[1] + indexes(table_name).detect { |i| i.name == index_name } + end + end + protected # Returns the version of the connected PostgreSQL version. def postgresql_version @@ -958,6 +965,17 @@ module ActiveRecord end end + def translate_exception(exception, message) + case exception.message + when /duplicate key value violates unique constraint/ + RecordNotUnique.new(message, exception) + when /violates foreign key constraint/ + InvalidForeignKey.new(message, exception) + else + super + end + end + private # The internal PostgreSQL identifier of the money data type. MONEY_COLUMN_TYPE_OID = 790 #:nodoc: diff --git a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb index 0bf97a9..31519f1 100644 --- a/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb @@ -315,6 +315,13 @@ module ActiveRecord "INSERT INTO #{table_name} VALUES(NULL)" end + def index_for_record_not_unique(exception, table_name) #:nodoc: + if match = exception.message.match(/column(?:s)? (.*) (?:is|are) not unique/) + index_columns = match[1].split(', ') + indexes(table_name).detect { |i| i.columns == index_columns } + end + end + protected def select(sql, name = nil) #:nodoc: execute(sql, name).map do |row| @@ -435,6 +442,16 @@ module ActiveRecord 'INTEGER PRIMARY KEY NOT NULL'.freeze end end + + def translate_exception(exception, message) + case exception.message + when /column(s)? .* (is|are) not unique/ + RecordNotUnique.new(message, exception) + else + super + end + end + end class SQLite2Adapter < SQLiteAdapter # :nodoc: diff --git a/activerecord/lib/active_record/locale/en.yml b/activerecord/lib/active_record/locale/en.yml index 2813524..a7dec95 100644 --- a/activerecord/lib/active_record/locale/en.yml +++ b/activerecord/lib/active_record/locale/en.yml @@ -15,6 +15,8 @@ en: too_short: "is too short (minimum is {{count}} characters)" wrong_length: "is the wrong length (should be {{count}} characters)" taken: "has already been taken" + taken_multiple: "has already been taken for {{context}}" + taken_generic: "Unique requirement not met" not_a_number: "is not a number" greater_than: "must be greater than {{count}}" greater_than_or_equal_to: "must be greater than or equal to {{count}}" diff --git a/activerecord/lib/active_record/unique_constraints.rb b/activerecord/lib/active_record/unique_constraints.rb new file mode 100644 index 0000000..99e6353 --- /dev/null +++ b/activerecord/lib/active_record/unique_constraints.rb @@ -0,0 +1,24 @@ +module ActiveRecord + # See ActiveRecord::Transactions::ClassMethods for documentation. + module UniqueConstraints + def self.included(base) + base.class_eval do + alias_method_chain :save, :unique_constraints + end + end + + def save_with_unique_constraints(perform_validation = true) #:nodoc: + save_without_unique_constraints(perform_validation) + rescue ActiveRecord::RecordNotUnique => e + index = connection.index_for_record_not_unique(e.original_exception, self.class.table_name) + if !index + errors.add_to_base(I18n.translate(:'activerecord.errors.messages.taken_generic')) + elsif index.columns.size == 1 + errors.add(index.columns.first, :taken, :value => attributes[index.columns.first]) + else + errors.add(index.columns.first, :taken_multiple, :context => index.columns.slice(1..-1).join('/'), :value => attributes[index.columns.first]) + end + false + end + end +end \ No newline at end of file diff --git a/activerecord/test/cases/adapter_test.rb b/activerecord/test/cases/adapter_test.rb index 3dd3dd8..0883ea0 100644 --- a/activerecord/test/cases/adapter_test.rb +++ b/activerecord/test/cases/adapter_test.rb @@ -142,4 +142,54 @@ class AdapterTest < ActiveRecord::TestCase assert_equal " LIMIT 1,7 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7) end end + + def test_uniqueness_violations_are_translated_to_specific_exception + @connection.execute "INSERT INTO subscribers(nick) VALUES('me')" + assert_raises(ActiveRecord::RecordNotUnique) do + @connection.execute "INSERT INTO subscribers(nick) VALUES('me')" + end + end + + def test_foreign_key_violations_are_translated_to_specific_exception + unless @connection.adapter_name == 'SQLite' + assert_raises(ActiveRecord::InvalidForeignKey) do + @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)" + end + end + end + + # tests for db-enforced unique constraints + unique_scenarios = { + :single => {:sql => "INSERT INTO unique_items(uniq) VALUES('abc')", + :expected => ['uniq']}, + :single_named => {:sql => "INSERT INTO unique_items(uniq_named) VALUES('abc')", + :expected => ['uniq_named']}, + :multiple => {:sql => "INSERT INTO unique_items(uniq_1, uniq_2, uniq_3) VALUES('a', 'b', 'c')", + :expected => ['uniq_1', 'uniq_2', 'uniq_3']}, + :multiple_named => {:sql => "INSERT INTO unique_items(uniq_1_named, uniq_2_named, uniq_3_named) VALUES('a', 'b', 'c')", + :expected => ['uniq_1_named', 'uniq_2_named', 'uniq_3_named']} + } + unique_scenarios.each do |name, data| + test "finds index for unique constraint #{name}" do + @connection.execute data[:sql] + exception = get_exception(ActiveRecord::RecordNotUnique) do + @connection.execute data[:sql] + end + # postgres can't query indexes until transaction is rolled back + @connection.rollback_db_transaction if current_adapter?(:PostgreSQLAdapter) + assert_equal data[:expected], @connection.index_for_record_not_unique(exception, 'unique_items').columns + end + end + + protected + + def get_exception(expected_exception) + begin + yield + rescue expected_exception => e + e + else + flunk "Expected #{expected_exception} exception" + end + end end diff --git a/activerecord/test/cases/unique_constraints_test.rb b/activerecord/test/cases/unique_constraints_test.rb new file mode 100644 index 0000000..2b5d0ee --- /dev/null +++ b/activerecord/test/cases/unique_constraints_test.rb @@ -0,0 +1,40 @@ +require "cases/helper" +require 'models/unique_item' + +class UniquenessValidationTest < ActiveRecord::TestCase + + def test_validate_uniqueness_on_create + valid_item = UniqueItem.create!(:uniq => 'abc') + invalid_item = UniqueItem.create(:uniq => 'abc') + assert_equal "has already been taken", invalid_item.errors[:uniq] + end + + def test_validate_uniqueness_on_save + item_1 = UniqueItem.create!(:uniq => 'abc') + item_2 = UniqueItem.create!(:uniq => 'xyz') + item_2.uniq = item_1.uniq + item_2.save + assert_equal "has already been taken", item_2.errors[:uniq] + end + + def test_validate_uniqueness_on_update + item_1 = UniqueItem.create!(:uniq => 'abc') + item_2 = UniqueItem.create!(:uniq => 'xyz') + item_2.update_attributes(:uniq => item_1.uniq) + assert_equal "has already been taken", item_2.errors[:uniq] + end + + def test_validate_uniqueness_multiple + valid_item = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + invalid_item = UniqueItem.create(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_equal "has already been taken for uniq_2/uniq_3", invalid_item.errors[:uniq_1] + end + + def test_validate_uniqueness_generic + ActiveRecord::Base.connection.expects(:index_for_record_not_unique).returns(nil) + valid_item = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + invalid_item = UniqueItem.create(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_equal "Unique requirement not met", invalid_item.errors[:base] + end + +end \ No newline at end of file diff --git a/activerecord/test/models/unique_item.rb b/activerecord/test/models/unique_item.rb new file mode 100644 index 0000000..3c6f6f0 --- /dev/null +++ b/activerecord/test/models/unique_item.rb @@ -0,0 +1,2 @@ +class UniqueItem < ActiveRecord::Base +end \ No newline at end of file diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb index b046104..17a6fc4 100644 --- a/activerecord/test/schema/schema.rb +++ b/activerecord/test/schema/schema.rb @@ -499,6 +499,21 @@ ActiveRecord::Schema.define do t.string :title end + create_table :unique_items, :force => true do |t| + t.string :uniq + t.string :uniq_1 + t.string :uniq_2 + t.string :uniq_3 + t.string :uniq_named + t.string :uniq_1_named + t.string :uniq_2_named + t.string :uniq_3_named + end + add_index :unique_items, [:uniq], :unique => true + add_index :unique_items, [:uniq_named], :unique => true, :name => 'unique_named_single_index' + add_index :unique_items, [:uniq_1, :uniq_2, :uniq_3], :unique => true + add_index :unique_items, [:uniq_1_named, :uniq_2_named, :uniq_3_named], :unique => true, :name => 'unique_named_multiple_index' + except 'SQLite' do # fk_test_has_fk should be before fk_test_has_pk create_table :fk_test_has_fk, :force => true do |t| -- 1.6.5 From d1df544fe916f8f5b129e7dc14a2bb4e04c18a52 Mon Sep 17 00:00:00 2001 From: Blythe Dunham Date: Thu, 24 Dec 2009 19:07:00 -0800 Subject: [PATCH 2/2] Customization options and validation consistency for validates_uniqueness_of using db constraints --- .../lib/active_record/unique_constraints.rb | 133 ++++++++++++++++++- activerecord/test/cases/unique_constraints_test.rb | 109 +++++++++++++++- activerecord/test/models/unique_item.rb | 17 +++- 3 files changed, 246 insertions(+), 13 deletions(-) diff --git a/activerecord/lib/active_record/unique_constraints.rb b/activerecord/lib/active_record/unique_constraints.rb index 99e6353..289e183 100644 --- a/activerecord/lib/active_record/unique_constraints.rb +++ b/activerecord/lib/active_record/unique_constraints.rb @@ -1,24 +1,143 @@ module ActiveRecord + + class RecordInvalidNotUnique < RecordInvalid; end + VALID_HANDLE_UNIQUE_KEY_OPTIONS = [:scope, :field_name, :message] + # See ActiveRecord::Transactions::ClassMethods for documentation. module UniqueConstraints - def self.included(base) + def self.included(base)#:nodoc: base.class_eval do - alias_method_chain :save, :unique_constraints + extend ClassMethods + alias_method_chain :save, :unique_constraints + alias_method_chain :save!, :unique_constraints + end + end + + module ClassMethods + def self.extended(base)#:nodoc: + base.class_eval do + class << self + alias_method_chain :validates_uniqueness_of, :unique_key + alias_method :handle_unique_key_violations, :handle_unique_key_violation + end + + class_inheritable_hash :unique_key_validation_options + self.unique_key_validation_options = {} + end + end + + # Specify custom error messages to use when converting database unique key violation errors + # into active record errors. + # For consistency with standard validation exceptions raised by save!, explicitly declared validations + # convert database RecordNotUnique to RecordInvalid derived exceptions. + # + # === Options + # :message - Specifies a custom error message (default is: "has already been taken"). + # :scope - One or more columns by which to limit the scope of the uniqueness constraint. + # + # === Examples + # # The following are equivalent + # class User + # handles_unique_key_violation :name, :message => 'already exists' + # validates_uniqueness_of :user, :message => 'already exists', :lazy => true, + # end + # + # # Convert all violations for all active record classes + # ActiveRecord::Base.handle_unique_key_violations + def handle_unique_key_violation(*attr_names) + options = attr_names.extract_options! + options.symbolize_keys! + options.assert_valid_keys(VALID_HANDLE_UNIQUE_KEY_OPTIONS) + + # when blank, convert all violations + attr_names << :all if attr_names.none? + + attr_names.each do |name| + self.unique_key_validation_options[ name.to_sym ] = if name.to_sym == :all + { :message => options[:message], :field_name => nil, :columns => [] } + else + options.reverse_merge( + :field_name => name.to_s, + :columns => [name.to_s]. + concat( (options[:scope]||[]).collect(&:to_s) ).uniq.sort + ) + end + end + end + + # :lazyReactively convert database unique key violations to active record error messages + # instead of proactively querying the database + # + # === Options + # :lazy option when set to true, the proactive validations are skipped + # Only the :scope and :message options are valid with :lazy => true + # === Examples + # # The following are equivalent + # class User + # handles_unique_key_violation :name, :message => 'already exists' + # validates_uniqueness_of :user, :message => 'already exists', :lazy => true, + # end + # + # # Convert all violations for all active record classes + # ActiveRecord::Base.validates_uniqueness_of :lazy => true + def validates_uniqueness_of_with_unique_key(*attr_names) + configuration = attr_names.extract_options! + configuration.symbolize_keys! + + if configuration.delete(:lazy) + configuration.assert_valid_keys(VALID_HANDLE_UNIQUE_KEY_OPTIONS) + else + validates_uniqueness_of_without_unique_key(*(attr_names + [configuration])) + end + + attr_names << configuration.reject{|k, v| !VALID_HANDLE_UNIQUE_KEY_OPTIONS.include?(k) } + handle_unique_key_violation(*attr_names) end + end - def save_with_unique_constraints(perform_validation = true) #:nodoc: - save_without_unique_constraints(perform_validation) - rescue ActiveRecord::RecordNotUnique => e + def save_with_unique_constraints(*args)#:nodoc: + save_without_unique_constraints(*args) + rescue RecordNotUnique => e + add_record_not_unique_errors(e) + false + end + + def save_with_unique_constraints!(*args)#:nodoc: + save_without_unique_constraints!(*args) + rescue RecordNotUnique => e + raise RecordInvalidNotUnique.new( self ) if add_record_not_unique_errors( e ) + raise e + end + + protected + + # Convert the RecordNotUnique exception into an error message + # return true if the violation occurred on column(s) explictly declared to be + # handled + def add_record_not_unique_errors(e)#:nodoc: index = connection.index_for_record_not_unique(e.original_exception, self.class.table_name) - if !index + + # If an index is found, find a the configuration for validates_uniqueness_of + # Or use :all (global) options if specified + record_not_found_options = unique_key_validation_options.values.detect{ |v| + v[:columns] == index.columns.sort || v[:field_name] == index.columns.first + } if index + record_not_found_options ||= unique_key_validation_options[:all] + + + if record_not_found_options && record_not_found_options[:message] + column_name = record_not_found_options[:field_name] || index.columns.first + errors.add(column_name,record_not_found_options[:message], :value => column_name) + elsif !index errors.add_to_base(I18n.translate(:'activerecord.errors.messages.taken_generic')) elsif index.columns.size == 1 errors.add(index.columns.first, :taken, :value => attributes[index.columns.first]) else errors.add(index.columns.first, :taken_multiple, :context => index.columns.slice(1..-1).join('/'), :value => attributes[index.columns.first]) end - false + + !!record_not_found_options end end end \ No newline at end of file diff --git a/activerecord/test/cases/unique_constraints_test.rb b/activerecord/test/cases/unique_constraints_test.rb index 2b5d0ee..aecbba2 100644 --- a/activerecord/test/cases/unique_constraints_test.rb +++ b/activerecord/test/cases/unique_constraints_test.rb @@ -1,6 +1,5 @@ require "cases/helper" require 'models/unique_item' - class UniquenessValidationTest < ActiveRecord::TestCase def test_validate_uniqueness_on_create @@ -9,19 +8,38 @@ class UniquenessValidationTest < ActiveRecord::TestCase assert_equal "has already been taken", invalid_item.errors[:uniq] end + def test_validate_uniqueness_on_create! + valid_item = UniqueItem.create!(:uniq => 'abc') + assert_raises_record_not_unique{ UniqueItem.create!(:uniq => 'abc') } + end + def test_validate_uniqueness_on_save item_1 = UniqueItem.create!(:uniq => 'abc') item_2 = UniqueItem.create!(:uniq => 'xyz') item_2.uniq = item_1.uniq - item_2.save - assert_equal "has already been taken", item_2.errors[:uniq] + assert !item_2.save + assert_equal("has already been taken", item_2.errors[:uniq]) + end + + def test_validate_uniqueness_on_save! + item_1 = UniqueItem.create!(:uniq => 'abc') + item_2 = UniqueItem.new(:uniq => 'abc') + assert_raises_record_not_unique{ item_2.save! } + assert_equal("has already been taken", item_2.errors[:uniq]) end def test_validate_uniqueness_on_update item_1 = UniqueItem.create!(:uniq => 'abc') item_2 = UniqueItem.create!(:uniq => 'xyz') - item_2.update_attributes(:uniq => item_1.uniq) - assert_equal "has already been taken", item_2.errors[:uniq] + assert !item_2.update_attributes( :uniq => 'abc' ) + assert_equal("has already been taken", item_2.errors[:uniq]) + end + + def test_validate_uniqueness_on_update! + item_1 = UniqueItem.create!(:uniq => 'abc') + item_2 = UniqueItem.create!(:uniq => 'xyz') + assert_raises_record_not_unique{ item_2.update_attributes!( :uniq => 'abc') } + assert_equal("has already been taken", item_2.errors[:uniq]) end def test_validate_uniqueness_multiple @@ -30,6 +48,77 @@ class UniquenessValidationTest < ActiveRecord::TestCase assert_equal "has already been taken for uniq_2/uniq_3", invalid_item.errors[:uniq_1] end + def test_validate_uniqueness_multiple! + valid_item = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_raises_record_not_unique { UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') } + end + + def test_validate_uniqueness_multiple_with_custom_translated_validation_message + UniqueItemWithValidation.validates_uniqueness_of :uniq_1, :message => :invalid, :lazy => true, :scope => %w(uniq_2 uniq_3) + valid_item = UniqueItemWithValidation.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + invalid_item = UniqueItemWithValidation.create(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_equal "is invalid", invalid_item.errors[:uniq_1] + end + + def test_validate_uniqueness_raises_record_invalid_with_custom_error_message + UniqueItemWithValidation.validates_uniqueness_of :uniq, :message => 'is really taken.', :lazy => true + item_1 = UniqueItemWithValidation.create!(:uniq => 'abc') + item_2 = UniqueItemWithValidation.create!(:uniq => 'xyz') + item_2.uniq = item_1.uniq + assert_raises_record_invalid{ item_2.save! } + assert_equal 'is really taken.', item_2.errors[:uniq] + end + + def test_raises_record_not_unique_violation_without_declaring_validates_uniqueness_of(message) + UniqueItemWithValidation.validates_uniqueness_of :uniq, :message => 'is really taken.', :lazy => true + item_1 = UniqueItemWithValidation.create!(:uniq_named => 'abc') + item_2 = UniqueItemWithValidation.create!(:uniq_named => 'xyz') + item_2.uniq_named = item_1.uniq_named + assert_raises_record_not_unique{ item_2.save! } + assert_equal "has already been taken", item_2.errors[:uniq_named] + end + + def test_standard_validates_uniqueness_of_save_failure_is_handled + # Standard validation succeeds + UniqueItemWithStandardValidation.expects(:exists?).returns(false) + valid_item = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + invalid_item = UniqueItemWithStandardValidation.new(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_raises_record_invalid{ invalid_item.save! } + assert_equal "standard validation", invalid_item.errors[:uniq_1] + end + + def test_standard_validates_uniqueness_of_create_failure_is_handled + # Standard validation succeeds + UniqueItemWithStandardValidation.expects(:exists?).returns(false) + item_1 = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + assert_raises_record_invalid { + UniqueItemWithStandardValidation.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') + } + end + + def test_validate_uniqueness_of_all_on_save! + assert(UniqueItemWithAllValidation.unique_key_validation_options.has_key?(:all)) + item_1 = UniqueItemWithAllValidation.create!(:uniq_named => 'abc') + item_2 = UniqueItemWithAllValidation.create!(:uniq_named => 'xyz') + item_2.uniq_named = item_1.uniq_named + assert_raises_record_invalid{ item_2.save! } + assert_equal 'all validation messages', item_2.errors[:uniq_named] + end + + def test_validate_uniqueness_of_invalid_options + assert_raises(ArgumentError) { + UniqueItem.validates_uniqueness_of :uniq, :allow_nil => false, :lazy => true + } + + assert_raises(ArgumentError) { + UniqueItem.handle_unique_key_violations :uniq, :message => 'goo', :if => lambda{ true }, :lazy => true + } + + assert_raises(ArgumentError) { + UniqueItem.handle_unique_key_violation :allow_nil => false, :lazy => true + } + end + def test_validate_uniqueness_generic ActiveRecord::Base.connection.expects(:index_for_record_not_unique).returns(nil) valid_item = UniqueItem.create!(:uniq_1 => 'a', :uniq_2 => 'b', :uniq_3 => 'c') @@ -37,4 +126,14 @@ class UniquenessValidationTest < ActiveRecord::TestCase assert_equal "Unique requirement not met", invalid_item.errors[:base] end + protected + + def assert_raises_record_not_unique(&block) + assert_raises(ActiveRecord::RecordNotUnique, &block) + end + + def assert_raises_record_invalid(&block) + assert_raises(ActiveRecord::RecordInvalidNotUnique, &block) + end + end \ No newline at end of file diff --git a/activerecord/test/models/unique_item.rb b/activerecord/test/models/unique_item.rb index 3c6f6f0..d34a40a 100644 --- a/activerecord/test/models/unique_item.rb +++ b/activerecord/test/models/unique_item.rb @@ -1,2 +1,17 @@ class UniqueItem < ActiveRecord::Base -end \ No newline at end of file +end + +class UniqueItemWithValidation < ActiveRecord::Base + set_table_name 'unique_items' + validates_uniqueness_of :uniq, :message => :invalid, :lazy => true +end + +class UniqueItemWithAllValidation < ActiveRecord::Base + set_table_name 'unique_items' + validates_uniqueness_of :message => 'all validation messages' +end + +class UniqueItemWithStandardValidation < ActiveRecord::Base + set_table_name 'unique_items' + validates_uniqueness_of :uniq_1, :message => 'standard validation', :scope => [:uniq_2, :uniq_3 ], :allow_nil => true +end -- 1.6.5