¿Cuál es la mejor manera de probar los métodos protegidos y privados en Ruby?

¿Cuál es la mejor manera de probar los métodos protegidos y privados en Ruby, utilizando el Test::Unitmarco estándar de Ruby ?

Estoy seguro de que alguien hablará y afirmará dogmáticamente que "solo debe realizar una prueba unitaria de los métodos públicos; si necesita una prueba unitaria, no debería ser un método protegido o privado", pero no estoy realmente interesado en debatir eso. Tengo varios métodos que están protegidos o privados por razones buenas y válidas, estos métodos privados / protegidos son moderadamente complejos, y los métodos públicos en la clase dependen de que estos métodos protegidos / privados funcionen correctamente, por lo tanto, necesito una forma de probar Los métodos protegidos / privados.

Una cosa más ... Generalmente pongo todos los métodos para una clase dada en un archivo, y las pruebas unitarias para esa clase en otro archivo. Idealmente, me gustaría toda la magia para implementar esta funcionalidad de "prueba unitaria de métodos protegidos y privados" en el archivo de prueba unitaria, no en el archivo fuente principal, para mantener el archivo fuente principal lo más simple y directo posible.

Puede omitir la encapsulación con el método de envío:

myobject.send(:method_name, args)

Esta es una 'característica' de Ruby. :)

Hubo un debate interno durante el desarrollo de Ruby 1.9 que consideró sendrespetar la privacidad e send!ignorarla, pero al final nada cambió en Ruby 1.9. Ignora los comentarios a continuación discutiendo send!y rompiendo cosas.

Aquí hay una manera fácil si usa RSpec:

before(:each) do
  MyClass.send(:public, *MyClass.protected_instance_methods)  
end

Simplemente vuelva a abrir la clase en su archivo de prueba y redefina el método o los métodos como públicos. No tiene que redefinir las agallas del método en sí, solo pase el símbolo en la publicllamada.

Si su clase original se define así:

class MyClass

  private

  def foo
    true
  end
end

En su archivo de prueba, simplemente haga algo como esto:

class MyClass
  public :foo

end

Puede pasar varios símbolos a publicsi desea exponer métodos más privados.

public :foo, :bar

instance_eval() podría ayudar:

--------------------------------------------------- Object#instance_eval
     obj.instance_eval(string [, filename [, lineno]] )   => obj
     obj.instance_eval {| | block }                       => obj
------------------------------------------------------------------------
     Evaluates a string containing Ruby source code, or the given 
     block, within the context of the receiver (obj). In order to set 
     the context, the variable self is set to obj while the code is 
     executing, giving the code access to obj's instance variables. In 
     the version of instance_eval that takes a String, the optional 
     second and third parameters supply a filename and starting line 
     number that are used when reporting compilation errors.

        class Klass
          def initialize
            @secret = 99
          end
        end
        k = Klass.new
        k.instance_eval { @secret }   #=> 99

Puede usarlo para acceder a métodos privados y variables de instancia directamente.

También podría considerar el uso send(), que también le dará acceso a métodos privados y protegidos (como sugirió James Baker)

Alternativamente, puede modificar la metaclase de su objeto de prueba para hacer públicos los métodos privados / protegidos solo para ese objeto.

    test_obj.a_private_method(...) #=> raises NoMethodError
    test_obj.a_protected_method(...) #=> raises NoMethodError
    class << test_obj
        public :a_private_method, :a_protected_method
    end
    test_obj.a_private_method(...) # executes
    test_obj.a_protected_method(...) # executes

    other_test_obj = test.obj.class.new
    other_test_obj.a_private_method(...) #=> raises NoMethodError
    other_test_obj.a_protected_method(...) #=> raises NoMethodError

Esto le permitirá llamar a estos métodos sin afectar a otros objetos de esa clase. Puede volver a abrir la clase dentro de su directorio de prueba y hacerlos públicos para todas las instancias dentro de su código de prueba, pero eso podría afectar su prueba de la interfaz pública.

Una forma de hacerlo en el pasado es:

class foo
  def public_method
    private_method
  end

private unless 'test' == Rails.env

  def private_method
    'private'
  end
end

Estoy seguro de que alguien hablará y afirmará dogmáticamente que "solo debe realizar una prueba unitaria de los métodos públicos; si necesita una prueba unitaria, no debería ser un método protegido o privado", pero no estoy realmente interesado en debatir eso.

También podría refactorizarlos en un nuevo objeto en el que esos métodos son públicos y delegarlos en privado en la clase original. Esto le permitirá probar los métodos sin metaruby mágico en sus especificaciones mientras los mantiene privados.

Tengo varios métodos protegidos o privados por razones válidas y válidas.

¿Cuáles son esas razones válidas? Otros lenguajes de OOP pueden escapar sin métodos privados (smalltalk viene a la mente, donde los métodos privados solo existen como una convención).

