基于docker的test-containers环境百宝箱

最新推荐文章于 2024-06-24 09:50:47 发布
最新推荐文章于 2024-06-24 09:50:47 发布
阅读量1.7k 收藏 3
点赞数 2
分类专栏： Java知识大杂烩 文章标签： test-containers 单元测试环境支持 单元测试环境快速搭建 中间件环境集成 Java环境百宝箱
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/justry_deng/article/details/109853587
版权

  在很多时候，程序猿们更关注代码本身，而不愿意把时间花费在环境搭建上，这也是Docker变得越来越受欢迎的原因之一。test-containers是Docker生态圈中的一颗新星，其 主要针对测试领域、背靠Docker实现环境百宝箱功能。

  test-containers： 你要的环境，我都有~

  假设我们现在需要一个redis-cluster环境来学习reids pipeline相关的代码知识，那么就需要搭建一套redis集群：

环境支持方式直接搭建docker搭建使用test-container
工作量(简单预估)100个单位30个单位15个单位

test-container环境支持(示例)：

提示一 ： test-container基于Docker,使用test-container前需要安装Docker环境。

提示二 ： test-container提供的环境不能应用于生产、只能用于测试环境等场景。

使用test-container提供单机redis：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import org.testcontainers.utility.DockerImageName;

/**
 * 单机redis环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:14:18
 */
@Slf4j
@Testcontainers
@Import(value = {ExcludedAllAutoConfiguration.class, RedisAutoConfiguration.class})
@ContextConfiguration(initializers = RedisStandaloneEnvSupport .Initializer.class)
public class RedisStandaloneEnvSupport implements RedisEnvSupport {
    
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "redis:5.0.3-alpine";
    
    /** docker开启的端口 */
    private static final int CONTAINER_PORT = 6379;
    
    @Container
    public static GenericContainer<?> redisContainer = new GenericContainer<>(DockerImageName.parse(DOCKER_IMAGE_NAME)).withExposedPorts(CONTAINER_PORT);
    
    /**
     * init application context
     *
     * @author {@link JustryDeng}
     * @since 2020/11/14 19:22:23
     */
    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        @Override
        public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
            String redisIpAddress = redisContainer.getContainerIpAddress();
            log.info("redisIpAddress is [{}]", redisIpAddress);
            System.setProperty("spring.redis.host", redisIpAddress);
            Integer redisPort = redisContainer.getMappedPort(CONTAINER_PORT);
            log.info("redisPort is [{}]", redisPort);
            Assert.assertNotNull("redisPort is null", redisPort);
            System.setProperty("spring.redis.port", redisPort.toString());
        }
    }
    
}

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.redis.RedisStandaloneEnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.concurrent.TimeUnit;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:36:21
 */
@Slf4j
@SpringBootTest
public class RedisStandaloneTest extends RedisStandaloneEnvSupport {
    
    @Resource
    StringRedisTemplate stringRedisTemplate;
    
    @Test
    void one() throws InterruptedException {
        String name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertNull(name);
        
        String justryDeng = "JustryDeng";
        stringRedisTemplate.opsForValue().set("name", justryDeng, Duration.ofSeconds(3));
        name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertEquals(justryDeng, name);
        
        TimeUnit.SECONDS.sleep(3);
        name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertNull(name);
    }

}

  • 输出
    在这里插入图片描述

使用test-container提供集群redis：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.redis.helper.ClientResources4Test;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.FixedHostPortGenericContainer;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

/**
 * redis集群环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:14:18
 */
@Slf4j
@Testcontainers
@Import(value = {ExcludedAllAutoConfiguration.class, ClientResources4Test.class, RedisAutoConfiguration.class})
@ContextConfiguration(initializers = RedisClusterEnvSupport.Initializer.class)
public class RedisClusterEnvSupport implements RedisEnvSupport {
    
    
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "grokzen/redis-cluster:6.0.7";
    
    /**
     * 集群最好用FixedHostPortGenericContainer， 主动避免端口冲突即可
     */
    @Container
    @SuppressWarnings("deprecation")
    public static GenericContainer<?> redisContainer = new FixedHostPortGenericContainer<>(DOCKER_IMAGE_NAME)
            .withFixedExposedPort(7000, 7000)
            .withFixedExposedPort(7001, 7001)
            .withFixedExposedPort(7002, 7002)
            .withFixedExposedPort(7003, 7003)
            .withFixedExposedPort(7004, 7004)
            .withFixedExposedPort(7005, 7005);
    
