Quelle est la meilleure façon de tester les méthodes protégées et privées dans Ruby?

Quelle est la meilleure façon de tester des méthodes protégées et privées dans Ruby, en utilisant le Test::Unitframework Ruby standard ?

Je suis sûr que quelqu'un dira dogmatiquement que "vous ne devriez tester que des méthodes publiques unitaires; si cela nécessite des tests unitaires, ce ne devrait pas être une méthode protégée ou privée", mais je ne suis pas vraiment intéressé à en débattre. J'ai plusieurs méthodes qui sont protégées ou privées pour de bonnes et valables raisons, ces méthodes privées / protégées sont modérément complexes, et les méthodes publiques de la classe dépendent du fonctionnement correct de ces méthodes protégées / privées, j'ai donc besoin d'un moyen de tester les méthodes protégées / privées.

Encore une chose ... Je mets généralement toutes les méthodes pour une classe donnée dans un fichier, et les tests unitaires pour cette classe dans un autre fichier. Idéalement, j'aimerais que toute la magie implémente cette fonctionnalité de "test unitaire des méthodes protégées et privées" dans le fichier de test unitaire, pas dans le fichier source principal, afin de garder le fichier source principal aussi simple et direct que possible.

Vous pouvez contourner l'encapsulation avec la méthode d'envoi:

myobject.send(:method_name, args)

C'est une «fonctionnalité» de Ruby. :)

Il y a eu un débat interne pendant le développement de Ruby 1.9 qui envisageait de sendrespecter la vie privée et de l' send!ignorer, mais au final, rien n'a changé dans Ruby 1.9. Ignorez les commentaires ci-dessous pour discuter send!et casser des choses.

Voici un moyen simple si vous utilisez RSpec:

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

Rouvrez simplement la classe dans votre fichier de test et redéfinissez la ou les méthodes comme publiques. Vous n'avez pas à redéfinir les tripes de la méthode elle-même, il suffit de passer le symbole dans l' publicappel.

Si votre classe d'origine est définie comme ceci:

class MyClass

  private

  def foo
    true
  end
end

Dans votre fichier de test, faites quelque chose comme ceci:

class MyClass
  public :foo

end

Vous pouvez transmettre plusieurs symboles à publicsi vous souhaitez exposer des méthodes plus privées.

public :foo, :bar

instance_eval() pourrait aider:

--------------------------------------------------- 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

Vous pouvez l'utiliser pour accéder directement aux méthodes privées et aux variables d'instance.

Vous pouvez également envisager d'utiliser send(), ce qui vous donnera également accès à des méthodes privées et protégées (comme James Baker l'a suggéré)

Vous pouvez également modifier la métaclasse de votre objet de test pour rendre les méthodes privées / protégées publiques uniquement pour cet objet.

    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

Cela vous permettra d'appeler ces méthodes sans affecter les autres objets de cette classe. Vous pouvez rouvrir la classe dans votre répertoire de test et les rendre publiques pour toutes les instances de votre code de test, mais cela peut affecter votre test de l'interface publique.

Une façon dont je l'ai fait dans le passé est:

class foo
  def public_method
    private_method
  end

private unless 'test' == Rails.env

  def private_method
    'private'
  end
end

Je suis sûr que quelqu'un dira dogmatiquement que "vous ne devriez tester que des méthodes publiques unitaires; si cela nécessite des tests unitaires, ce ne devrait pas être une méthode protégée ou privée", mais je ne suis pas vraiment intéressé à en débattre.

Vous pouvez également les refactoriser dans un nouvel objet dans lequel ces méthodes sont publiques et leur déléguer en privé dans la classe d'origine. Cela vous permettra de tester les méthodes sans métarubie magique dans vos spécifications tout en les gardant privées.

J'ai plusieurs méthodes qui sont protégées ou privées pour de bonnes et valables raisons

Quelles sont ces raisons valables? D'autres langages POO peuvent se passer de méthodes privées du tout (smalltalk vient à l'esprit - là où les méthodes privées n'existent que comme convention).

Semblable à la réponse de @ WillSargent, voici ce que j'ai utilisé dans un describebloc pour le cas particulier du test de certains validateurs protégés sans avoir à passer par le processus lourd de création / mise à jour avec FactoryGirl (et vous pouvez utiliser de la private_instance_methodsmême manière):

  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

Pour rendre publiques toutes les méthodes protégées et privées de la classe décrite, vous pouvez ajouter ce qui suit à votre spec_helper.rb sans avoir à toucher à aucun de vos fichiers de spécifications.

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

Vous pouvez «rouvrir» la classe et fournir une nouvelle méthode qui délègue à la classe privée:

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

Je pencherais probablement vers l'utilisation de instance_eval (). Avant de connaître instance_eval (), cependant, je créerais une classe dérivée dans mon fichier de test unitaire. Je définirais alors la ou les méthodes privées comme publiques.

Dans l'exemple ci-dessous, la méthode build_year_range est privée dans la classe PublicationSearch :: ISIQuery. Dériver une nouvelle classe uniquement à des fins de test me permet de définir une ou plusieurs méthodes pour qu'elles soient publiques et, par conséquent, directement testables. De même, la classe dérivée expose une variable d'instance appelée «résultat» qui n'était auparavant pas exposée.

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

Dans mon test unitaire, j'ai un cas de test qui instancie la classe MockISIQuery et teste directement la méthode build_year_range ().

Dans Test :: Unit, le framework peut écrire,

MyClass.send(:public, :method_name)

Ici, "nom_méthode" est une méthode privée.

& en appelant cette méthode peut écrire,

assert_equal expected, MyClass.instance.method_name(params)

Voici un ajout général à la classe que j'utilise. C'est un peu plus insensé que de rendre publique la méthode que vous testez, mais dans la plupart des cas, cela n'a pas d'importance et c'est beaucoup plus lisible.

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

L'utilisation d'envoi pour accéder aux méthodes protégées / privées est interrompue dans la version 1.9, ce n'est donc pas une solution recommandée.

Pour corriger la première réponse ci-dessus: dans Ruby 1.9.1, c'est Object # send qui envoie tous les messages, et Object # public_send qui respecte la confidentialité.

Au lieu de obj.send, vous pouvez utiliser une méthode singleton. Il s'agit de 3 lignes de code supplémentaires dans votre classe de test et ne nécessite aucune modification du code réel à tester.

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

Dans les cas de test, vous utilisez ensuite my_private_method_publiclychaque fois que vous souhaitez tester my_private_method.

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

obj.sendpour les méthodes privées a été remplacé par send!dans la version 1.9, mais a send!été supprimé ultérieurement . Fonctionne donc obj.sendparfaitement bien.

Je sais que je suis en retard à la fête, mais ne testez pas les méthodes privées ... Je ne vois aucune raison de le faire. Une méthode accessible au public utilise cette méthode privée quelque part, teste la méthode publique et la variété de scénarios qui entraîneraient l'utilisation de cette méthode privée. Quelque chose entre, quelque chose sort. Tester des méthodes privées est un grand non-non, et il sera beaucoup plus difficile de refactoriser votre code plus tard. Ils sont privés pour une raison.

Pour ce faire:

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

Vous pouvez l'implémenter dans votre fichier 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