add full test scenario. refactor

Author: hjgraca

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/AWS.Lambda.Powertools.Tracing.Tests.csproj

@@ -13,6 +13,8 @@
     <ItemGroup>
         <!--   Package versions are Centrally managed in Directory.Packages.props file  -->
         <!--   More info https://learn.microsoft.com/en-us/nuget/consume-packages/central-package-management   -->
+        <PackageReference Include="Amazon.Lambda.Core" />
+        <PackageReference Include="Amazon.Lambda.TestUtilities" />
         <PackageReference Include="coverlet.collector">
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/Handlers/FullExampleHandler.cs

@@ -13,13 +13,42 @@
  * permissions and limitations under the License.
  */
 
+using System.Threading.Tasks;
+using Amazon.Lambda.Core;
+
 namespace AWS.Lambda.Powertools.Tracing.Tests.Handlers;
 
 public class FullExampleHandler
 {
-    [Tracing()]
-    public string[] Handle()
+    [Tracing(Namespace = "ns", CaptureMode = TracingCaptureMode.ResponseAndError)]
+    public Task<string> Handle(string text, ILambdaContext context)
+    {
+        Tracing.AddAnnotation("annotation", "value");
+        BusinessLogic1().GetAwaiter().GetResult();
+        
+        return Task.FromResult(text.ToUpper());
+    }
+    
+    [Tracing(SegmentName = "First Call")]
+    private async Task BusinessLogic1()
+    {
+        await BusinessLogic2();
+    }
+
+    [Tracing(CaptureMode = TracingCaptureMode.Disabled)]
+    private async Task BusinessLogic2()
+    {
+        Tracing.AddMetadata("metadata", "value");
+        
+        Tracing.WithSubsegment("localNamespace", "GetSomething", (subsegment) => {
+            GetSomething();
+        });
+        
+        await Task.FromResult(0);
+    }
+
+    private void GetSomething()
     {
-        return new[] { "A", "B" };
+        Tracing.AddAnnotation("getsomething", "value");
     }
 }

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/Handlers/HandlerTests.cs

@@ -1,12 +1,22 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
+using Amazon.Lambda.TestUtilities;
+using Amazon.XRay.Recorder.Core;
+using AWS.Lambda.Powertools.Tracing.Internal;
+using AWS.Lambda.Powertools.Tracing.Tests.Handlers;
 using Xunit;
 
-namespace AWS.Lambda.Powertools.Tracing.Tests.Handlers;
+namespace AWS.Lambda.Powertools.Tracing.Tests;
 
 [Collection("Sequential")]
-public sealed class HandlerTests
+public sealed class HandlerTests : IDisposable
 {
+    public HandlerTests()
+    {
+        Environment.SetEnvironmentVariable("LAMBDA_TASK_ROOT", "AWS");
+    }
+    
     [Fact]
     public async Task Stack_Trace_Included_When_Decorator_Present()
     {
@@ -19,7 +29,6 @@ public async Task Stack_Trace_Included_When_Decorator_Present()
         // Assert
         var tracedException = await Assert.ThrowsAsync<NullReferenceException>(Handle);
         Assert.StartsWith("at AWS.Lambda.Powertools.Tracing.Tests.Handlers.ExceptionFunctionHandler.ThisThrows()", tracedException.StackTrace?.TrimStart());
-
     }
 
     [Fact]
@@ -33,4 +42,70 @@ public async Task When_Decorator_Present_In_Generic_Method_Should_Not_Throw_When
 
         // Assert
     }
