【消息队列开发】 实现 VirtualHostTests 类——测试虚拟主机操作

简介: 【消息队列开发】 实现 VirtualHostTests 类——测试虚拟主机操作

🍃前言

本次开发任务

  • 实现 VirtualHostTests 类,对虚拟主机进行测试

🎍准备与收尾工作

准备工作我们需要做的有

  1. 虚拟机操作后续涉及操作数据库,所以我们需要将spring上下文进行获取一下;
  2. 创建一个虚拟主机

收尾工作我们需要做的有:

  1. 关闭上下文
  2. 虚拟主机置为null
  3. 删除硬盘上的目录及目录下的文件

代码实现如下:

private VirtualHost virtualHost = null;
@BeforeEach
public void setUp() {
    MqApplication.context = SpringApplication.run(MqApplication.class);
    virtualHost = new VirtualHost("default");
}
@AfterEach
public void tearDown() throws IOException {
    MqApplication.context.close();
    virtualHost = null;
    // 把硬盘的目录删除掉
    File dataDir = new File("./data");
    FileUtils.deleteDirectory(dataDir);
}

🍀测试交换机与队列操作

测试交换机我们主要测试四方法:

  1. 增加交换机
  2. 删除交换机
  3. 增加队列
  4. 删除队列

由于虚拟机里面的方法,都是调用我们前面已经测试过了的方法,所以我们这里只用看该方法返回值知否未true就好

代码实现如下:

@Test
public void testExchangeDeclare() {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
}
@Test
public void testExchangeDelete() {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDelete("testExchange");
    Assertions.assertTrue(ok);
}
@Test
public void testQueueDeclare() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
}
@Test
public void testQueueDelete() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueDelete("testQueue");
    Assertions.assertTrue(ok);
}

🎄测试绑定操作

创建相应的队列与交换机,然后将这些队列交换机添加绑定即可

删除也是如此:

代码实现如下:

@Test
public void testQueueBind() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue", "testExchange", "testBindingKey");
    Assertions.assertTrue(ok);
}
@Test
public void testQueueUnbind() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue", "testExchange", "testBindingKey");
    Assertions.assertTrue(ok);
    ok = virtualHost.queueUnbind("testQueue", "testExchange");
    Assertions.assertTrue(ok);
}

🌴测试将消息发入交换机

传参调用即可,代码实现如下:

@Test
public void testBasicPublish() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
}

🌲测试订阅消息

订阅消息我们分为两种情况:

  1. 先订阅队列,再发送消息
  2. 先发送消息,再订阅队列

订阅队列操作,我们只需要出入相应的参数,再实现以下消费者自身的回调方法即可。

发送消息直径发送即可

代码实现如下:

// 先订阅队列, 后发送消息
@Test
public void testBasicConsume1() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    // 先订阅队列
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            try {
                // 消费者自身设定的回调方法.
                System.out.println("messageId=" + basicProperties.getMessageId());
                System.out.println("body=" + new String(body, 0, body.length));
                Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
                Assertions.assertEquals(1, basicProperties.getDeliverMode());
                Assertions.assertArrayEquals("hello".getBytes(), body);
            } catch (Error e) {
                // 断言如果失败, 抛出的是 Error, 而不是 Exception!
                e.printStackTrace();
                System.out.println("error");
            }
        }
    });
    Assertions.assertTrue(ok);
    Thread.sleep(500);
    // 再发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
}
// 先发送消息, 后订阅队列.
@Test
public void testBasicConsume2() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    // 先发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
    // 再订阅队列
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            // 消费者自身设定的回调方法.
            System.out.println("messageId=" + basicProperties.getMessageId());
            System.out.println("body=" + new String(body, 0, body.length));
            Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
            Assertions.assertEquals(1, basicProperties.getDeliverMode());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);
    Thread.sleep(500);
}

🌳测试FANOUT与TOPIC类型的交换机

上面我们只测试了 DIRECT 类型的交换机,接下来我们测试一下FANOUT与TOPIC类型的交换机。

测试步骤与上述类似,准备数据传入,进行测试就好

