Java Apache Camel junit测试中的对象结果

我尝试将骆驼输出作为对象进行测试，但未能获取exchange对象。这就是它失败的原因。

Customer resultCustomer=processActs.getExchanges（）.get（0.getIn（）.getBody（Customer.class）

。请帮我解决这个问题。我把这个交给你了

客户POJO:

public class Customer {
    private String firstName;
    private String lastName;
   // getters and setters
    @Override
    public String toString(){
        return firstName +":::" + lastName;
    }
}

public class FileTest4 extends CamelTestSupport {

    @EndpointInject(uri = "direct:teststart")
    private Endpoint start;

    @EndpointInject(uri = "mock:direct:processActs")
    private MockEndpoint processActs;

    @EndpointInject(uri = "mock:direct:write2File")
    private MockEndpoint write2File;

    @EndpointInject(uri = "mock:end")
    private MockEndpoint mockEndResult;

    @Override
    public boolean isUseAdviceWith() {
        return true;
    }

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("file:/var/file.log&noop=true").routeId("MY_ROUTE").to("direct:processActs");

                from("direct:processActs").process(exchange -> {
                    List<Customer> customers = new ArrayList<>();
                    customers.add(new Customer("F1", "L1"));
                    customers.add(new Customer("F2", "L2"));
                    customers.add(new Customer("F3", "L3"));
                    exchange.getOut().setBody(customers);
                }).to("direct:write2File");

                from("direct:write2File").split(simple("${body}")).log("Content: ${body}");
            }
        };
    }

    @Override
    protected void doPostSetup() throws Exception {
        context.getRouteDefinition("MY_ROUTE").adviceWith(context, new AdviceWithRouteBuilder() {
            @Override
            public void configure() throws Exception {
                replaceFromWith("direct:teststart");
                weaveAddLast().to("mock:end");
            }
        });
        context.start();
    }

    @Test
    public void testUnmarshal() throws Exception {
        mockEndResult.expectedMessageCount(1);

    // ArrayIndex Exception here exchanges list is empty
        Customer resultCustomer = processActs.getExchanges().get(0).getIn().getBody(Customer.class); 
        assertEquals(resultCustomer.toString(),"F1:::L1"); 

        write2File.expectedBodiesReceived("F1:::L1", "F3:::L3", "F2:::L2");
        template.sendBody("direct:teststart", new File("src/test/resources/test.txt"));
        mockEndResult.assertIsSatisfied();

    }

}

测试路线：

public class Customer {
    private String firstName;
    private String lastName;
   // getters and setters
    @Override
    public String toString(){
        return firstName +":::" + lastName;
    }
}

public class FileTest4 extends CamelTestSupport {

    @EndpointInject(uri = "direct:teststart")
    private Endpoint start;

    @EndpointInject(uri = "mock:direct:processActs")
    private MockEndpoint processActs;

    @EndpointInject(uri = "mock:direct:write2File")
    private MockEndpoint write2File;

    @EndpointInject(uri = "mock:end")
    private MockEndpoint mockEndResult;

    @Override
    public boolean isUseAdviceWith() {
        return true;
    }

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("file:/var/file.log&noop=true").routeId("MY_ROUTE").to("direct:processActs");

                from("direct:processActs").process(exchange -> {
                    List<Customer> customers = new ArrayList<>();
                    customers.add(new Customer("F1", "L1"));
                    customers.add(new Customer("F2", "L2"));
                    customers.add(new Customer("F3", "L3"));
                    exchange.getOut().setBody(customers);
                }).to("direct:write2File");

                from("direct:write2File").split(simple("${body}")).log("Content: ${body}");
            }
        };
    }

    @Override
    protected void doPostSetup() throws Exception {
        context.getRouteDefinition("MY_ROUTE").adviceWith(context, new AdviceWithRouteBuilder() {
            @Override
            public void configure() throws Exception {
                replaceFromWith("direct:teststart");
                weaveAddLast().to("mock:end");
            }
        });
        context.start();
    }

    @Test
    public void testUnmarshal() throws Exception {
        mockEndResult.expectedMessageCount(1);

    // ArrayIndex Exception here exchanges list is empty
        Customer resultCustomer = processActs.getExchanges().get(0).getIn().getBody(Customer.class); 
        assertEquals(resultCustomer.toString(),"F1:::L1"); 

        write2File.expectedBodiesReceived("F1:::L1", "F3:::L3", "F2:::L2");
        template.sendBody("direct:teststart", new File("src/test/resources/test.txt"));
        mockEndResult.assertIsSatisfied();

    }

}

