package io.sentry

import io.sentry.SentryFeedbackOptions.IDialogHandler

import io.sentry.SentryOptions.ProfilesSamplerCallback

import io.sentry.SentryOptions.TracesSamplerCallback

import io.sentry.backpressure.BackpressureMonitor

import io.sentry.backpressure.NoOpBackpressureMonitor

import io.sentry.cache.EnvelopeCache

import io.sentry.cache.IEnvelopeCache

import io.sentry.internal.debugmeta.IDebugMetaLoader

import io.sentry.internal.debugmeta.ResourcesDebugMetaLoader

import io.sentry.internal.modules.CompositeModulesLoader

import io.sentry.internal.modules.IModulesLoader

import io.sentry.internal.modules.NoOpModulesLoader

import io.sentry.protocol.Feedback

import io.sentry.protocol.SdkVersion

import io.sentry.protocol.SentryId

import io.sentry.protocol.SentryThread

import io.sentry.test.ImmediateExecutorService

import io.sentry.test.createSentryClientMock

import io.sentry.test.initForTest

import io.sentry.test.injectForField

import io.sentry.util.PlatformTestManipulator

import io.sentry.util.thread.IThreadChecker

import io.sentry.util.thread.ThreadChecker

import java.io.Closeable

import java.io.File

import java.io.FileReader

import java.nio.file.Files

import java.util.Properties

import java.util.concurrent.CompletableFuture

import java.util.concurrent.atomic.AtomicBoolean

import kotlin.test.AfterTest

import kotlin.test.BeforeTest

import kotlin.test.Test

import kotlin.test.assertEquals

import kotlin.test.assertFails

import kotlin.test.assertFalse

import kotlin.test.assertIs

import kotlin.test.assertNotEquals

import kotlin.test.assertNotNull

import kotlin.test.assertNotSame

import kotlin.test.assertNull

import kotlin.test.assertSame

import kotlin.test.assertTrue

import org.awaitility.kotlin.await

import org.junit.Assert.assertThrows

import org.junit.Rule

import org.junit.rules.TemporaryFolder

import org.mockito.kotlin.any

import org.mockito.kotlin.anyOrNull

import org.mockito.kotlin.argThat

import org.mockito.kotlin.check

import org.mockito.kotlin.eq

import org.mockito.kotlin.inOrder

import org.mockito.kotlin.mock

import org.mockito.kotlin.never

import org.mockito.kotlin.verify

import org.mockito.kotlin.whenever

