SentryAutoConfigurationTest.kt

package io.sentry.spring.boot

import com.acme.MainBootClass
import com.nhaarman.mockitokotlin2.any
import com.nhaarman.mockitokotlin2.anyOrNull
import com.nhaarman.mockitokotlin2.mock
import com.nhaarman.mockitokotlin2.verify
import com.nhaarman.mockitokotlin2.whenever
import io.sentry.AsyncHttpTransportFactory
import io.sentry.Breadcrumb
import io.sentry.EventProcessor
import io.sentry.IHub
import io.sentry.ITransportFactory
import io.sentry.Integration
import io.sentry.NoOpTransportFactory
import io.sentry.SamplingContext
import io.sentry.Sentry
import io.sentry.SentryEvent
import io.sentry.SentryLevel
import io.sentry.SentryOptions
import io.sentry.protocol.User
import io.sentry.spring.HttpServletRequestSentryUserProvider
import io.sentry.spring.SentryUserProvider
import io.sentry.spring.SentryUserProviderEventProcessor
import io.sentry.spring.tracing.SentryTracingFilter
import io.sentry.test.checkEvent
import io.sentry.transport.ITransport
import io.sentry.transport.ITransportGate
import io.sentry.transport.apache.ApacheHttpClientTransportFactory
import java.lang.RuntimeException
import javax.servlet.Filter
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
import org.aspectj.lang.ProceedingJoinPoint
import org.assertj.core.api.Assertions.assertThat
import org.awaitility.kotlin.await
import org.springframework.aop.support.NameMatchMethodPointcut
import org.springframework.boot.autoconfigure.AutoConfigurations
import org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
import org.springframework.boot.context.annotation.UserConfigurations
import org.springframework.boot.info.GitProperties
import org.springframework.boot.test.context.FilteredClassLoader
import org.springframework.boot.test.context.assertj.ApplicationContextAssert
import org.springframework.boot.test.context.runner.WebApplicationContextRunner
import org.springframework.boot.web.servlet.FilterRegistrationBean
import org.springframework.context.ApplicationContext
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.core.Ordered
import org.springframework.core.annotation.Order
import org.springframework.web.client.RestTemplate

class SentryAutoConfigurationTest {

    private val contextRunner = WebApplicationContextRunner()
        .withConfiguration(AutoConfigurations.of(SentryAutoConfiguration::class.java, WebMvcAutoConfiguration::class.java))

    @Test
    fun `hub is not created when auto-configuration dsn is not set`() {
        contextRunner
            .run {
                assertThat(it).doesNotHaveBean(IHub::class.java)
            }
    }

