blocks|key|3357247|text|您可以使用send方法绕过封装：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3357248|myobject.send(:method_name,+args)|code-block|syntax|javascript|3357249|这是Ruby的一个“特性”。:)|3357250|在Ruby1.9开发期间有内部争论，认为让send尊重隐私，而send!忽略它，但最终在Ruby1.9中没有任何改变。忽略下面讨论send!和破坏内容的评论。|offset|length|style|CODE|3357251|entityMap^0|0|0|0|L|4|V|5|1T|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

You can bypass encapsulation with the send method:

<pre class="lang-ruby prettyprint-override"><code>myobject.send(:method_name, args)
</code></pre>

This is a 'feature' of Ruby. :)

There was internal debate during Ruby 1.9 development which considered having <code>send</code> respect privacy and <code>send!</code> ignore it, but in the end nothing changed in Ruby 1.9. Ignore the comments below discussing <code>send!</code> and breaking things.

blocks|key|356294|text|instance_eval()可能会有所帮助：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|356295|---------------------------------------------------+Object#instance_eval
+++++obj.instance_eval(string+[,+filename+[,+lineno]]+)+++=>+obj
+++++obj.instance_eval+{%7C+%7C+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|code-block|syntax|javascript|356296|您可以使用它直接访问私有方法和实例变量。|356297|您还可以考虑使用send()，它还可以让您访问私有和受保护的方法(就像James+Baker建议的那样)|356298|或者，您可以修改测试对象的元类，使私有/受保护的方法只对该对象是公共的。|356299|++++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|356300|这将允许您在不影响该类的其他对象的情况下调用这些方法。您可以重新打开测试目录中的类，并使它们对测试代码中的所有实例都是公共的，但这可能会影响您对公共接口的测试。|356301|entityMap^0|0|F|0|0|0|8|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

<code>instance_eval()</code> might help:

<pre><code>--------------------------------------------------- Object#instance_eval
 obj.instance_eval(string [, filename [, lineno]] ) =&gt; obj
 obj.instance_eval {| | block } =&gt; 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 } #=&gt; 99
</code></pre>

You can use it to access private methods and instance variables directly.

You could also consider using <code>send()</code>, which will also give you access to private and protected methods (like James Baker suggested)

Alternatively, you could modify the metaclass of your test object to make the private/protected methods public just for that object.

<pre><code> test_obj.a_private_method(...) #=&gt; raises NoMethodError
 test_obj.a_protected_method(...) #=&gt; raises NoMethodError
 class &lt;&lt; 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(...) #=&gt; raises NoMethodError
 other_test_obj.a_protected_method(...) #=&gt; raises NoMethodError
</code></pre>

This will let you call these methods without affecting other objects of that class.
You could reopen the class within your test directory and make them public for all the 
instances within your test code, but that might affect your test of the public interface.

blocks|key|357620|text|我以前做过的一种方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357621|class+foo
++def+public_method
++++private_method
++end

private+unless+'test'+==+Rails.env

++def+private_method
++++'private'
++end
end|code-block|syntax|javascript|357622|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One way I've done it in the past is:

<pre><code>class foo
 def public_method
 private_method
 end

private unless 'test' == Rails.env

 def private_method
 'private'
 end
end
</code></pre>

blocks|key|3144607|text|我可能倾向于使用instance_eval()。然而，在我了解instance_eval()之前，我会在我的单元测试文件中创建一个派生类。然后，我会将私有方法设置为公共方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144608|在下面的示例中，build_year_range方法在PublicationSearch::ISIQuery类中是私有的。仅仅为了测试目的而派生一个新类允许我将一个(或多个)方法设置为公共的，因此可以直接测试。同样，派生类公开了一个名为“result”的实例变量，该变量以前未公开。|3144609|#+A+derived+class+useful+for+testing.
class+MockISIQuery+<+PublicationSearch::ISIQuery
++++attr_accessor+:result
++++public+:build_year_range
end|code-block|syntax|javascript|3144610|在我的单元测试中，我有一个测试用例，它实例化MockISIQuery类并直接测试build_year_range()方法。|3144611|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I would probably lean toward using instance_eval(). Before I knew about instance_eval(), however, I would create a derived class in my unit test file. I would then set the private method(s) to be public.

