ruby on rails - tutorial - validación y manejo de errores para objetos de servicio

tutorial django

Question

Creé un objeto de servicio en Rails para que funcione como una interfaz entre nuestra aplicación y nuestra API.

Obtuve la idea de http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/

Aquí hay un pequeño ejemplo:

class PackagesService
  def self.get_package(package_id)
    raise ArgumentError.new("package_id can''t be nil") if package_id.blank?
    package = API::get "/packages/#{package_id}"
    package = JSON.parse package,
                          :symbolize_names => true unless package.blank?

  end
end

¿Hay algún buen patrón para manejar la validación y / o arrojar errores para los objetos de servicio?

Para validaciones:

• Tengo que verificar todas las entradas para el tipo nulo o incorrecto. ¿Hay alguna forma de validación fácil? Tal vez una extensión de rieles?

Para errores:

• Pude detectar todos los errores de API y luego devolver un nulo de forma segura. Pero el programador que usa el objeto de servicio puede no saber el significado de nil.
• Pude detectar los errores de API y generar otro error, lo que significa un esfuerzo adicional para hacerlo en todas las funciones
• La tercera opción es dejarlo tal como está y dejar que el programador maneje todos los errores de la API.

Avíseme si conoce algún patrón bueno o si tiene mejores ideas para interactuar con una API.

Answer 1

Para casos simples (por ejemplo, con solo un argumento), entonces su check-and-raise con ArgumentError está bien. Tan pronto como comienzas a tener casos complejos (argumentos múltiples, objetos, etc.), empiezo a apoyarme en Virtus y Validaciones de ActiveModel .

Su artículo vinculado realmente los menciona (ver "Extraer objetos de formulario"). Algunas veces uso algo como esto para construir objetos de servicio, ej.

require ''active_model''
require ''virtus''

class CreatePackage
  include Virtus
  include ActiveModel::Validations

  attribute :name, String
  attribute :author, String
  validates_presence_of :name, :author

  def create
    raise ArgumentError.new("Invalid package") unless self.valid?
    response = JSON.parse(
      API::post("/packages", self.attributes),
      :symbolize_names => true
    )
    Package.new(response)
  end
end

class Package
  include Virtus
  attribute :id, Integer
  attribute :name, String
  attribute :author, String
end

# eg.
service = CreatePackage.new(
  :name => "Tim''s Tams",
  :author => "Tim",
)
service.valid? # true; if false, see service.errors
package = service.create

package.attributes
# => { :id => 123, :name => "Tim''s Tams", :author => "Tim" }

En cuanto a las excepciones, las dejaría como están para acciones más pequeñas (como esta clase de servicio). Me gustaría envolverlos si estoy escribiendo algo más sustancial, como una biblioteca de cliente API completa.

Nunca volveré a nada. Cosas como un error de red, o una respuesta mala o inaplicable del servidor se benefician de errores explícitos.

Finalmente, hay un enfoque mucho más pesado llamado use_case . Incluso si no lo usa, tiene muchas ideas sobre cómo abordar los objetos de servicio, las validaciones y los resultados que puede encontrar interesantes.

Editar : También, mira Mutaciones . Como use_case, excepto que es más simple y menos completo.