    @Test
    fun `hub is created when dsn is provided`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).hasSingleBean(IHub::class.java)
            }
    }

    @Test
    fun `OptionsConfiguration is created if custom one with name "sentryOptionsConfiguration" is not provided`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
            }
    }

    @Test
    fun `OptionsConfiguration with name "sentryOptionsConfiguration" is created if another one with different name is provided`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
            .run {
                assertThat(it).getBeans(Sentry.OptionsConfiguration::class.java).hasSize(2)
                assertThat(it).getBean("sentryOptionsConfiguration")
                    .isNotNull()
                    .isInstanceOf(Sentry.OptionsConfiguration::class.java)
                assertThat(it).getBean("customOptionsConfiguration")
                    .isNotNull()
                    .isInstanceOf(Sentry.OptionsConfiguration::class.java)
            }
    }

    @Test
    fun `"sentryOptionsConfiguration" bean is configured before custom OptionsConfiguration`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
            .run {
                val options = it.getBean(SentryOptions::class.java)
                assertThat(options.beforeSend).isNull()
            }
    }

    @Test
    fun `OptionsConfiguration is not created if custom one with name "sentryOptionsConfiguration" is provided`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(OverridingOptionsConfigurationConfiguration::class.java)
            .run {
                assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
                assertThat(it.getBean(Sentry.OptionsConfiguration::class.java, "customOptionsConfiguration")).isNotNull
            }
    }

    @Test
    fun `properties are applied to SentryOptions`() {
        contextRunner.withPropertyValues(
            "sentry.dsn=http://key@localhost/proj",
            "sentry.read-timeout-millis=10",
            "sentry.shutdown-timeout=20",
            "sentry.flush-timeout-millis=30",
            "sentry.debug=true",
            "sentry.diagnostic-level=INFO",
            "sentry.sentry-client-name=my-client",
            "sentry.max-breadcrumbs=100",
            "sentry.release=1.0.3",
            "sentry.environment=production",
            "sentry.sample-rate=0.2",
            "sentry.in-app-includes=org.springframework,com.myapp",
            "sentry.in-app-excludes=org.jboss,com.microsoft",
            "sentry.dist=my-dist",
            "sentry.attach-threads=true",
            "sentry.attach-stacktrace=true",
            "sentry.server-name=host-001",
            "sentry.exception-resolver-order=100",
            "sentry.proxy.host=example.proxy.com",
            "sentry.proxy.port=8090",
            "sentry.proxy.user=proxy-user",
            "sentry.proxy.pass=proxy-pass",
            "sentry.enable-tracing=true",
            "sentry.traces-sample-rate=0.3",
            "sentry.tags.tag1=tag1-value",
            "sentry.tags.tag2=tag2-value",
            "sentry.ignored-exceptions-for-type=java.lang.RuntimeException,java.lang.IllegalStateException,io.sentry.Sentry"
        ).run {
            val options = it.getBean(SentryProperties::class.java)
            assertThat(options.readTimeoutMillis).isEqualTo(10)
            assertThat(options.shutdownTimeout).isEqualTo(20)
            assertThat(options.flushTimeoutMillis).isEqualTo(30)
            assertThat(options.isDebug).isTrue()
            assertThat(options.diagnosticLevel).isEqualTo(SentryLevel.INFO)
            assertThat(options.maxBreadcrumbs).isEqualTo(100)
            assertThat(options.release).isEqualTo("1.0.3")
            assertThat(options.environment).isEqualTo("production")
            assertThat(options.sampleRate).isEqualTo(0.2)
            assertThat(options.inAppIncludes).containsOnly("org.springframework", "com.myapp")
            assertThat(options.inAppExcludes).containsOnly("com.microsoft", "org.jboss")
            assertThat(options.dist).isEqualTo("my-dist")
            assertThat(options.isAttachThreads).isEqualTo(true)
            assertThat(options.isAttachStacktrace).isEqualTo(true)
            assertThat(options.serverName).isEqualTo("host-001")
            assertThat(options.exceptionResolverOrder).isEqualTo(100)
            assertThat(options.proxy).isNotNull()
            assertThat(options.proxy!!.host).isEqualTo("example.proxy.com")
            assertThat(options.proxy!!.port).isEqualTo("8090")
            assertThat(options.proxy!!.user).isEqualTo("proxy-user")
            assertThat(options.proxy!!.pass).isEqualTo("proxy-pass")
            assertThat(options.isEnableTracing).isTrue()
            assertThat(options.tracesSampleRate).isEqualTo(0.3)
            assertThat(options.tags).containsEntry("tag1", "tag1-value").containsEntry("tag2", "tag2-value")
            assertThat(options.ignoredExceptionsForType).containsOnly(RuntimeException::class.java, IllegalStateException::class.java)
        }
    }

    @Test
    fun `when traces sample rate is set to null and tracing is enabled, traces sample rate should be set to 0`() {
        contextRunner.withPropertyValues(
            "sentry.dsn=http://key@localhost/proj",
            "sentry.enable-tracing=true"
        ).run {
            val options = it.getBean(SentryProperties::class.java)
            assertThat(options.isEnableTracing).isTrue()
            assertThat(options.tracesSampleRate).isNotNull().isEqualTo(0.0)
        }
    }

    @Test
    fun `when traces sample rate is set to a value and tracing is enabled, traces sample rate should not be overwritten`() {
        contextRunner.withPropertyValues(
            "sentry.dsn=http://key@localhost/proj",
            "sentry.enable-tracing=true",
            "sentry.traces-sample-rate=0.3"
        ).run {
            val options = it.getBean(SentryProperties::class.java)
            assertThat(options.isEnableTracing).isTrue()
            assertThat(options.tracesSampleRate).isNotNull().isEqualTo(0.3)
        }
    }

    @Test
    fun `sets sentryClientName property on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it.getBean(SentryOptions::class.java).sentryClientName).isEqualTo("sentry.java.spring-boot")
            }
    }

    @Test
    fun `sets SDK version on sent events`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(MockTransportConfiguration::class.java)
            .run {
                Sentry.captureMessage("Some message")
                val transport = it.getBean(ITransport::class.java)
                await.untilAsserted {
                    verify(transport).send(checkEvent { event ->
                        assertThat(event.sdk).isNotNull()
                        val sdk = event.sdk!!
                        assertThat(sdk.version).isEqualTo(BuildConfig.VERSION_NAME)
                        assertThat(sdk.name).isEqualTo(BuildConfig.SENTRY_SPRING_BOOT_SDK_NAME)
                        assertThat(sdk.packages).anyMatch { pkg ->
                            pkg.name == "maven:io.sentry:sentry-spring-boot-starter" && pkg.version == BuildConfig.VERSION_NAME
                        }
                    }, anyOrNull())
                }
            }
    }

    @Test
    fun `registers beforeSendCallback on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomBeforeSendCallbackConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).beforeSend).isInstanceOf(CustomBeforeSendCallback::class.java)
            }
    }

    @Test
    fun `registers beforeBreadcrumbCallback on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomBeforeBreadcrumbCallbackConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).beforeBreadcrumb).isInstanceOf(CustomBeforeBreadcrumbCallback::class.java)
            }
    }

    @Test
    fun `registers event processor on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomEventProcessorConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).eventProcessors).anyMatch { processor -> processor.javaClass == CustomEventProcessor::class.java }
            }
    }

    @Test
    fun `registers transport gate on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomTransportGateConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).transportGate).isInstanceOf(CustomTransportGate::class.java)
            }
    }

    @Test
    fun `registers custom integration on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomIntegration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).integrations).anyMatch { integration -> integration.javaClass == CustomIntegration::class.java }
            }
    }

    @Test
    fun `sets release on SentryEvents if Git integration is configured`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(MockTransportConfiguration::class.java, MockGitPropertiesConfiguration::class.java)
            .run {
                Sentry.captureMessage("Some message")
                val transport = it.getBean(ITransport::class.java)
                await.untilAsserted {
                    verify(transport).send(checkEvent { event ->
                        assertThat(event.release).isEqualTo("git-commit-id")
                    }, anyOrNull())
                }
            }
    }

    @Test
    fun `sets custom release on SentryEvents if release property is set and Git integration is configured`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.release=my-release")
            .withUserConfiguration(MockTransportConfiguration::class.java, MockGitPropertiesConfiguration::class.java)
            .run {
                Sentry.captureMessage("Some message")
                val transport = it.getBean(ITransport::class.java)
                await.untilAsserted {
                    verify(transport).send(checkEvent { event ->
                        assertThat(event.release).isEqualTo("my-release")
                    }, anyOrNull())
                }
            }
    }

    @Test
    fun `sets inAppIncludes on SentryOptions from a class annotated with @SpringBootApplication`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(MainBootClass::class.java)
            .run {
                assertThat(it.getBean(SentryProperties::class.java).inAppIncludes)
                    .containsOnly("com.acme")
            }
    }

    @Test
    fun `when custom SentryUserProvider bean is configured, it's added after HttpServletRequestSentryUserProvider`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.send-default-pii=true")
            .withConfiguration(UserConfigurations.of(SentryUserProviderConfiguration::class.java))
            .run {
                val options = it.getBean(SentryProperties::class.java)
                val userProviderEventProcessors = options.eventProcessors.filterIsInstance<SentryUserProviderEventProcessor>()
                assertEquals(2, userProviderEventProcessors.size)
                assertTrue(userProviderEventProcessors[0].sentryUserProvider is HttpServletRequestSentryUserProvider)
                assertTrue(userProviderEventProcessors[1].sentryUserProvider is CustomSentryUserProvider)
            }
    }

    @Test
    fun `when custom SentryUserProvider bean with higher order is configured, it's added before HttpServletRequestSentryUserProvider`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.send-default-pii=true")
            .withConfiguration(UserConfigurations.of(SentryHighestOrderUserProviderConfiguration::class.java))
            .run {
                val options = it.getBean(SentryProperties::class.java)
                val userProviderEventProcessors = options.eventProcessors.filterIsInstance<SentryUserProviderEventProcessor>()
                assertEquals(2, userProviderEventProcessors.size)
                assertTrue(userProviderEventProcessors[0].sentryUserProvider is CustomSentryUserProvider)
                assertTrue(userProviderEventProcessors[1].sentryUserProvider is HttpServletRequestSentryUserProvider)
            }
    }

    @Test
    fun `when tracing is enabled, creates tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when traces sample rate is set, creates tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=0.2")
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when enable tracing is set to false and traces sample rate is set, creates tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=false", "sentry.traces-sample-rate=0.2")
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when traces sample rate is set to 0, creates tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=0.0")
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when custom traces sampler callback is registered, creates tracing filter`() {
        contextRunner.withUserConfiguration(CustomTracesSamplerCallbackConfiguration::class.java)
            .withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when tracing is set, does not create tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).doesNotHaveBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when tracing is disabled, does not create tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=false")
            .run {
                assertThat(it).doesNotHaveBean("sentryTracingFilter")
            }
    }

    @Test
    fun `when tracing is enabled and sentryTracingFilter already exists, does not create tracing filter`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withUserConfiguration(CustomSentryTracingFilter::class.java)
            .run {
                assertThat(it).hasBean("sentryTracingFilter")
                val filter = it.getBean("sentryTracingFilter")

                if (filter is FilterRegistrationBean<*>) {
                    assertThat(filter.filter).isNotInstanceOf(SentryTracingFilter::class.java)
                } else {
                    assertThat(filter).isNotInstanceOf(SentryTracingFilter::class.java)
                }
            }
    }

    @Test
    fun `when tracing is enabled creates AOP beans to support @SentryTransaction`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .run {
                assertThat(it).hasSentryTransactionBeans()
            }
    }

    @Test
    fun `when traces sample rate is set to 0, creates AOP beans to support @SentryTransaction`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=0.0")
            .run {
                assertThat(it).hasSentryTransactionBeans()
            }
    }

    @Test
    fun `when custom traces sampler callback is registered, creates AOP beans to support @SentryTransaction`() {
        contextRunner.withUserConfiguration(CustomTracesSamplerCallbackConfiguration::class.java)
            .withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).hasSentryTransactionBeans()
            }
    }

    @Test
    fun `when tracing is disabled, does not create AOP beans to support @SentryTransaction`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=false")
            .run {
                assertThat(it).doesNotHaveSentryTransactionBeans()
            }
    }

    @Test
    fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentryTransaction`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
            .run {
                assertThat(it).doesNotHaveSentryTransactionBeans()
            }
    }

    @Test
    fun `when tracing is enabled and custom sentryTransactionPointcut is provided, sentryTransactionPointcut bean is not created`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
            .run {
                assertThat(it).hasBean("sentryTransactionPointcut")
                val pointcut = it.getBean("sentryTransactionPointcut")
                assertThat(pointcut).isInstanceOf(NameMatchMethodPointcut::class.java)
            }
    }

    @Test
    fun `when tracing is enabled creates AOP beans to support @SentrySpan`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .run {
                assertThat(it).hasSentrySpanBeans()
            }
    }

    @Test
    fun `when traces sample rate is set to 0, creates AOP beans to support @SentrySpan`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=0.0")
            .run {
                assertThat(it).hasSentrySpanBeans()
            }
    }

    @Test
    fun `when custom traces sampler callback is registered, creates AOP beans to support @SentrySpan`() {
        contextRunner.withUserConfiguration(CustomTracesSamplerCallbackConfiguration::class.java)
            .withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it).hasSentrySpanBeans()
            }
    }

    @Test
    fun `when tracing is disabled, does not create AOP beans to support @Span`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=false")
            .run {
                assertThat(it).doesNotHaveSentrySpanBeans()
            }
    }

    @Test
    fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentrySpan`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
            .run {
                assertThat(it).doesNotHaveSentrySpanBeans()
            }
    }

    @Test
    fun `when tracing is enabled and custom sentrySpanPointcut is provided, sentrySpanPointcut bean is not created`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
            .run {
                assertThat(it).hasBean("sentrySpanPointcut")
                val pointcut = it.getBean("sentrySpanPointcut")
                assertThat(pointcut).isInstanceOf(NameMatchMethodPointcut::class.java)
            }
    }

    @Test
    fun `when tracing is enabled and RestTemplate is on the classpath, SentrySpanRestTemplateCustomizer bean is created`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .run {
                assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java)
            }
    }

    @Test
    fun `when tracing is enabled and RestTemplate is not on the classpath, SentrySpanRestTemplateCustomizer bean is not created`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.enable-tracing=true")
            .withClassLoader(FilteredClassLoader(RestTemplate::class.java))
            .run {
                assertThat(it).doesNotHaveBean(SentrySpanRestTemplateCustomizer::class.java)
            }
    }

    @Test
    fun `registers tracesSamplerCallback on SentryOptions`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(CustomTracesSamplerCallbackConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).tracesSampler).isInstanceOf(CustomTracesSamplerCallback::class.java)
            }
    }

    @Test
    fun `when sentry-apache-http-client-5 is on the classpath, creates apache transport factory`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .run {
                assertThat(it.getBean(SentryOptions::class.java).transportFactory).isInstanceOf(ApacheHttpClientTransportFactory::class.java)
            }
    }

    @Test
    fun `when sentry-apache-http-client-5 is not on the classpath, does not create apache transport factory`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withClassLoader(FilteredClassLoader(ApacheHttpClientTransportFactory::class.java))
            .run {
                assertThat(it.getBean(SentryOptions::class.java).transportFactory).isInstanceOf(AsyncHttpTransportFactory::class.java)
            }
    }

    @Test
    fun `when sentry-apache-http-client-5 is on the classpath and custom transport factory bean is set, does not create apache transport factory`() {
        contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj")
            .withUserConfiguration(MockTransportConfiguration::class.java)
            .run {
                assertThat(it.getBean(SentryOptions::class.java).transportFactory)
                    .isNotInstanceOf(ApacheHttpClientTransportFactory::class.java)
                    .isNotInstanceOf(NoOpTransportFactory::class.java)
            }
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomOptionsConfigurationConfiguration {

        @Bean
        open fun customOptionsConfiguration() = Sentry.OptionsConfiguration<SentryOptions> {
            it.setBeforeSend(null)
        }

        @Bean
        open fun beforeSendCallback() = CustomBeforeSendCallback()
    }

    @Configuration(proxyBeanMethods = false)
    open class OverridingOptionsConfigurationConfiguration {

        @Bean
        open fun sentryOptionsConfiguration() = Sentry.OptionsConfiguration<SentryOptions> {
        }
    }

    @Configuration(proxyBeanMethods = false)
    open class MockTransportConfiguration {

        private val transport = mock<ITransport>()

        @Bean
        open fun mockTransportFactory(): ITransportFactory {
            val factory = mock<ITransportFactory>()
            whenever(factory.create(any(), any())).thenReturn(transport)
            return factory
        }

        @Bean
        open fun sentryTransport() = transport
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomBeforeSendCallbackConfiguration {

        @Bean
        open fun beforeSendCallback() = CustomBeforeSendCallback()
    }

    class CustomBeforeSendCallback : SentryOptions.BeforeSendCallback {
        override fun execute(event: SentryEvent, hint: Any?): SentryEvent? = null
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomBeforeBreadcrumbCallbackConfiguration {

        @Bean
        open fun beforeBreadcrumbCallback() = CustomBeforeBreadcrumbCallback()
    }

    class CustomBeforeBreadcrumbCallback : SentryOptions.BeforeBreadcrumbCallback {
        override fun execute(breadcrumb: Breadcrumb, hint: Any?): Breadcrumb? = null
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomEventProcessorConfiguration {

        @Bean
        open fun customEventProcessor() = CustomEventProcessor()
    }

    class CustomEventProcessor : EventProcessor {
        override fun process(event: SentryEvent, hint: Any?) = null
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomIntegrationConfiguration {

        @Bean
        open fun customIntegration() = CustomIntegration()
    }

    class CustomIntegration : Integration {
        override fun register(hub: IHub, options: SentryOptions) {}
    }

    @Configuration(proxyBeanMethods = false)
    open class CustomTransportGateConfiguration {

        @Bean
        open fun customTransportGate() = CustomTransportGate()
    }

    class CustomTransportGate : ITransportGate {
        override fun isConnected() = true
    }

    @Configuration(proxyBeanMethods = false)
    open class MockGitPropertiesConfiguration {

        @Bean
        open fun gitProperties(): GitProperties {
            val git = mock<GitProperties>()
            whenever(git.commitId).thenReturn("git-commit-id")
            return git
        }
    }

    @Configuration
    open class SentryUserProviderConfiguration {

        @Bean
        open fun userProvider() = CustomSentryUserProvider()
    }

    @Configuration
    open class SentryHighestOrderUserProviderConfiguration {

        @Bean
        @Order(Ordered.HIGHEST_PRECEDENCE)
        open fun userProvider() = CustomSentryUserProvider()
    }

    @Configuration
    open class CustomSentryTracingFilter {

        @Bean
        open fun sentryTracingFilter() = mock<Filter>()
    }

    @Configuration
    open class CustomSentryPerformancePointcutConfiguration {

        @Bean
        open fun sentryTransactionPointcut() = NameMatchMethodPointcut()

        @Bean
        open fun sentrySpanPointcut() = NameMatchMethodPointcut()
    }

    @Configuration
    open class CustomTracesSamplerCallbackConfiguration {

        @Bean
        open fun tracingSamplerCallback() = CustomTracesSamplerCallback()
    }

    class CustomTracesSamplerCallback : SentryOptions.TracesSamplerCallback {
        override fun sample(samplingContext: SamplingContext) = 1.0
    }

    open class CustomSentryUserProvider : SentryUserProvider {
        override fun provideUser(): User? {
            val user = User()
            user.username = "john.smith"
            return user
        }
    }

    private fun <C : ApplicationContext> ApplicationContextAssert<C>.hasSentryTransactionBeans(): ApplicationContextAssert<C> {
        this.hasBean("sentryTransactionPointcut")
        this.hasBean("sentryTransactionAdvice")
        this.hasBean("sentryTransactionAdvisor")
        return this
    }

    private fun <C : ApplicationContext> ApplicationContextAssert<C>.doesNotHaveSentryTransactionBeans(): ApplicationContextAssert<C> {
        this.doesNotHaveBean("sentryTransactionPointcut")
        this.doesNotHaveBean("sentryTransactionAdvice")
        this.doesNotHaveBean("sentryTransactionAdvisor")
        return this
    }

    private fun <C : ApplicationContext> ApplicationContextAssert<C>.hasSentrySpanBeans(): ApplicationContextAssert<C> {
        this.hasBean("sentrySpanPointcut")
        this.hasBean("sentrySpanAdvice")
        this.hasBean("sentrySpanAdvisor")
        return this
    }

    private fun <C : ApplicationContext> ApplicationContextAssert<C>.doesNotHaveSentrySpanBeans(): ApplicationContextAssert<C> {
        this.doesNotHaveBean("sentrySpanPointcut")
        this.doesNotHaveBean("sentrySpanAdvice")
        this.doesNotHaveBean("sentrySpanAdvisor")
        return this
    }
}