如何使用Junit和Java模拟和编写Azure服务总线主题的单元测试？

我有一个从Azure服务总线主题发送和接收消息的方法，我需要使用JUnit5模拟和编写该方法的测试用例

基于Microsoft文档的示例代码

    public class MyServiceBusTopicClient {

    static final Gson GSON = new Gson();
    
    public static void main(String[] args) throws Exception, ServiceBusException {
        // TODO Auto-generated method stub

        TopicClient sendClient;
        String connectionString = "Endpoint=sb://<NameOfServiceBusNamespace>.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=<AccessKey>";
        sendClient = new TopicClient(new ConnectionStringBuilder(connectionString, "BasicTopic"));       
        sendMessagesAsync(sendClient).thenRunAsync(() -> sendClient.closeAsync());
    }

    static CompletableFuture<Void> sendMessagesAsync(TopicClient sendClient) {
        List<HashMap<String, String>> data =
                GSON.fromJson(
                        "[" +
                                "{'name' = 'Einstein', 'firstName' = 'Albert'}," +
                                "{'name' = 'Heisenberg', 'firstName' = 'Werner'}," +
                                "{'name' = 'Curie', 'firstName' = 'Marie'}," +
                                "{'name' = 'Hawking', 'firstName' = 'Steven'}," +
                                "{'name' = 'Newton', 'firstName' = 'Isaac'}," +
                                "{'name' = 'Bohr', 'firstName' = 'Niels'}," +
                                "{'name' = 'Faraday', 'firstName' = 'Michael'}," +
                                "{'name' = 'Galilei', 'firstName' = 'Galileo'}," +
                                "{'name' = 'Kepler', 'firstName' = 'Johannes'}," +
                                "{'name' = 'Kopernikus', 'firstName' = 'Nikolaus'}" +
                                "]",
                        new TypeToken<List<HashMap<String, String>>>() {
                        }.getType());

        List<CompletableFuture> tasks = new ArrayList<>();
        for (int i = 0; i < data.size(); i++) {
            final String messageId = Integer.toString(i);
            Message message = new Message(GSON.toJson(data.get(i), Map.class).getBytes(UTF_8));
            message.setContentType("application/json");
            message.setLabel("Scientist");
            message.setMessageId(messageId);
            message.setTimeToLive(Duration.ofMinutes(2));
            System.out.printf("Message sending: Id = %s\n", message.getMessageId());
            tasks.add(
                    sendClient.sendAsync(message).thenRunAsync(() -> {
                        System.out.printf("\tMessage acknowledged: Id = %s\n", message.getMessageId());
                    }));
        }
        return CompletableFuture.allOf(tasks.toArray(new CompletableFuture<?>[tasks.size()]));
    }
}

公共类MyServiceBusTopicClient{
静态最终Gson Gson=新Gson（）；
公共静态void main（字符串[]args）引发异常，ServiceBusException{
//TODO自动生成的方法存根
主题客户端发送客户端；
String connectionString=“Endpoint=sb://.servicebus.windows.net/；SharedAccessKeyName=RootManageSharedAccessKey；SharedAccessKey=”；
sendClient=newtopicclient（newconnectionstringbuilder（connectionString，“BasicTopic”）；
sendMessagesAsync（sendClient）.thenRunAsync（（）->sendClient.closeAsync（））；
}
静态CompletableFuture sendMessagesAsync（TopicClient sendClient）{
列表数据=
GSON.fromJson(
"[" +
{'name'='Einstein'，'firstName'='Albert'}+
“{'name'='Heisenberg'，'firstName'='Werner'}”+
“{'name'='Curie'，'firstName'='Marie'}”+
“{'name'='Hawking'，'firstName'='Steven'}，”+
{'name'='Newton'，'firstName'='Isaac'}+
“{'name'='Bohr'，'firstName'='Niels'}”+
“{'name'='Faraday'，'firstName'='Michael'}”+
{'name'='galiley'，'firstName'='Galileo'}+
“{'name'='Kepler'，'firstName'='Johannes'}”+
{'name'='Kopernikus'，'firstName'='Nikolaus'}+
"]",
新的TypeToken（）{
}.getType（））；
列表任务=新建ArrayList（）；
对于（int i=0；i{
System.out.printf（“\t消息已确认：Id=%s\n”，message.getMessageId（））；
}));
}
返回CompletableFuture.allOf（tasks.toArray（新的CompletableFuture[tasks.size（）]）；
}
}

用于从azure服务总线订阅接收消息的方法

import com.microsoft.azure.servicebus.*;
import com.microsoft.azure.servicebus.primitives.ConnectionStringBuilder;
import com.microsoft.azure.servicebus.primitives.ServiceBusException;
import com.google.gson.Gson;
import static java.nio.charset.StandardCharsets.*;
import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;

public class MyServiceBusSubscriptionClient {
    static final Gson GSON = new Gson();
    
    public static void main(String[] args) throws Exception, ServiceBusException {
        String connectionString = "Endpoint=sb://<NameOfServiceBusNamespace>.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=<AccessKey>";
        
        SubscriptionClient subscription1Client = new SubscriptionClient(new ConnectionStringBuilder(connectionString, "BasicTopic/subscriptions/Subscription1"), ReceiveMode.PEEKLOCK);
        SubscriptionClient subscription2Client = new SubscriptionClient(new ConnectionStringBuilder(connectionString, "BasicTopic/subscriptions/Subscription2"), ReceiveMode.PEEKLOCK);
        SubscriptionClient subscription3Client = new SubscriptionClient(new ConnectionStringBuilder(connectionString, "BasicTopic/subscriptions/Subscription3"), ReceiveMode.PEEKLOCK);        

        ExecutorService executorService = Executors.newCachedThreadPool();
        registerMessageHandlerOnClient(subscription1Client, executorService);
        registerMessageHandlerOnClient(subscription2Client, executorService);
        registerMessageHandlerOnClient(subscription3Client, executorService);
    }
    