class SentryTest {

private val dsn = "http://key@localhost/proj"

@get:Rule val tmpDir = TemporaryFolder()

@BeforeTest

@AfterTest

fun beforeTest() {

Sentry.close()

SentryCrashLastRunState.getInstance().reset()

}

@Test

fun `init multiple times calls scopes close with isRestarting true`() {

val scopes = mock<IScopes>()

initForTest { it.dsn = dsn }

Sentry.setCurrentScopes(scopes)

initForTest { it.dsn = dsn }

verify(scopes).close(eq(true))

}

@Test

fun `init multiple times calls close on previous options not new`() {

val profiler1 = mock<ITransactionProfiler>()

val profiler2 = mock<ITransactionProfiler>()

initForTest {

it.dsn = dsn

it.setTransactionProfiler(profiler1)

}

verify(profiler1, never()).close()

initForTest {

it.dsn = dsn

it.setTransactionProfiler(profiler2)

}

verify(profiler2, never()).close()

verify(profiler1).close()

Sentry.close()

verify(profiler2).close()

}

@Test

fun `init multiple times calls close on previous integrations not new`() {

val integration1 = mock<CloseableIntegration>()

val integration2 = mock<CloseableIntegration>()

initForTest {

it.dsn = dsn

it.addIntegration(integration1)

}

verify(integration1, never()).close()

initForTest {

it.dsn = dsn

it.addIntegration(integration2)

}

verify(integration2, never()).close()

verify(integration1).close()

Sentry.close()

verify(integration2).close()

}

@Test

fun `if a single integration crashes, the SDK and other integrations are still initialized`() {

val goodIntegrationInitialized = AtomicBoolean(false)

val goodIntegration = Integration { scopes, options ->

// no-op

goodIntegrationInitialized.set(true)

}

val badIntegration = Integration { scopes, options ->

throw IllegalStateException("bad integration")

}

initForTest {

it.dsn = dsn

it.integrations.clear()

it.integrations.add(badIntegration)

it.integrations.add(goodIntegration)

}

assertTrue(Sentry.isEnabled())

assertTrue(goodIntegrationInitialized.get())

}

interface CloseableIntegration : Integration, Closeable

@Test

fun `global client is enabled after restart`() {

val scopes = mock<IScopes>()

whenever(scopes.close()).then { Sentry.getGlobalScope().client.close() }

whenever(scopes.close(anyOrNull())).then { Sentry.getGlobalScope().client.close() }

initForTest { it.dsn = dsn }

Sentry.setCurrentScopes(scopes)

initForTest { it.dsn = dsn }

verify(scopes).close(eq(true))

assertTrue(Sentry.getGlobalScope().client.isEnabled)

}

@Test

fun `global client is disabled after close`() {

val scopes = mock<IScopes>()

whenever(scopes.close()).then { Sentry.getGlobalScope().client.close() }

whenever(scopes.close(anyOrNull())).then { Sentry.getGlobalScope().client.close() }

initForTest { it.dsn = dsn }

Sentry.setCurrentScopes(scopes)

Sentry.close()

verify(scopes).close(eq(false))

assertFalse(Sentry.getGlobalScope().client.isEnabled)

}

@Test

fun `close calls scopes close with isRestarting false`() {

val scopes = mock<IScopes>()

initForTest { it.dsn = dsn }

Sentry.setCurrentScopes(scopes)

Sentry.close()

verify(scopes).close(eq(false))

}

@Test

fun `outboxPath should be created at initialization`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

sentryOptions = it

}

val file = File(sentryOptions!!.outboxPath!!)

assertTrue(file.exists())

file.deleteOnExit()

}

@Test

fun `cacheDirPath should be created at initialization`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

sentryOptions = it

}

val file = File(sentryOptions!!.cacheDirPath!!)

assertTrue(file.exists())

file.deleteOnExit()

}

@Test

fun `getCacheDirPathWithoutDsn should be created at initialization`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

sentryOptions = it

}

val cacheDirPathWithoutDsn = sentryOptions!!.cacheDirPathWithoutDsn!!

val file = File(cacheDirPathWithoutDsn)

assertTrue(file.exists())

file.deleteOnExit()

}

@Test

fun `Init sets SystemOutLogger if logger is NoOp and debug is enabled`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

sentryOptions = it

it.setDebug(true)

}

assertTrue((sentryOptions!!.logger as DiagnosticLogger).logger is SystemOutLogger)

}

@Test

fun `scope changes are isolated to a thread`() {

initForTest { it.dsn = dsn }

Sentry.configureScope { it.setTag("a", "a") }

CompletableFuture.runAsync {

Sentry.configureScope { it.setTag("b", "b") }

Sentry.configureScope { assertEquals(setOf("a", "b"), it.tags.keys) }

}

.get()

Sentry.configureScope { assertEquals(setOf("a"), it.tags.keys) }

}

@Test

fun `warns about multiple Sentry initializations`() {

val logger = mock<ILogger>()

initForTest { it.dsn = dsn }

initForTest {

it.dsn = dsn

it.setDebug(true)

it.setLogger(logger)

}

verify(logger)

.log(

eq(SentryLevel.WARNING),

eq("Sentry has been already initialized. Previous configuration will be overwritten."),

)

}

@Test