    /**
     * init application context
     *
     * @author {@link JustryDeng}
     * @since 2020/11/14 19:22:23
     */
    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        @Override
        public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
            String redisIpAddress = redisContainer.getContainerIpAddress();
            String nodesInfo = redisIpAddress + ":" + 7000
                    + "," + redisIpAddress + ":" + 7001
                    + "," + redisIpAddress + ":" + 7002
                    + "," + redisIpAddress + ":" + 7003
                    + "," + redisIpAddress + ":" + 7004
                    + "," + redisIpAddress + ":" + 7005;
            log.info("spring.redis.cluster.nodes is [{}]", nodesInfo);
            System.setProperty("spring.redis.cluster.nodes", nodesInfo);
        }
    }
}

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.redis.RedisClusterEnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.concurrent.TimeUnit;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:36:21
 */
@Slf4j
@SpringBootTest
public class RedisClusterTest extends RedisClusterEnvSupport {
    
    @Resource
    StringRedisTemplate stringRedisTemplate;
    
    @Test
    void one() throws InterruptedException {
        String name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertNull(name);
        
        String justryDeng = "JustryDeng";
        stringRedisTemplate.opsForValue().set("name", justryDeng, Duration.ofSeconds(3));
        name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertEquals(justryDeng, name);
        
        TimeUnit.SECONDS.sleep(3);
        name = stringRedisTemplate.opsForValue().get("name");
        System.err.println(name);
        Assert.assertNull(name);
    }

}

  • 输出
    在这里插入图片描述

使用test-container提供MySQL：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import com.zaxxer.hikari.HikariDataSource;
import lombok.extern.slf4j.Slf4j;
import org.junit.ClassRule;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.utility.DockerImageName;

/**
 * Mysql8环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/17 14:14:43
 */
@Slf4j
@ContextConfiguration(initializers = Mysql8EnvSupport.Initializer.class)
@Import(value = {ExcludedAllAutoConfiguration.class, DataSourceAutoConfiguration.class})
public class Mysql8EnvSupport implements MysqlEnvSupport{
    
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "mysql:8.0.22";

/** 数据库 */
private static final String DATABASE = "mine_database";

/** 连接池类型 */
private static final Class<?> POOL_TYPE_CLASS = HikariDataSource.class;

@ClassRule
public static MySQLContainer<?> mySqlContainer = new MySQLContainer<>(DockerImageName.parse(DOCKER_IMAGE_NAME))
        .withDatabaseName(DATABASE)
        // 初始化脚本
        .withInitScript("mysql/init_mysql.sql")
        /// 配置文件
        ///.withConfigurationOverride("mysql/config")
        ;

/**
 * init application context
 *
 * @author {@link JustryDeng}
 * @since 2020/11/14 19:22:23
 */
public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
        // start
        mySqlContainer.start();
        
        String jdbcUrl = mySqlContainer.getJdbcUrl();
        int endIndex = jdbcUrl.indexOf("?");
        String additionalSetting = "?characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false";
        if (endIndex < 0) {
            jdbcUrl = jdbcUrl + additionalSetting;
        } else {
            jdbcUrl = jdbcUrl.substring(0, endIndex) + additionalSetting;
        }
        System.setProperty("spring.datasource.url", jdbcUrl);
        System.setProperty("spring.datasource.username", mySqlContainer.getUsername());
        System.setProperty("spring.datasource.password", mySqlContainer.getPassword());
        System.setProperty("spring.datasource.driver-class-name", mySqlContainer.getDriverClassName());
        System.setProperty("spring.datasource.type", POOL_TYPE_CLASS.getName());
    }
}

}

  • 基类中涉及到的脚本的位置及内容为
    在这里插入图片描述

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.mysql.Mysql8EnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:36:21
 */
@Slf4j
@SpringBootTest
public class Mysql8Test extends Mysql8EnvSupport {
    
    @Resource
    TestMapper testMapper;
    
    @Test
    void one() {
        System.err.println(testMapper.count());
        List<Map<String, Object>> x = testMapper.selectAll();
        System.err.println(x);
    }
    
    @Mapper
    public interface TestMapper {
        
        @Select("select count(*) from employee")
        int count();
        
        @Select("select * from employee")
        List<Map<String, Object>> selectAll();
    }
    
}

  • 输出
    在这里插入图片描述

