open-telemetry
/
opentelemetry-java-instrumentation
mirror of https://github.com/open-telemetry/opentelemetry-java-instrumentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix tests

This commit is contained in:
Laplie Anderson 2019-09-12 20:51:50 -04:00
parent 6c445ad030
commit 4e5e75ebff
6 changed files with 191 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dd-java-agent/instrumentation/couchbase-2.0/src/main/java/datadog/trace/instrumentation/couchbase/client/CouchbaseClusterInstrumentation.java
View File

@ -53,7 +53,7 @@ public class CouchbaseClusterInstrumentation extends Instrumenter.Default {
@Override
public Map<? extends ElementMatcher<? super MethodDescription>, String> transformers() {
return singletonMap(
isMethod().and(isPublic()).and(returns(named("rx.Observable"))),
isMethod().and(isPublic()).and(returns(named("rx.Observable"))).and(not(named("core"))),
CouchbaseClientAdvice.class.getName());
}

72
dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/CouchbaseAsyncClientTest.groovy
View File

@ -1,9 +1,13 @@
import com.couchbase.client.java.AsyncCluster
import com.couchbase.client.java.CouchbaseAsyncCluster
import com.couchbase.client.java.document.JsonDocument
import com.couchbase.client.java.document.json.JsonObject
import com.couchbase.client.java.query.N1qlQuery
import spock.util.concurrent.BlockingVariable
import util.AbstractCouchbaseTest
import java.util.concurrent.TimeUnit
import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
@ -13,21 +17,29 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
def hasBucket = new BlockingVariable<Boolean>()
when:
manager.hasBucket(bucketSettings.name()).subscribe({ result -> hasBucket.set(result) })
cluster.openBucket(bucketSettings.name(), bucketSettings.password()).subscribe({ bkt ->
manager.hasBucket(bucketSettings.name()).subscribe({ result -> hasBucket.set(result) })
})
then:
assert hasBucket.get()
assertTraces(1) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "ClusterManager.hasBucket")
sortAndAssertTraces(1) {
trace(0, 2) {
assertCouchbaseCall(it, 0, "Cluster.openBucket", null)
assertCouchbaseCall(it, 1, "ClusterManager.hasBucket", null, span(0))
}
}
where:
manager | cluster | bucketSettings
couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
memcacheAsyncManager | memcacheAsyncCluster | bucketMemcache
cleanup:
cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
manager = cluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
type = bucketSettings.type().name()
}
@ -49,7 +61,7 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
then:
inserted.get().content().getString("hello") == "world"
assertTraces(1) {
sortAndAssertTraces(1) {
trace(0, 3) {
basicSpan(it, 0, "someTrace")
@ -58,11 +70,15 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
}
}
where:
manager | cluster | bucketSettings
couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
memcacheAsyncManager | memcacheAsyncCluster | bucketMemcache
cleanup:
cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
type = bucketSettings.type().name()
}
@ -92,7 +108,7 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
found.get() == inserted.get()
found.get().content().getString("hello") == "world"
assertTraces(1) {
sortAndAssertTraces(1) {
trace(0, 4) {
basicSpan(it, 0, "someTrace")
@ -102,23 +118,29 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
}
}
where:
manager | cluster | bucketSettings
couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
memcacheAsyncManager | memcacheAsyncCluster | bucketMemcache
cleanup:
cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseAsyncCluster.create(environment, Arrays.asList("127.0.0.1"))
type = bucketSettings.type().name()
}
def "test query"() {
setup:
// Only couchbase buckets support queries.
AsyncCluster cluster = CouchbaseAsyncCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
def queryResult = new BlockingVariable<JsonObject>()
when:
// Mock expects this specific query.
// See com.couchbase.mock.http.query.QueryServer.handleString.
runUnderTrace("someTrace") {
cluster.openBucket(bucketSettings.name(), bucketSettings.password()).subscribe({
cluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password()).subscribe({
bkt ->
bkt.query(N1qlQuery.simple("SELECT mockrow"))
.flatMap({ query -> query.rows() })
@ -132,20 +154,16 @@ class CouchbaseAsyncClientTest extends AbstractCouchbaseTest {
then:
queryResult.get().get("row") == "value"
assertTraces(1) {
sortAndAssertTraces(1) {
trace(0, 3) {
basicSpan(it, 0, "someTrace")
assertCouchbaseCall(it, 2, "Cluster.openBucket", null, span(0))
assertCouchbaseCall(it, 1, "Bucket.query", bucketSettings.name(), span(2))
assertCouchbaseCall(it, 1, "Bucket.query", bucketCouchbase.name(), span(2))
}
}
where:
manager | cluster | bucketSettings
couchbaseAsyncManager | couchbaseAsyncCluster | bucketCouchbase
// Only couchbase buckets support queries.
type = bucketSettings.type().name()
cleanup:
cluster?.disconnect()?.timeout(5, TimeUnit.SECONDS)?.toBlocking()?.single()
}
}

79
dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/CouchbaseClientTest.groovy
View File

@ -1,4 +1,6 @@
import com.couchbase.client.java.Bucket
import com.couchbase.client.java.Cluster
import com.couchbase.client.java.CouchbaseCluster
import com.couchbase.client.java.document.JsonDocument
import com.couchbase.client.java.document.json.JsonObject
import com.couchbase.client.java.query.N1qlQuery
@ -8,24 +10,28 @@ import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
class CouchbaseClientTest extends AbstractCouchbaseTest {
def "test hasBucket #type"() {
when:
def hasBucket = manager.hasBucket(bucketSettings.name())
then:
assert hasBucket
assertTraces(1) {
sortAndAssertTraces(1) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "ClusterManager.hasBucket")
}
}
where:
manager | cluster | bucketSettings
couchbaseManager | couchbaseCluster | bucketCouchbase
memcacheManager | memcacheCluster | bucketMemcache
cleanup:
cluster?.disconnect()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
manager = cluster.clusterManager(USERNAME, PASSWORD)
type = bucketSettings.type().name()
}
@ -43,20 +49,27 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
found == inserted
found.content().getString("hello") == "world"
assertTraces(2) {
sortAndAssertTraces(3) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "Bucket.upsert", bucketSettings.name())
assertCouchbaseCall(it, 0, "Cluster.openBucket")
}
trace(1, 1) {
assertCouchbaseCall(it, 0, "Bucket.upsert", bucketSettings.name())
}
trace(2, 1) {
assertCouchbaseCall(it, 0, "Bucket.get", bucketSettings.name())
}
}
where:
manager | cluster | bucketSettings
couchbaseManager | couchbaseCluster | bucketCouchbase
memcacheManager | memcacheCluster | bucketMemcache
cleanup:
cluster?.disconnect()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
type = bucketSettings.type().name()
}
@ -74,31 +87,42 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
runUnderTrace("someTrace") {
inserted = bkt.upsert(JsonDocument.create("helloworld", content))
found = bkt.get("helloworld")
blockUntilChildSpansFinished(2)
}
then:
found == inserted
found.content().getString("hello") == "world"
assertTraces(1) {
trace(0, 3) {
sortAndAssertTraces(2) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "Cluster.openBucket")
}
trace(1, 3) {
basicSpan(it, 0, "someTrace")
assertCouchbaseCall(it, 2, "Bucket.upsert", bucketSettings.name(), span(0))
assertCouchbaseCall(it, 1, "Bucket.get", bucketSettings.name(), span(0))
}
}
where:
manager | cluster | bucketSettings
couchbaseManager | couchbaseCluster | bucketCouchbase
memcacheManager | memcacheCluster | bucketMemcache
cleanup:
cluster?.disconnect()
where:
environment | bucketSettings
couchbaseEnvironment | bucketCouchbase
memcacheEnvironment | bucketMemcache
cluster = CouchbaseCluster.create(environment, Arrays.asList("127.0.0.1"))
type = bucketSettings.type().name()
}
def "test query"() {
setup:
Bucket bkt = cluster.openBucket(bucketSettings.name(), bucketSettings.password())
// Only couchbase buckets support queries.
Cluster cluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
Bucket bkt = cluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
when:
// Mock expects this specific query.
@ -111,17 +135,16 @@ class CouchbaseClientTest extends AbstractCouchbaseTest {
result.first().value().get("row") == "value"
and:
assertTraces(1) {
sortAndAssertTraces(2) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "Bucket.query", bucketSettings.name())
assertCouchbaseCall(it, 0, "Cluster.openBucket")
}
trace(1, 1) {
assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
}
}
where:
manager | cluster | bucketSettings
couchbaseManager | couchbaseCluster | bucketCouchbase
// Only couchbase buckets support queries.
type = bucketSettings.type().name()
cleanup:
cluster?.disconnect()
}
}