fun `warns about multiple Sentry initializations with string overload`() {

val logger = mock<ILogger>()

initForTest(dsn)

initForTest {

it.dsn = dsn

it.setDebug(true)

it.setLogger(logger)

}

verify(logger)

.log(

eq(SentryLevel.WARNING),

eq("Sentry has been already initialized. Previous configuration will be overwritten."),

)

}

@Test

fun `initializes Sentry using external properties`() {

// create a sentry.properties file in temporary folder

val temporaryFolder = TemporaryFolder()

temporaryFolder.create()

val file = temporaryFolder.newFile("sentry.properties")

file.writeText("dsn=http://key@localhost/proj")

// set location of the sentry.properties file

System.setProperty("sentry.properties.file", file.absolutePath)

try {

// initialize Sentry with empty DSN and enable loading properties from external sources

initForTest { it.isEnableExternalConfiguration = true }

assertTrue(ScopesAdapter.getInstance().isEnabled)

} finally {

temporaryFolder.delete()

}

}

@Test

fun `initializes Sentry with enabled=false, thus disabling Sentry even if dsn is set`() {

initForTest {

it.isEnabled = false

it.dsn = "http://key@localhost/proj"

}

Sentry.setTag("none", "shouldNotExist")

var value: String? = null

Sentry.getCurrentScopes().configureScope { value = it.tags[value] }

assertTrue(Sentry.getCurrentScopes().isNoOp)

assertNull(value)

}

@Test

fun `initializes Sentry with enabled=false, thus disabling Sentry even if dsn is null`() {

initForTest { it.isEnabled = false }

Sentry.setTag("none", "shouldNotExist")

var value: String? = null

Sentry.getCurrentScopes().configureScope { value = it.tags[value] }

assertTrue(Sentry.getCurrentScopes().isNoOp)

assertNull(value)

}

@Test

fun `initializes Sentry with dsn = null, throwing IllegalArgumentException`() {

val exception = assertThrows(java.lang.IllegalArgumentException::class.java) { initForTest() }

assertEquals(

"DSN is required. Use empty string or set enabled to false in SentryOptions to disable SDK.",

exception.message,

)

}

@Test

fun `captureUserFeedback gets forwarded to client`() {

initForTest { it.dsn = dsn }

val client = createSentryClientMock()

Sentry.getCurrentScopes().bindClient(client)

val userFeedback = UserFeedback(SentryId.EMPTY_ID)

Sentry.captureUserFeedback(userFeedback)

verify(client).captureUserFeedback(argThat { eventId == userFeedback.eventId })

}

@Test

fun `startTransaction sets operation and description`() {

initForTest {

it.dsn = dsn

it.tracesSampleRate = 1.0

}

val transaction = Sentry.startTransaction("name", "op", "desc", TransactionOptions())

assertEquals("name", transaction.name)

assertEquals("op", transaction.operation)

assertEquals("desc", transaction.description)

}

@Test

fun `isCrashedLastRun returns true if crashedLastRun is set`() {

initForTest { it.dsn = dsn }

SentryCrashLastRunState.getInstance().setCrashedLastRun(true)

assertTrue(Sentry.isCrashedLastRun()!!)

}

@Test

fun `profilingTracesDirPath should be created and cleared at initialization when profiling is enabled`() {

val tempPath = getTempPath()

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.profilesSampleRate = 1.0

it.cacheDirPath = tempPath

sentryOptions = it

}

assertTrue(File(sentryOptions?.profilingTracesDirPath!!).exists())

assertTrue(File(sentryOptions?.profilingTracesDirPath!!).list()!!.isEmpty())

}

@Test

fun `profilingTracesDirPath should be created and cleared at initialization when continuous profiling is enabled`() {

val tempPath = getTempPath()

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.profileSessionSampleRate = 1.0

it.cacheDirPath = tempPath

sentryOptions = it

}

assertTrue(File(sentryOptions?.profilingTracesDirPath!!).exists())

