Rails enum validation not working but raise ArgumentError - ruby-on-rails

Question

A thread was created here, but it doesn't solve my problem.
My code is:
course.rb
class Course < ApplicationRecord
COURSE_TYPES = %i( trial limited unlimited )
enum course_type: COURSE_TYPES
validates_inclusion_of :course_type, in: COURSE_TYPES
end
courses_controller.rb
class CoursesController < ApiController
def create
course = Course.new(course_params) # <-- Exception here
if course.save # <-- But I expect the process can go here
render json: course, status: :ok
else
render json: {error: 'Failed to create course'}, status: :unprocessable_entity
end
end
private
def course_params
params.require(:course).permit(:course_type)
end
end
My test cases:
courses_controller_spec.rb
describe '#create' do
context 'when invalid course type' do
let(:params) { { course_type: 'english' } }
before { post :create, params: { course: params } }
it 'returns 422' do
expect(response.status).to eq(422)
end
end
end
When running the above test case, I got an ArgumentError exception which was described at Rails issues
So I expect if I set an invalid course_type to enum, it will fail in validation phase instead of raising an exception.
Additionally, I know what really happens under the hook in rails at here and I don't want to manually rescue this kind of exception in every block of code which assigns an enum type value!
Any suggestion on this?

Answer 1

I've found a solution. Tested by myself in Rails 6.
# app/models/contact.rb
class Contact < ApplicationRecord
include LiberalEnum
enum kind: {
phone: 'phone', skype: 'skype', whatsapp: 'whatsapp'
}
liberal_enum :kind
validates :kind, presence: true, inclusion: { in: kinds.values }
end
# app/models/concerns/liberal_enum.rb
module LiberalEnum
extend ActiveSupport::Concern
class_methods do
def liberal_enum(attribute)
decorate_attribute_type(attribute, :enum) do |subtype|
LiberalEnumType.new(attribute, public_send(attribute.to_s.pluralize), subtype)
end
end
end
end
# app/types/liberal_enum_type.rb
class LiberalEnumType < ActiveRecord::Enum::EnumType
# suppress <ArgumentError>
# returns a value to be able to use +inclusion+ validation
def assert_valid_value(value)
value
end
end
Usage:
contact = Contact.new(kind: 'foo')
contact.valid? #=> false
contact.errors.full_messages #=> ["Kind is not included in the list"]

Answer 2

UPDATED to support .valid? to have idempotent validations.
This solution isn't really elegant, but it works.
We had this problem in an API application. We do not like the idea of rescueing this error every time it is needed to be used in any controller or action. So we rescued it in the model-side as follows:
class Course < ApplicationRecord
validate :course_type_should_be_valid
def course_type=(value)
super value
#course_type_backup = nil
rescue ArgumentError => exception
error_message = 'is not a valid course_type'
if exception.message.include? error_message
#course_type_backup = value
self[:course_type] = nil
else
raise
end
end
private
def course_type_should_be_valid
if #course_type_backup
self.course_type ||= #course_type_backup
error_message = 'is not a valid course_type'
errors.add(:course_type, error_message)
end
end
end
Arguably, the rails-team's choice of raising ArgumentError instead of validation error is correct in the sense that we have full control over what options a user can select from a radio buttons group, or can select over a select field, so if a programmer happens to add a new radio button that has a typo for its value, then it is good to raise an error as it is an application error, and not a user error.
However, for APIs, this will not work because we do not have any control anymore on what values get sent to the server.

Answer 3

Want to introduce another solution.
class Course < ApplicationRecord
COURSE_TYPES = %i[ trial limited unlimited ]
enum course_type: COURSE_TYPES
validate do
if #not_valid_course_type
errors.add(:course_type, "Not valid course type, please select from the list: #{COURSE_TYPES}")
end
end
def course_type=(value)
if !COURSE_TYPES.include?(value.to_sym)
#not_valid_course_type = true
else
super value
end
end
end
This will avoid ArgumentError in controllers. Works well on my Rails 6 application.

Answer 4

