@Before
public void createContext() {
    this.context = new AnnotationConfigWebApplicationContext();
    this.context.setServletContext(new MockServletContext());
    this.context.register(JacksonAutoConfiguration.class,HttpMessageConvertersAutoConfiguration.class,EndpointAutoConfiguration.class,EndpointWebMvcAutoConfiguration.class,ManagementServerPropertiesAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class,JolokiaAutoConfiguration.class,WebMvcAutoConfiguration.class);
}

@Before
public void createContext() {
    this.context = new AnnotationConfigWebApplicationContext();
    this.context.setServletContext(new MockServletContext());
    this.context.register(JacksonAutoConfiguration.class,WebMvcAutoConfiguration.class);
}

@Before
public void createContext() {
    this.context = new AnnotationConfigWebApplicationContext();
    this.context.setServletContext(new MockServletContext());
    this.context.register(JacksonAutoConfiguration.class,WebMvcAutoConfiguration.class);
}

@Before
public void init() {
    dbUrl = "h2:mem:testdb-" + new Random().nextInt();
    EnvironmentTestUtils.addEnvironment(context,"spring.datasource.initialize:false","spring.datasource.url:jdbc:" + dbUrl);
    context.setClassLoader(new HidePackagesClassLoader("com.vladmihalcea.flexypool","net.ttddyy.dsproxy"));
    context.register(DataSourceAutoConfiguration.class,DataSourceDecoratorAutoConfiguration.class,TraceAutoConfiguration.class,SleuthLogAutoConfiguration.class,SleuthListenerAutoConfiguration.class,SavingSpanReporterConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    dataSource = context.getBean(DataSource.class);
    spanReporter = context.getBean(CollectingSpanReporter.class);
}

@Before
public void init() {
    dbUrl = "h2:mem:testdb-" + new Random().nextInt();
    EnvironmentTestUtils.addEnvironment(context,"com.p6spy"));
    context.register(DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    dataSource = context.getBean(DataSource.class);
    spanReporter = context.getBean(CollectingSpanReporter.class);
}

@Test
public void testAddsDatasourceProxyListener() {
    context.setClassLoader(new HidePackagesClassLoader("com.vladmihalcea.flexypool",PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    ProxyDataSource proxyDataSource = (ProxyDataSource) ((DecoratedDataSource) dataSource).getDecoratedDataSource();
    ChainListener chainListener = proxyDataSource.getProxyConfig().getQueryListener();
    assertthat(chainListener.getListeners()).extracting("class").contains(TracingQueryExecutionListener.class);
}

@Test
public void testDecoratedHikariSpecificPropertiesIsSet() throws Exception {
    EnvironmentTestUtils.addEnvironment(context,"spring.datasource.type:" + HikariDataSource.class.getName(),"spring.datasource.hikari.catalog:test_catalog");
    context.register(DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();
    DataSource dataSource = context.getBean(DataSource.class);
    assertthat(dataSource).isNotNull();
    assertthat(dataSource).isinstanceOf(DecoratedDataSource.class);
    DataSource realDataSource = ((DecoratedDataSource) dataSource).getRealDataSource();
    assertthat(realDataSource).isinstanceOf(HikariDataSource.class);
    assertthat(((HikariDataSource) realDataSource).getCatalog()).isEqualTo("test_catalog");
}

@Test
public void testCustomDataSourceDecoratorApplied() throws Exception {
    System.setProperty(PropertyLoader.PROPERTIES_FILE_PATH,"db/decorator/flexy-pool.properties");
    context.register(TestDataSourceDecoratorConfiguration.class,DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    assertthat(dataSource).isNotNull();

    DataSource customDataSource = ((DecoratedDataSource) dataSource).getDecoratedDataSource();
    assertthat(customDataSource).isinstanceOf(CustomDataSourceProxy.class);

    DataSource realDataSource = ((DecoratedDataSource) dataSource).getRealDataSource();
    assertthat(realDataSource).isinstanceOf(org.apache.tomcat.jdbc.pool.DataSource.class);

    assertthatDataSourceDecoratingChain(dataSource).containsExactly(CustomDataSourceProxy.class,P6DataSource.class,ProxyDataSource.class,FlexyPoolDataSource.class);
}

@Test
public void testDecoratingCanBedisabledForSpecificBeans() throws Exception {
    EnvironmentTestUtils.addEnvironment(context,"decorator.datasource.exclude-beans:secondDataSource");
    context.register(TestMultiDataSourceConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean("dataSource",DataSource.class);
    assertthat(dataSource).isinstanceOf(DecoratedDataSource.class);

    DataSource secondDataSource = context.getBean("secondDataSource",DataSource.class);
    assertthat(secondDataSource).isinstanceOf(BasicDataSource.class);
}

@Test
public void testDecoratingHikariDataSourceWithDefaultStrategies() throws Exception {
    EnvironmentTestUtils.addEnvironment(context,"spring.datasource.type:" + HikariDataSource.class.getName());
    context.register(DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    assertDataSourceOfType(dataSource,HikariDataSource.class);
    FlexyPoolDataSource<HikariDataSource> flexyPoolDataSource = assertDataSourceOfType(dataSource,HikariDataSource.class);
    IncrementPoolOnTimeoutConnectionAcquiringStrategy strategy1 =
            findStrategy(flexyPoolDataSource,IncrementPoolOnTimeoutConnectionAcquiringStrategy.class);
    assertthat(strategy1).isNotNull();
    assertthat(strategy1).hasFieldOrPropertyWithValue("maxOverflowPoolSize",15);
    assertthat(strategy1).hasFieldOrPropertyWithValue("timeoutMillis",500);

    RetryConnectionAcquiringStrategy strategy2 =
            findStrategy(flexyPoolDataSource,RetryConnectionAcquiringStrategy.class);
    assertthat(strategy2).isNotNull();
    assertthat(strategy2).hasFieldOrPropertyWithValue("retryAttempts",2);
}

@Test
public void testDecoratingHikariDataSourceWithCustomPropertyStrategies() throws Exception {
    EnvironmentTestUtils.addEnvironment(context,"decorator.datasource.flexy-pool.acquiring-strategy.increment-pool.max-overflow-pool-size:15","decorator.datasource.flexy-pool.acquiring-strategy.increment-pool.timeout-millis:500","decorator.datasource.flexy-pool.acquiring-strategy.retry.attempts:5");
    context.register(DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class,HikariConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    FlexyPoolDataSource<HikariDataSource> flexyPoolDataSource = assertDataSourceOfType(dataSource,35);
    assertthat(strategy1).hasFieldOrPropertyWithValue("timeoutMillis",10000);

    RetryConnectionAcquiringStrategy strategy2 =
            findStrategy(flexyPoolDataSource,5);
}

@Test
public void providesCollectorComponent_whenBootstrapServeRSSet() {
  addEnvironment(context,"zipkin.sparkstreaming.stream.kafka.bootstrap-servers:" + KAFKA_BOOTSTRAP
  );
  context.register(
      PropertyPlaceholderAutoConfiguration.class,ZipkinKafkaStreamFactoryAutoConfiguration.class
  );
  context.refresh();

  ZipkinKafkaStreamFactoryProperties props =
      context.getBean(ZipkinKafkaStreamFactoryProperties.class);
  assertthat(props.getBootstrapServers())
      .containsExactly(KAFKA_BOOTSTRAP);
}

@Test
public void providesCollectorComponent_whenKafkaZookeeperSet() {
  addEnvironment(context,"zipkin.sparkstreaming.stream.kafka.zookeeper.connect:" + KAFKA_ZOOKEEPER
  );
  context.register(
      PropertyPlaceholderAutoConfiguration.class,ZipkinKafkaStreamFactoryAutoConfiguration.class
  );
  context.refresh();

  ZipkinKafkaStreamFactoryProperties props =
      context.getBean(ZipkinKafkaStreamFactoryProperties.class);
  assertthat(props.getZookeeper().getConnect())
      .isEqualTo(KAFKA_ZOOKEEPER);
}

@Test
public void provideCollectorComponent_setsZipkinSqsCollectorProperties() {
  context = new AnnotationConfigApplicationContext();
  addEnvironment(context,"zipkin.collector.sqs.queue-url:" + sqsRule.queueUrl());
  addEnvironment(context,"zipkin.collector.sqs.wait-time-seconds:1");
  addEnvironment(context,"zipkin.collector.sqs.parallelism:3");
  addEnvironment(context,"zipkin.collector.sqs.aws-access-key-id: x");
  addEnvironment(context,"zipkin.collector.sqs.aws-secret-access-key: x");
  context.register(PropertyPlaceholderAutoConfiguration.class,Region.class,ZipkinSQSCollectorAutoConfiguration.class,ZipkinSQSCredentialsAutoConfiguration.class,InMemoryConfiguration.class);
  context.refresh();

  ZipkinSQSCollectorProperties properties = context.getBean(ZipkinSQSCollectorProperties.class);

  assertthat(properties.getQueueUrl()).isEqualTo(sqsRule.queueUrl());
  assertthat(properties.getWaitTimeSeconds()).isEqualTo(1);
  assertthat(properties.getParallelism()).isEqualTo(3);
}

@Test
public void provideSecurityTokenService_whenAwsstsRoleArnIsSet() {
  context = new AnnotationConfigApplicationContext();
  addEnvironment(context,"zipkin.collector.sqs.aws-secret-access-key: x");
  addEnvironment(context,"zipkin.collector.sqs.aws-sts-role-arn: test");
  context.register(PropertyPlaceholderAutoConfiguration.class,InMemoryConfiguration.class);
  context.refresh();

  assertthat(context.getBean(SQSCollector.class)).isNotNull();
  assertthat(context.getBean(AWSSecurityTokenService.class)).isNotNull();
  assertthat(context.getBean(AWSCredentialsProvider.class)).isinstanceOf(STSAssumeRoleSessionCredentialsProvider.class);
}

@Test
public void testWithConfigurationVariablesAndPropertiesOtherKey() {
    TestPropertyValues.of(
            "mybatis.configuration.variables.key1:value1","mybatis.configuration-properties.key2:value2")
            .applyTo(this.context);
    this.context.register(EmbeddedDataSourceConfiguration.class,MybatisAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    this.context.refresh();

    Properties variables = this.context.getBean(sqlSessionFactory.class).getConfiguration().getvariables();
    assertthat(variables).hasSize(2);
    assertthat(variables.getProperty("key1")).isEqualTo("value1");
    assertthat(variables.getProperty("key2")).isEqualTo("value2");
}

@Test
public void defaultsToV2Endpoint() throws Exception {
    context = new AnnotationConfigApplicationContext();
    addEnvironment(context,"spring.zipkin.base-url:" + server.url("/"));
    context.register(
            PropertyPlaceholderAutoConfiguration.class,TraceMetricsAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    spanReporter.report(span);

    Awaitility.await().untilAsserted(() -> then(server.getRequestCount()).isGreaterThan(0));

    RecordedRequest request = server.takeRequest();
    then(request.getPath()).isEqualTo("/api/v2/spans");
    then(request.getBody().readUtf8()).contains("localEndpoint");
}

@Test
public void encoderDirectsEndpoint() throws Exception {
    context = new AnnotationConfigApplicationContext();
    addEnvironment(
            context,"spring.zipkin.base-url:" + server.url("/"),"spring.zipkin.encoder:JSON_V1");
    context.register(
            PropertyPlaceholderAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    spanReporter.report(span);

    Awaitility.await().untilAsserted(() -> then(server.getRequestCount()).isGreaterThan(0));

    RecordedRequest request = server.takeRequest();
    then(request.getPath()).isEqualTo("/api/v1/spans");
    then(request.getBody().readUtf8()).contains("binaryAnnotations");
}

@Test
public void overrideRabbitMQQueue() throws Exception {
    context = new AnnotationConfigApplicationContext();
    addEnvironment(context,"spring.zipkin.rabbitmq.queue:zipkin2");
    context.register(
            PropertyPlaceholderAutoConfiguration.class,RabbitAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    assertthat(spanReporter).extracting("reporter.sender.queue")
            .contains("zipkin2");

    context.close();
}

@Test
public void overrideKafkaTopic() throws Exception {
    context = new AnnotationConfigApplicationContext();
    addEnvironment(context,"spring.zipkin.kafka.topic:zipkin2");
    context.register(
            PropertyPlaceholderAutoConfiguration.class,KafkaAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    assertthat(spanReporter).extracting("reporter.sender.topic")
            .contains("zipkin2");

    context.close();
}

@Test
public void canOverrideBySender() throws Exception {
    context = new AnnotationConfigApplicationContext();
    addEnvironment(context,"spring.zipkin.sender.type:web");
    context.register(
            PropertyPlaceholderAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    assertthat(spanReporter).extracting("reporter.sender").allSatisfy(
            s -> assertthat(s.getClass().getSimpleName()).isEqualTo("RestTemplateSender")
    );

    context.close();
}

@Test
public void rabbitWinsWhenKafkaPresent() throws Exception {
    context = new AnnotationConfigApplicationContext();
    context.register(
            PropertyPlaceholderAutoConfiguration.class,ZipkinAutoConfiguration.class);
    context.refresh();

    SpanReporter spanReporter = context.getBean(SpanReporter.class);
    assertthat(spanReporter).extracting("reporter.sender")
            .allSatisfy(s -> assertthat(s).isinstanceOf(RabbitMQSender.class));

    context.close();
}

@Test
public void defaultsTo64BitTraceId() {
    context = new AnnotationConfigApplicationContext();
    context.register(PropertyPlaceholderAutoConfiguration.class,TraceAutoConfiguration.class);
    context.refresh();
    Tracer tracer = context.getBean(Tracer.class);

    Span span = null;
    try {
        span = tracer.createSpan("foo",NeverSampler.INSTANCE);
        assertthat(span.getTraceIdHigh()).isEqualTo(0L);
        assertthat(span.getTraceId()).isNotEqualTo(0L);
    }
    finally {
        if (span != null) {
            tracer.close(span);
        }
    }
}

@Test
public void optInto128BitTraceId() {
    EnvironmentTestUtils.addEnvironment(context,"spring.sleuth.traceId128:true");
    context.register(PropertyPlaceholderAutoConfiguration.class,NeverSampler.INSTANCE);
        assertthat(span.getTraceIdHigh()).isNotEqualTo(0L);
        assertthat(span.getTraceId()).isNotEqualTo(0L);
    }
    finally {
        if (span != null) {
            tracer.close(span);
        }
    }
}

@Test
public void testOrderConfiguration() {
    ConfigurableApplicationContext applicationContext =
            SpringApplication.run(new Class[]{BatchEventAutoConfiguration.JobExecutionListenerConfiguration.class,EventJobExecutionConfiguration.class,TestSupportBinderAutoConfiguration.class},new String[]{"--spring.cloud.task.closecontext_enable=false","--spring.main.web-environment=false","--spring.cloud.task.batch.events.chunk-order=5","--spring.cloud.task.batch.events.item-process-order=5","--spring.cloud.task.batch.events.item-read-order=5","--spring.cloud.task.batch.events.item-write-order=5","--spring.cloud.task.batch.events.job-execution-order=5","--spring.cloud.task.batch.events.skip-order=5","--spring.cloud.task.batch.events.step-execution-order=5"
            });
    for (String beanName : LISTENER_BEAN_NAMES) {
        Ordered ordered = (Ordered)applicationContext.getBean(beanName);
        assertEquals("Expected order value of 5 for " + beanName,ordered.getorder(),5);
    }
}

@Test
public void testMultipleDataSources() {
    this.applicationContext = SpringApplication.run(new Class[] {JobConfigurationMultipleDataSources.class,EmbeddedDataSourceConfiguration.class,BatchAutoConfiguration.class,TaskBatchAutoConfiguration.class},ARGS);

    TaskExplorer taskExplorer = this.applicationContext.getBean(TaskExplorer.class);

    Page<TaskExecution> page = taskExplorer.findTaskExecutionsByName("application",new PageRequest(0,1));

    Set<Long> jobExecutionIds = taskExplorer.getJobExecutionIdsByTaskExecutionId(page.iterator().next().getExecutionId());

    assertEquals(1,jobExecutionIds.size());
    assertEquals(1,taskExplorer.getTaskExecution(jobExecutionIds.iterator().next()).getExecutionId());
}

@Test
public void testAutobuiltDataSourceNoJob() {
    this.applicationContext = SpringApplication.run(new Class[] {NoJobConfiguration.class,PageRequest.of(0,1));

    Set<Long> jobExecutionIds = taskExplorer.getJobExecutionIdsByTaskExecutionId(page.iterator().next().getExecutionId());

    assertEquals(0,jobExecutionIds.size());
}

@Test
public void testMapBased() {
    this.applicationContext = SpringApplication.run(new Class[] {JobConfiguration.class,(long) taskExplorer.getTaskExecutionIdByJobExecutionId(jobExecutionIds.iterator().next()));
}

@Test
public void testMultipleJobs() {
    this.applicationContext = SpringApplication.run(new Class[] {EmbeddedDataSourceConfiguration.class,MultipleJobConfiguration.class,1));

    Set<Long> jobExecutionIds = taskExplorer.getJobExecutionIdsByTaskExecutionId(page.iterator().next().getExecutionId());

    assertEquals(2,jobExecutionIds.size());
    Iterator<Long> jobExecutionIdsIterator = jobExecutionIds.iterator();
    assertEquals(1,(long) taskExplorer.getTaskExecutionIdByJobExecutionId(jobExecutionIdsIterator.next()));
    assertEquals(1,(long) taskExplorer.getTaskExecutionIdByJobExecutionId(jobExecutionIdsIterator.next()));
}

@Test
public void successfulTasktest() {
    applicationContext = new SpringApplicationBuilder().sources(new Class[]{TaskConfiguration.class,PropertyPlaceholderAutoConfiguration.class}).build().run(new String[]{
            "--spring.cloud.task.closecontext.enable=false","--spring.cloud.task.name=" + TASK_NAME,"--spring.main.web-environment=false"});

    String output = this.outputCapture.toString();
    assertTrue("Test results do not show create task message: " + output,output.contains(CREATE_TASK_MESSAGE));
    assertTrue("Test results do not show success message: " + output,output.contains(UPDATE_TASK_MESSAGE));
    assertTrue("Test results have incorrect exit code: " + output,output.contains(SUCCESS_EXIT_CODE_MESSAGE));
}

@Test
public void invalidExecutionId() {
    boolean exceptionFired = false;
    try {
        applicationContext = new SpringApplicationBuilder().sources(TaskExceptionConfiguration.class,PropertyPlaceholderAutoConfiguration.class).build().run(new String[]{
                "--spring.cloud.task.closecontext.enable=false","--spring.cloud.task.executionid=55"});
    }
    catch (ApplicationContextException exception) {
        exceptionFired = true;
    }
    assertTrue("An ApplicationContextException should have been thrown",exceptionFired);

    String output = this.outputCapture.toString();
    assertTrue("Test results do not show the correct exception message: " + output,output.contains(EXCEPTION_INVALID_TASK_EXECUTION_ID));
}

@Test
public void testRepositorynotinitialized() throws Exception {
    Properties properties = new Properties();

    properties.put("spring.cloud.task.tablePrefix","foobarless");
    PropertiesPropertySource propertiesSource = new PropertiesPropertySource("test",properties);

    this.context = new AnnotationConfigApplicationContext();
    this.context.getEnvironment().getPropertySources().addLast(propertiesSource);
    ((AnnotationConfigApplicationContext)context).register(SimpleTaskConfiguration.class);
    ((AnnotationConfigApplicationContext)context).register(PropertyPlaceholderAutoConfiguration.class);
    ((AnnotationConfigApplicationContext)context).register(EmbeddedDataSourceConfiguration.class);
    boolean wasExceptionThrown = false;
    try {
        this.context.refresh();
    }
    catch (ApplicationContextException ex) {
        wasExceptionThrown = true;
    }
    assertTrue("Expected ApplicationContextException to be thrown",wasExceptionThrown);
}

private DeployerProperties loadCloudProperties() {

        final ConfigurableApplicationContext context = new SpringApplicationBuilder(
                PropertyPlaceholderAutoConfiguration.class,DeployerConfiguration.class)
                        .bannerMode(Mode.OFF).logStartupInfo(false).web(false)
                        .properties("spring.config.name=cloud","logging.level.ROOT=OFF","spring.cloud.launcher.list=true","launcher.version=" + getVersion())
                        .run(this.args);
        try {
            return context.getBean(DeployerProperties.class);
        }
        finally {
            context.close();
        }
    }

@Test
public void serviceUrlWithCompositePropertySource() {
    CompositePropertySource source = new CompositePropertySource("composite");
    this.context.getEnvironment().getPropertySources().addFirst(source);
    source.addPropertySource(new MapPropertySource("config",Collections
            .<String,Object> singletonMap("eureka.client.serviceUrl.defaultZone","http://example.com,http://example2.com")));
    this.context.register(PropertyPlaceholderAutoConfiguration.class,TestConfiguration.class);
    this.context.refresh();
    assertEquals("{defaultZone=http://example.com,http://example2.com}",this.context.getBean(EurekaClientConfigBean.class).getServiceUrl()
                    .toString());
    assertEquals("[http://example.com/,http://example2.com/]",getEurekaServiceUrlsForDefaultZone());
}

private void setup(String... env) {
    AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();
    EnvironmentTestUtils.addEnvironment(parent,env);
    parent.register(UtilAutoConfiguration.class,EurekadiscoveryClientConfiguration.class,EnvironmentKnobbler.class,EurekadiscoveryClientConfigServiceBootstrapConfiguration.class,discoveryClientConfigServiceBootstrapConfiguration.class,ConfigClientProperties.class);
    parent.refresh();
    this.context = new AnnotationConfigApplicationContext();
    this.context.setParent(parent);
    this.context.register(PropertyPlaceholderAutoConfiguration.class,EurekadiscoveryClientConfigServiceAutoConfiguration.class,EurekaClientAutoConfiguration.class);
    this.context.refresh();
}

@Override
public Environment findOne(String config,String profile,String label) {
    SpringApplicationBuilder builder = new SpringApplicationBuilder(
            PropertyPlaceholderAutoConfiguration.class);
    ConfigurableEnvironment environment = getEnvironment(profile);
    builder.environment(environment);
    builder.web(WebApplicationType.NONE).bannerMode(Mode.OFF);
    if (!logger.isDebugEnabled()) {
        // Make the mini-application startup less verbose
        builder.logStartupInfo(false);
    }
    String[] args = getArgs(config,profile,label);
    // Explicitly set the listeners (to exclude logging listener which would change
    // log levels in the caller)
    builder.application()
            .setListeners(Arrays.asList(new ConfigFileApplicationListener()));
    ConfigurableApplicationContext context = builder.run(args);
    environment.getPropertySources().remove("profiles");
    try {
        return clean(new PassthruEnvironmentRepository(environment).findOne(config,label));
    }
    finally {
        context.close();
    }
}

private void setup(String... env) {
    AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext();
    TestPropertyValues.of(env).applyTo(parent);
    parent.register(UtilAutoConfiguration.class,ConsuldiscoveryClientConfigServiceBootstrapConfiguration.class,ConsulconfigserverAutoConfiguration.class,ConsulAutoConfiguration.class,ConsuldiscoveryClientConfiguration.class);
    this.context.refresh();
}

private void setupContextForgraph(String graph) {
    String[] ARGS = new String[] {CLOSE_CONTEXT_ARG,TASK_NAME_ARG,"--graph=" + graph};

    this.applicationContext = SpringApplication.run(new Object[] {ComposedRunnerVisitorConfiguration.class,ARGS);
}

@Test
public void testAddsP6SpyListener() {
    context.setClassLoader(new HidePackagesClassLoader("com.vladmihalcea.flexypool",PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    JdbcEventListenerFactory jdbcEventListenerFactory = context.getBean(JdbcEventListenerFactory.class);
    CompoundJdbcEventListener jdbcEventListener = (CompoundJdbcEventListener) jdbcEventListenerFactory.createJdbcEventListener();
    assertthat(jdbcEventListener.getEventListeners()).extracting("class").contains(TracingJdbcEventListener.class);
}

@Test
public void testDoesNotAddP6SpyListenerIfNoTracer() {
    context.setClassLoader(new HidePackagesClassLoader("com.vladmihalcea.flexypool",PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    JdbcEventListenerFactory jdbcEventListenerFactory = context.getBean(JdbcEventListenerFactory.class);
    CompoundJdbcEventListener jdbcEventListener = (CompoundJdbcEventListener) jdbcEventListenerFactory.createJdbcEventListener();
    assertthat(jdbcEventListener.getEventListeners()).extracting("class").doesNotContain(TracingJdbcEventListener.class);
}

@Test
public void testDoesntAddDatasourceProxyListenerIfNoTracer() {
    context.setClassLoader(new HidePackagesClassLoader("com.vladmihalcea.flexypool",PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    ProxyDataSource proxyDataSource = (ProxyDataSource) ((DecoratedDataSource) dataSource).getDecoratedDataSource();
    ChainListener chainListener = proxyDataSource.getProxyConfig().getQueryListener();
    assertthat(chainListener.getListeners()).extracting("class").doesNotContain(TracingQueryExecutionListener.class);
}

@Test
public void testCustomListeners() throws Exception {
    context.register(CustomListenerConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    JdbcEventListenerFactory jdbcEventListenerFactory = context.getBean(JdbcEventListenerFactory.class);
    GetCountingListener getCountingListener = context.getBean(GetCountingListener.class);
    ClosingCountingListener closingCountingListener = context.getBean(ClosingCountingListener.class);
    P6DataSource p6DataSource = (P6DataSource) ((DecoratedDataSource) dataSource).getDecoratedDataSource();
    assertthat(p6DataSource).extracting("jdbcEventListenerFactory").containsOnly(jdbcEventListenerFactory);

    CompoundJdbcEventListener jdbcEventListener = (CompoundJdbcEventListener) jdbcEventListenerFactory.createJdbcEventListener();

    assertthat(jdbcEventListener.getEventListeners()).contains(getCountingListener,closingCountingListener);
    assertthat(getCountingListener.connectionCount).isEqualTo(0);

    Connection connection1 = p6DataSource.getConnection();

    assertthat(getCountingListener.connectionCount).isEqualTo(1);
    assertthat(closingCountingListener.connectionCount).isEqualTo(0);

    Connection connection2 = p6DataSource.getConnection();

    assertthat(getCountingListener.connectionCount).isEqualTo(2);

    connection1.close();

    assertthat(closingCountingListener.connectionCount).isEqualTo(1);

    connection2.close();

    assertthat(closingCountingListener.connectionCount).isEqualTo(2);
}

@Test
public void testRegisterLogAndSlowQueryLogByDefaultToSlf4j() throws Exception {
    context.register(DataSourceAutoConfiguration.class,PropertyPlaceholderAutoConfiguration.class);
    context.refresh();

    DataSource dataSource = context.getBean(DataSource.class);
    ProxyDataSource proxyDataSource = (ProxyDataSource) ((DecoratedDataSource) dataSource).getDecoratedDataSource();
    ChainListener chainListener = proxyDataSource.getProxyConfig().getQueryListener();
    assertthat(chainListener.getListeners()).extracting("class").contains(SLF4JSlowQueryListener.class);
    assertthat(chainListener.getListeners()).extracting("class").contains(SLF4JQueryLoggingListener.class);
}