使用test-container提供pgSQL：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import com.zaxxer.hikari.HikariDataSource;
import lombok.extern.slf4j.Slf4j;
import org.junit.ClassRule;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.utility.DockerImageName;

/**
 * PostgreSql10环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/17 21:14:29
 */
@Slf4j
@ContextConfiguration(initializers = PostgreSql10EnvSupport.Initializer.class)
@Import(value = {ExcludedAllAutoConfiguration.class, DataSourceAutoConfiguration.class})
public class PostgreSql10EnvSupport implements PostgreSqlEnvSupport {
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "postgres:10.15";
    
    /** 数据库 */
    private static final String DATABASE = "mine_database";
    
    /** 连接池类型 */
    private static final Class<?> POOL_TYPE_CLASS = HikariDataSource.class;
    
    @ClassRule
    public static PostgreSQLContainer<?> pgSqlContainer = new PostgreSQLContainer<>(DockerImageName.parse(DOCKER_IMAGE_NAME))
            .withDatabaseName(DATABASE)
            // 初始化脚本
            .withInitScript("postgresql/init_postgresql.sql");
    
    /**
     * init application context
     *
     * @author {@link JustryDeng}
     * @since 2020/11/14 19:22:23
     */
    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        @Override
        public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
            // start
            pgSqlContainer.start();
            
            System.setProperty("spring.datasource.url", pgSqlContainer.getJdbcUrl());
            System.setProperty("spring.datasource.username", pgSqlContainer.getUsername());
            System.setProperty("spring.datasource.password", pgSqlContainer.getPassword());
            System.setProperty("spring.datasource.driver-class-name", pgSqlContainer.getDriverClassName());
            System.setProperty("spring.datasource.type", POOL_TYPE_CLASS.getName());
        }
    }
    
}

  • 基类中涉及到的脚本的位置及内容为
    在这里插入图片描述

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.postgresql.PostgreSql10EnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/13 16:36:21
 */
@Slf4j
@SpringBootTest
public class PostgreSql10Test extends PostgreSql10EnvSupport {
    
    @Resource
    TestMapper testMapper;
    
    @Test
    void one() {
        System.err.println(testMapper.count());
        System.err.println(testMapper.selectAll());
    }
    
    @Mapper
    public interface TestMapper {
        
        @Select("select count(*) from employee")
        int count();
        
        @Select("select * from employee")
        List<Map<String, Object>> selectAll();
    }
    
}

  • 输出
    在这里插入图片描述

使用test-container提供Kafka：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import lombok.extern.slf4j.Slf4j;
import org.junit.ClassRule;
import org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.KafkaContainer;
import org.testcontainers.utility.DockerImageName;

/**
 * 一个简单的kafka环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/18 12:11:54
 */
@Slf4j
@EnableKafka
@ContextConfiguration(initializers = KafkaSimpleEnvSupport.Initializer.class)
@Import(value = {ExcludedAllAutoConfiguration.class, KafkaAutoConfiguration.class})
public class KafkaSimpleEnvSupport implements KafkaEnvSupport {
    
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "confluentinc/cp-kafka:5.4.3";
    
    @ClassRule
    public static KafkaContainer kafkaContainer = new KafkaContainer(DockerImageName.parse(DOCKER_IMAGE_NAME));
    
    /**
     * init application context
     *
     * @author {@link JustryDeng}
     * @since 2020/11/14 19:22:23
     */
    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        
        @Override
        public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
            // start
            kafkaContainer.start();
            
            String bootstrapServers = kafkaContainer.getBootstrapServers();
            System.setProperty("spring.kafka.bootstrap-servers", bootstrapServers);
            // 因为是测试环境， 这里用earliest， 以避免在没有提交offset情况下，用latest不会读取旧数据的问题
            System.setProperty("spring.kafka.consumer.auto-offset-reset", "earliest");
        }
    }
}

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.kafka.KafkaSimpleEnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

import javax.annotation.Resource;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/18 12:15:47
 */
@Slf4j
@SpringBootTest
@Import(value = {KafkaSimpleTest.MyConsumer.class, KafkaSimpleTest.MyProducer.class})
public class KafkaSimpleTest extends KafkaSimpleEnvSupport {
    
    static final String TOPIC_NAME4TEST = "my-topic4test";
    
    @Resource
    MyProducer myProducer;
    
    @Test
    void one() throws InterruptedException {
        // 生产消息
        for (int i = 0; i < 10; i++) {
            myProducer.sendMessage("邓沙利文-" + i);
        }
        
        // sleep几秒，以便观察消费者是否消费消息
        TimeUnit.SECONDS.sleep(3);
        Assert.assertTrue("消费消息失败(或消费消息超时)", MyConsumer.hasConsumedMsg);
    }
    