代码实现如下:

@Test
public void testBasicConsumeFanout() throws InterruptedException {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.FANOUT, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueDeclare("testQueue1", false, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue1", "testExchange", "");
    Assertions.assertTrue(ok);
    ok = virtualHost.queueDeclare("testQueue2", false, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue2", "testExchange", "");
    Assertions.assertTrue(ok);
    // 往交换机中发布一个消息
    ok = virtualHost.basicPublish("testExchange", "", null, "hello".getBytes());
    Assertions.assertTrue(ok);
    Thread.sleep(500);
    // 两个消费者订阅上述的两个队列.
    ok = virtualHost.basicConsume("testConsumer1", "testQueue1", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);
    ok = virtualHost.basicConsume("testConsumer2", "testQueue2", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);
    Thread.sleep(500);
}
@Test
public void testBasicConsumeTopic() throws InterruptedException {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.TOPIC, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueDeclare("testQueue", false, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue", "testExchange", "aaa.*.bbb");
    Assertions.assertTrue(ok);
    ok = virtualHost.basicPublish("testExchange", "aaa.ccc.bbb", null, "hello".getBytes());
    Assertions.assertTrue(ok);
    ok = virtualHost.basicConsume("testConsumer", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);
    Thread.sleep(500);
}

🎋测试手动应答

测试手动应答的时候。

我们需要在订阅队列时,将 autoAck 改成 false;

并且我们需要在消费者的回调方法里进行调用手动应答的方法。

代码实现如下:

@Test
public void testBasicAck() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
    // 先发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
    // 再订阅队列 [要改的地方, 把 autoAck 改成 false]
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", false, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            // 消费者自身设定的回调方法.
            System.out.println("messageId=" + basicProperties.getMessageId());
            System.out.println("body=" + new String(body, 0, body.length));
            Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
            Assertions.assertEquals(1, basicProperties.getDeliverMode());
            Assertions.assertArrayEquals("hello".getBytes(), body);
            // [要改的地方, 新增手动调用 basicAck]
            boolean ok = virtualHost.basicAck("testQueue", basicProperties.getMessageId());
            Assertions.assertTrue(ok);
        }
    });
    Assertions.assertTrue(ok);
    Thread.sleep(500);
}

⭕总结

关于《【消息队列开发】 实现 VirtualHostTests 类——测试虚拟主机操作》就讲解到这儿,感谢大家的支持,欢迎各位留言交流以及批评指正,如果文章对您有帮助或者觉得作者写的还不错可以点一下关注,点赞,收藏支持一下

