blocks|key|1425623|text|如果您的run()方法唯一做的事情就是调用其他对象，那么您可以对其进行测试，但要验证模拟是否已被调用。具体如何做到这一点取决于mock包，但通常您会找到某种"expect“方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1425624|不要在run()方法中编写跟踪其执行的代码。如果您不能基于其与协作者(模拟)的交互来验证方法的操作，则表明需要重新考虑这些交互。这样做也会使主线代码变得混乱，增加维护成本。|1425625|entityMap^0|4|5|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

If the only thing that your <code>run()</code> method does is invoke other objects, then you test it but verifying that the mocks were invoked. Exactly how you do this depends on the mock package, but generally you will find an "expect" method of some sort.

Do not write code within your run() method that will track its execution. If you are unable to verify the method's operation based on its interactions with collaborators (the mocks), that indicates a need to rethink those interactions. Doing so also clutters the mainline code, increasing maintenance costs.

blocks|key|1425725|text|当您注入一个mock时，您将向Run类的构造函数传递一个测试类，您将询问测试是否通过。例如，您可以在构造函数中传递excel文件的情况下，测试IParser模拟是否收到了正确的请求。您可以通过您自己的类完成此操作，并收集其中的结果并测试它收集的结果，或者您可以通过模拟框架完成此操作，该框架为您提供了在不构造类的情况下表达此类测试的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1425726|我看到你用tdd标记了你的问题，但在真正的tdd中，你并没有真正理解这个问题(你理解了，但问得不一样)，因为你首先构建测试，它定义了接口，而不是构建类接口，然后考虑如何测试这个东西。测试的需要驱动了设计。您仍然使用相同的技术(在这种情况下，很可能以相同的设计结束)，但问题可能会有一点不同。|1425727|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

When you inject a mock, you pass to the Run class's constructor a test class that you will ask if the test passed. For example, you could test that the IParser mock got the correct request given the excel file you passed in the constructor. You can do this via your own class, and collect the results in it and test what it collected, or you could do this via a mocking framework that gives you ways of expressing such testing without constructing a class.

I see that you tagged your question with tdd, but in true tdd you don't really get this question (you do, but asked differently) because you build the test first, which defines the interface, instead of building the class interface and then thinking how are you going to test this thing. The need to test drives the design. You still use the same techniques (and likely end up with the same design in this case), but the question would have come out a bit different.

blocks|key|1210924|text|您提到在您的自包含类中使用了3个类/接口的模拟实现...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1210925|为什么不创建一些从模拟IConnection返回的已知值，只需通过模拟IParser传递所有这些值，并将它们存储在模拟IDataAccess中-然后在测试检查中查看模拟IDataAccess中的结果是否与运行run()方法后从模拟IConnection中输入的预期结果匹配？|1210926|编辑后添加了一个示例-|1210927|应用程序接口/类：|1210928|public+interface+IConnection+{
++++public+List<Foo>+findFoos();
}

public+interface+IParser+{
++++public+List<Foo>+parse(List<Foo>+originalFoos);
}

public+interface+IDataAccess+{
++++public+void+save(List<Foo>+toSave);
}

public+class+Job+implements+Runnable+{
++++private+IConnection+connection;
++++private+IParser+parser;
++++private+IDataAccess+dataAccess;

++++public+Job(IConnection+connection,+IParser+parser,+IDataAccess+dataAccess)+{
++++++++this.connection+=+connection;
++++++++this.parser+=+parser;
++++++++this.dataAccess+=+dataAccess;
++++}

++++public+void+run()+{
++++++++List<Foo>+allFoos+=+connection.findFoos();
++++++++List<Foo>+someFoos+=+parser.parse(allFoos);
++++++++dataAccess.save(someFoos);
++++}
}|code-block|syntax|javascript|1210929|模拟/测试类：|1210930|public+class+MockConnection+implements+IConnection+{
++++private+List<Foo>+foos;

++++public+List<Foo>+findFoos()+{
++++++++return+foos;
++++}

++++public+void+setFoos(List<Foo>+foos)+{
++++++++this.foos+=+foos;
++++}
}