public类FileTest4扩展了CamelTestSupport{
@端点注入（uri=“direct:teststart”）
私有端点启动；
@端点注入（uri=“mock:direct:processActs”）
私人行为；
@端点注入（uri=“mock:direct:write2File”）
私有文件；
@端点注入（uri=“mock:end”）
私有MockEndpoint mockEndResult；
@凌驾
公共布尔值isUseAdviceWith（）{
返回true；
}
@凌驾
受保护的RouteBuilder createRouteBuilder（）引发异常{
返回新的RouteBuilder（）{
@凌驾
public void configure（）引发异常{
从（“file:/var/file.log&noop=true”）.routeId（“MY_ROUTE”）。到（“direct:processActs”）；
from（“direct:processActs”）.process（交换->{
列出客户=新建ArrayList（）；
添加（新客户（“F1”、“L1”）；
添加（新客户（“F2”、“L2”）；
添加（新客户（“F3”、“L3”）；
exchange.getOut（）.setBody（客户）；
}).to（“直接：写入文件”）；
from（“direct:write2File”）.split（简单（${body}”）.log（“Content:${body}”）；
}
};
}
@凌驾
受保护的void doPostSetup（）引发异常{
context.getRouteDefinition（“我的路线”）.adviceWith（context，newadviceWithRouteBuilder（）{
@凌驾
public void configure（）引发异常{
替换为（“直接：测试开始”）；
weaveAddLast（）.to（“mock:end”）；
}
});
context.start（）；
}
@试验
public void testUnmarshal（）引发异常{
mockEndResult.expectedMessageCount（1）；
//此处的ArrayIndex异常交换列表为空
Customer resultCustomer=processActs.getExchanges（）.get（0.getIn（）.getBody（Customer.class））；
assertEquals（resultCustomer.toString（），“F1:：：L1”）；
write2File.expectedBodiesReceived（“F1:：：L1”、“F3:：：L3”、“F2:：：L2”）；
sendBody（“direct:teststart”，新文件（“src/test/resources/test.txt”）；
mockEndResult.assertessatified（）；
}
}

看起来您在实际发送任何交换之前正在检查模拟端点。尝试将支票移至测试结束处，例如：

@Test
public void testUnmarshal() throws Exception {
    mockEndResult.expectedMessageCount(1);

    write2File.expectedBodiesReceived("F1:::L1", "F3:::L3", "F2:::L2");
    template.sendBody("direct:teststart", new File("src/test/resources/test.txt"));
    mockEndResult.assertIsSatisfied();

    Customer resultCustomer = processActs.getExchanges().get(0).getIn().getBody(Customer.class); 
    assertEquals(resultCustomer.toString(),"F1:::L1"); 
}

更新

仔细检查一下，我想你把你的模拟弄糊涂了。根据您想要检查的断言判断，有三个客户被写了出来。但是，您的模拟并不是为此而设置的

mock:end

被添加到

MY_ROUTE

的末尾，但这只会在

direct:processActs

另外，您使用

@EndpointInject

声明的模拟不会涉及路由，因为您实际上不会模拟真实的端点。除了

mockEndResult

之外，您还可以删除它们

以下测试确实通过了

@Test
public void testUnmarshal() throws Exception {
    mockEndResult.expectedMessageCount(1);

    template.sendBody("direct:teststart", new File("src/test/resources/test.txt"));

    mockEndResult.assertIsSatisfied();

    @SuppressWarnings("unchecked")
    List<Customer> customers = mockEndResult.getExchanges().get(0).getIn().getBody(List.class);
    assertEquals(customers.get(0).toString(), "F1:::L1");
    assertEquals(customers.get(1).toString(), "F2:::L2");
    assertEquals(customers.get(2).toString(), "F3:::L3");
}

---

在执行断言之后，将调用sendtBody。直到车身被打开，才会触发路线sent@NelsonChristos谢谢你的回复，但同样的例外。你必须在得到交换之前声明mock。因为这些交换是到达模拟的实际交换。因此，必须首先满足它的期望，这意味着应该有1条消息到达。List List=（List）mockEndResult.getExchanges（）.get（0.getIn（）.getBody（）；不，这不起作用，mockend将只有字符串not POJO，对吗？谢谢你的回复，但同样的例外。更新了更多细节，并通过了测试。这是起作用的，但我不明白它是什么，你能解释一下吗+谢谢。请检查一下