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

Make tests work for StatelessSession as well as Session

This commit is contained in:
Will Gittoes 2019-02-13 15:08:53 +11:00
parent e019fcbda5
commit b68563f5d1
No known key found for this signature in database
GPG Key ID: 521026A02DB0BB42
1 changed files with 99 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

171
dd-java-agent/instrumentation/hibernate/src/test/groovy/SessionTest.groovy
View File

@ -2,6 +2,7 @@ import datadog.trace.agent.test.AgentTestRunner
import datadog.trace.api.DDSpanTypes import datadog.trace.api.DDSpanTypes
import datadog.trace.api.DDTags import datadog.trace.api.DDTags
import io.opentracing.tag.Tags import io.opentracing.tag.Tags
import lombok.NonNull
import org.hibernate.* import org.hibernate.*
import org.hibernate.boot.MetadataSources import org.hibernate.boot.MetadataSources
import org.hibernate.boot.registry.StandardServiceRegistry import org.hibernate.boot.registry.StandardServiceRegistry
@ -31,128 +32,154 @@ class SessionTest extends AgentTestRunner {
} }
} }
@lombok.Value
static class SessionTypeTest {
// Lombok can't get the types right for the constructor.
SessionTypeTest(Closure fn) {
sessionBuilder = fn
}
@NonNull
Closure sessionBuilder
@NonNull
Value value = new Value("Hello :)")
}
def "test hibernate #testName"() { def "test hibernate #testName"() {
setup: setup:
Session session = sessionFactory.openSession() // Test two different types of Session. Groovy doesn't allow testing the cross-product/combinations of two data
session.beginTransaction() // tables, so we get this hack instead.
Value value = new Value("Hello :)") Map<String, SessionTypeTest> sessionTests = new HashMap<>();
session.save(value) sessionTests.put("Session", new SessionTypeTest({ return sessionFactory.openSession() }))
session.getTransaction().commit() sessionTests.put("StatelessSession", new SessionTypeTest({ return sessionFactory.openStatelessSession() }))
session.close()
// Pre-populate the DB, so delete/update can be tested.
Session writer = sessionFactory.openSession()
writer.beginTransaction()
for (SessionTypeTest sessionTypeTest : sessionTests.values()) {
writer.save(sessionTypeTest.value)
}
writer.getTransaction().commit()
writer.close()
TEST_WRITER.waitForTraces(1) TEST_WRITER.waitForTraces(1)
TEST_WRITER.clear() TEST_WRITER.clear()
session = sessionFactory.openSession() // Test for each implementation of Session.
session.beginTransaction() for (String sessionImplementation : sessionImplementations) {
SessionTypeTest sessionTypeTest = sessionTests.get(sessionImplementation)
def session = sessionTypeTest.getSessionBuilder().call()
session.beginTransaction()
try { try {
sessionMethodTest.call(session, value) sessionMethodTest.call(session, sessionTypeTest.getValue())
} catch (Exception e) { } catch (Exception e) {
// We expected this, we should see the error field set on the span. // We expected this, we should see the error field set on the span.
}
session.getTransaction().commit()
session.close()
} }
session.getTransaction().commit()
session.close()
expect: expect:
assertTraces(1) { assertTraces(sessionImplementations.size()) {
trace(0, 3) { for (int i = 0; i < sessionImplementations.size(); i++) {
span(0) { trace(i, 3) {
serviceName "hibernate" span(0) {
resourceName "hibernate.session" serviceName "hibernate"
operationName "hibernate.session" resourceName "hibernate.session"
spanType DDSpanTypes.HIBERNATE operationName "hibernate.session"
parent() spanType DDSpanTypes.HIBERNATE
tags { parent()
"$Tags.COMPONENT.key" "hibernate-java" tags {
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT "$Tags.COMPONENT.key" "hibernate-java"
"$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_CLIENT
defaultTags() "$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE
} defaultTags()
} }
span(1) { }
serviceName "hibernate" span(1) {
resourceName "hibernate.transaction.commit" serviceName "hibernate"
operationName "hibernate.transaction.commit" resourceName "hibernate.transaction.commit"
spanType DDSpanTypes.HIBERNATE operationName "hibernate.transaction.commit"
childOf span(0) spanType DDSpanTypes.HIBERNATE
tags { childOf span(0)
"$Tags.COMPONENT.key" "hibernate-java" tags {
"$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE "$Tags.COMPONENT.key" "hibernate-java"
defaultTags() "$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE
} defaultTags()
} }
span(2) { }
serviceName "hibernate" span(2) {
resourceName resource serviceName "hibernate"
operationName "hibernate.$methodName" resourceName resource
spanType DDSpanTypes.HIBERNATE operationName "hibernate.$methodName"
childOf span(0) spanType DDSpanTypes.HIBERNATE
if (isError) { childOf span(0)
errored true if (isError) {
} errored true
tags { }
if (isError) { tags {
errorTags(MappingException, "Unknown entity: java.lang.Long") if (isError) {
errorTags(MappingException, "Unknown entity: java.lang.Long")
}
"$Tags.COMPONENT.key" "hibernate-java"
"$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE
defaultTags()
} }
"$Tags.COMPONENT.key" "hibernate-java"
"$DDTags.SPAN_TYPE" DDSpanTypes.HIBERNATE
defaultTags()
} }
} }
} }
} }
where: where:
testName | methodName | resource | isError | sessionMethodTest testName | methodName | resource | isError | sessionImplementations | sessionMethodTest
"replicate" | "replicate" | "Value" | false | { sesh, val -> "replicate" | "replicate" | "Value" | false | ["Session"] | { sesh, val ->
Value replicated = new Value(val.getName() + " replicated") Value replicated = new Value(val.getName() + " replicated")
replicated.setId(val.getId()) replicated.setId(val.getId())
sesh.replicate(replicated, ReplicationMode.OVERWRITE) sesh.replicate(replicated, ReplicationMode.OVERWRITE)
} }
"replicate by entityName" | "replicate" | "Value" | false | { sesh, val -> "replicate by entityName" | "replicate" | "Value" | false | ["Session"] | { sesh, val ->
Value replicated = new Value(val.getName() + " replicated") Value replicated = new Value(val.getName() + " replicated")
replicated.setId(val.getId()) replicated.setId(val.getId())
sesh.replicate("Value", replicated, ReplicationMode.OVERWRITE) sesh.replicate("Value", replicated, ReplicationMode.OVERWRITE)
} }
"failed replicate" | "replicate" | "unknown object" | true | { sesh, val -> "failed replicate" | "replicate" | "unknown object" | true | ["Session"] | { sesh, val ->
sesh.replicate(new Long(123) /* Not a valid entity */, ReplicationMode.OVERWRITE) sesh.replicate(new Long(123) /* Not a valid entity */, ReplicationMode.OVERWRITE)
} }
"save" | "save" | "Value" | false | { sesh, val -> "save" | "save" | "Value" | false | ["Session"] | { sesh, val ->
sesh.save(new Value("Another value")) sesh.save(new Value("Another value"))
} }
"saveOrUpdate save" | "saveOrUpdate" | "Value" | false | { sesh, val -> "saveOrUpdate save" | "saveOrUpdate" | "Value" | false | ["Session"] | { sesh, val ->
sesh.saveOrUpdate(new Value("Value")) sesh.saveOrUpdate(new Value("Value"))
} }
"saveOrUpdate update" | "saveOrUpdate" | "Value" | false | { sesh, val -> "saveOrUpdate update" | "saveOrUpdate" | "Value" | false | ["Session"] | { sesh, val ->
val.setName("New name") val.setName("New name")
sesh.saveOrUpdate(val) sesh.saveOrUpdate(val)
} }
"update" | "update" | "Value" | false | { sesh, val -> "update" | "update" | "Value" | false | ["Session", "StatelessSession"] | { sesh, val ->
val.setName("New name") val.setName("New name")
sesh.update(val) sesh.update(val)
} }
"update by entityName" | "update" | "Value" | false | { sesh, val -> "update by entityName" | "update" | "Value" | false | ["Session", "StatelessSession"] | { sesh, val ->
val.setName("New name") val.setName("New name")
sesh.update("Value", val) sesh.update("Value", val)
} }
"merge" | "merge" | "Value" | false | { sesh, val -> "merge" | "merge" | "Value" | false | ["Session"] | { sesh, val ->
sesh.merge(new Value("merge me in")) sesh.merge(new Value("merge me in"))
} }
"persist" | "persist" | "Value" | false | { sesh, val -> "persist" | "persist" | "Value" | false | ["Session"] | { sesh, val ->
sesh.persist(new Value("merge me in")) sesh.persist(new Value("merge me in"))
} }
"lock" | "lock" | "Value" | false | { sesh, val -> "lock" | "lock" | "Value" | false | ["Session"] | { sesh, val ->
sesh.lock(val, LockMode.READ) sesh.lock(val, LockMode.READ)
} }
"refresh" | "refresh" | "Value" | false | { sesh, val -> "refresh" | "refresh" | "Value" | false | ["Session", "StatelessSession"] | { sesh, val ->
sesh.refresh(val) sesh.refresh(val)
} }
"delete" | "delete" | "Value" | false | { sesh, val -> "delete" | "delete" | "Value" | false | ["Session", "StatelessSession"] | { sesh, val ->
sesh.delete(val) sesh.delete(val)
} }
"get" | "get" | "Value" | false | { sesh, val -> "get" | "get" | "Value" | false | ["Session", "StatelessSession"] | { sesh, val ->
sesh.get("Value", val.getId()) sesh.get("Value", val.getId())
} }
} }