assertTrue(File(sentryOptions?.profilingTracesDirPath!!).list()!!.isEmpty())

}

@Test

fun `profilingTracesDirPath should not be created when no profiling is enabled`() {

val tempPath = getTempPath()

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.profileSessionSampleRate = 0.0

it.cacheDirPath = tempPath

sentryOptions = it

}

assertFalse(File(sentryOptions?.profilingTracesDirPath!!).exists())

}

@Test

fun `only old profiles in profilingTracesDirPath should be cleared when profiling is enabled`() {

val tempPath = getTempPath()

val options =

SentryOptions().also {

it.dsn = dsn

it.cacheDirPath = tempPath

}

val dir = File(options.profilingTracesDirPath!!)

val oldProfile = File(dir, "oldProfile")

val newProfile = File(dir, "newProfile")

// Create all files

dir.mkdirs()

oldProfile.createNewFile()

newProfile.createNewFile()

// Make the old profile look like it's created earlier

oldProfile.setLastModified(10000)

// Make the new profile look like it's created later

newProfile.setLastModified(System.currentTimeMillis() + 10000)

// Assert both file exist

assertTrue(oldProfile.exists())

assertTrue(newProfile.exists())

initForTest {

it.dsn = dsn

it.profilesSampleRate = 1.0

it.cacheDirPath = tempPath

it.executorService = ImmediateExecutorService()

}

// Assert only the new profile exists

assertFalse(oldProfile.exists())

assertTrue(newProfile.exists())

}

@Test

fun `profilingTracesDirPath should not be created and cleared when profiling is disabled`() {

val tempPath = getTempPath()

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.profilesSampleRate = 0.0

it.cacheDirPath = tempPath

sentryOptions = it

}

assertFalse(File(sentryOptions?.profilingTracesDirPath!!).exists())

}

@Test

fun `using sentry before calling init creates NoOpScopes but after init Sentry uses a new clone`() {

// noop as not yet initialized, caches NoOpScopes in ThreadLocal

Sentry.captureMessage("noop caused")

assertTrue(Sentry.getCurrentScopes().isNoOp)

// init Sentry in another thread

val thread = Thread {

initForTest {

it.dsn = dsn

it.isDebug = true

}

}

thread.start()

thread.join()

Sentry.captureMessage("should work now")

val scopes = Sentry.getCurrentScopes()

assertNotNull(scopes)

assertFalse(scopes.isNoOp)

}

@Test

