Java Flink-多来源集成测试

我有一份Flink工作，我正在使用下面描述的方法进行集成测试：

作业从两个源获取输入，这两个源组合在一个

coflatmapFunction

中。在测试环境中，我目前使用两个简单的SourceFunction来发出值，但是这不提供对事件发出顺序的任何控制。这是正确测试作业功能所必需的

如何修改测试以确保一个源函数在第二个源函数之前发出其所有数据

---

我已经看到了中建议的方法，这对于单元测试很好，但我正在寻找一种解决方案，允许我集成测试整个工作。

我建议将控制代码添加到您的两个

源函数中，并使用
MiniClusterWithClientResource
。它可以如下所示：

public class JobITCase {

    private static final int NUM_TMS = 2;
    private static final int NUM_SLOTS = 2;
    private static final int PARALLELISM = NUM_SLOTS * NUM_TMS;

    @ClassRule
    public final static MiniClusterWithClientResource MINI_CLUSTER_WITH_CLIENT_RESOURCE = new MiniClusterWithClientResource(
            new MiniClusterResourceConfiguration.Builder()
                .setNumberSlotsPerTaskManager(NUM_SLOTS)
                .setNumberTaskManagers(NUM_TMS)
                .build());

    @Test
    public void testJob() throws Exception {

        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(PARALLELISM);

        final MyControllableSourceFunction source1 = new MyControllableSourceFunction("source1");
        final MyControllableSourceFunction source2 = new MyControllableSourceFunction("source2");

        final DataStreamSource<Integer> input1 = env.addSource(source1);
        final DataStreamSource<Integer> input2 = env.addSource(source2);

        input1.connect(input2).map(new CoMapFunction<Integer, Integer, Integer>() {
            @Override
            public Integer map1(Integer integer) {
                System.out.println("Input 1: " + integer);
                return integer;
            }

            @Override
            public Integer map2(Integer integer) {
                System.out.println("Input 2: " + integer);
                return integer;
            }
        }).print();

        final JobGraph jobGraph = env.getStreamGraph().getJobGraph();

        MINI_CLUSTER_WITH_CLIENT_RESOURCE.getMiniCluster().submitJob(jobGraph).get();

        final CompletableFuture<JobResult> jobResultFuture = MINI_CLUSTER_WITH_CLIENT_RESOURCE.getMiniCluster().requestJobResult(jobGraph.getJobID());

        final ArrayList<CompletableFuture<Void>> finishedFutures = new ArrayList<>(PARALLELISM);

        for (int i = 0; i < PARALLELISM; i++) {
            MyControllableSourceFunction.startExecution(source1, i);
            finishedFutures.add(MyControllableSourceFunction.getFinishedFuture(source1, i));
        }

        FutureUtils.waitForAll(finishedFutures).join();

        for (int i = 0; i < PARALLELISM; i++) {
            MyControllableSourceFunction.startExecution(source2, i);
        }

        jobResultFuture.join();
    }

    private static class MyControllableSourceFunction extends RichParallelSourceFunction<Integer> {

        private static final ConcurrentMap<String, CountDownLatch> startLatches = new ConcurrentHashMap<>();
        private static final ConcurrentMap<String, CompletableFuture<Void>> finishedFutures = new ConcurrentHashMap<>();

        private final String name;

        private boolean running = true;

        private MyControllableSourceFunction(String name) {
            this.name = name;
        }

        @Override
        public void run(SourceContext<Integer> sourceContext) throws Exception {
            final int index = getRuntimeContext().getIndexOfThisSubtask();

            final CountDownLatch startLatch = startLatches.computeIfAbsent(getId(index), ignored -> new CountDownLatch(1));
            final CompletableFuture<Void> finishedFuture = finishedFutures.computeIfAbsent(getId(index), ignored -> new CompletableFuture<>());

            startLatch.await();
            int counter = 0;

            while (running && counter < 10) {
                synchronized (sourceContext.getCheckpointLock()) {
                    sourceContext.collect(counter++);
                }
            }

            finishedFuture.complete(null);
        }

        @Override
        public void cancel() {
            running = false;
        }

        private String getId(int index) {
            return name + '_' + index;
        }

        static void startExecution(MyControllableSourceFunction source, int index) {
            final CountDownLatch startLatch = startLatches.computeIfAbsent(source.getId(index), ignored -> new CountDownLatch(1));
            startLatch.countDown();
        }

        static CompletableFuture<Void> getFinishedFuture(MyControllableSourceFunction source, int index) {
            return finishedFutures.computeIfAbsent(source.getId(index), ignored -> new CompletableFuture<>());
        }
    }
}

公共类职务案例{
专用静态最终int NUM_TMS=2；
专用静态最终int NUM_插槽=2；
私有静态最终int并行度=NUM_SLOTS*NUM_TMS；
@阶级规则
public final static MiniClusterWithClientResource MINI_CLUSTER_WITH CLIENT_RESOURCE=新建MiniClusterWithClientResource(
新建MiniClusterResourceConfiguration.Builder（）
.setNumberSlotsPerTaskManager（NUM_插槽）
.SetNumberTaskManager（NUM_TMS）
.build（））；
@试验
public void testJob（）引发异常{
StreamExecutionEnvironment env=StreamExecutionEnvironment.getExecutionEnvironment（）；
环境设置并行性（PARALLELISM）；
最终MyControllableSourceFunction source1=新的MyControllableSourceFunction（“source1”）；
最终MyControllableSourceFunction source2=新的MyControllableSourceFunction（“source2”）；
最终数据流源input1=env.addSource（source1）；
final DataStreamSource input2=env.addSource（source2）；
input1.connect（input2.map）（新的CoMapFunction（）{
@凌驾
公共整数映射1（整数）{
System.out.println（“输入1:+整数”）；
返回整数；
}
@凌驾
公共整数映射2（整数）{
System.out.println（“输入2:+整数”）；
返回整数；
}
}).print（）；
final JobGraph JobGraph=env.getStreamGraph（）.getJobGraph（）；
带有客户端资源的迷你集群。getMiniCluster（）.submitJob（jobGraph.get（）；
final CompletableFuture jobResultFuture=MINI_CLUSTER_与_CLIENT_RESOURCE.getMiniCluster（）.requestJobResult（jobGraph.getJobID（））；
最终ArrayList finishedFutures=新ArrayList（并行度）；
for（int i=0；i新建CountDownLatch（1））；
final CompletableFuture finishedFuture=finishedFutures.computeIfAbsent（getId（index），忽略->新建CompletableFuture（））；
惊吓，等待；
int计数器=0；
同时（运行和计数器<10）{
已同步（sourceContext.getCheckpointLock（））{
collect（counter++）；
}
}
finishedFuture.complete（空）；
}
@凌驾
公开作废取消（）{
运行=错误；
}
私有字符串getId（int索引）{
返回名称+''\'+索引；
}
静态void startExecution（MyControllableSourceFunction源，int索引）{
final CountDownLatch startatch=startatches.computeIfAbsent（source.getId（index），忽略->新建CountDownLatch（1））；
倒计时（）；
}
静态CompletableFuture getFinishedFuture（MyControlableSourceFunction源，int索引）{
返回finishedFutures.computeIfAbsent（source.getId（index），忽略->新建CompletableFuture（））；
}
}
}