Similar a la respuesta de @ WillSargent, esto es lo que he usado en un describebloque para el caso especial de probar algunos validadores protegidos sin necesidad de pasar por el pesado proceso de crearlos / actualizarlos con FactoryGirl (y podría usar de private_instance_methodsmanera similar):

  describe "protected custom `validates` methods" do
    # Test these methods directly to avoid needing FactoryGirl.create
    # to trigger before_create, etc.
    before(:all) do
      @protected_methods = MyClass.protected_instance_methods
      MyClass.send(:public, *@protected_methods)
    end
    after(:all) do
      MyClass.send(:protected, *@protected_methods)
      @protected_methods = nil
    end

    # ...do some tests...
  end

Para hacer públicos todos los métodos protegidos y privados para la clase descrita, puede agregar lo siguiente a su spec_helper.rb y no tener que tocar ninguno de sus archivos de especificaciones.

RSpec.configure do |config|
  config.before(:each) do
    described_class.send(:public, *described_class.protected_instance_methods)
    described_class.send(:public, *described_class.private_instance_methods)
  end
end

Puede "volver a abrir" la clase y proporcionar un nuevo método que delegue al privado:

class Foo
  private
  def bar; puts "Oi! how did you reach me??"; end
end
# and then
class Foo
  def ah_hah; bar; end
end
# then
Foo.new.ah_hah

Probablemente me inclinaría hacia el uso de instance_eval (). Sin embargo, antes de saber sobre instance_eval (), creaba una clase derivada en mi archivo de prueba unitaria. Luego establecería los métodos privados para que sean públicos.

En el ejemplo a continuación, el método build_year_range es privado en la clase PublicationSearch :: ISIQuery. Derivar una nueva clase solo con fines de prueba me permite establecer uno o varios métodos para que sean públicos y, por lo tanto, directamente comprobables. Del mismo modo, la clase derivada expone una variable de instancia llamada 'resultado' que anteriormente no estaba expuesta.

# A derived class useful for testing.
class MockISIQuery < PublicationSearch::ISIQuery
    attr_accessor :result
    public :build_year_range
end

En mi prueba unitaria, tengo un caso de prueba que crea una instancia de la clase MockISIQuery y prueba directamente el método build_year_range ().

En Test :: Unit framework puede escribir,

MyClass.send(:public, :method_name)

Aquí "nombre_método" es un método privado.

y mientras llama a este método puede escribir,

assert_equal expected, MyClass.instance.method_name(params)

Aquí hay una adición general a la clase que uso. Es un poco más escopeta que solo hacer público el método que está probando, pero en la mayoría de los casos no importa, y es mucho más legible.

class Class
  def publicize_methods
    saved_private_instance_methods = self.private_instance_methods
    self.class_eval { public *saved_private_instance_methods }
    begin
      yield
    ensure
      self.class_eval { private *saved_private_instance_methods }
    end
  end
end

MyClass.publicize_methods do
  assert_equal 10, MyClass.new.secret_private_method
end

El uso de métodos de envío / acceso protegidos / privados se divide en 1.9, por lo que no es una solución recomendada.

Para corregir la respuesta superior anterior: en Ruby 1.9.1, es Object # send el que envía todos los mensajes, y Object # public_send que respeta la privacidad.

En lugar de obj.send, puede usar un método singleton. Son 3 líneas más de código en su clase de prueba y no requiere cambios en el código real para ser probado.

def obj.my_private_method_publicly (*args)
  my_private_method(*args)
end

En los casos de prueba, puede usarlos my_private_method_publiclycuando quiera my_private_method.

http://mathandprogramming.blogspot.com/2010/01/ruby-testing-private-methods.html

obj.sendpara métodos privados fue reemplazado por send!en 1.9, pero luego send!fue eliminado nuevamente. Entonces obj.sendfunciona perfectamente bien.

Sé que llego tarde a la fiesta, pero no pruebes métodos privados ... No puedo pensar en una razón para hacerlo. Un método de acceso público está utilizando ese método privado en alguna parte, pruebe el método público y la variedad de escenarios que causarían el uso de ese método privado. Algo entra, algo sale. Probar métodos privados es un gran no-no, y hace que sea mucho más difícil refactorizar su código más adelante. Son privados por una razón.

Para hacer esto:

disrespect_privacy @object do |p|
  assert p.private_method
end

Puede implementar esto en su archivo test_helper:

class ActiveSupport::TestCase
  def disrespect_privacy(object_or_class, &block)   # access private methods in a block
    raise ArgumentError, 'Block must be specified' unless block_given?
    yield Disrespect.new(object_or_class)
  end

  class Disrespect
    def initialize(object_or_class)
      @object = object_or_class
    end
    def method_missing(method, *args)
      @object.send(method, *args)
    end
  end
end