141
dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/springdata/CouchbaseSpringRepositoryTest.groovy
View File

@ -1,9 +1,9 @@
package springdata
import com.couchbase.client.java.Cluster
import com.couchbase.client.java.CouchbaseCluster
import com.couchbase.client.java.view.DefaultView
import com.couchbase.client.java.view.DesignDocument
import datadog.trace.api.DDSpanTypes
import io.opentracing.tag.Tags
import org.springframework.context.ConfigurableApplicationContext
import org.springframework.context.annotation.AnnotationConfigApplicationContext
import org.springframework.data.repository.CrudRepository
@ -31,20 +31,21 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
DocRepository repo
def setupSpec() {
Cluster couchbaseCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
// Create view for SpringRepository's findAll()
couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password()).bucketManager()
.insertDesignDocument(
DesignDocument.create("doc", Collections.singletonList(DefaultView.create("all",
'''
DesignDocument.create("doc", Collections.singletonList(DefaultView.create("all",
'''
function (doc, meta) {
if (doc._class == "springdata.Doc") {
emit(meta.id, null);
}
}
'''.stripIndent()
)))
)
)))
)
CouchbaseConfig.setEnvironment(couchbaseEnvironment)
CouchbaseConfig.setBucketSettings(bucketCouchbase)
@ -75,21 +76,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
and:
assertTraces(1) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.query"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
}
}
@ -107,21 +94,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
and:
assertTraces(1) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.upsert"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.upsert", bucketCouchbase.name())
}
}
TEST_WRITER.clear()
@ -132,21 +105,7 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
and:
assertTraces(1) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.get"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.get", bucketCouchbase.name())
}
}
TEST_WRITER.clear()
@ -160,55 +119,13 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
assertTraces(3) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.upsert"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.upsert", bucketCouchbase.name())
}
trace(1, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.query"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
}
trace(2, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.get"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.get", bucketCouchbase.name())
}
}
TEST_WRITER.clear()
@ -222,38 +139,10 @@ class CouchbaseSpringRepositoryTest extends AbstractCouchbaseTest {
and:
assertTraces(2) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.remove"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.remove", bucketCouchbase.name())
}
trace(1, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.query"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" bucketCouchbase.name()
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.query", bucketCouchbase.name())
}
}
}

111
dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/springdata/CouchbaseSpringTemplateTest.groovy
View File

@ -1,18 +1,32 @@
package springdata
import com.couchbase.client.java.Bucket
import datadog.trace.api.DDSpanTypes
import io.opentracing.tag.Tags
import com.couchbase.client.java.Cluster
import com.couchbase.client.java.CouchbaseCluster
import com.couchbase.client.java.cluster.ClusterManager
import org.springframework.data.couchbase.core.CouchbaseTemplate
import spock.lang.Shared
import util.AbstractCouchbaseTest
import java.util.concurrent.TimeUnit
class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
@Shared
List<CouchbaseTemplate> templates
@Shared
Cluster couchbaseCluster
@Shared
Cluster memcacheCluster
def setupSpec() {
couchbaseCluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
memcacheCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
ClusterManager couchbaseManager = couchbaseCluster.clusterManager(USERNAME, PASSWORD)
ClusterManager memcacheManager = memcacheCluster.clusterManager(USERNAME, PASSWORD)
Bucket bucketCouchbase = couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
Bucket bucketMemcache = memcacheCluster.openBucket(bucketMemcache.name(), bucketMemcache.password())
@ -20,8 +34,12 @@ class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
new CouchbaseTemplate(memcacheManager.info(), bucketMemcache)]
}
def cleanupSpec() {
couchbaseCluster?.disconnect(5, TimeUnit.SECONDS)
memcacheCluster?.disconnect(5, TimeUnit.SECONDS)
}
def "test write/read #name"() {
def "test write #name"() {
setup:
def doc = new Doc()
@ -31,81 +49,42 @@ class CouchbaseSpringTemplateTest extends AbstractCouchbaseTest {
then:
template.findById("1", Doc) != null
and:
assertTraces(2) {
trace(0, 1) {
assertCouchbaseCall(it, 0, "Bucket.upsert", name)
}
trace(1, 1) {
assertCouchbaseCall(it, 0, "Bucket.get", name)
}
}
where:
template << templates
name = template.couchbaseBucket.name()
}
def "test remove #name"() {
setup:
def doc = new Doc()
when:
template.save(doc)
template.remove(doc)
then:
template.findById("1", Doc) == null
and:
assertTraces(4) {
assertTraces(3) {
trace(0, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.upsert"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" name
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.upsert", name)
}
trace(1, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.get"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" name
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.remove", name)
}
trace(2, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.remove"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" name
defaultTags()
}
}
}
trace(3, 1) {
span(0) {
serviceName "couchbase"
resourceName "Bucket.get"
operationName "couchbase.call"
spanType DDSpanTypes.COUCHBASE
errored false
parent()
tags {
"$Tags.COMPONENT.key" "couchbase-client"
"$Tags.DB_TYPE.key" "couchbase"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
"bucket" name
defaultTags()
}
}
assertCouchbaseCall(it, 0, "Bucket.get", name)
}
}

84
dd-java-agent/instrumentation/couchbase-2.0/src/test/groovy/util/AbstractCouchbaseTest.groovy
View File

@ -2,12 +2,8 @@ package util
import com.couchbase.client.core.metrics.DefaultLatencyMetricsCollectorConfig
import com.couchbase.client.core.metrics.DefaultMetricsCollectorConfig
import com.couchbase.client.java.CouchbaseAsyncCluster
import com.couchbase.client.java.CouchbaseCluster
import com.couchbase.client.java.bucket.BucketType
import com.couchbase.client.java.cluster.AsyncClusterManager
import com.couchbase.client.java.cluster.BucketSettings
import com.couchbase.client.java.cluster.ClusterManager
import com.couchbase.client.java.cluster.DefaultBucketSettings
import com.couchbase.client.java.env.CouchbaseEnvironment
import com.couchbase.client.java.env.DefaultCouchbaseEnvironment
@ -17,20 +13,22 @@ import com.couchbase.mock.CouchbaseMock
import com.couchbase.mock.http.query.QueryServer
import datadog.opentracing.DDSpan
import datadog.trace.agent.test.AgentTestRunner
import datadog.trace.agent.test.asserts.ListWriterAssert
import datadog.trace.agent.test.asserts.TraceAssert
import datadog.trace.agent.test.utils.PortUtils
import datadog.trace.api.Config
import datadog.trace.api.DDSpanTypes
import groovy.transform.stc.ClosureParams
import groovy.transform.stc.SimpleType
import io.opentracing.tag.Tags
import spock.lang.Shared
import java.util.concurrent.RejectedExecutionException
import java.util.concurrent.TimeUnit
abstract class AbstractCouchbaseTest extends AgentTestRunner {
private static final USERNAME = "Administrator"
private static final PASSWORD = "password"
static final USERNAME = "Administrator"
static final PASSWORD = "password"
@Shared
private int port = PortUtils.randomOpenPort()
@ -58,53 +56,23 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
@Shared
CouchbaseMock mock
@Shared
protected CouchbaseCluster couchbaseCluster
@Shared
protected CouchbaseAsyncCluster couchbaseAsyncCluster
@Shared
protected CouchbaseCluster memcacheCluster
@Shared
protected CouchbaseAsyncCluster memcacheAsyncCluster
@Shared
protected CouchbaseEnvironment couchbaseEnvironment
@Shared
protected CouchbaseEnvironment memcacheEnvironment
@Shared
protected ClusterManager couchbaseManager
@Shared
protected AsyncClusterManager couchbaseAsyncManager
@Shared
protected ClusterManager memcacheManager
@Shared
protected AsyncClusterManager memcacheAsyncManager
def setupSpec() {
mock = new CouchbaseMock("127.0.0.1", port, 1, 1)
mock.httpServer.register("/query", new QueryServer())
mock.start()
println "CouchbaseMock listening on localhost:$port"
mock.createBucket(convert(bucketCouchbase))
couchbaseEnvironment = envBuilder(bucketCouchbase).build()
couchbaseCluster = CouchbaseCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
couchbaseAsyncCluster = CouchbaseAsyncCluster.create(couchbaseEnvironment, Arrays.asList("127.0.0.1"))
couchbaseManager = couchbaseCluster.clusterManager(USERNAME, PASSWORD)
couchbaseAsyncManager = couchbaseAsyncCluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
mock.createBucket(convert(bucketMemcache))
couchbaseEnvironment = envBuilder(bucketCouchbase).build()
memcacheEnvironment = envBuilder(bucketMemcache).build()
memcacheCluster = CouchbaseCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
memcacheAsyncCluster = CouchbaseAsyncCluster.create(memcacheEnvironment, Arrays.asList("127.0.0.1"))
memcacheManager = memcacheCluster.clusterManager(USERNAME, PASSWORD)
memcacheAsyncManager = memcacheAsyncCluster.clusterManager(USERNAME, PASSWORD).toBlocking().single()
// Cache buckets:
couchbaseCluster.openBucket(bucketCouchbase.name(), bucketCouchbase.password())
memcacheCluster.openBucket(bucketMemcache.name(), bucketMemcache.password())
// This setting should have no effect since decorator returns null for the instance.
System.setProperty(Config.PREFIX + Config.DB_CLIENT_HOST_SPLIT_BY_INSTANCE, "true")
@ -121,17 +89,6 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
}
def cleanupSpec() {
try {
couchbaseCluster?.disconnect()
} catch (RejectedExecutionException e) {
// already closed by a test?
}
try {
memcacheCluster?.disconnect()
} catch (RejectedExecutionException e) {
// already closed by a test?
}
mock?.stop()
System.clearProperty(Config.PREFIX + Config.DB_CLIENT_HOST_SPLIT_BY_INSTANCE)
@ -159,6 +116,33 @@ abstract class AbstractCouchbaseTest extends AgentTestRunner {
.socketConnectTimeout(timeout.intValue())
}
void sortAndAssertTraces(
final int size,
@ClosureParams(value = SimpleType, options = "datadog.trace.agent.test.asserts.ListWriterAssert")
@DelegatesTo(value = ListWriterAssert, strategy = Closure.DELEGATE_FIRST)
final Closure spec) {
TEST_WRITER.waitForTraces(size)
TEST_WRITER.each {
it.sort({
a, b ->
boolean aIsCouchbaseOperation = a.operationName == "couchbase.call"
boolean bIsCouchbaseOperation = b.operationName == "couchbase.call"
if (aIsCouchbaseOperation && !bIsCouchbaseOperation) {
return 1
} else if (!aIsCouchbaseOperation && bIsCouchbaseOperation) {
return -1
}
return a.resourceName.compareTo(b.resourceName)
})
}
assertTraces(size, spec)
}
void assertCouchbaseCall(TraceAssert trace, int index, String name, String bucketName = null, Object parentSpan = null) {
trace.span(index) {
serviceName "couchbase"