如何为Vertex composit future或rxJava编写Junit测试用例

下面是我需要为其编写Junit测试用例的方法。 这里的问题是为下面返回未来的方法编写JUnit测试用例

public Future<SomeResponse> getSomeResponse(SomeQuery someQuery){
    if(dbCircuitBreaker == null){
        dbCircuitBreaker= CircuitBreakers.getDbCircuitBreaker();
    }
    return dbCircuitBreaker.execute(future -> {
        List<SomeResponseMetaData> SomeResponseMetaDataList = new ArrayList<>();
        SomeResponse someResponse = new SomeResponse();
        Observable<Some> someMetaDataObservable = someSQLRepository.findSomeDetails(someQuery);
        someMetaDataObservable.subscribe(some -> {
            getSomeResponse(someResponseMetaDataList,some);
        },throwable -> {
            FIDAL_LOGGER.error(CLASS_FULL_NAME, "getSomeResponse", LogConstants.UNCAUGHT_ERROR, "Could not able to fetch the data from some", throwable);
        },()->{
            FIDAL_LOGGER.info(CLASS_FULL_NAME, "getSomeResponse", LogConstants.UNCAUGHT_ERROR, "fetch the data for some is completed");
            someResponse.setSomeLists(someResponseMetaDataList);
            future.complete(someResponse);
        });
    });
}

public Future getSomeResponse（SomeQuery-SomeQuery）{
如果（dbCircuitBreaker==null）{
dbCircuitBreaker=断路器。getDbCircuitBreaker（）；
}
返回dbCircuitBreaker.execute（未来->{
列出SomeResponseMetaDataList=new ArrayList（）；
SomeResponse SomeResponse=新的SomeResponse（）；
Observable someMetaDataObservable=someSQLRepository.findSomeDetails（someQuery）；
someMetaDataObservable.subscribe（一些->{
getSomeResponse（SomeResponseMetadata，some）；
}，可丢弃->{
FIDAL_LOGGER.error（类_全名，“getSomeResponse”，LogConstants.UNCAUGHT_error，“无法从某些对象获取数据”，可丢弃）；
},()->{
FIDAL_LOGGER.info（类_全名，“getSomeResponse”，LogConstants.UNCAUGHT_错误，“获取某些数据已完成”）；
someResponse.SetSomeList（someResponseMetaDataList）；
未来。完成（一些回应）；
});
});
}

这不是最好的解决方案，但我已经编写了适合我的解决方案

import io.vertx.rxjava.circuitbreaker.CircuitBreaker;
import io.vertx.rxjava.core.Future;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.modules.junit4.PowerMockRunner;
import rx.Single;
import rx.observers.TestSubscriber;

import java.util.ArrayList;
import java.util.List;

@RunWith(PowerMockRunner.class)
@PowerMockIgnore("javax.management.*")
public class FileServiceHelperTest {

    @Mock
    SomeServiceHelper someServiceHelper = null;
    @InjectMocks
    CircuitBreaker dbCircuitBreaker = null;
    @InjectMocks
    SomeLineSQLRepository someLineSQLRepository = null;
    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
    }


    @Test
    public void getSomeResponse() {
        SomeResponseMetaData someResponseMetaData = new SomeResponseMetaData();
        someResponseMetaData.setRecievedDate("2020-02-12T03:57:01-0600");
        someResponseMetaData.setFileName("29579_3_Order_File1_20200207050043852");
        someResponseMetaData.setSomeId("43b61ab4-52b8-48e6-9489-b5824d278254");
        someResponseMetaData.setSomeStatus("PROCESSED");
        someResponseMetaData.setSubmitted("3");
        someResponseMetaData.setProcessed("0");
        someResponseMetaData.setPending("0");
        someResponseMetaData.setErrors("3");
        someResponseMetaData.setSomeType("ORDER");
        someResponseMetaData.setShipNodeId("29579_3");
        List<SomeResponseMetaData> someResponseMetaDataList = new ArrayList();
        someResponseMetaDataList.add(someResponseMetaData);
        SomeResponse someResponseExpected = new SomeResponse();
        someResponseExpected.setSomeLists(someResponseMetaDataList);
        Future<SomeResponse> someResponseFuture = Future.succeededFuture(someResponseExpected);
        SomeQuery someQuery = new SomeQuery.SomeQueryBuilder("29579").setPageNo(0).setPageSize(1).build();
        Mockito.when(someServiceHelper.getSomeResponse(someQuery)).thenReturn(someResponseFuture);
        Single<SomeResponse> someResponseSingle = someServiceHelper.getSomeResponse(someQuery).rxSetHandler();
        TestSubscriber<SomeResponse> testSubscriber = new TestSubscriber();
        someResponseSingle.subscribe(testSubscriber);
        testSubscriber.assertCompleted();
        testSubscriber.assertNoErrors();
        testSubscriber.assertValue(someResponseExpected);
    }
}

导入io.vertx.rxjava.circuitbreaker.circuitbreaker；
导入io.vertx.rxjava.core.Future；
导入org.junit.Before；
导入org.junit.Test；
导入org.junit.runner.RunWith；
导入org.mockito.InjectMocks；
导入org.mockito.Mock；
导入org.mockito.mockito；
导入org.mockito.MockitoAnnotations；
导入org.powermock.core.classloader.annotations.PowerMockIgnore；
导入org.powermock.modules.junit4.PowerMockRunner；
进口接收单；
导入rx.observators.TestSubscriber；
导入java.util.ArrayList；
导入java.util.List；
@RunWith（PowerMockRunner.class）
@PowerMockIgnore（“javax.management.*”）
公共类FileServiceHelperTest{
@嘲弄
SomeServiceHelper SomeServiceHelper=null；
@注射模拟
断路器Db断路器=零；
@注射模拟
SomeLineSQLRepository SomeLineSQLRepository=null；
@以前
public void setUp（）引发异常{
initMocks（this）；
}
@试验
public void getSomeResponse（）{
SomeResponseMetaData SomeResponseMetaData=新的SomeResponseMetaData（）；
设置接收日期（“2020-02-12T03:57:01-0600”）；
setFileName（“29579_3_Order_File1_20200207050043852”）；
someResponseMetaData.setSomeId（“43b61ab4-52b8-48e6-9489-b5824d278254”）；
someResponseMetaData.setSomeStatus（“已处理”）；
提交的一些响应数据（“3”）；
someResponseMetaData.setProcessed（“0”）；
someResponseMetaData.setPending（“0”）；
someResponseMetaData.setErrors（“3”）；
someResponseMetaData.setSomeType（“订单”）；
someResponseMetaData.setShipNodeId（“29579_3”）；
列出someResponseMetaDataList=new ArrayList（）；
someResponseMetaData.add（someResponseMetaData）；
SomeResponse someResponseExpected=新的SomeResponse（）；
someResponseExpected.SetSomeList（someResponseMetaDataList）；
Future someResponseFuture=Future.SucceedFuture（someResponseExpected）；
SomeQuery SomeQuery=new SomeQuery.SomeQueryBuilder（“29579”）.setPageNo（0.setPageSize（1.build（）；
Mockito.when（someServiceHelper.getSomeResponse（someQuery）），然后返回（someResponseFuture）；
Single-someResponseSingle=someServiceHelper.getSomeResponse（someQuery.rxSetHandler（）；
TestSubscriber TestSubscriber=新的TestSubscriber（）；
someResponseSingle.subscribe（testSubscriber）；
testSubscriber.assertCompleted（）；
testSubscriber.assertNoErrors（）；
testSubscriber.assertValue（someResponseExpected）；
}
}