blocks|key|2794318|text|如果您希望更改callMethod方法的签名，一种可能的解决方案是使用接口和依赖项注入。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2794319|创建一个为您提供Dataset[Row]的接口|2794320|trait+ObtainDataSet+{
++def+obtain:+DataSet[Row]
}|code-block|syntax|javascript|2794321|然后让你的callMethod有一个接受这个接口的参数：|2794322|public+void+callMethod(ObtainDataSet+obtainDataSet)+{
++Dataset<Row>++df+=+obtainDataSet.obtain;
}|2794323|然后在生产代码中使用Operations.load方法注入真正的实现：|2794324|class+ObtainDataSetImpl(spark:+SparkSession,+path:+String)+extends+ObtainDataSet+{
++override+def+obtain:+Dataset[Row]+=+Operations.load(sparkSession,+path)
}|2794325|但是，您可以很容易地将该生产实现替换为测试中的特别实现。你甚至不需要使用模拟框架：|2794326|class+MyMock+extends+ObtainDataSet+{
++override+def+obtain:+DataSet[Row]+=+???+//+something+useful+for+tests.
}|2794327|但如果您愿意，通常会使用ScalaMock|2794328|entityMap|0|LINK|mutability|MUTABLE|url|https://www.scalatest.org/user_guide/testing_with_mock_objects^0|7|A|0|8|C|0|0|5|A|0|0|A|F|0|0|0|0|C|9|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|S|3|T|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1N|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|1O|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|1P|8|@]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|10|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|11|$12|$5|13|14|15|E|$16|17]]]]

If you are willing to change the signature of your <code>callMethod</code> method, one possible solution is to use interfaces and dependency injection.
Create an interface which gives you a <code>Dataset[Row]</code>:
<pre class="lang-scala prettyprint-override"><code>trait ObtainDataSet {
 def obtain: DataSet[Row]
}
</code></pre>
And then have your <code>callMethod</code> have a parameter that takes that interface:
<pre class="lang-java prettyprint-override"><code>public void callMethod(ObtainDataSet obtainDataSet) {
 Dataset&lt;Row&gt; df = obtainDataSet.obtain;
}
</code></pre>
Then on production code you inject the real implementation using the <code>Operations.load</code> method:
<pre class="lang-scala prettyprint-override"><code>class ObtainDataSetImpl(spark: SparkSession, path: String) extends ObtainDataSet {
 override def obtain: Dataset[Row] = Operations.load(sparkSession, path)
}
</code></pre>
But you can easily swap that production implementation for something ad-hoc on the tests. You don't even need to use mocking frameworks:
<pre class="lang-scala prettyprint-override"><code>class MyMock extends ObtainDataSet {
 override def obtain: DataSet[Row] = ??? // something useful for tests.
}
</code></pre>
But if you want, <a href="https://www.scalatest.org/user_guide/testing_with_mock_objects" rel="nofollow noreferrer">ScalaMock</a> is normally used

blocks|key|190173|text|这通常是这样做的。我将用scala编写它，因为java的语法要冗长得多(坦率地说，我记不太清楚了)，但它的概念是一样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|190174|+++trait+Operations+{+
+++++++def+load(s:+SparkSession,+path:+String):+DataSet[Row]
+++}
+++object+Operations+extends+Operations+{
+++++++def+load(s:+SparkSession,+path:+String)+=+???+//+implementation+here
+++}

