Rename local variables in test assertions to improve some groovy assert messages (#3013)

testing-common/src/main/groovy/io/opentelemetry/instrumentation/test/asserts/AttributesAssert.groovy

@@ -28,20 +28,20 @@ class AttributesAssert {
     asserter.assertAttributesAllVerified()
   }
 
-  def attribute(String name, value) {
+  def attribute(String name, expected) {
-    if (value == null) {
+    if (expected == null) {
       return
     }
     assertedAttributes.add(name)
-    def val = attributes.get(name)
+    def value = attributes.get(name)
-    if (value instanceof Pattern) {
+    if (expected instanceof Pattern) {
-      assert val =~ value
+      assert value =~ expected
-    } else if (value instanceof Class) {
+    } else if (expected instanceof Class) {
-      assert ((Class) value).isInstance(val)
+      assert ((Class) expected).isInstance(value)
-    } else if (value instanceof Closure) {
+    } else if (expected instanceof Closure) {
-      assert ((Closure) value).call(val)
+      assert ((Closure) expected).call(value)
     } else {
-      assert val == value
+      assert value == expected
     }
   }
 

testing-common/src/main/groovy/io/opentelemetry/instrumentation/test/asserts/SpanAssert.groovy

@@ -54,34 +54,30 @@ class SpanAssert {
     assertEvent(span.events.get(index), spec)
   }
 
-  def assertNameContains(String spanName, String... shouldContainArr) {
+  def name(String expected) {
-    for (String shouldContain : shouldContainArr) {
+    assert span.name == expected
-      assert spanName.contains(shouldContain)
+    checked.name = true
+  }
+
+  def name(Pattern expected) {
+    assert span.name =~ expected
+    checked.name = true
+  }
+
+  def name(Closure expected) {
+    assert ((Closure) expected).call(span.name)
+    checked.name = true
+  }
+
+  def nameContains(String... expectedParts) {
+    for (String expectedPart : expectedParts) {
+      assert span.name.contains(expectedPart)
     }
-  }
-
-  def name(String name) {
-    assert span.name == name
     checked.name = true
   }
 
-  def name(Pattern pattern) {
+  def kind(SpanKind expected) {
-    assert span.name =~ pattern
+    assert span.kind == expected
-    checked.name = true
-  }
-
-  def name(Closure spec) {
-    assert ((Closure) spec).call(span.name)
-    checked.name = true
-  }
-
-  def nameContains(String... nameParts) {
-    assertNameContains(span.name, nameParts)
-    checked.name = true
-  }
-
-  def kind(SpanKind kind) {
-    assert span.kind == kind
     checked.kind = true
   }
 
@@ -90,29 +86,29 @@ class SpanAssert {
     checked.parentSpanId = true
   }
 
-  def parentSpanId(String parentSpanId) {
+  def parentSpanId(String expected) {
-    assert span.parentSpanId == parentSpanId
+    assert span.parentSpanId == expected
     checked.parentId = true
   }
 
-  def traceId(String traceId) {
+  def traceId(String expected) {
-    assert span.traceId == traceId
+    assert span.traceId == expected
     checked.traceId = true
   }
 
-  def childOf(SpanData parent) {
+  def childOf(SpanData expectedParent) {
-    parentSpanId(parent.spanId)
+    parentSpanId(expectedParent.spanId)
-    traceId(parent.traceId)
+    traceId(expectedParent.traceId)
   }
 
-  def hasLink(SpanData linked) {
+  def hasLink(SpanData expectedLink) {
-    hasLink(linked.traceId, linked.spanId)
+    hasLink(expectedLink.traceId, expectedLink.spanId)
   }
 
-  def hasLink(String traceId, String spanId) {
+  def hasLink(String expectedTraceId, String expectedSpanId) {
     def found = false
     for (def link : span.links) {
-      if (link.spanContext.traceId == traceId && link.spanContext.spanId == spanId) {
+      if (link.spanContext.traceId == expectedTraceId && link.spanContext.spanId == expectedSpanId) {
         found = true
         break
       }
@@ -120,27 +116,27 @@ class SpanAssert {
     assert found
   }
 
-  def status(StatusCode status) {
+  def status(StatusCode expected) {
-    assert span.status.statusCode == status
+    assert span.status.statusCode == expected
     checked.status = true
   }
 
-  def errorEvent(Class<Throwable> errorType) {
+  def errorEvent(Class<Throwable> expectedClass) {
-    errorEvent(errorType, null)
+    errorEvent(expectedClass, null)
   }
 
-  def errorEvent(Class<Throwable> errorType, message) {
+  def errorEvent(Class<Throwable> expectedClass, expectedMessage) {
-    errorEvent(errorType, message, 0)
+    errorEvent(expectedClass, expectedMessage, 0)
   }
 
-  def errorEvent(Class<Throwable> errorType, message, int index) {
+  def errorEvent(Class<Throwable> errorClass, expectedMessage, int index) {
     event(index) {
       eventName(SemanticAttributes.EXCEPTION_EVENT_NAME)
       attributes {
-        "${SemanticAttributes.EXCEPTION_TYPE.key}" errorType.canonicalName
+        "${SemanticAttributes.EXCEPTION_TYPE.key}" errorClass.canonicalName
         "${SemanticAttributes.EXCEPTION_STACKTRACE.key}" String
-        if (message != null) {
+        if (expectedMessage != null) {
-          "${SemanticAttributes.EXCEPTION_MESSAGE.key}" message
+          "${SemanticAttributes.EXCEPTION_MESSAGE.key}" expectedMessage
         }
       }
     }