public+class+MockParser+implements+IParser+{

++++private+int[]+keepIndexes+=+new+int[0];

++++public+List<Foo>+parse(List<Foo>+originalFoos)+{
++++++++List<Foo>+parsedFoos+=+new+ArrayList<Foo>();
++++++++for+(int+i+=+0;+i+<+originalFoos.size();+i%2B%2B)+{
++++++++++++for+(int+j+=+0;+j+<+keepIndexes.length;+j%2B%2B)+{
++++++++++++++++if+(i+==+keepIndexes[j])+{
++++++++++++++++++++parsedFoos.add(originalFoos.get(i));
++++++++++++++++}
++++++++++++}
++++++++}
++++++++return+parsedFoos;
++++}

++++public+void+setKeepIndexes(int[]+keepIndexes)+{
++++++++this.keepIndexes+=+keepIndexes;
++++}
}

public+class+MockDataAccess+implements+IDataAccess+{
++++private+List<Foo>+saved;

++++public+void+save(List<Foo>+toSave)+{
++++++++saved+=+toSave;
++++}

++++public+List<Foo>+getSaved()+{
++++++++return+saved;
++++}
}

public+class+JobTestCase+extends+TestCase+{

++++public+void+testJob()+{
++++++++List<Foo>+foos+=+new+ArrayList<Foo>();
++++++++foos.add(new+Foo(0));
++++++++foos.add(new+Foo(1));
++++++++foos.add(new+Foo(2));
++++++++MockConnection+connection+=+new+MockConnection();
++++++++connection.setFoos(foos);
++++++++int[]+keepIndexes+=+new+int[]+{1,+2};
++++++++MockParser+parser+=+new+MockParser();
++++++++parser.setKeepIndexes(keepIndexes);
++++++++MockDataAccess+dataAccess+=+new+MockDataAccess();
++++++++Job+job+=+new+Job(connection,+parser,+dataAccess);
++++++++job.run();
++++++++List<Foo>+savedFoos+=+dataAccess.getSaved();
++++++++assertTrue(savedFoos.length+==+2);
++++++++assertTrue(savedFoos.contains(foos.get(1)));
++++++++assertTrue(savedFoos.contains(foos.get(2)));
++++++++assertFalse(savedFoos.contains(foos.get(0)));
++++}
}|1210931|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You mention you have mock implementations of the 3 classes/interfaces being used in in your self-contained class...

Why not create some known values to return from your mock IConnection, just pass all of them through your mock IParser, and store them in your mock IDataAccess - then in the test check to see that the results in the mock IDataAccess match the expected results from the input from the mock IConnection after running through the run() method?

Edited to add an example - 

Application interfaces / classes:

<pre><code>public interface IConnection {
 public List&lt;Foo&gt; findFoos();
}

public interface IParser {
 public List&lt;Foo&gt; parse(List&lt;Foo&gt; originalFoos);
}

public interface IDataAccess {
 public void save(List&lt;Foo&gt; toSave);
}

public class Job implements Runnable {
 private IConnection connection;
 private IParser parser;
 private IDataAccess dataAccess;

 public Job(IConnection connection, IParser parser, IDataAccess dataAccess) {
 this.connection = connection;
 this.parser = parser;
 this.dataAccess = dataAccess;
 }

 public void run() {
 List&lt;Foo&gt; allFoos = connection.findFoos();
 List&lt;Foo&gt; someFoos = parser.parse(allFoos);
 dataAccess.save(someFoos);
 }
}
</code></pre>

Mocks / Test classes:

<pre><code>public class MockConnection implements IConnection {
 private List&lt;Foo&gt; foos;

 public List&lt;Foo&gt; findFoos() {
 return foos;
 }

 public void setFoos(List&lt;Foo&gt; foos) {
 this.foos = foos;
 }
}

public class MockParser implements IParser {

