单元测试保护和保护的最佳方法是什么？ Ruby 中的私有方法？

Question

使用标准 Ruby Test::Unit 框架在 Ruby 中对受保护方法和私有方法进行单元测试的最佳方法是什么？

我确信有人会大喊大叫并教条地断言“你应该只对公共方法进行单元测试；如果需要单元测试，它不应该是受保护或私有方法”，但我对此并不感兴趣。 我有几个出于良好和有效的原因而受保护或私有的方法，这些私有/受保护的方法相当复杂，并且类中的公共方法依赖于这些受保护/私有的方法正常运行，因此我需要一种方法来测试受保护/私有方法。

还有一件事......我通常将给定类的所有方法放在一个文件中，并将该类的单元测试放在另一个文件中。 理想情况下，我希望将“受保护和私有方法的单元测试”功能实现到单元测试文件中，而不是主源文件中，以便使主源文件尽可能简单明了。

Answer 1

您可以使用 send 方法绕过封装：

myobject.send(:method_name, args)

这是 Ruby 的一个“功能”。 :)

在 Ruby 1.9 开发过程中存在内部争论，认为 send 尊重隐私而 send! 忽略它，但最终 Ruby 1.9 没有任何改变。 忽略下面讨论 send! 和破坏事物的评论。

Answer 2

如果您使用 RSpec，这是一种简单的方法：

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

Answer 3

只需在测试文件中重新打开该类，并将一个或多个方法重新定义为公共方法即可。 您不必重新定义方法本身的内部内容，只需将符号传递到 public 调用中即可。

如果您的原始类是这样定义的：

class MyClass

  private

  def foo
    true
  end
end

在您的测试文件中，只需执行以下操作：

class MyClass
  public :foo

end

如果您想公开更多私有方法，可以将多个符号传递给 public 。

public :foo, :bar

Answer 4

instance_eval() 可能会有所帮助：

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

您可以使用它直接访问私有方法和实例变量。

您还可以考虑使用 send()，它还可以让您访问私有和受保护的方法（就像 James Baker 建议的那样）

或者，您可以修改测试对象的元类以使私有/受保护的方法仅针对该对象的公共方法。

    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

这将使您可以调用这些方法，而不会影响该类的其他对象。
您可以在测试目录中重新打开该类，并将它们公开给所有
测试代码中的实例，但这可能会影响您对公共接口的测试。

Answer 5

我过去这样做的一种方法是：

class foo
  def public_method
    private_method
  end

private unless 'test' == Rails.env

  def private_method
    'private'
  end
end

Answer 6

我确信有人会大声说
教条地断言“你应该
仅对公共方法进行单元测试； 如果它
需要单元测试，它不应该是
受保护或私有方法”，但我
对辩论不太感兴趣
那个。

您还可以将它们重构为一个新对象，其中这些方法是公共的，并在原始类中私有地委托给它们。 这将允许您测试这些方法，而无需在您的规范中使用神奇的metaruby，同时保持它们的私密性。

我有几种方法
永久保护或私有
正当理由

这些正当理由是什么？ 其他 OOP 语言根本不需要私有方法（我想到了smalltalk - 其中私有方法仅作为约定而存在）。

Answer 7

与 @WillSargent 的回复类似，这是我在 describe 块中使用的内容，用于测试某些受保护验证器的特殊情况，而无需使用 FactoryGirl 经历创建/更新它们的重量级过程（并且您可以类似地使用private_instance_methods）：

  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

Answer 8

要公开所描述的类的所有受保护和私有方法，您可以将以下内容添加到您的spec_helper.rb中，而不必触及任何规范文件。

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

Answer 9

您可以“重新打开”该类并提供一种委托给私有方法的新方法：

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

Answer 10

我可能倾向于使用instance_eval()。 然而，在了解 instance_eval() 之前，我会在单元测试文件中创建一个派生类。 然后我将私有方法设置为公共方法。

在下面的示例中，build_year_range 方法在 PublicationSearch::ISIQuery 类中是私有的。 仅出于测试目的派生一个新类允许我将方法设置为公共方法，因此可以直接测试。 同样，派生类公开了一个名为“result”的实例变量，该变量以前未公开过。

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

在我的单元测试中，我有一个测试用例，它实例化 MockISIQuery 类并直接测试 build_year_range() 方法。

Answer 11

在Test::Unit框架中可以这样写，

MyClass.send(:public, :method_name)

这里的“method_name”是私有方法。

& 调用这个方法的时候可以这样写，

assert_equal expected, MyClass.instance.method_name(params)

Answer 12

这是我使用的类的一般添加。 这比仅仅公开您正在测试的方法更像是一种霰弹枪，但在大多数情况下这并不重要，而且更具可读性。

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

使用 send 访问受保护/私有方法在 1.9 中被破坏，因此不是推荐的解决方案。

Answer 13

更正上面的最佳答案：在 Ruby 1.9.1 中，是 Object#send 发送所有消息，而 Object#public_send 尊重隐私。

Answer 14

您可以使用单例方法来代替 obj.send。 你的代码中还有 3 行代码
测试类，不需要更改要测试的实际代码。

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

在测试用例中，只要您想测试 my_private_method，就可以使用 my_private_method_publicly。

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

私有方法的 obj.send 在 1.9 中被 send! 取代，但后来 send! 再次被删除。 所以 obj.send 工作得很好。

Answer 15

为了做到这一点：

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

您可以在 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

Answer 16

我知道我参加聚会迟到了，但不要测试私有方法......我想不出这样做的理由。 公共可访问方法是在某处使用该私有方法，测试该公共方法以及导致使用该私有方法的各种场景。 有东西进去，有东西出来。 测试私有方法是一个很大的禁忌，它会让以后重构代码变得更加困难。 它们是私人的是有原因的。