In the example below, the build_year_range method is private in the PublicationSearch::ISIQuery class. Deriving a new class just for testing purposes allows me to set a method(s) to be public and, therefore, directly testable. Likewise, the derived class exposes an instance variable called 'result' that was previously not exposed.

<pre><code># A derived class useful for testing.
class MockISIQuery &lt; PublicationSearch::ISIQuery
 attr_accessor :result
 public :build_year_range
end
</code></pre>

In my unit test I have a test case which instantiates the MockISIQuery class and directly tests the build_year_range() method.

blocks|key|357650|text|您可以“重新打开”这个类，并提供一个委托给私有方法的新方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357651|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|code-block|syntax|javascript|357652|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can "reopen" the class and provide a new method that delegates to the private one:

<pre><code>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
</code></pre>

blocks|key|3144627|text|如果您使用RSpec，这里有一个简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144628|before(:each)+do
++MyClass.send(:public,+*MyClass.protected_instance_methods)++
end|code-block|syntax|javascript|3144629|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's one easy way if you use RSpec:

<pre><code>before(:each) do
 MyClass.send(:public, *MyClass.protected_instance_methods) 
end
</code></pre>

blocks|key|3357407|text|只需在测试文件中重新打开类，并将一个或多个方法重新定义为public。您不必重新定义方法本身的内部，只需将符号传递给public调用即可。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3357408|如果您的原始类是这样定义的：|3357409|class+MyClass

++private

++def+foo
++++true
++end
end|code-block|syntax|javascript|3357410|在您的测试文件中，只需执行以下操作：|3357411|class+MyClass
++public+:foo

end|3357412|如果你想公开更多的私有方法，你可以将多个符号传递给public。|3357413|public+:foo,+:bar|3357414|entityMap^0|1M|6|0|0|0|0|0|P|6|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

Just reopen the class in your test file, and redefine the method or methods as public. You don't have to redefine the guts of the method itself, just pass the symbol into the <code>public</code> call.

If you original class is defined like this:

<pre><code>class MyClass

 private

 def foo
 true
 end
end
</code></pre>

In you test file, just do something like this:

<pre><code>class MyClass
 public :foo

end
</code></pre>

You can pass multiple symbols to <code>public</code> if you want to expose more private methods.

<pre><code>public :foo, :bar
</code></pre>

blocks|key|358481|text|下面是我使用的Class的一般添加。这比仅仅公开你正在测试的方法更像猎枪，但在大多数情况下这都无关紧要，而且更具可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358482|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|code-block|syntax|javascript|358483|使用send访问受保护的/私有方法在1.9中被破坏，因此不是推荐的解决方案。|358484|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is a general addition to Class which I use. It's a bit more shotgun than only making public the method you are testing, but in most cases it doesn't matter, and it's much more readable.

<pre><code>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
</code></pre>

Using send to access protected/private methods is broken in 1.9, so is not a recommended solution.

