module ActiveModel::Lint::Tests

def assert_boolean(result, name) 

def assert_boolean(result, name)
  assert result == true || result == false, "#{name} should be a boolean"
end

def model 

def model
  assert @model.respond_to?(:to_model), "The object should respond_to to_model"
  @model.to_model
end

def test_errors_aref

return an empty Array.
for the current locale. If no error is present, this method should
question. If localization is used, the Strings should be localized
Returns an Array of Strings that are the errors for the attribute in

for more details.
Returns an object that has :[] and :full_messages defined on it. See below

== Errors Testing 
def test_errors_aref
  assert model.respond_to?(:errors), "The model should respond to errors"
  assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
end

def test_errors_full_messages

should contain information about the field, if applicable.
Returns an Array of all error messages for the object. Each message 
def test_errors_full_messages
  assert model.respond_to?(:errors), "The model should respond to errors"
  assert model.errors.full_messages.is_a?(Array), "errors#full_messages should return an Array"
end

def test_model_naming


:human and :partial_path. Check ActiveModel::Naming for more information.
Model.model_name must return a string with some convenience methods as

== Naming 
def test_model_naming
  assert model.class.respond_to?(:model_name), "The model should respond to model_name"
  model_name = model.class.model_name
  assert_kind_of String, model_name
  assert_kind_of String, model_name.human
  assert_kind_of String, model_name.partial_path
  assert_kind_of String, model_name.singular
  assert_kind_of String, model_name.plural
end

def test_persisted?

URL for the object.
collection. If it is persisted, a form for the object will be PUT to the
not persisted, a form for that object, for instance, will be POSTed to the
This is used when calculating the URL for an object. If the object is
Returns a boolean that specifies whether the object has been persisted yet.

== Responds to persisted? 
def test_persisted?
  assert model.respond_to?(:persisted?), "The model should respond to persisted?"
  assert_boolean model.persisted?, "persisted?"
end

def test_to_key

or nil if model.persisted? is false
Returns an Enumerable of all (primary) key attributes

== Responds to to_key 
def test_to_key
  assert model.respond_to?(:to_key), "The model should respond to to_key"
  def model.persisted?() false end
  assert model.to_key.nil?
end

def test_to_param

not persisted?, then to_param should always return nil.
implementation strategies on the implementer. However, if the resource is
behavior in lint because it doesn't make sense to force any of the possible
in case the record uses a composite primary key. There are no tests for this
Implementers can decide to either raise an exception or provide a default

or nil if model.persisted? is false.
Returns a string representing the object's key suitable for use in URLs

== Responds to to_param 
def test_to_param
  assert model.respond_to?(:to_param), "The model should respond to to_param"
  def model.to_key() [1] end
  def model.persisted?() false end
  assert model.to_param.nil?
end

def test_valid?

state.
Returns a boolean that specifies whether the object is in a valid or invalid

== Responds to valid? 
def test_valid?
  assert model.respond_to?(:valid?), "The model should respond to valid?"
  assert_boolean model.valid?, "valid?"
end