+++class+Main(operations:+Operations+=+Operations)+{
+++++++callMethod():+Unit+=+{
+++++++++val+df+=+operations.load(sparkSession,+path);
+++++++++...
+++++++++//+do+stuff+
++++++}
+++}|code-block|syntax|javascript|190175|然后在测试中，您可以编写(这是使用Mockito/scalatest，但同样，对于您用于测试的任何库，想法也是相同的)：|offset|length|style|CODE|190176|++++val+ops+=+mock[Operations]
++++when(ops.load(any,+any)).thenReturn(whatever)
++++new+Main(ops).callMethod(mock[SparkSession],+"/foo/bar")|190177|这种方法被称为“依赖注入”：您的Main类对Operations有一个“依赖”，现在是在运行时“注入”，而不是像在代码片段中那样被硬编码。这允许您为生产(实际的Operations对象)和测试(模拟)运行使用不同的依赖项实例。|190178|此外，这是一个单独的主题，但我认为它仍然值得一提:您正在测试的方法的Unit+(void)返回类型似乎不是最好的想法，并且可能会在以后的测试中给您带来更多问题(您如何确保该方法实际上产生了您所期望的副作用？)。|190179|最好让此方法返回实际结果，并让调用者处理副作用。然后，您可以很容易地测试它是否产生了您期望的结果：|190180|+++new+Main(ops).callMethod(mock[SparkSession],+"/foo/bar")+shouldBe+"ExpectedFooResult"|190181|entityMap^0|0|0|H|7|P|9|0|0|G|4|M|A|28|A|0|Y|4|14|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$I|1E|J|1F|K|L]|$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1I|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|X|$]]

Here is how this is usually done ... I'll write it in scala, because java syntax is soooo much more verbose (and frankly, I don't remember it very well), but it is the same idea.
<pre><code> trait Operations { 
 def load(s: SparkSession, path: String): DataSet[Row]
 }
 object Operations extends Operations {
 def load(s: SparkSession, path: String) = ??? // implementation here
 }

 class Main(operations: Operations = Operations) {
 callMethod(): Unit = {
 val df = operations.load(sparkSession, path);
 ...
 // do stuff 
 }
 }
</code></pre>
and then in test, you write (this is with <code>Mockito</code>/<code>scalatest</code> but, again, same idea with whatever library you use for testing):
<pre><code> val ops = mock[Operations]
 when(ops.load(any, any)).thenReturn(whatever)
 new Main(ops).callMethod(mock[SparkSession], &quot;/foo/bar&quot;)
</code></pre>
This approach is called &quot;dependency injection&quot;: Your <code>Main</code> class has a &quot;dependency&quot; on <code>Operations</code>, that is now &quot;injected&quot; at run time rather than than being hardcoded as in your snippet. This allows you to use different dependency instances for production (actual <code>Operations</code> object) and test (the mock) runs.
Also, this is a separate topic, but I thought it is still worth mentioning: <code>Unit</code> (<code>void</code>) return type for the method you are testing doesn't seem like the best idea, and will likely cause you more problems testing it down the road (how do you make sure the method actually produced whatever side effects you are expecting from it?).
It would be better to make this method return the actual result, and have the caller take care of the side effects. Then you could easily test that it produces the result you expect:
<pre><code> new Main(ops).callMethod(mock[SparkSession], &quot;/foo/bar&quot;) shouldBe &quot;ExpectedFooResult&quot;
</code></pre>

I have a java code where I am calling a scala object's method (of a dependent library). For writing unit test I want to mock the scala object's method invocation
Operations.scala
<pre><code>object Operations {

 def load(spark: SparkSession, path: String): Dataset[Row] = {

 }
}
</code></pre>
Main.java
<pre><code>public class Main {
 public void callMethod() {
 Dataset&lt;Row&gt; df = Operations.load(sparkSession, path);
 }
}
</code></pre>
I want to write a Unit test for callMethod() and hence mock the Operations.load scala call. I did not find a way to do it.
Any help will be appreciated.

Mock scala objects method call in java class

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一段java代码，其中我调用了一个scala对象的方法(属于一个依赖库)。为了编写单元测试，我想模拟scala对象的方法调用Operations.scalaobject Operations {     def load(spark: SparkSession, path: String): Dataset[Row...

问模拟java类中的scala对象方法调用
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问模拟java类中的scala对象方法调用EN