如何对操作IBM MQ的Java服务进行本地单元测试？

当然可以不用连接生产队列开展测试，针对你的场景，主要有两种实用方案：Mock模拟MQ客户端依赖，或者用嵌入式MQ服务器搭建本地测试环境。下面结合你的代码具体说明：

一、使用Mock框架（Mockito）隔离真实MQ依赖 #

你的代码直接依赖MQEnvironment静态类和MQQueueManager实例，为了方便测试，建议先做小幅重构，把静态配置和队列管理器创建逻辑抽成可替换的方法，再用Mockito模拟这些依赖：

重构后的QueueConnectionService #

@Service
public class QueueConnectionService {

    private final MQConfigMapping configMapping;
    private MQQueueManager queueManager;

    @Autowired
    public QueueConnectionService(MQConfigMapping configMapping) {
        this.configMapping = configMapping;
    }

    MQQueue connect(String queuePropertyTitle, int openOptions, String queueName) throws MQException {
        MQConfig config = configMapping.getNamed().get(queuePropertyTitle);
        setMQEnvironment(config);
        queueManager = createQueueManager(config.getQueueManager());
        return queueManager.accessQueue(queueName, openOptions);
    }

    // 抽成protected方法，方便测试时替换
    protected void setMQEnvironment(MQConfig config) {
        MQEnvironment.hostname = config.getHostname();
        MQEnvironment.channel = config.getChannel();
        MQEnvironment.port = config.getPort();
        MQEnvironment.userID = config.getUser();
        MQEnvironment.password = config.getPassword();
    }

    // 抽成protected方法，方便测试时Mock队列管理器实例
    protected MQQueueManager createQueueManager(String queueManagerName) throws MQException {
        return new MQQueueManager(queueManagerName);
    }
}

单元测试代码（Mockito） #

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;

@ExtendWith(MockitoExtension.class)
public class QueueConnectionServiceTest {

    @Mock
    private MQConfigMapping configMapping;
    @Mock
    private MQConfig mockConfig;
    @Mock
    private MQQueueManager mockQueueManager;
    @Mock
    private MQQueue mockQueue;

    @InjectMocks
    private QueueConnectionService service = spy(new QueueConnectionService(configMapping));

    @Test
    void connect_returnsQueueWhenConfigIsValid() throws MQException {
        // 测试参数
        String propertyTitle = "testQueue";
        int openOptions = MQC.MQOO_INPUT_AS_Q_DEF;
        String queueName = "TEST.QUEUE";
        String qmName = "QM_TEST";

        // 配置Mock行为
        when(configMapping.getNamed()).thenReturn(Map.of(propertyTitle, mockConfig));
        when(mockConfig.getHostname()).thenReturn("localhost");
        when(mockConfig.getChannel()).thenReturn("TEST.CHL");
        when(mockConfig.getPort()).thenReturn(1414);
        when(mockConfig.getUser()).thenReturn("testUser");
        when(mockConfig.getPassword()).thenReturn("testPass");
        when(mockConfig.getQueueManager()).thenReturn(qmName);

        // 替换队列管理器创建逻辑，返回Mock实例
        doReturn(mockQueueManager).when(service).createQueueManager(qmName);
        when(mockQueueManager.accessQueue(eq(queueName), eq(openOptions))).thenReturn(mockQueue);

        // 执行测试
        MQQueue result = service.connect(propertyTitle, openOptions, queueName);

        // 验证结果和调用
        assertThat(result).isEqualTo(mockQueue);
        verify(service).setMQEnvironment(mockConfig);
        verify(mockQueueManager).accessQueue(queueName, openOptions);
    }
}

二、使用嵌入式MQ服务器做集成测试 #

如果需要验证真实的MQ交互逻辑（比如队列创建、消息收发），可以用嵌入式MQ服务器搭建本地测试环境，完全不需要连接生产队列。以IBM MQ嵌入式版本为例：

添加测试依赖（Maven） #

<dependency>
    <groupId>com.ibm.mq</groupId>
    <artifactId>mq-jms-spring-boot-starter</artifactId>
    <version>2.7.6</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.ibm.mq</groupId>
    <artifactId>com.ibm.mq.allclient</artifactId>
    <version>9.3.3.0</version>
    <scope>test</scope>
</dependency>

集成测试代码 #

import com.ibm.mq.MQException;
import com.ibm.mq.MQQueue;
import com.ibm.mq.MQQueueManager;
import com.ibm.mq.constants.MQConstants;
import com.ibm.mq.junit.extensions.EmbeddedMQ;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
@TestPropertySource(properties = {
        "mq.config.named.testQueue.hostname=localhost",
        "mq.config.named.testQueue.channel=SYSTEM.DEF.SVRCONN",
        "mq.config.named.testQueue.port=1414",
        "mq.config.named.testQueue.user=admin",
        "mq.config.named.testQueue.password=passw0rd",
        "mq.config.named.testQueue.queueManager=QM_TEST"
})
public class QueueConnectionServiceIntegrationTest {

    private static EmbeddedMQ embeddedMQ;

    @BeforeAll
    static void setUp() throws Exception {
        // 启动嵌入式队列管理器
        embeddedMQ = EmbeddedMQ.builder()
                .queueManagerName("QM_TEST")
                .listenerPort(1414)
                .channel("SYSTEM.DEF.SVRCONN")
                .build();
        embeddedMQ.start();

        // 创建测试队列
        try (MQQueueManager qm = embeddedMQ.getQueueManager()) {
            qm.createQueue("TEST.QUEUE", MQConstants.MQQA_PERSISTENCE_AS_Q_DEF);
        }
    }

    @AfterAll
    static void tearDown() throws Exception {
        embeddedMQ.stop();
    }

    @Test
    void connect_successfullyConnectsToEmbeddedQueue() throws MQException {
        QueueConnectionService service = new QueueConnectionService(new MQConfigMapping());
        MQQueue queue = service.connect("testQueue", MQConstants.MQOO_INPUT_AS_Q_DEF, "TEST.QUEUE");

        assertNotNull(queue);
        assertEquals("TEST.QUEUE", queue.getName());
        queue.close();
    }
}

方案对比 #

• Mock方案：速度快，完全隔离外部依赖，适合单元测试验证业务逻辑正确性。
• 嵌入式MQ方案：更接近生产环境，适合集成测试验证真实MQ交互流程。

内容的提问来源于stack exchange，提问作者TwiKKz