 private int[] keepIndexes = new int[0];

 public List&lt;Foo&gt; parse(List&lt;Foo&gt; originalFoos) {
 List&lt;Foo&gt; parsedFoos = new ArrayList&lt;Foo&gt;();
 for (int i = 0; i &lt; originalFoos.size(); i++) {
 for (int j = 0; j &lt; keepIndexes.length; j++) {
 if (i == keepIndexes[j]) {
 parsedFoos.add(originalFoos.get(i));
 }
 }
 }
 return parsedFoos;
 }

 public void setKeepIndexes(int[] keepIndexes) {
 this.keepIndexes = keepIndexes;
 }
}

public class MockDataAccess implements IDataAccess {
 private List&lt;Foo&gt; saved;

 public void save(List&lt;Foo&gt; toSave) {
 saved = toSave;
 }

 public List&lt;Foo&gt; getSaved() {
 return saved;
 }
}

public class JobTestCase extends TestCase {

 public void testJob() {
 List&lt;Foo&gt; foos = new ArrayList&lt;Foo&gt;();
 foos.add(new Foo(0));
 foos.add(new Foo(1));
 foos.add(new Foo(2));
 MockConnection connection = new MockConnection();
 connection.setFoos(foos);
 int[] keepIndexes = new int[] {1, 2};
 MockParser parser = new MockParser();
 parser.setKeepIndexes(keepIndexes);
 MockDataAccess dataAccess = new MockDataAccess();
 Job job = new Job(connection, parser, dataAccess);
 job.run();
 List&lt;Foo&gt; savedFoos = dataAccess.getSaved();
 assertTrue(savedFoos.length == 2);
 assertTrue(savedFoos.contains(foos.get(1)));
 assertTrue(savedFoos.contains(foos.get(2)));
 assertFalse(savedFoos.contains(foos.get(0)));
 }
}
</code></pre>

blocks|key|1211002|text|TDD的基本思想是，通过遵守它，您将编写易于测试的代码，因为您首先针对缺乏实现的接口编写测试，然后编写代码以使测试通过。在测试之前，您似乎已经编写了Job类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1211003|我认为您可以更改Job.Run实现，在这种情况下，如果您希望代码是可测试的，则应该对其执行一些操作，以便能够读取需要测试的值。|1211004|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The idea of TDD is basically that by adhering to it, you are going to write code that is easy to test, because you first write the tests against an interface that lacks the implementation, and then write the code to make the tests pass. It seems that you have written the Job class before the tests.

I figured out that you can change the Job.Run implementation, in which case if you want the code to be testable, you should do something to it to be able to read the values you need to test for.

blocks|key|1211044|text|你所描述的is+often+called+behavior+verification+(与状态验证相对)。它有支持者，也有反对者，但对于某些类别的类来说，如果你想进行单元测试，它是唯一的游戏。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1211045|要对其行为仅限于与协作者交互的类进行单元测试，您通常会传递模拟协作者对象，这些对象是以允许您验证其方法是否以您期望的方式调用的方式进行检测的。|1211046|如果你用手来做这件事(讨厌！)对于您在问题中提到的类，您可以创建实现IParser的MockParser类，并添加记录是否以及如何调用其方法的属性。|style|CODE|1211047|最好使用mocking框架来动态创建mock，指定对它们的期望，并验证这些期望。|1211048|我最近一直在使用NMock2，测试结果如下所示：|1211049|//+'mockery'+is+the+central+framework+object+and+Mock+object+factory
IParser+mockParser+++=+mockery.NewMock<IParser>();

//+Other+dependencies+omitted
Job+++++job++++++++++=+new+Job(mockParser);

//+This+just+ensures+this+method+is+called+so+the+return+value+doesn't+matter
Expect.Once.On(mockParser).
++++.Method("Parse").
++++.WithAnyArguments().
++++.Will(Return.Value(new+object()));