    /**
     * 生产者
     */
    @Slf4j
    public static class MyProducer {
        
        @Resource
        private KafkaTemplate<String, String> kafkaTemplate;
        
        public void sendMessage(String message) {
            kafkaTemplate.send(TOPIC_NAME4TEST, "key-" + UUID.randomUUID().toString(), message);
        }
    }
    
    /**
     * 消费者
     */
    @SuppressWarnings("unused")
    @Slf4j
    public static class MyConsumer {
        
        /** 是否已经消费了消息 */
        static boolean hasConsumedMsg = false;
        
        @KafkaListener(topics = TOPIC_NAME4TEST, groupId = "group-b")
        public void consumerOne(String message) {
            log.info("consumerOne消费了消息 [{}]", message);
            hasConsumedMsg = true;
        }
    }
}

  • 输出
    在这里插入图片描述

使用test-container提供RabbitMQ：

  • 环境基类

    import com.niantou.testcontainer.ExcludedAllAutoConfiguration;
import com.niantou.testcontainer.author.JustryDeng;
import lombok.extern.slf4j.Slf4j;
import org.junit.ClassRule;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.RabbitMQContainer;

/**
 * 一个简单的RabbitMQ环境支持
 *
 * @author {@link JustryDeng}
 * @since 2020/11/20 12:49:45
 */
@Slf4j
@ContextConfiguration(initializers = RabbitMqSimpleEnvSupport.Initializer.class)
@Import(value = {ExcludedAllAutoConfiguration.class})
public class RabbitMqSimpleEnvSupport {
    
    /** 标准的docker镜像(即${镜像名}:${tag名}) */
    private static final String DOCKER_IMAGE_NAME = "rabbitmq:management-alpine";
    
    @ClassRule
    public static RabbitMQContainer rabbitMqContainer = new RabbitMQContainer(DOCKER_IMAGE_NAME)
            .withAdminPassword("ds123");
            
    
    /**
     * init application context
     *
     * @author {@link JustryDeng}
     * @since 2020/11/14 19:22:23
     */
    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        
        @Override
        public void initialize(@SuppressWarnings("NullableProblems") ConfigurableApplicationContext configurableApplicationContext) {
            // start
            rabbitMqContainer.start();
            
            String host = rabbitMqContainer.getHost();
            log.info("spring.rabbitmq.host={}", host);
            System.setProperty("spring.rabbitmq.host", host);
            
            Integer amqpPort = rabbitMqContainer.getAmqpPort();
            log.info("spring.rabbitmq.port={}", amqpPort);
            System.setProperty("spring.rabbitmq.port", String.valueOf(amqpPort));
    
            String adminUsername = rabbitMqContainer.getAdminUsername();
            log.info("spring.rabbitmq.username={}", adminUsername);
            System.setProperty("spring.rabbitmq.username", adminUsername);
    
            String adminPassword = rabbitMqContainer.getAdminPassword();
            log.info("spring.rabbitmq.password={}", adminPassword);
            System.setProperty("spring.rabbitmq.password", adminPassword);
        }
    }
    
}

  • 测试类

    import com.niantou.testcontainer.author.JustryDeng;
import com.niantou.testcontainer.rabbitmq.RabbitMqSimpleEnvSupport;
import lombok.extern.slf4j.Slf4j;
import org.junit.Assert;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

import static com.niantou.testcontainer.rabbitmq.test.RabbitMqSimpleTest.MyConfig.MY_EXCHANGE_NAME;
import static com.niantou.testcontainer.rabbitmq.test.RabbitMqSimpleTest.MyConfig.QUEUE_NAME;
import static com.niantou.testcontainer.rabbitmq.test.RabbitMqSimpleTest.MyConfig.ROUTING_KEY;

/**
 * 测试
 *
 * @author {@link JustryDeng}
 * @since 2020/11/18 12:15:47
 */
@Slf4j
@SpringBootTest
@Import(value = {RabbitMqSimpleTest.MyConsumer.class, RabbitMqSimpleTest.MyProducer.class,
        RabbitMqSimpleTest.MyConfig.class})
public class RabbitMqSimpleTest extends RabbitMqSimpleEnvSupport {
    
    @Resource
    MyProducer myProducer;
    
