updated to make it work with tests

Author: bitsandfoxes

src/Sentry.Unity/ScreenshotEventProcessor.cs

@@ -1,24 +1,23 @@
 using Sentry.Extensibility;
-using Sentry.Unity.Integrations;
-using UnityEngine;
 
 namespace Sentry.Unity;
 
 public class ScreenshotEventProcessor : ISentryEventProcessor
 {
     private readonly SentryUnityOptions _options;
-    private readonly SentryMonoBehaviour _sentryMonoBehaviour;
+    private readonly ISentryMonoBehaviour _sentryMonoBehaviour;
 
     public ScreenshotEventProcessor(SentryUnityOptions sentryOptions) : this(sentryOptions, SentryMonoBehaviour.Instance) { }
 
-    internal ScreenshotEventProcessor(SentryUnityOptions sentryOptions, SentryMonoBehaviour? sentryMonoBehaviour)
+    internal ScreenshotEventProcessor(SentryUnityOptions sentryOptions, ISentryMonoBehaviour sentryMonoBehaviour)
     {
         _options = sentryOptions;
-        _sentryMonoBehaviour = sentryMonoBehaviour ?? SentryMonoBehaviour.Instance;
+        _sentryMonoBehaviour = sentryMonoBehaviour;
     }
 
     public SentryEvent Process(SentryEvent @event)
     {
+        // Screenshot capture is happening within the MonoBehaviour as it has to happen at the "EndOfFrame"
         _sentryMonoBehaviour.CaptureScreenshotForEvent(_options, @event.EventId);
         return @event;
     }

src/Sentry.Unity/SentryMonoBehaviour.cs

@@ -2,7 +2,6 @@
 using System.Collections;
 using Sentry.Extensibility;
 using Sentry.Internal;
-using Sentry.Protocol.Envelopes;
 using Sentry.Unity.Integrations;
 using UnityEngine;
 
@@ -11,6 +10,7 @@ namespace Sentry.Unity;
 internal interface ISentryMonoBehaviour
 {
     event Action? ApplicationResuming;
+    public void CaptureScreenshotForEvent(SentryUnityOptions options, SentryId eventId);
 }
 
 /// <summary>
@@ -120,43 +120,45 @@ private void Awake()
 /// <summary>
 /// A MonoBehaviour that captures screenshots
 /// </summary>
-public partial class SentryMonoBehaviour
+public partial class SentryMonoBehaviour : ISentryMonoBehaviour
 {
-    private bool _isCapturingScreenshot = false;
+    private bool _isCapturingScreenshot;
+    internal Func<SentryUnityOptions, byte[]> ScreenshotCaptureFunction = SentryScreenshot.Capture;
+    internal Action<SentryId, SentryAttachment> AttachmentCaptureFunction = (eventId, attachment) =>
+        ((Hub)Sentry.SentrySdk.CurrentHub).CaptureAttachment(eventId, attachment);
 
     public void CaptureScreenshotForEvent(SentryUnityOptions options, SentryId eventId)
     {
         // Only ever capture one screenshot per frame
         if (!_isCapturingScreenshot)
         {
             _isCapturingScreenshot = true;
-            StartCoroutine(CaptureScreenshotCoroutine(options, eventId));
+            StartCoroutine(CaptureScreenshot(options, eventId));
         }
     }
 
-    private IEnumerator CaptureScreenshotCoroutine(SentryUnityOptions options, SentryId eventId)
+    private IEnumerator CaptureScreenshot(SentryUnityOptions options, SentryId eventId)
     {
-        options.LogDebug("Screenshot capturing triggered. Waiting for End of Frame.");
+        options.LogDebug("Screenshot capture triggered. Waiting for End of Frame.");
 
         yield return new WaitForEndOfFrame();
 
         try
         {
-            options.LogDebug("Capturing screenshot.");
-            var screenshotBytes = SentryScreenshot.Capture(options);
+            var screenshotBytes = ScreenshotCaptureFunction(options);
             var attachment = new SentryAttachment(
                     AttachmentType.Default,
                     new ByteAttachmentContent(screenshotBytes),
                     "screenshot.jpg",
                     "image/jpeg");
 
-            Sentry.SentrySdk.CaptureAttachment(eventId, attachment);
+            options.LogDebug("Screenshot captured for event {0}", eventId);
 
-            options.LogDebug("Screenshot captured and sent for event {0}", eventId);
+            AttachmentCaptureFunction(eventId, attachment);
         }
         catch (Exception e)
         {
-            options.LogError(e, "Failed to capture screenshot: {0}");
+            options.LogError(e, "Failed to capture screenshot.");
         }
         finally
         {

src/Sentry.Unity/SentrySdk.cs

@@ -20,7 +20,6 @@ public static void Init(Action<SentryUnityOptions> sentryUnityOptionsConfigure)
         var options = new SentryUnityOptions();
         sentryUnityOptionsConfigure.Invoke(options);
 
-
         Init(options);
     }
 

src/Sentry.Unity/SentryUnitySdk.cs

@@ -134,7 +134,11 @@ internal void CaptureAttachment(SentryId eventId, SentryAttachment attachment)
             if (Sentry.SentrySdk.CurrentHub is Hub hub)
             {
                 hub.CaptureAttachment(eventId, attachment);
-                _options.DiagnosticLogger?.LogDebug("Attachment captured for event {0}", eventId);
+                _options.LogDebug("Attachment captured for event {0}", eventId);
+            }
+            else
+            {
+                _options.LogError("Capturing the attachment failed due to the current hub.");
             }
         }
         catch (Exception ex)

test/Sentry.Unity.Tests/ScreenshotEventProcessorTests.cs

@@ -1,32 +1,18 @@
-using System.Threading;
 using NUnit.Framework;
 using Sentry.Unity.Tests.Stubs;
 
 namespace Sentry.Unity.Tests;
 
 public class ScreenshotEventProcessorTests
 {
-    private class Fixture
+    [Test]
+    public void SentryEventProcessor_Process_CallsCaptureScreenshotForEvent()
     {
-        public SentryUnityOptions Options = new() { AttachScreenshot = true };
-        public TestApplication TestApplication = new();
+        var sentryMonoBehaviour = new TestSentryMonoBehaviour();
 
-        public ScreenshotEventProcessor GetSut() => new(Options);
-    }
-
-    private Fixture _fixture = null!;
-
-    [SetUp]
-    public void SetUp() => _fixture = new Fixture();
+        var screenshotProcessor = new ScreenshotEventProcessor(new SentryUnityOptions(), sentryMonoBehaviour);
+        screenshotProcessor.Process(new SentryEvent());
 
-    [TearDown]
-    public void TearDown()
-    {
-        if (SentrySdk.IsEnabled)
-        {
-            SentrySdk.Close();
-        }
+        Assert.IsTrue(sentryMonoBehaviour.CaptureScreenshotForEventCalled);
     }
-
-    // Todo: Add tests that verify passing the capture on to the MonoBehaviour
 }

test/Sentry.Unity.Tests/SentryMonoBehaviourTests.cs

@@ -1,6 +1,9 @@
+using System.Collections;
+using System.Collections.Generic;
 using NUnit.Framework;
 using Sentry.Unity.Tests.Stubs;
 using UnityEngine;
+using UnityEngine.TestTools;
 
 namespace Sentry.Unity.Tests;
 
@@ -78,4 +81,122 @@ public void UpdatePauseStatus_ResumedTwice_ApplicationResumingInvokedOnlyOnce()
 
         Assert.AreEqual(1, counter);
     }
+
+    [UnityTest]
+    public IEnumerator CaptureScreenshotForEvent_Called_CapturesScreenshotAttachmentForEventId()
+    {
+        // Arrange
+        var options = new SentryUnityOptions();
+        var sut = _fixture.GetSut();
+
+        var capturedId = SentryId.Empty;
+        SentryAttachment? capturedAttachment = null;
+        sut.AttachmentCaptureFunction = (eventId, attachment) =>
+        {
+            capturedId = eventId;
+            capturedAttachment = attachment;
+        };
+
+        var eventId = SentryId.Create();
+
+        // Act
+        sut.CaptureScreenshotForEvent(options, eventId);
+
+        // Wait for the coroutine to complete
+        yield return 0;
+
+        // Assert
+        Assert.AreEqual(eventId, capturedId);
+        Assert.IsNotNull(capturedAttachment); // Sanity check
+        Assert.AreEqual("screenshot.jpg", capturedAttachment!.FileName);
+        Assert.AreEqual("image/jpeg", capturedAttachment.ContentType);
+        Assert.AreEqual(AttachmentType.Default, capturedAttachment.Type);
+    }
+
+    [UnityTest]
+    public IEnumerator CaptureScreenshotForEvent_CalledMultipleTimesInOneFrame_OnlyExecutesOnce()
+    {
+        // Arrange
+        var options = new SentryUnityOptions();
+        var sut = _fixture.GetSut();
+
+        var didScreenshotCaptureGetCalled = false;
+        sut.ScreenshotCaptureFunction = _ =>
+        {
+            didScreenshotCaptureGetCalled = true;
+            return [0];
+        };
+
+        var didCaptureMethodGetCalled = false;
+        var captureMethodCallCount = 0;
+        sut.AttachmentCaptureFunction = (_, _) =>
+        {
+            didCaptureMethodGetCalled = true;
+            captureMethodCallCount++;
+        };
+
+        var eventId = SentryId.Create();
+
+        // Act
+        sut.CaptureScreenshotForEvent(options, eventId);
+        sut.CaptureScreenshotForEvent(options, eventId);
+        sut.CaptureScreenshotForEvent(options, eventId);
+
+        // Wait for the coroutine to complete
+        yield return 0;
+
+        // Assert
+        Assert.IsTrue(didScreenshotCaptureGetCalled);
+        Assert.IsTrue(didCaptureMethodGetCalled);
+        Assert.AreEqual(1, captureMethodCallCount);
+    }
+
+    [UnityTest]
+    public IEnumerator CaptureScreenshotForEvent_CalledTwoFramesApart_CapturesBothScreenshots()
+    {
+        // Arrange
+        var options = new SentryUnityOptions();
+        var sut = _fixture.GetSut();
+
+        var capturedEventIds = new List<SentryId>();
+        var capturedAttachments = new List<SentryAttachment>();
+        sut.AttachmentCaptureFunction = (eventId, attachment) =>
+        {
+            capturedEventIds.Add(eventId);
+            capturedAttachments.Add(attachment);
+        };
+
+        var eventId1 = SentryId.Create();
+        var eventId2 = SentryId.Create();
+
+        // Act
+        sut.CaptureScreenshotForEvent(options, eventId1);
+
+        // Wait for the first coroutine to complete
+        yield return 0;
+
+        // Capture second screenshot in next frame
+        sut.CaptureScreenshotForEvent(options, eventId2);
+
+        // Wait for the second coroutine to complete
+        yield return 0;
+
+        // Assert
+        Assert.AreEqual(2, capturedEventIds.Count);
+        Assert.AreEqual(2, capturedAttachments.Count);
+
+        // First screenshot
+        Assert.AreEqual(eventId1, capturedEventIds[0]);
+        Assert.IsNotNull(capturedAttachments[0]);
+        Assert.AreEqual("screenshot.jpg", capturedAttachments[0].FileName);
+        Assert.AreEqual("image/jpeg", capturedAttachments[0].ContentType);
+        Assert.AreEqual(AttachmentType.Default, capturedAttachments[0].Type);
+
+        // Second screenshot
+        Assert.AreEqual(eventId2, capturedEventIds[1]);
+        Assert.IsNotNull(capturedAttachments[1]);
+        Assert.AreEqual("screenshot.jpg", capturedAttachments[1].FileName);
+        Assert.AreEqual("image/jpeg", capturedAttachments[1].ContentType);
+        Assert.AreEqual(AttachmentType.Default, capturedAttachments[1].Type);
+    }
 }

test/Sentry.Unity.Tests/Stubs/SentryTestMonoBehaviour.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Sentry.Unity.Tests.Stubs;
+
+internal class TestSentryMonoBehaviour : ISentryMonoBehaviour
+{
+    public event Action? ApplicationResuming;
+    public bool CaptureScreenshotForEventCalled {get; private set;}
+
+    public void ResumeApplication() => ApplicationResuming?.Invoke();
+    public void CaptureScreenshotForEvent(SentryUnityOptions options, SentryId eventId)
+        => CaptureScreenshotForEventCalled = true;
+}

test/Sentry.Unity.Tests/TraceGenerationIntegrationTests.cs

@@ -93,11 +93,4 @@ public void TraceGeneration_OnActiveSceneChange_GeneratesNewTrace()
 
         Assert.AreNotEqual(initialPropagationContext, scope.PropagationContext);
     }
-
-    internal class TestSentryMonoBehaviour : ISentryMonoBehaviour
-    {
-        public event Action? ApplicationResuming;
-
-        public void ResumeApplication() => ApplicationResuming?.Invoke();
-    }
 }