fun `main scopes can be cloned and does not share scope with current scopes`() {

// noop as not yet initialized, caches NoOpScopes in ThreadLocal

Sentry.addBreadcrumb("breadcrumbNoOp")

Sentry.captureMessage("messageNoOp")

assertTrue(Sentry.getCurrentScopes().isNoOp)

val capturedEvents = mutableListOf<SentryEvent>()

// init Sentry in another thread

val thread = Thread {

initForTest {

it.dsn = dsn

it.isDebug = true

it.beforeSend =

SentryOptions.BeforeSendCallback { event, hint ->

capturedEvents.add(event)

event

}

}

}

thread.start()

thread.join()

Sentry.addBreadcrumb("breadcrumbCurrent")

val scopes = Sentry.getCurrentScopes()

assertNotNull(scopes)

assertFalse(Sentry.getCurrentScopes().isNoOp)

val forkedRootScopes = Sentry.forkedRootScopes("test")

forkedRootScopes.addBreadcrumb("breadcrumbMainClone")

scopes.captureMessage("messageCurrent")

forkedRootScopes.captureMessage("messageMainClone")

assertEquals(2, capturedEvents.size)

val mainCloneEvent = capturedEvents.firstOrNull { it.message?.formatted == "messageMainClone" }

val currentScopesEvent =

capturedEvents.firstOrNull { it.message?.formatted == "messageCurrent" }

assertNotNull(mainCloneEvent)

assertNotNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" })

assertNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbCurrent" })

assertNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbNoOp" })

assertNotNull(currentScopesEvent)

assertNull(currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" })

assertNotNull(currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbCurrent" })

assertNull(currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbNoOp" })

}

@Test

fun `main scopes is not cloned in global scopes mode and shares scope with current scopes`() {

// noop as not yet initialized, caches NoOpScopes in ThreadLocal

Sentry.addBreadcrumb("breadcrumbNoOp")

Sentry.captureMessage("messageNoOp")

assertTrue(Sentry.getCurrentScopes().isNoOp)

val capturedEvents = mutableListOf<SentryEvent>()

// init Sentry in another thread

val thread = Thread {

initForTest(

{

it.dsn = dsn

it.isDebug = true

it.beforeSend =

SentryOptions.BeforeSendCallback { event, hint ->

capturedEvents.add(event)

event

}

},

true,

)

}

thread.start()

thread.join()

Sentry.addBreadcrumb("breadcrumbCurrent")

val scopes = Sentry.getCurrentScopes()

assertNotNull(scopes)

assertFalse(scopes.isNoOp)

val forkedRootScopes = Sentry.forkedRootScopes("test")

forkedRootScopes.addBreadcrumb("breadcrumbMainClone")

scopes.captureMessage("messageCurrent")

forkedRootScopes.captureMessage("messageMainClone")

assertEquals(2, capturedEvents.size)

val mainCloneEvent = capturedEvents.firstOrNull { it.message?.formatted == "messageMainClone" }

val currentScopesEvent =

capturedEvents.firstOrNull { it.message?.formatted == "messageCurrent" }

assertNotNull(mainCloneEvent)

assertNotNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" })

assertNotNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbCurrent" })

assertNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbNoOp" })

assertNotNull(currentScopesEvent)

assertNotNull(

currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" }

)

assertNotNull(currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbCurrent" })

assertNull(currentScopesEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbNoOp" })

}

@Test

fun `when init is called and configure throws an exception then an error is logged`() {

val logger = mock<ILogger>()

val initException = Exception("init")

initForTest(

{

it.dsn = dsn

it.isDebug = true

it.setLogger(logger)

throw initException

},

true,

)

verify(logger).log(eq(SentryLevel.ERROR), any(), eq(initException))

}

@Test

fun `when init with a SentryOptions Subclass is called and configure throws an exception then an error is logged`() {

class ExtendedSentryOptions : SentryOptions()

val logger = mock<ILogger>()

val initException = Exception("init")

Sentry.init(OptionsContainer.create(ExtendedSentryOptions::class.java)) {

options: ExtendedSentryOptions ->

options.dsn = dsn

options.isDebug = true

options.setLogger(logger)

throw initException

}

verify(logger).log(eq(SentryLevel.ERROR), any(), eq(initException))

}

@Test

fun `overrides envelope cache if it's not set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

sentryOptions = it

}

assertTrue { sentryOptions!!.envelopeDiskCache is EnvelopeCache }

}

@Test

fun `does not override envelope cache if it's already set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.cacheDirPath = getTempPath()

it.setEnvelopeDiskCache(CustomEnvelopCache())

sentryOptions = it

}

assertTrue { sentryOptions!!.envelopeDiskCache is CustomEnvelopCache }

}

@Test

fun `overrides modules loader if it's not set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

sentryOptions = it

}

assertTrue { sentryOptions!!.modulesLoader is CompositeModulesLoader }

}

@Test

fun `does not override modules loader if it's already set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.setModulesLoader(CustomModulesLoader())

sentryOptions = it

}

assertTrue { sentryOptions!!.modulesLoader is CustomModulesLoader }

}

@Test

fun `overrides debug meta loader if it's not set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

sentryOptions = it

}

assertTrue { sentryOptions!!.debugMetaLoader is ResourcesDebugMetaLoader }

}

@Test

fun `does not override debug meta loader if it's already set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.setDebugMetaLoader(CustomDebugMetaLoader())

sentryOptions = it

}