Using the above answer of the logic of Dmitry I made this dynamic solution to the ActiveRecord model
Solution 1:
#app/models/account.rb
class Account < ApplicationRecord
ENUMS = %w(state kind meta_mode meta_margin_mode)
enum state: {disable: 0, enable: 1}
enum kind: {slave: 0, copy: 1}
enum meta_mode: {demo: 0, real: 1}
enum meta_margin_mode: {netting: 0, hedging: 1}
validate do
ENUMS.each do |e|
if instance_variable_get("#not_valid_#{e}")
errors.add(e.to_sym, "must be #{self.class.send("#{e}s").keys.join(' or ')}")
end
end
end
after_initialize do |account|
Account::ENUMS.each do |e|
account.class.define_method("#{e}=") do |value|
if !account.class.send("#{e}s").keys.include?(value)
instance_variable_set("#not_valid_#{e}", true)
else
super value
end
end
end
end
end
Updated.
Solution2: Here's another approach to dynamically replicate to other models.
#lib/lib_enums.rb
module LibEnums
extend ActiveSupport::Concern
included do
validate do
self.class::ENUMS.each do |e|
if instance_variable_get("#not_valid_#{e}")
errors.add(e.to_sym, "must be #{self.class.send("#{e}s").keys.join(' or ')}")
end
end
end
self::ENUMS.each do |e|
self.define_method("#{e}=") do |value|
if !self.class.send("#{e}s").keys.include?(value)
instance_variable_set("#not_valid_#{e}", true)
else
super value
end
end
end
end
end
#app/models/account.rb
require 'lib_enums'
class Account < ApplicationRecord
ENUMS = %w(state kind meta_mode meta_margin_mode)
include LibEnums
end

Answer 5

The above answer by Aliaksandr does not work for Rails 7.0.4 as the decorate_attribute_type method was removed in Rails 7 and unified with the attribute method.
As such, the above solution will raise a NoMethodError similar to the following:
NoMethodError (undefined method `decorate_attribute_type' for <Model>:Class)
To implement that solution in Rails 7 consider using the following modified concern instead:
# app/models/concerns/liberal_enum.rb
module LiberalEnum
extend ActiveSupport::Concern
class_methods do
def liberal_enum(attribute)
attribute(attribute, :enum) do |subtype|
LiberalEnumType.new(attribute, public_send(attribute.to_s.pluralize), subtype)
end
end
end
end

Answer 6

The answer posted by fin-cos won't work for me in Rails 7.0.4.2
In my tests I get the following error:
ArgumentError: You tried to define an enum named "name_of_the_enum" on the model "Model", but this will generate a instance method "name_of_the_enum_value?", which is already defined by another enum.
The Rails docs state that attribute overrides existing definitions. But somehow that isn't true.
UPDATE (2023-02-20):
I took Dmitry Shveikus solution, which was working for me and mixed it with the concern approach. So I ended up with:
models/concerns/validates_enum.rb:
module ValidatesEnum
extend ActiveSupport::Concern
class_methods do
def validates_enum(*enums)
enums.each do |enum_attribute|
define_method(:"#{enum_attribute}_types") do
self.class.const_get(:"#{enum_attribute.to_s.upcase}_TYPES").keys.map(&:to_s)
end
define_method(:"#{enum_attribute}=") do |value|
if !send("#{enum_attribute}_types").include?(value)
self.instance_variable_set(:"#not_valid_#{enum_attribute}_type", true)
else
super value
end
end
validate do
if self.instance_variable_get(:"#not_valid_#{enum_attribute}_type")
errors.add(enum_attribute, "Not a valid #{enum_attribute} type, please select from the list: #{send(:"#{enum_attribute}_types").join(', ')}")
end
end
end
end
end
end
And in your model:
class Model < ApplicationRecord
include ValidatesEnum
THE_ENUM_TYPES = {
something: 0,
something_other: 1,
}
enum the_enum: THE_ENUM_TYPES
validates_enum :the_enum
end
The convention is to declare the enum values in a constant with the role ENUM_NAME_TYPES (where ENUM_NAME is the name of your defined enum), which you then pass to define the enum itself. The concern will check for that and validate against it.
If you have multiple enums in your model, repeat the above steps. But you can call: validates_enum with multiple enums like so:
validates_enum :enum1, :enum2
Hope that helps!