job.Run();
mockery.VerifyAllExpectationsHaveBeenMet();|code-block|syntax|javascript|1211050|entityMap|0|LINK|mutability|MUTABLE|url|http://martinfowler.com/articles/mocksArentStubs.html|1|http://www.nmock.org/^0|5|11|0|0|0|Y|7|16|A|0|0|8|6|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|17|8|@$A|18|B|19|H|I]|$A|1A|B|1B|H|I]]|9|@]|C|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|N|3|O|5|P|7|1H|8|@]|9|@]|C|$Q|R]]|$1|S|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]]]

What you're describing <a href="http://martinfowler.com/articles/mocksArentStubs.html" rel="noreferrer">is often called behavior verification</a> (as opposed to state verification). It's got its proponents and detractors, but for several categories of classes it's the only game in town if you want to unit test.

To unit test a class whose behavior is limited to interacting with collaborators, you typically pass mock collaborator objects that are instrumented in a way that allows you to verify their methods have been called in the way you expect.

If you were to do this by hand (yuck!) for the classes you mentioned in your question, you might create a <code>MockParser</code> class that implements <code>IParser</code> and adds properties that record if and how its methods were called.

It's better to use mocking framework that will create the mocks on the fly, specify expections on them, and verify those expectations.

I've been using <a href="http://www.nmock.org/" rel="noreferrer">NMock2</a> these days, and the tests look something like this:

<pre><code>// 'mockery' is the central framework object and Mock object factory
IParser mockParser = mockery.NewMock&lt;IParser&gt;();

// Other dependencies omitted
Job job = new Job(mockParser);

// This just ensures this method is called so the return value doesn't matter
Expect.Once.On(mockParser).
 .Method("Parse").
 .WithAnyArguments().
 .Will(Return.Value(new object()));

job.Run();
mockery.VerifyAllExpectationsHaveBeenMet();
</code></pre>

I didn't find much in tutorials on this specific question..

So I have a class called 'Job' which has public ctors and a single public Run() function. Everything in the class is private and encapsulated in the class. (You may remember an older post here on this <a href="https://stackoverflow.com/questions/1590953/testing-only-the-public-method-on-a-mid-sized-class">Testing only the public method on a mid sized class?</a>, which replies helped me greatly)

This Run() method does a bunch of things - takes an excel file as input, extracts data out of it, sends a request to a third party data vendor, takes the result and puts it in the database and logs the begining / end of the job.

This Job class uses 3 seperate interfaces / classes inside it's run method, (IConnection will connect to the third party vendor and send the request, IParser will parse the results, and IDataAccess will save the results to the database). So now, the only real logic inside my Run() method is extracting out the excel input and sending it down the chain of the other classes. I created 3 mock classes and use DI on the Job class ctor and everything is fine and dandy...

Except - I'm still a little lost on how the heck to test my Run() method - because it's void and doesn't return anything...

In this case, should I add a return value to the Run() method that returns how many records were extracted from the Excel file? Since this is the only logic done in that function now.. this wouldn't be handled in real code, but would be in the unit tests... which seems a bit smelly to me - but i'm a newb as far as true TDD is concerned...

Second question - should I created a fourth class called IExcelExtractor, which does that logic for me? Or is this a bit of class explosion??

Even if I did the latter, how would I test my Run() function if it returns void and all of its work is being carried out by mocked objects which really do nothing? I could understand if my function had a meaningful return value... but in this case I'm a but confused.

Thanks so much for reading through all this if you made it this far.

Unit testing a class with no return value?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

关于这个特定的问题，我在教程中没有找到太多。所以我有一个叫做'Job‘的类，它有公共的ctor和一个公共的Run()函数。类中的所有内容都是私有的，并封装在类中。(你可能还记得这个上的一个老帖子，它的回复对我帮助很大)Run()方法做了一大堆事情-接受一个excel文件作为输入，从中提取数据，向第三方数据供应商发送请求...

问对没有返回值的类进行单元测试？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对没有返回值的类进行单元测试？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问对没有返回值的类进行单元测试？
EN