assertTrue { sentryOptions!!.debugMetaLoader is CustomDebugMetaLoader }

}

@Test

fun `overrides main thread checker if it's not set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

sentryOptions = it

}

assertTrue { sentryOptions!!.threadChecker is ThreadChecker }

}

@Test

fun `does not override main thread checker if it's already set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.threadChecker = CustomThreadChecker()

sentryOptions = it

}

assertTrue { sentryOptions!!.threadChecker is CustomThreadChecker }

}

@Test

fun `overrides collector if it's not set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

sentryOptions = it

}

assertTrue { sentryOptions!!.performanceCollectors.any { it is JavaMemoryCollector } }

}

@Test

fun `does not override collector if it's already set`() {

var sentryOptions: SentryOptions? = null

initForTest {

it.dsn = dsn

it.addPerformanceCollector(CustomMemoryCollector())

sentryOptions = it

}

assertTrue { sentryOptions!!.performanceCollectors.any { it is CustomMemoryCollector } }

}

@Test

fun `init does not throw on executor shut down`() {

val logger = mock<ILogger>()

initForTest {

it.dsn = dsn

it.profilesSampleRate = 1.0

it.cacheDirPath = getTempPath()

it.setLogger(logger)

it.executorService.close(0)

it.isDebug = true

}

verify(logger)

.log(

eq(SentryLevel.ERROR),

eq(

"Failed to call the executor. Old profiles will not be deleted. Did you call Sentry.close()?"

),

any(),

)

}

@Test

fun `reportFullyDisplayed calls scopes reportFullyDisplayed`() {

val scopes = mock<IScopes>()

initForTest { it.dsn = dsn }

Sentry.setCurrentScopes(scopes)

Sentry.reportFullyDisplayed()

verify(scopes).reportFullyDisplayed()

}

@Test

fun `ignores executorService if it is closed`() {

var sentryOptions: SentryOptions? = null

val executorService = mock<ISentryExecutorService>()

whenever(executorService.isClosed).thenReturn(true)

initForTest {

it.dsn = dsn

it.executorService = executorService

sentryOptions = it

}

assertNotEquals(executorService, sentryOptions!!.executorService)

}

@Test

fun `accept executorService if it is not closed`() {

var sentryOptions: SentryOptions? = null

val executorService = mock<ISentryExecutorService>()

whenever(executorService.isClosed).thenReturn(false)

initForTest {

it.dsn = dsn

it.executorService = executorService

sentryOptions = it

}

assertEquals(executorService, sentryOptions!!.executorService)

}

@Test

fun `init notifies option observers`() {

val optionsObserver = InMemoryOptionsObserver()

initForTest {

it.dsn = dsn

it.executorService = ImmediateExecutorService()

it.addOptionsObserver(optionsObserver)

it.release = "[email protected]+220"

it.proguardUuid = "uuid"

it.dist = "220"

it.sdkVersion = SdkVersion("sentry.java.android", "6.13.0")

it.environment = "debug"

it.setTag("one", "two")

it.sessionReplay.onErrorSampleRate = 0.5

}

assertEquals("[email protected]+220", optionsObserver.release)

assertEquals("debug", optionsObserver.environment)

assertEquals("220", optionsObserver.dist)

assertEquals("uuid", optionsObserver.proguardUuid)

assertEquals(mapOf("one" to "two"), optionsObserver.tags)

assertEquals(SdkVersion("sentry.java.android", "6.13.0"), optionsObserver.sdkVersion)

assertEquals(0.5, optionsObserver.replayErrorSampleRate)

}

@Test