blocks|key|361059|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|361060|我相信有人会大声疾呼，教条式地断言“你应该只对公共方法进行单元测试；如果它需要单元测试，它就不应该是一个受保护的或私有的方法”，但我对此并不感兴趣。|blockquote|361061|361062|361063|您还可以将这些方法重构为一个新对象，在该对象中这些方法是公共的，并在原始类中私下委托它们。这将允许您在规范中不使用魔法metaruby的情况下测试这些方法，同时保持它们的私密性。|361064|361065|我有几个受保护的或私有的方法，这是有充分和正当理由的|361066|361067|361068|这些合理的理由是什么？其他OOP语言可以完全不使用私有方法(我想到了smalltalk--私有方法只作为一种约定存在)。|361069|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|Q|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|R|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|S|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|T|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|U|7|@]|8|@]|9|$]]|$1|H|3|-4|4|5|6|V|7|@]|8|@]|9|$]]|$1|I|3|J|4|C|6|W|7|@]|8|@]|9|$]]|$1|K|3|-4|4|5|6|X|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|Y|7|@]|8|@]|9|$]]|$1|M|3|N|4|5|6|Z|7|@]|8|@]|9|$]]|$1|O|3|-4|4|5|6|10|7|@]|8|@]|9|$]]]|P|$]]

<blockquote>
 I'm sure somebody will pipe up and
 dogmatically assert that "you should
 only unit test public methods; if it
 needs unit testing, it shouldn't be a
 protected or private method", but I'm
 not really interested in debating
 that.
</blockquote>

You could also refactor those into a new object in which those methods are public, and delegate to them privately in the original class. This will allow you to test the methods without magic metaruby in your specs while yet keeping them private.

<blockquote>
 I've got several methods that are
 protected or private for good and
 valid reasons
</blockquote>

What are those valid reasons? Other OOP languages can get away without private methods at all (smalltalk comes to mind - where private methods only exist as a convention).

blocks|key|3144697|text|您可以使用单例方法来代替obj.send。它在您的测试类中多了3行代码，并且不需要对实际要测试的代码进行任何更改。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144698|def+obj.my_private_method_publicly+(*args)
++my_private_method(*args)
end|code-block|syntax|javascript|3144699|在测试用例中，只要您想测试my_private_method，就可以使用my_private_method_publicly。|offset|length|style|CODE|3144700|http://mathandprogramming.blogspot.com/2010/01/ruby-testing-private-methods.html|3144701|私有方法的obj.send在1.9中被send!取代，但后来send!再次被删除。所以obj.send运行得很好。|3144702|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|D|H|10|Q|0|0|28|0|0|5|8|J|5|U|5|17|8|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Z|8|@$I|10|J|11|K|L]|$I|12|J|13|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|14|8|@]|9|@$I|15|J|16|1|17]]|A|$]]|$1|O|3|P|5|6|7|18|8|@$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|N]]]]

Instead of obj.send you can use a singleton method. It’s 3 more lines of code in your 
test class and requires no changes in the actual code to be tested.

<pre><code>def obj.my_private_method_publicly (*args)
 my_private_method(*args)
end
</code></pre>

In the test cases you then use <code>my_private_method_publicly</code> whenever you want to test <code>my_private_method</code>.

<a href="http://mathandprogramming.blogspot.com/2010/01/ruby-testing-private-methods.html" rel="nofollow noreferrer">http://mathandprogramming.blogspot.com/2010/01/ruby-testing-private-methods.html</a>

<code>obj.send</code> for private methods was replaced by <code>send!</code> in 1.9, but later <code>send!</code> was removed again. So <code>obj.send</code> works perfectly well.

blocks|key|358493|text|纠正上面的答案:在Ruby1.9.1中，发送所有消息的是Object#send，而Object#public_send尊重隐私。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358494|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

To correct the top answer above: in Ruby 1.9.1, it's Object#send that sends all the messages, and Object#public_send that respects privacy.

blocks|key|361074|text|要为所描述的类公开所有受保护的私有方法，您可以将以下内容添加到您的spec_helper.rb中，而不必接触任何规范文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|361075|RSpec.configure+do+%7Cconfig%7C
++config.before(:each)+do
++++described_class.send(:public,+*described_class.protected_instance_methods)
++++described_class.send(:public,+*described_class.private_instance_methods)
++end
end|code-block|syntax|javascript|361076|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

To make public all protected and private method for the described class, you can add the following to your spec_helper.rb and not having to touch any of your spec files.

<pre><code>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
</code></pre>

