Unit testing 如何模拟ApacheCamel

我有下面的RouteBuilder

公共类MyRoute扩展RouteBuilder{
@凌驾
public void configure（）{
errorHandler（死信通道（errorHandlerEndpoint）
.最大可再交付量（1）
.重新交付展示（2000年）
.retryAttemptedLogLevel（LoggingLevel.WARN））；
from（fromEndpoint）.routeId（“FetchPrepreprocessingResultFromMarkLogicRoute”）
.setHeader（“principal”）.method（principalService，“getPrincipal”）.id（“getPrincipalServiceMethod”）//将主体放在头中供以后使用
.multicast（）
.filter（xpath（//文件[@ml generated='true']））
.choice（）
.when（PredicateBuilder.isEqualTo（常量（EPrincipal.VETCENTER.principal（）），simple（${header.principal.principal.principal}）））
.log（“正在发送VetCenter预处理报告…”）
.inOnly（toVetCenterEmailNotificationEndpoint）
.when（PredicateBuilder.isEqualTo（常量（EPrincipal.ostethek.principal（）），simple（${header.principal.principal.principal.principal}）））
.log（“发送骨科预处理报告…”）
.inOnly（ToosethekeEmailNotificationEndpoint）
.否则（）
.log（“主体未知。不发送预处理报告…”）
.inoOnly（“direct:trash”）/@ToDo:Write-test
(完)
.inOnly（到清理阶段决策点）
.inOnly（删除导入资源点）
.end（）；
}
}

这是JUnit测试：

@RunWith（SpringJUnit4ClassRunner.class）
@ContextConfiguration（位置={“classpath:application context test.xml”}）
来自MarkLogicRoute_测试的公共类FetchPreprocessingResultFromMarklogicRoute_测试扩展了CamelTest支持{
私人航线建造商航线；
@值（${fetchPreprocessingResultFromMarklogicRoute.fromEndpoint}”）
私有字符串testFromEndpoint；
@值（${fetchPreprocessingResultFromMarklogicRoute.toCleaningPhaseDecisionEndpoint}”）
专用字符串到CleaningPhaseDecisionEndpoint；
@值（${fetchPreprocessingResultFromMarklogicRoute.vetcenter.toEmailNotificationEndpoint}）
私有字符串toEmailNotificationVetCenterEndpoint；
@值（${fetchPreprocessingResultFromMarklogicRoute.osteThek.toEmailNotificationEndpoint}”）
私有字符串发送通知到kendpoint；
@值（${fetchPreprocessingResultFromMarklogicRoute.deleteImportDirsEndpoint}”）
私有字符串testDeleteImportDissendPoint；
@值（${fetchPreprocessingResultFromMarklogicRoute.errorHandlerEndpoint}”）
私有字符串测试器RorrHandlerEndpoint；
私有MockEndpoint emailNotificationVetCenterMOCKEndpoint；
@嘲弄
private PrincipalsService principalServiceMOCK；
@凌驾
受保护的RouteBuilder createRouteBuilder（）引发异常{
如果（路由==null）{
route=新的MyRoute(
testFromEndpoint，
要清理阶段决策点，
toEmailNotificationVetCenterEndpoint，
向Kendpoint发送通知，
TestDeleteImportDissendPoint，
测试仪箭头和参考点，
principalServiceMOCK）；
}
返回路线；
}
@凌驾
public void setUp（）引发异常{
initMocks（this）；
主体=新主体（）；
委托人：setPrincipal（EPrincipal.VETCENTER）；
Mockito.when（principalServiceMOCK.getPrincipal（“anyIdentificator”））。然后返回（principal）；
super.setUp（）；
}
@试验
public void test（）引发InterruptedException{
InputStream resourceInputStream=Thread.currentThread（）.getContextClassLoader（）.getResourceAsStream（“testdata/importreport/inc/import log Vetcenter.xml”）；
字符串消息=新扫描仪（resourceInputStream）。使用分隔符（\\A”）.next（）；
emailNotificationVetCenterMOCKEndpoint=getMockEndpoint（toEmailNotificationVetCenterEndpoint）；
emailNotificationVetCenterMOCKEndpoint.expectedBodiesReceived（消息）；
//这是一个很好的例子，它是一个很好的例子
template.sendBody（testFromEndpoint，message）；
emailNotificationVetCenterMOCKEndpoint.Assertessatified（）；
}
}

这是Principal和enum EPrincipal的片段：

公共类主体{
私人委托人；
公共EPrincipal getPrincipal（）{
返还本金；
}
公共无效集合委托人（EPrincipal委托人）{
this.principal=principal；
}
}
公共枚举EPrincipal{
VETCENTER（“VETCENTER”）、OSTEOTHEK（“OSTEOTHEK”）；
私有最终字符串主体；
EPrincipal（最终字符串主体）
{
this.principal=principal；
}
公共字符串主体（）
{
返还本金；
}
}

我不知道如何对这个片段进行模拟：

.when(PredicateBuilder.isEqualTo(constant(EPrincipal.VETCENTER.principal()), simple("${header.principal.principal.principal}")))

更确切地说，这一部分：

simple("${header.principal.principal.principal}")

这是一种表达语言，我不知道如何为它创建一个模拟。是否有其他解决方案为其创建单元测试

---

非常感谢您的帮助

强制

principalServiceMOCK

在

getPrincipal

中返回所需的测试主体

请看下面的简化示例

接口：

public static interface PrincipalService {
    Principal getPrincipal(String id);
    Principal getPrincipal();
}

测试等级：

@Mock
PrincipalService principalServiceMOCK;

@EndpointInject(uri = "mock:result")
MockEndpoint resultEndpoint;

@Override
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    Principal principal = new Principal();
    principal.setPrincipal(Type.VETCENTER);
    Mockito.when(principalServiceMOCK.getPrincipal(TEST_ID)).thenReturn(principal);
    Mockito.when(principalServiceMOCK.getPrincipal()).thenReturn(principal);
    super.setUp();
}

@Test
public void test() throws InterruptedException {
    resultEndpoint.expectedMessageCount(1);
    resultEndpoint.expectedBodiesReceived(TEST_ID); // OK
    resultEndpoint.expectedHeaderReceived("principal1", Type.VETCENTER);
    resultEndpoint.expectedHeaderReceived("principal2", Type.VETCENTER);

    template.sendBody("direct:start", TEST_ID);

    resultEndpoint.assertIsSatisfied();
}

@Override
protected RouteBuilder createRouteBuilder() throws Exception {
    return new RouteBuilder() {
        @Override
        public void configure() {
            from("direct:start")
                    .setHeader("principal1").method(principalServiceMOCK, "getPrincipal(${body}).getPrincipal()")
                    .setHeader("principal2").method(principalServiceMOCK, "getPrincipal().getPrincipal()")
                    .to("mock:result");
        }
    };
}

请注意：

• 如果使用原始服务实现和

  constant

  ，则在配置时（

  configure（）

  被调用）评估报头，如果在运行时使用

  方法（
  direct:start
  被调用）

• 如果使用模拟服务，则在配置时对这两种情况的头进行评估

---

所以我明白了。问题在于标题的设置。彼得，我有公司