Java 单元测试库的改进

我正在为使用Reformation2进行调用的存储库编写单元测试

我想在从服务器接收到

调用后测试逻辑

问题：当分别运行每个测试时，它们都通过了，但是当运行类的所有测试时，只有一个通过了。其他测试失败，原因是：
需要但未调用：。。。但是，与此模拟正好有一个交互：
，它指的是
listener.onDataFailure（）
。原因是：调用总是返回相同的对象
调用。失败（IOException（））
作为每个测试的结果。

存储库类代码：

public class Repository {

    private static Repository repository;

    private Repository(@NonNull final RetrofitService service) {
        this.service = service;
    }

    public synchronized static Repository getInstance(RetrofitService service) {

        if (repository == null) {
            repository = new Repository(service);
        }
        return repository;
    }

    public void getDataFromApi(@NonNull final DataListener listener) {

            service.getData("application/json").clone().enqueue(new Callback<DataList>() {

                @Override
                public void onResponse(@NonNull Call<DataList> call, @NonNull Response<DataList> response) {

                    if (response.errorBody() == null && response.body() != null) {
                    listener.onDataSuccess(response.body())
                    } else {
                    listener.onDataFailure(new Exception(t.getMessage()));
                    }
                }

                @Override
                public void onFailure(@NonNull Call<DataList> call, @NonNull Throwable t) {

                    listener.onDataFailure(new Exception(t.getMessage()));

                }
            });
    }
}

公共类存储库{
私有静态存储库；
专用存储库（@NonNull最终服务）{
服务=服务；
}
公共同步静态存储库getInstance（更新服务）{
if（存储库==null）{
repository=新存储库（服务）；
}
返回存储库；
}
public void getDataFromApi（@NonNull final DataListener listener）{
service.getData（“application/json”）.clone（）.enqueue（新回调（）{
@凌驾
public void onResponse（@NonNull调用，@NonNull响应）{
if（response.errorBody（）==null&&response.body（）！=null）{
listener.onDataSuccess（response.body（））
}否则{
onDataFailure（新异常（t.getMessage（））；
}
}
@凌驾
public void onFailure（@NonNull Call Call，@NonNull Throwable t）{
onDataFailure（新异常（t.getMessage（））；
}
});
}
}

RepositoryTest类代码：


import com.google.common.truth.Truth.assertThat
import okhttp3.ResponseBody
import org.junit.*
import org.mockito.*
import org.mockito.Mockito.*
import retrofit2.Call
import retrofit2.Response
import retrofit2.mock.Calls
import java.io.IOException
import org.mockito.Mockito.`when` as mockitoWhen

class RepositoryTest {

    @Mock
    lateinit var retrofitService: RetrofitService
    @Mock
    lateinit var dataListener: DataListener
    @Mock
    lateinit var body: ResponseBody


    private lateinit var repo: Repository

    @Before
    fun setup() {
        MockitoAnnotations.initMocks(this)
        repo = Repository.getInstance(retrofitService)
    }

    @Test
    fun `geteData given_failure result_onDataFailure called`() {
        val call: Call<DataList> = Calls.failure(IOException())
        mockitoWhen(retrofitService.getData(any(), any()))
            .thenReturn(call.clone())

        repo.getDataFromApi(dataListener)

        verify(dataListener).onDataFailure(ArgumentMatchers.any())

    }

    @Test
    fun `geteData given_success result_onDataSuccess called`() {
        val call: Call<DataList> = Calls.response(Response.success(dataList))
        mockitoWhen(retrofitService.getData(any(), any()))
            .thenReturn(call.clone())

        repo.getDataFromApi(dataListener)

        verify(dataListener).onDataFailure(ArgumentMatchers.any())

    }
}



导入com.google.common.truth.truth.assertThat
导入okhttp3.responsebook
导入org.junit*
导入org.mockito*
导入org.mockito.mockito*
2.致电
2.回应
导入2.mock.Calls
导入java.io.IOException
导入org.mockito.mockito.`when`作为mockitoWhen
类存储测试{
@嘲弄
lateinit var翻新服务：翻新服务
@嘲弄
lateinit var dataListener:dataListener
@嘲弄
lateinit变量主体：ResponseBody
私有lateinit var repo:存储库
@以前
趣味设置（）{
initMocks（this）
repo=Repository.getInstance（服务）
}
@试验
fun`geteData给定\u失败结果\u onDataFailure调用`（）{
val call:call=Calls.failure（IOException（））
mockitoWhen（reformationservice.getData（any（），any（）））
.thenReturn（调用.clone（））
repo.getDataFromApi（dataListener）
验证（dataListener.onDataFailure（ArgumentMatchers.any（））
}
@试验
fun`geteData给定\u成功结果\u onDataSuccess调用`（）{
val call:call=Calls.response（response.success（数据列表））
mockitoWhen（reformationservice.getData（any（），any（）））
.thenReturn（调用.clone（））
repo.getDataFromApi（dataListener）
验证（dataListener.onDataFailure（ArgumentMatchers.any（））
}
}



因此，在本例中，上述1个测试通过，另一个测试在这两种情况下都失败
dataListener.onDataFailure
已在同一对象上调用。
同时，分别运行这两种方法可以获得2倍的通过率

问题：为什么每个单元测试都返回相同的
调用
对象（这导致测试失败）？
我认为存储库中的
单例
在一次运行所有测试时会导致问题。尽量不要在
setup（）
方法中创建单例，然后立即运行所有测试。