blocks|key|361078|text|我知道我来晚了，但不要测试私有方法……我想不出这样做的理由。可公开访问的方法是在某个地方使用该私有方法，测试该公共方法以及导致使用该私有方法的各种场景。有东西进去，就会有东西出来。测试私有方法是一个很大的禁忌，而且它使得以后重构代码变得更加困难。它们是私人的，这是有原因的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|361079|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I know I'm late to the party, but don't test private methods....I can't think of a reason to do this. A publicly accessible method is using that private method somewhere, test the public method and the variety of scenarios that would cause that private method to be used. Something goes in, something comes out. Testing private methods is a big no-no, and it makes it much harder to refactor your code later. They are private for a reason.

blocks|key|3144747|text|为此，请执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144748|disrespect_privacy+@object+do+%7Cp%7C
++assert+p.private_method
end|code-block|syntax|javascript|3144749|您可以在test_helper文件中实现此功能：|3144750|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|3144751|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In order to do this:

<pre><code>disrespect_privacy @object do |p|
 assert p.private_method
end
</code></pre>

You can implement this in your test_helper file:

<pre><code>class ActiveSupport::TestCase
 def disrespect_privacy(object_or_class, &amp;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
</code></pre>

blocks|key|357723|text|在Test::Unit框架中可以编写，|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357724|MyClass.send(:public,+:method_name)|code-block|syntax|javascript|357725|这里的"method_name“是私有方法。|357726|在调用此方法时，可以编写，|357727|assert_equal+expected,+MyClass.instance.method_name(params)|357728|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In Test::Unit framework can write,

<pre><code>MyClass.send(:public, :method_name)
</code></pre>

Here "method_name" is private method. 

&amp; while calling this method can write,

<pre><code>assert_equal expected, MyClass.instance.method_name(params)
</code></pre>

blocks|key|361102|text|与@WillSargent的响应类似，下面是我在describe块中使用的，用于测试一些受保护的验证器的特殊情况，而不需要通过FactoryGirl创建/更新它们的重量级过程(您也可以类似地使用private_instance_methods+)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|361103|++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|code-block|syntax|javascript|361104|entityMap^0|O|8|2P|O|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Similar to @WillSargent's response, here's what I've used in a <code>describe</code> block for the special case of testing some protected validators without needing to go through the heavyweight process of creating/updating them with FactoryGirl (and you could use <code>private_instance_methods</code> similarly):

<pre><code> 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
</code></pre>

What's the best way to unit test protected and private methods in Ruby, using the standard Ruby <code>Test::Unit</code> framework?

I'm sure somebody will pipe up and dogmatically assert that "you should only unit test public methods; if it needs unit testing, it shouldn't be a protected or private method", but I'm not really interested in debating that. I've got several methods that are protected or private for good and valid reasons, these private/protected methods are moderately complex, and the public methods in the class depend upon these protected/private methods functioning correctly, therefore I need a way to test the protected/private methods.

One more thing... I generally put all the methods for a given class in one file, and the unit tests for that class in another file. Ideally, I'd like all the magic to implement this "unit test of protected and private methods" functionality into the unit test file, not the main source file, in order to keep the main source file as simple and straightforward as possible.

What's the best way to unit test protected & private methods in Ruby?

单元测试

使用标准的Ruby Test::Unit框架，在Ruby中对受保护的和私有的方法进行单元测试的最佳方式是什么？我相信有人会大声疾呼，教条式地断言“你应该只对公共方法进行单元测试；如果它需要单元测试，它就不应该是一个受保护的或私有的方法”，但我对此并不感兴趣。我有几个是保护的或私有的方法，这些私有/受保护的方法是中等复杂...

问在Ruby中对受保护的私有方法进行单元测试的最佳方式是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中对受保护的私有方法进行单元测试的最佳方式是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中对受保护的私有方法进行单元测试的最佳方式是什么？
EN