    static void registerMessageHandlerOnClient(SubscriptionClient receiveClient, ExecutorService executorService) throws Exception {
        // register the RegisterMessageHandler callback
        receiveClient.registerMessageHandler(
                new IMessageHandler() {
                    // callback invoked when the message handler loop has obtained a message
                    public CompletableFuture<Void> onMessageAsync(IMessage message) {
                        // receives message is passed to callback
                        if (message.getLabel() != null &&
                                message.getContentType() != null &&
                                message.getLabel().contentEquals("Scientist") &&
                                message.getContentType().contentEquals("application/json")) {

                            byte[] body = message.getBody();
                            Map scientist = GSON.fromJson(new String(body, UTF_8), Map.class);

                            System.out.printf(
                                    "\n\t\t\t\t%s Message received: \n\t\t\t\t\t\tMessageId = %s, \n\t\t\t\t\t\tSequenceNumber = %s, \n\t\t\t\t\t\tEnqueuedTimeUtc = %s," +
                                            "\n\t\t\t\t\t\tExpiresAtUtc = %s, \n\t\t\t\t\t\tContentType = \"%s\",  \n\t\t\t\t\t\tContent: [ firstName = %s, name = %s ]\n",
                                    receiveClient.getEntityPath(),
                                    message.getMessageId(),
                                    message.getSequenceNumber(),
                                    message.getEnqueuedTimeUtc(),
                                    message.getExpiresAtUtc(),
                                    message.getContentType(),
                                    scientist != null ? scientist.get("firstName") : "",
                                    scientist != null ? scientist.get("name") : "");
                        }
                        return receiveClient.completeAsync(message.getLockToken());
                    }

                    // callback invoked when the message handler has an exception to report
                    public void notifyException(Throwable throwable, ExceptionPhase exceptionPhase) {
                        System.out.printf(exceptionPhase + "-" + throwable.getMessage());
                    }
                },
                // 1 concurrent call, messages are auto-completed, auto-renew duration
                new MessageHandlerOptions(1, false, Duration.ofMinutes(1)),
                executorService);
    }
}

导入com.microsoft.azure.servicebus.*；
导入com.microsoft.azure.servicebus.primitives.ConnectionStringBuilder；
导入com.microsoft.azure.servicebus.primitives.ServiceBusException；
导入com.google.gson.gson；
导入静态java.nio.charset.StandardCharsets.*；
导入java.time.Duration；
导入java.util.*；
导入java.util.concurrent.*；
公共类MyServiceBusSubscriptionClient{
静态最终Gson Gson=新Gson（）；
公共静态void main（字符串[]args）引发异常，ServiceBusException{
String connectionString=“Endpoint=sb://.servicebus.windows.net/；SharedAccessKeyName=RootManageSharedAccessKey；SharedAccessKey=”；
SubscriptionClient subscription1Client=新的SubscriptionClient（新的ConnectionStringBuilder（connectionString，“BasicTopic/subscriptions/Subscription1”）、ReceiveMode.PEEKLOCK）；
SubscriptionClient subscription2Client=新的SubscriptionClient（新的ConnectionStringBuilder（connectionString，“BasicTopic/subscriptions/Subscription2”）、ReceiveMode.PEEKLOCK）；
SubscriptionClient subscription3Client=新的SubscriptionClient（新的ConnectionStringBuilder（connectionString，“BasicTopic/subscriptions/Subscription3”）、ReceiveMode.PEEKLOCK）；
ExecutorService ExecutorService=Executors.newCachedThreadPool（）；
registerMessageHandlerOnClient（subscription1Client，executorService）；
registerMessageHandlerOnClient（subscription2Client，executorService）；
registerMessageHandlerOnClient（subscription3Client，executorService）；
}
静态无效注册表MessageHandlerOnClient（SubscriptionClient receiveClient，ExecutorService ExecutorService）引发异常{
//注册RegisterMessageHandler回调
receiveClient.registerMessageHandler(
新的IMessageHandler（）{
//当消息处理程序循环获得消息时调用回调
公共CompletableFuture onMessageAsync（IMessage消息）{
//接收传递给回调函数的消息
如果（message.getLabel（）！=null&&
message.getContentType（）！=null&&
message.getLabel（）.contentEquals（“科学家”）&&
message.getContentType（）.contentEquals（“应用程序/json”））{
byte[]body=message.getBody（）；
Map scientist=GSON.fromJson（新字符串（body，UTF_8），Map.class）；
System.out.printf(
\n\t\t\t\t%s收到的消息：\n\t\t\t\t\t消息ID=%s\n\t\t\t\t\t序列号=%s\n\t\t\t\t\tQueuedTimeUTC=%s+
“\n\t\t\t\t\t\t\texpiresautc=%s，\n\t\t\t\t\t内容类型=\%s\，\n\t\t\t\t\t内容：[名字=%s，名字=%s]\n”，
receiveClient.getEntityPath（），
message.getMessageId（），
消息