    @Test
    void one() throws InterruptedException {
        // 生产消息
        for (int i = 0; i < 10; i++) {
            myProducer.sendMessage("邓沙利文-" + i);
        }
        
        // sleep几秒，以便观察消费者是否消费消息
        TimeUnit.SECONDS.sleep(3);
        Assert.assertTrue("消费消息失败(或消费消息超时)", MyConsumer.hasConsumedMsg);
    }
    
    /**
     * 配置类
     */
    @Slf4j
    public static class MyConfig {
        
        static final String ROUTING_KEY = "myRoutingKey";
        
        static final String QUEUE_NAME = "my-queue";
        
        static final String MY_EXCHANGE_NAME = "my-direct-exchange";
        
        @Bean
        public Queue myQueue() {
            return new Queue(QUEUE_NAME);
        }
        
        @Bean
        public DirectExchange myDirectExchange() {
            return new DirectExchange(MY_EXCHANGE_NAME);
        }
        
        @Bean
        public Binding myBinding(Queue myQueue, DirectExchange myDirectExchange) {
            return BindingBuilder.bind(myQueue).to(myDirectExchange).with(ROUTING_KEY);
        }
        
    }
    
    /**
     * 生产者
     */
    @Slf4j
    public static class MyProducer {
        
        @Resource
        private AmqpTemplate amqpTemplate;
        
        public void sendMessage(String message) {
            amqpTemplate.convertAndSend(MY_EXCHANGE_NAME, ROUTING_KEY, message);
        }
    }
    
    /**
     * 消费者
     */
    @Slf4j
    public static class MyConsumer {
        
        /** 是否已经消费了消息 */
        static boolean hasConsumedMsg = false;
        
        @SuppressWarnings("unused")
        @RabbitListener(queues = QUEUE_NAME)
        public void consumerOne(String message) {
            log.info("consumerOne消费了消息 [{}]", message);
            hasConsumedMsg = true;
        }
    }
}

  • 输出
    在这里插入图片描述

test-containers，初步学习完毕！

^_^ 如有不当之处，欢迎指正

^_^ 参考链接
         https://www.testcontainers.org/

^_^ 测试代码托管链接
         https://github.com/JustryDeng…test-containers

^_^ 本文已经被收录进《程序员成长笔记》 ，笔者JustryDeng

