Unit tests

Author: jamescrosswell

test/Sentry.Tests/Platforms/iOS/RuntimeMarshalManagedExceptionIntegrationTests.cs

@@ -0,0 +1,70 @@
+# if IOS
+using ObjCRuntime;
+using Sentry.Cocoa;
+
+namespace Sentry.Tests.Platforms.iOS;
+
+public class RuntimeMarshalManagedExceptionIntegrationTests
+{
+    private class Fixture
+    {
+        public IHub Hub { get; } = Substitute.For<IHub, IDisposable>();
+        public IRuntime Runtime { get; } = Substitute.For<IRuntime>();
+
+        public RuntimeMarshalManagedExceptionIntegration GetSut() => new(Runtime);
+    }
+
+    private readonly Fixture _fixture = new();
+    private SentryOptions SentryOptions { get; } = new();
+
+    [Fact]
+    public void Handle_WithException_CaptureEvent()
+    {
+        var sut = _fixture.GetSut();
+        sut.Register(_fixture.Hub, SentryOptions);
+
+        sut.Handle(this, new MarshalManagedExceptionEventArgs{Exception = new Exception()});
+
+        _fixture.Hub.Received(1).CaptureEvent(Arg.Any<SentryEvent>());
+    }
+
+    [Fact]
+    public void Handle_WithException_IsHandledFalse()
+    {
+        var sut = _fixture.GetSut();
+        sut.Register(_fixture.Hub, SentryOptions);
+
+        var exception = new Exception();
+        sut.Handle(this, new MarshalManagedExceptionEventArgs{Exception = exception});
+        Assert.Equal(false, exception.Data[Mechanism.HandledKey]);
+        Assert.True(exception.Data.Contains(Mechanism.MechanismKey));
+
+        var stackTraceFactory = Substitute.For<ISentryStackTraceFactory>();
+        var exceptionProcessor = new MainExceptionProcessor(SentryOptions, () => stackTraceFactory);
+        var @event = new SentryEvent(exception);
+
+        exceptionProcessor.Process(exception, @event);
+        Assert.NotNull(@event.SentryExceptions?.ToList().Single(p => p.Mechanism?.Handled == false));
+    }
+
+    [Fact]
+    public void Handle_NoException_NoCaptureEvent()
+    {
+        var sut = _fixture.GetSut();
+        sut.Register(_fixture.Hub, SentryOptions);
+
+        sut.Handle(this, new MarshalManagedExceptionEventArgs());
+
+        _fixture.Hub.DidNotReceive().CaptureEvent(Arg.Any<SentryEvent>());
+    }
+
+    [Fact]
+    public void Register_UnhandledException_Subscribes()
+    {
+        var sut = _fixture.GetSut();
+        sut.Register(_fixture.Hub, SentryOptions);
+
+        _fixture.Runtime.Received().MarshalManagedException += sut.Handle;
+    }
+}
+#endif

test/Sentry.Tests/SentryOptionsTests.cs

@@ -1,6 +1,8 @@
 namespace Sentry.Tests;
 #if NETFRAMEWORK
 using Sentry.PlatformAbstractions;
+#elif IOS || MACCATALYST
+using Sentry.Cocoa;
 #endif
 public partial class SentryOptionsTests
 {
@@ -285,6 +287,16 @@ public void DisableNetFxInstallationsEventProcessor_RemovesDisableNetFxInstallat
     }
 #endif
 
+#if IOS || MACCATALYST
+    [Fact]
+    public void DisableRuntimeMarshalManagedExceptionCapture_RemovesRuntimeMarshalManagedExceptionIntegration()
+    {
+        var sut = new SentryOptions();
+        sut.DisableRuntimeMarshalManagedExceptionCapture();
+        Assert.DoesNotContain(sut.Integrations,
+            p => p is RuntimeMarshalManagedExceptionIntegration);
+    }
+#else
     [Fact]
     public void DisableAppDomainUnhandledExceptionCapture_RemovesAppDomainUnhandledExceptionIntegration()
     {
@@ -293,6 +305,7 @@ public void DisableAppDomainUnhandledExceptionCapture_RemovesAppDomainUnhandledE
         Assert.DoesNotContain(sut.Integrations,
             p => p is AppDomainUnhandledExceptionIntegration);
     }
+#endif
 
     [Fact]
     public void DisableTaskUnobservedTaskExceptionCapture_UnobservedTaskExceptionIntegration()
@@ -581,12 +594,21 @@ public void GetAllEventProcessors_NoAdding_FirstReturned_DuplicateDetectionProce
         _ = Assert.IsType<DuplicateEventDetectionEventProcessor>(sut.GetAllEventProcessors().First());
     }
 
+#if IOS || MACCATALYST
+    [Fact]
+    public void Integrations_Includes_RuntimeMarshalManagedExceptionIntegration()
+    {
+        var sut = new SentryOptions();
+        Assert.Contains(sut.Integrations, i => i.GetType() == typeof(RuntimeMarshalManagedExceptionIntegration));
+    }
+#else
     [Fact]
     public void Integrations_Includes_AppDomainUnhandledExceptionIntegration()
     {
         var sut = new SentryOptions();
         Assert.Contains(sut.Integrations, i => i.GetType() == typeof(AppDomainUnhandledExceptionIntegration));
     }
+#endif
 
     [Fact]
     public void Integrations_Includes_AppDomainProcessExitIntegration()