fun `if there is work enqueued, init notifies options observers after that work is done`() {

val optionsObserver =

InMemoryOptionsObserver().apply {

setRelease("[email protected]")

setEnvironment("production")

}

val triggered = AtomicBoolean(false)

initForTest {

it.dsn = dsn

it.addOptionsObserver(optionsObserver)

it.release = "[email protected]+220"

it.environment = "debug"

it.executorService.submit {

// here the values should be still old. Sentry.init will submit another runnable

// to notify the options observers, but because the executor is single-threaded, the

// work will be enqueued and the observers will be notified after current work is

// finished, ensuring that even if something is using the options observer from a

// different thread, it will still use the old values.

Thread.sleep(1000L)

assertEquals("[email protected]", optionsObserver.release)

assertEquals("production", optionsObserver.environment)

triggered.set(true)

}

}

await.untilTrue(triggered)

assertEquals("[email protected]+220", optionsObserver.release)

assertEquals("debug", optionsObserver.environment)

}

@Test

fun `init finalizes previous session`() {

lateinit var previousSessionFile: File

initForTest {

it.dsn = dsn

it.isDebug = true

it.setLogger(SystemOutLogger())

it.release = "[email protected]"

it.cacheDirPath = tmpDir.newFolder().absolutePath

it.executorService = ImmediateExecutorService()

previousSessionFile = EnvelopeCache.getPreviousSessionFile(it.cacheDirPath!!)

previousSessionFile.parentFile.mkdirs()

it.serializer.serialize(

Session(null, null, "release", "[email protected]"),

previousSessionFile.bufferedWriter(),

)

assertEquals(

"release",

it.serializer

.deserialize(previousSessionFile.bufferedReader(), Session::class.java)!!

.environment,

)

it.sessionFlushTimeoutMillis = 100

}

assertFalse(previousSessionFile.exists())

}

@Test

fun `if there is work enqueued, init finalizes previous session after that work is done`() {

lateinit var previousSessionFile: File

val triggered = AtomicBoolean(false)

initForTest {

it.dsn = dsn

it.release = "[email protected]"

it.cacheDirPath = tmpDir.newFolder().absolutePath

previousSessionFile = EnvelopeCache.getPreviousSessionFile(it.cacheDirPath!!)

previousSessionFile.parentFile.mkdirs()

it.serializer.serialize(

Session(null, null, "release", "[email protected]"),

previousSessionFile.bufferedWriter(),

)

it.executorService.submit {

// here the previous session should still exist. Sentry.init will submit another runnable

// to finalize the previous session, but because the executor is single-threaded, the

// work will be enqueued and the previous session will be finalized after current work is

// finished, ensuring that even if something is using the previous session from a

// different thread, it will still be able to access it.

Thread.sleep(1000L)

val session =

it.serializer.deserialize(previousSessionFile.bufferedReader(), Session::class.java)

assertEquals("[email protected]", session!!.release)

assertEquals("release", session.environment)

triggered.set(true)

}

}

await.untilTrue(triggered)

assertFalse(previousSessionFile.exists())

}

@Test

fun `captureFeedback gets forwarded to client`() {

initForTest { it.dsn = dsn }

val client = createSentryClientMock()

Sentry.getCurrentScopes().bindClient(client)

val feedback = Feedback("message")

val hint = Hint()

Sentry.captureFeedback(feedback)

Sentry.captureFeedback(feedback, hint)

Sentry.captureFeedback(feedback, hint) { it.setTag("testKey", "testValue") }

verify(client).captureFeedback(eq(feedback), eq(null), anyOrNull())

verify(client)

.captureFeedback(

eq(feedback),

eq(hint),

check { assertFalse(it.tags.containsKey("testKey")) },

)

verify(client)

.captureFeedback(

eq(feedback),

eq(hint),

check { assertEquals("testValue", it.tags["testKey"]) },

)

}

@Test

fun `captureCheckIn gets forwarded to client`() {

initForTest { it.dsn = dsn }

val client = createSentryClientMock()

Sentry.getCurrentScopes().bindClient(client)

val checkIn = CheckIn("some_slug", CheckInStatus.OK)