justry_deng
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
使用TestContainers提高测试性能
最佳 Java 编程
06-05 440
在我以前的测试文章中，我描述了如何使用TestContainers为数据库测试提供现实的测试环境。 此评论显示了缺点： …如上所述，似乎总是有一些缺点。 在这种情况下，启动Docker映像及其包含的所有内容的开销将增加您的总体构建时间。 提醒一下，这是TestContainer特定的代码。 注意实例成员postgres ，以及根据每个方法重新初始化它的JUnit Rule 。 pa...
TestContainer介绍
xiaoyi52的专栏
09-09 2330
在日常开发过程中，经常会用到第三方组件或中间件，如redis，mq，db等。因为这些第三方组件的引入，测试过程会变得复杂起来。可能换了一个环境之后，因为中间件的缺失，测试用例就跑不起来了。而TestContainer可以通过和docker结合，很方便的在代码中启动docker容器，在docker容器中运行这些第三方组件，从而方便进行测试。 基本使用 以maven构建的springboot工程为例，引入依赖 <dependency> <groupId>org.testco
使用Testcontainers进行Java集成测试
最新发布
weixin_53840353的博客
06-24 442
在现代软件开发中，集成测试是确保应用程序与其依赖项（如数据库、消息队列等）正确交互的关键步骤。Testcontainers是一个支持JUnit测试的Java库，它提供了一个简单而强大的方式来创建和管理测试所需的任何Docker容器。本文将详细介绍如何使用Testcontainers进行集成测试，并提供丰富的代码示例。
Testcontainers是一个轻量级的Java库，它包含可以在Docker容器中运行的所有内容
06-15 579
我们喜欢定期浏览未被充分认识的Java库，以了解一些宝石。 今天，我们来看看Testcontainers ，这是一个支持JUnit测试的Java库。 现在，开发人员可以轻松地在他们的JUnit测试期间启动有用的Docker容器，这些容器可以满足他们的所有需求。 Testcontainer提供了可以装入容器的任何东西的轻量，一次性的实例。 这使得使用Docker容器进行测试变得比以往更加容易...
java使用testcontainer自定义docker连接
LHFFFFF的博客
09-30 1235
java使用testcontainer自定义docker连接
Docker---环境搭建
loftiest的博客
04-14 1107
使用Docker repository安装Docker 要安装 Docker Engine，需要 CentOS 7 或 8 的维护版本。 安装yum-utils包 sudo yum install -y yum-utils 创建repository sudo yum-config-manager \ --add-repo \ https://download.docker.com/linux/centos/docker-ce.repo 可以选择启用nightly 或者 test
基于docker-compose快速部署spiderflow
05-25
包含了docker-compose快速部署spiderflow的所有相关文件，包含docker-compose.yml，mysql， spiderflow.jar 可直接运行docker-compose up -d 启动容器。 数据库相关配置都可以通过docker-compose.yml修改。
docker-speedtest-cli
04-18
docker-speedtest-cli
docker-compose-linux-aarch64
12-14
用户在解压后，通常需要将`docker-compose`放到系统的PATH环境变量指定的目录下，以便于命令行中直接使用。 总结来说，"docker-compose-linux-aarch64"提供了在Linux AArch64系统上运行Docker Compose的途径，解决...
clj-test-containers:围绕Testcontainers Java库的轻量级非官方包装
05-06
一个简单的示例，如何创建带有Docker标签的容器，如下所示： ( require '[clj-test-containers.core :as tc])( def container ( -> ( tc/create { :image-name " postgres:12.1 " :exposed-ports [ 5432 ] :env-var...
内网离线安装docker、docker-compose
03-29
一键离线安装docker、docker-compose
Testcontainers是一个支持JUnit测试的Java8库
08-07
Testcontainers是一个支持JUnit测试的Java 8库，提供常见数据库，Selenium Web浏览器或可以在Docker容器中运行的任何其他东西的轻量级，一次性实例。
docker-compose-window-2.14.2.exe
12-27
docker-compose-window-2.14.2.exe免费下载
DockerToolbox-19.03.1.rar
07-22
Docker Compose 用于运行docker-compose命令 Kitematic，Docker GUI 为Docker命令行环境预先配置的Docker QuickStart shell Oracle VM VirtualBox 由于Github下载比较慢，这里我把该安装包下载下来以方便
基于docker kudu-python1.15搭建开发环境，跳过编译kudu-python
04-30
docker compose kudu dev
基于docker-compose实现haproxy+keepalived+teleport的负载均衡和高可用1
08-04
主机名IP地址操作系统组件备注环境说明架构图目录结构配置文件docker-compose配置文件keepalived配置文件keepalived检测脚本hapr
Spring Boot：Testcontainers支持
听海边涛声
02-13 815
Spring Boot：Testcontainers支持
Testcontainer-01篇 基本入门
mail_liuxing的专栏
08-10 4991
一、TestContainer是什么？ 在我们开发的过程中，经常会用到一些第三方的产品或者中间件，如：redis，mq，db等等，然而，因为这些产品的引入，测试过程变得复杂起来，因为中间件的缺失（可能本地有，但是换了环境就没有了），导致测试用例编写很麻烦。 TestContainer可以通过和docker结合，让我们在编写测试用例的时候，很方便的启动docker容器（容器内有我们需要的第三方产品）...
TestContainers+Docker中打造集成测试神器
flyspirit的专栏
09-21 146
用TestContainers+Docker，轻松实现真实地集成测试。
- docker images： - docker rmi - docker pull - docker push - docker save - docker load
02-23
Docker images是Docker中的一个重要概念它是用于创建Docker容器的基础。一个Dock image是一个只读的模板，包含了运行一个容器所需的所有文件系统、代码和依赖项。 下是对于您提到的几个D命令的介绍1. docker rmi：该命令用于删除一个或多个Docker镜像。可以通过镜像ID或者镜像名称来指定要删除的像。 2. docker pull：该命令于从Docker仓库中拉取（下载）一个Docker镜像到本地。可以通过指定镜像名称和标签来拉取特定版本的镜像。 3. docker push：该命令用于将本地的Docker镜像推送（上传）到Docker仓库中，以便其他人可以从仓库中拉取使用。需要先登录到Docker仓库才能进行推送操作。 4. docker save：该命令用于将一个或多个Docker镜像保存为一个tar文件。这个tar文件可以用于在其他机器上使用docker load命令加载这些镜像。 5. docker load：该命令用于从一个tar文件中加载（导入）一个或多个Docker镜像到本地。这些镜像可以是通过docker save命令保存的。 希望以上解答对您有帮助！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值