测试驱动 Hystrix 断路器配置

Question

我们的应用程序是通过使用 Hystrix 实现断路器模式以抗脆弱的方式编写的。

整个应用程序是使用测试驱动实践创建的，但陷入了我们需要通过在方法上配置相同策略来实现断路器策略的阶段。

以下是我们使用的示例配置 -

@HystrixCommand(commandProperties = {
        @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "8"),
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "25"),
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000")},
        fallbackMethod = "retrieveMapFallback")

如果有可用的功能或机会在我的集成测试中测试它（它加载整个 WebApplicationContext，因此了解应用程序可用的所有配置），任何人都可以评论吗？

或者如果这根本不可能在我的应用程序上下文中进行验证？

任何投入都会有价值。

Answer 1

您可以测试您的

Hystrix

断路器配置。

例如，使用

Spring Boot 1.4

查看此示例应用程序：

    import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
    import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
    import org.springframework.stereotype.Component;

    @EnableCircuitBreaker
    @SpringBootApplication
    public class HystrixDemo {

        public static void main(String[] args) {
            SpringApplication.run(HystrixDemo.class, args);
        }

        @Component
        static class MyService {

            static final String COMMAND_KEY = "MyCommandKey";

            private final Outbound outbound;

            MyService(Outbound outbound) {
                this.outbound = outbound;
            }

            @HystrixCommand(
                    commandKey = COMMAND_KEY,
                    commandProperties = {
                        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2016")
                    })
            void process() {
                outbound.call();
            }
        }

        interface Outbound {
            void call();
        }
    }

您的配置测试可能如下所示：

    import com.netflix.hystrix.HystrixCommandKey;
    import com.netflix.hystrix.HystrixCommandMetrics;
    import com.netflix.hystrix.HystrixCommandProperties;
    import org.junit.Before;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.boot.test.mock.mockito.MockBean;
    import org.springframework.test.context.junit4.SpringRunner;

    import static org.junit.Assert.assertTrue;

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class MyServiceCircuitBreakerConfigurationTests {

        @Autowired
        private HystrixDemo.MyService myService;

        @MockBean
        private HystrixDemo.Outbound outbound;

        @Before
        public void setup() {
            warmUpCircuitBreaker();
        }

        @Test
        public void shouldHaveCustomTimeout() {
            assertTrue(getCircuitBreakerCommandProperties().executionTimeoutInMilliseconds().get() == 2016);
        }

        private void warmUpCircuitBreaker() {
            myService.process();
        }

        public static HystrixCommandProperties getCircuitBreakerCommandProperties() {
            return HystrixCommandMetrics.getInstance(getCommandKey()).getProperties();
        }

        private static HystrixCommandKey getCommandKey() {
            return HystrixCommandKey.Factory.asKey(HystrixDemo.MyService.COMMAND_KEY);
        }
    }
    

另外，如果你想测试断路器，可以看看这个测试：

    import com.netflix.config.ConfigurationManager;
    import com.netflix.hystrix.Hystrix;
    import com.netflix.hystrix.HystrixCircuitBreaker;
    import com.netflix.hystrix.HystrixCommandKey;
    import org.junit.Before;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.boot.test.mock.mockito.MockBean;
    import org.springframework.test.context.junit4.SpringRunner;

    import static org.junit.Assert.assertFalse;
    import static org.junit.Assert.assertTrue;
    import static org.junit.Assert.fail;
    import static org.mockito.BDDMockito.willThrow;

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class MyServiceCircuitBreakerTests {

        @Autowired
        private HystrixDemo.MyService myService;

        @MockBean
        private HystrixDemo.Outbound outbound;

        @Before
        public void setup() {
            resetHystrix();
            warmUpCircuitBreaker();
            openCircuitBreakerAfterOneFailingRequest();
        }

        @Test
        public void shouldTripCircuit() throws InterruptedException {
            willThrow(new RuntimeException()).given(outbound).call();

            HystrixCircuitBreaker circuitBreaker = getCircuitBreaker();

            // demonstrates circuit is actually closed
            assertFalse(circuitBreaker.isOpen());
            assertTrue(circuitBreaker.allowRequest());

            try {
                myService.process();
                fail("unexpected");
            } catch (RuntimeException exception) {
                waitUntilCircuitBreakerOpens();
                assertTrue(circuitBreaker.isOpen());
                assertFalse(circuitBreaker.allowRequest());
            }
        }

        private void waitUntilCircuitBreakerOpens() throws InterruptedException {
            /* one second is almost sufficient
               borrowed from https://github.com/Netflix/Hystrix/blob/v1.5.5/hystrix-core/src/test/java/com/netflix/hystrix/HystrixCircuitBreakerTest.java#L140
             */
            Thread.sleep(1000);
        }

        private void resetHystrix() {
            Hystrix.reset();
        }

        private void warmUpCircuitBreaker() {
            myService.process();
        }

        public static HystrixCircuitBreaker getCircuitBreaker() {
            return HystrixCircuitBreaker.Factory.getInstance(getCommandKey());
        }

        private static HystrixCommandKey getCommandKey() {
            return HystrixCommandKey.Factory.asKey(HystrixDemo.MyService.COMMAND_KEY);
        }

        private void openCircuitBreakerAfterOneFailingRequest() {
            ConfigurationManager.getConfigInstance().setProperty("hystrix.command." + HystrixDemo.MyService.COMMAND_KEY + ".circuitBreaker.requestVolumeThreshold", 1);
        }
    }