相关文章
|
1月前
|
测试技术 网络安全
什么是软件测试? 软件测试都有什么岗位 ?软件测试和调试的区别? 软件测试和开发的区别? 一位优秀的测试人员应该具备哪些素质? 软件测试等相关概念入门篇
文章全面介绍了软件测试的基本概念、目的、岗位分类、与开发和调试的区别,并阐述了成为优秀测试人员应具备的素质和技能。
178 1
什么是软件测试? 软件测试都有什么岗位 ?软件测试和调试的区别? 软件测试和开发的区别? 一位优秀的测试人员应该具备哪些素质? 软件测试等相关概念入门篇
|
5天前
|
安全 测试技术 持续交付
云计算时代的软件开发与测试:高效、灵活、可扩展
云计算时代的软件开发与测试:高效、灵活、可扩展
|
30天前
|
人工智能 监控 测试技术
云应用开发平台测试
云应用开发平台测试
46 2
|
1月前
|
敏捷开发 测试技术
开发模型(瀑布、螺旋、scrum) 和 测试模型(V、W)、增量和迭代、敏捷(思想)及敏捷开发 scrum
文章详细介绍了软件开发过程中的不同开发模型(瀑布、螺旋、Scrum)和测试模型(V模型、W模型),以及增量和迭代的概念,最后阐述了敏捷思想及其在敏捷开发(如Scrum)中的应用。
63 0
开发模型(瀑布、螺旋、scrum) 和 测试模型(V、W)、增量和迭代、敏捷(思想)及敏捷开发 scrum
|
24天前
|
消息中间件 中间件 Kafka
解锁Kafka等消息队列中间件的测试之道
在这个数字化时代,分布式系统和消息队列中间件(如Kafka、RabbitMQ)已成为日常工作的核心组件。本次公开课由前字节跳动资深专家KK老师主讲,深入解析消息队列的基本原理、架构及测试要点,涵盖功能、性能、可靠性、安全性和兼容性测试,并探讨其主要应用场景,如应用解耦、异步处理和限流削峰。课程最后设有互动答疑环节,助你全面掌握消息队列的测试方法。
|
2月前
|
测试技术 UED 开发者
软件测试的艺术:从代码审查到用户反馈的全景探索在软件开发的宇宙中,测试是那颗确保星系正常运转的暗物质。它或许不总是站在聚光灯下,但无疑是支撑整个系统稳定性与可靠性的基石。《软件测试的艺术:从代码审查到用户反馈的全景探索》一文,旨在揭开软件测试这一神秘面纱,通过深入浅出的方式,引领读者穿梭于测试的各个环节,从细微处着眼,至宏观视角俯瞰,全方位解析如何打造无懈可击的软件产品。
本文以“软件测试的艺术”为核心,创新性地将技术深度与通俗易懂的语言风格相结合,绘制了一幅从代码审查到用户反馈全过程的测试蓝图。不同于常规摘要的枯燥概述,这里更像是一段旅程的预告片,承诺带领读者经历一场从微观世界到宏观视野的探索之旅,揭示每一个测试环节背后的哲学与实践智慧,让即便是非专业人士也能领略到软件测试的魅力所在,并从中获取实用的启示。
|
4月前
|
消息中间件 C语言 RocketMQ
消息队列 MQ操作报错合集之出现"Connection reset by peer"的错误,该如何处理
消息队列(MQ)是一种用于异步通信和解耦的应用程序间消息传递的服务,广泛应用于分布式系统中。针对不同的MQ产品,如阿里云的RocketMQ、RabbitMQ等,它们在实现上述场景时可能会有不同的特性和优势,比如RocketMQ强调高吞吐量、低延迟和高可用性,适合大规模分布式系统;而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集,这些场景涵盖了多种行业和业务需求。
|
4月前
|
消息中间件 Java C语言
消息队列 MQ使用问题之在使用C++客户端和GBase的ESQL进行编译时出现core dump,该怎么办
消息队列(MQ)是一种用于异步通信和解耦的应用程序间消息传递的服务,广泛应用于分布式系统中。针对不同的MQ产品,如阿里云的RocketMQ、RabbitMQ等,它们在实现上述场景时可能会有不同的特性和优势,比如RocketMQ强调高吞吐量、低延迟和高可用性,适合大规模分布式系统;而RabbitMQ则以其灵活的路由规则和丰富的协议支持受到青睐。下面是一些常见的消息队列MQ产品的使用场景合集,这些场景涵盖了多种行业和业务需求。
|
19天前
|
消息中间件 存储 Kafka
MQ 消息队列核心原理,12 条最全面总结!
本文总结了消息队列的12个核心原理,涵盖消息顺序性、ACK机制、持久化及高可用性等内容。关注【mikechen的互联网架构】,10年+BAT架构经验倾囊相授。
|
2月前
|
消息中间件
手撸MQ消息队列——循环数组
队列是一种常用的数据结构,类似于栈,但采用先进先出(FIFO)的原则。生活中常见的排队场景就是队列的应用实例。在数据结构中,队列通常用数组实现,包括入队(队尾插入元素)和出队(队头移除元素)两种基本操作。本文介绍了如何用数组实现队列,包括定义数组长度、维护队头和队尾下标(front 和 tail),并通过取模运算解决下标越界问题。此外,还讨论了队列的空与满状态判断,以及并发和等待机制的实现。通过示例代码展示了队列的基本操作及优化方法,确保多线程环境下的正确性和高效性。
41 0
手撸MQ消息队列——循环数组