+    
+    [Fact]
+    public async Task Full_Example()
+    {
+        // Arrange
+        Environment.SetEnvironmentVariable("LAMBDA_TASK_ROOT", "AWS");
+        Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "POWERTOOLS");
+        
+        var handler = new FullExampleHandler();
+        var context = new TestLambdaContext
+        {
+            FunctionName = "FullExampleLambda",
+            FunctionVersion = "1",
+            MemoryLimitInMB = 215,
+            AwsRequestId = Guid.NewGuid().ToString("D")
+        };
+
+        // Act
+        await handler.Handle("Hello World", context);
+        var handleSegment = AWSXRayRecorder.Instance.TraceContext.GetEntity();
+        
+        // Assert
+        Assert.True(handleSegment.IsAnnotationsAdded);
+        Assert.True(handleSegment.IsSubsegmentsAdded);
+        
+        Assert.Equal("POWERTOOLS", handleSegment.Annotations["Service"]);
+        Assert.Equal(true, handleSegment.Annotations["ColdStart"]);
+        Assert.Equal("value", handleSegment.Annotations["annotation"]);
+        Assert.Equal("## Handle", handleSegment.Name);
+
+        var firstCallSubsegment = handleSegment.Subsegments[0];
+        
+        Assert.Equal("First Call", firstCallSubsegment.Name);
+        Assert.False(firstCallSubsegment.IsInProgress);
+        Assert.False(firstCallSubsegment.IsAnnotationsAdded);
+        // Assert.True(firstCallSubsegment.IsMetadataAdded);
+        Assert.True(firstCallSubsegment.IsSubsegmentsAdded);
+        
+        var businessLogicSubsegment = firstCallSubsegment.Subsegments[0];
+        
+        Assert.Equal("## BusinessLogic2", businessLogicSubsegment.Name);
+        Assert.True(businessLogicSubsegment.IsMetadataAdded);
+        Assert.False(businessLogicSubsegment.IsInProgress);
+        Assert.Single(businessLogicSubsegment.Metadata);
+        var metadata = businessLogicSubsegment.Metadata["POWERTOOLS"];
+        Assert.Contains("metadata", metadata.Keys.Cast<string>());
+        Assert.Contains("value", metadata.Values.Cast<string>());
+        Assert.True(businessLogicSubsegment.IsSubsegmentsAdded);
+        
+        var getSomethingSubsegment = businessLogicSubsegment.Subsegments[0];
+        
+        Assert.Equal("## GetSomething", getSomethingSubsegment.Name);
+        Assert.Equal("localNamespace", getSomethingSubsegment.Namespace);
+        Assert.True(getSomethingSubsegment.IsAnnotationsAdded);
+        Assert.False(getSomethingSubsegment.IsSubsegmentsAdded);
+        Assert.False(getSomethingSubsegment.IsInProgress);
+        Assert.Equal("value", getSomethingSubsegment.Annotations["getsomething"]);
+    }
+
+    public void Dispose()
+    {
+        Environment.SetEnvironmentVariable("LAMBDA_TASK_ROOT", "");
+        Environment.SetEnvironmentVariable("POWERTOOLS_SERVICE_NAME", "");
+        Environment.SetEnvironmentVariable("POWERTOOLS_TRACE_DISABLED", "");
+        TracingAspect.ResetForTest();
+    }
 }

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/Handlers/Handlers.cs

@@ -15,9 +15,9 @@
 
 using System;
 
-namespace AWS.Lambda.Powertools.Tracing.Tests.Handlers;
+namespace AWS.Lambda.Powertools.Tracing.Tests;
 
-public class Handlers
+public class HandlerFunctions
 {
     [Tracing()]
     public string[] Handle()

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/TracingAttributeTest.cs

@@ -27,11 +27,11 @@ namespace AWS.Lambda.Powertools.Tracing.Tests
     [Collection("Sequential")]
     public class TracingAttributeColdStartTest : IDisposable
     {
-        private readonly Handlers.Handlers _handler;
+        private readonly HandlerFunctions _handler;
 
         public TracingAttributeColdStartTest()
         {
-            _handler = new Handlers.Handlers();
+            _handler = new HandlerFunctions();
         }
 
         [Fact]
@@ -122,11 +122,11 @@ public void Dispose()
     [Collection("Sequential")]
     public class TracingAttributeDisableTest : IDisposable
     {
-        private readonly Handlers.Handlers _handler;
+        private readonly HandlerFunctions _handler;
 
         public TracingAttributeDisableTest()
         {
-            _handler = new Handlers.Handlers();
+            _handler = new HandlerFunctions();
         }
 
         [Fact]
@@ -178,11 +178,11 @@ private static void ClearEnvironment()
     [Collection("Sequential")]
     public class TracingAttributeLambdaEnvironmentTest
     {
-        private readonly Handlers.Handlers _handler;
+        private readonly HandlerFunctions _handler;
 
         public TracingAttributeLambdaEnvironmentTest()
         {
-            _handler = new Handlers.Handlers();
+            _handler = new HandlerFunctions();
         }
 
         [Fact]
@@ -212,11 +212,11 @@ public void Tracing_WhenOutsideOfLambdaEnv_DisablesTracing()
     [Collection("Sequential")]
     public class TracingAttributeTest : IDisposable
     {
-        private readonly Handlers.Handlers _handler;
+        private readonly HandlerFunctions _handler;
 
         public TracingAttributeTest()
         {
-            _handler = new Handlers.Handlers();
+            _handler = new HandlerFunctions();
         }
 
         #region OnEntry Tests

libraries/tests/AWS.Lambda.Powertools.Tracing.Tests/XRayRecorderTests.cs

@@ -8,6 +8,7 @@
 
 namespace AWS.Lambda.Powertools.Tracing.Tests;
 
+// This has to be the last tests to run otherwise it will keep state and fail other random tests
 [Collection("Sequential")]
 public class XRayRecorderTests
 {