feat: more exception details

Internal/Xcepto.Internal.Http/Builders/HttpStateBuilder.T.cs

@@ -27,7 +27,24 @@ public abstract class HttpStateBuilderIdentity<TBuilder> : AbstractStateBuilderI
 
         protected HttpStateBuilderIdentity(IStateMachineBuilder stateMachineBuilder, IStateBuilderIdentity stateBuilderIdentity) : base(stateMachineBuilder, stateBuilderIdentity) { }
         protected HttpStateBuilderIdentity(IStateMachineBuilder stateMachineBuilder) : base(stateMachineBuilder) { }
-
+
+        protected override string DefaultName
+        {
+            get
+            {
+                string url;
+                try
+                {
+                    url = Url().ToString();
+                }
+                catch (Exception)
+                {
+                    url = "promised url";
+                }
+                return $"Http {MethodVerb} request to {url}";
+            }
+        }
+
         /// <summary>
         /// Based on Http Verb idempotency
         /// </summary>

Samples/Compartments/Compartments.Tests/Test/AdapterCompartmentAccessTests.cs

@@ -51,15 +51,15 @@ await XceptoTest.Given(new CompartmentalizationScenario(), TimeoutConfig.FromSec
     [Test]
     public void CompartmentRepositoryDoesNotExist()
     {
-        Assert.CatchAsync<InvalidOperationException>(async () =>
+        Assert.That(async () =>
         {
             await XceptoTest.Given(new SharedSyncScenario(), TimeoutConfig.FromSeconds(3), builder =>
             {
                 var compartmentAccessAdapter = builder.RegisterAdapter(new CompartmentAccessAdapter());
                 compartmentAccessAdapter.JoinedCompartmentExpectation("service1", "service2",
                     (_, _) => true);
             });
-        });
+        }, Throws.InnerException.TypeOf<InvalidOperationException>());
     }
 
 

Samples/Compartments/Compartments.Tests/Test/DifferentServiceTests.cs

@@ -5,6 +5,7 @@
 using Xcepto.Adapters;
 using Xcepto.Builder;
 using Xcepto.Config;
+using Xcepto.Exceptions;
 
 namespace Compartments.Tests.Test;
 
@@ -33,7 +34,7 @@ public async Task ServicesDontAffectEachOther()
     [Test]
     public void ServicesAffectEachOther()
     {
-        Assert.CatchAsync<TimeoutException>(async () =>
+        Assert.CatchAsync<XceptoTimeoutException>(async () =>
         {
             await XceptoTest.Given(new SharedSyncScenario(), TimeoutConfig.FromSeconds(3), Definition);
         });

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Adapters/FailingCleanupAdapter.cs

@@ -0,0 +1,11 @@
+using Xcepto.Adapters;
+
+namespace Samples.ExceptionDetail.Tests.Adapters;
+
+public class FailingCleanupAdapter: XceptoAdapter
+{
+    protected override Task Cleanup(IServiceProvider serviceProvider)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Adapters/FailingConstructionAdapter.cs

@@ -0,0 +1,11 @@
+using Xcepto.Adapters;
+
+namespace Samples.ExceptionDetail.Tests.Adapters;
+
+public class FailingConstructionAdapter: XceptoAdapter
+{
+    public FailingConstructionAdapter()
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Adapters/FailingInitAdapter.cs

@@ -0,0 +1,11 @@
+using Xcepto.Adapters;
+
+namespace Samples.ExceptionDetail.Tests.Adapters;
+
+public class FailingInitAdapter: XceptoAdapter
+{
+    protected override Task Initialize(IServiceProvider serviceProvider)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Samples.ExceptionDetail.Tests.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+
+        <IsPackable>false</IsPackable>
+        <IsTestProject>true</IsTestProject>
+        <TargetFramework>net9.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
+        <PackageReference Include="NUnit" Version="3.14.0"/>
+        <PackageReference Include="NUnit.Analyzers" Version="3.9.0"/>
+        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <Using Include="NUnit.Framework"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\..\..\Xcepto\Xcepto.csproj" />
+    </ItemGroup>
+</Project>

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Scenarios/CleanScenario.cs

@@ -0,0 +1,10 @@
+using Xcepto.Builder;
+using Xcepto.Data;
+using Xcepto.Scenarios;
+
+namespace Samples.ExceptionDetail.Tests.Scenarios;
+
+public class CleanScenario: XceptoScenario
+{
+    protected override ScenarioSetup Setup(ScenarioSetupBuilder builder) => builder.Build();
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Scenarios/FailingCleanupScenario.cs

@@ -0,0 +1,15 @@
+using Xcepto.Builder;
+using Xcepto.Data;
+using Xcepto.Scenarios;
+
+namespace Samples.ExceptionDetail.Tests.Scenarios;
+
+public class FailingCleanupScenario: XceptoScenario
+{
+    protected override ScenarioSetup Setup(ScenarioSetupBuilder builder) => builder.Build();
+
+    protected override ScenarioCleanup Cleanup(ScenarioCleanupBuilder builder)
+    {
+        throw new IOException();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Scenarios/FailingInitScenario.cs

@@ -0,0 +1,15 @@
+using Xcepto.Builder;
+using Xcepto.Data;
+using Xcepto.Scenarios;
+
+namespace Samples.ExceptionDetail.Tests.Scenarios;
+
+public class FailingInitScenario: XceptoScenario
+{
+    protected override ScenarioSetup Setup(ScenarioSetupBuilder builder) => builder.Build();
+
+    protected override ScenarioInitialization Initialize(ScenarioInitializationBuilder builder)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Scenarios/FailingSetupScenario.cs

@@ -0,0 +1,13 @@
+using Xcepto.Builder;
+using Xcepto.Data;
+using Xcepto.Scenarios;
+
+namespace Samples.ExceptionDetail.Tests.Scenarios;
+
+public class FailingSetupScenario: XceptoScenario
+{
+    protected override ScenarioSetup Setup(ScenarioSetupBuilder builder)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/FailingEnterState.cs

@@ -0,0 +1,16 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class FailingEnterState: XceptoState
+{
+    public FailingEnterState(string name) : base(name) { }
+
+    public override Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider) =>
+        Task.FromResult(true);
+
+    public override Task OnEnter(IServiceProvider serviceProvider)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/FailingInitState.cs

@@ -0,0 +1,18 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class FailingInitState: XceptoState
+{
+    public FailingInitState(string name) : base(name) { }
+
+    public override Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider) =>
+        Task.FromResult(true);
+
+    public override Task OnEnter(IServiceProvider serviceProvider) => Task.CompletedTask;
+
+    public override Task Initialize(IServiceProvider serviceProvider)
+    {
+        throw new Exception();
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/FailingSetupState.cs

@@ -0,0 +1,16 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class FailingSetupState: XceptoState
+{
+    public FailingSetupState(string name) : base(name)
+    {
+        throw new Exception();
+    }
+
+    public override Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider) =>
+        Task.FromResult(true);
+
+    public override Task OnEnter(IServiceProvider serviceProvider) => Task.CompletedTask;
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/FailingTransitionState.cs

@@ -0,0 +1,15 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class FailingTransitionState: XceptoState
+{
+    public FailingTransitionState(string name) : base(name) { }
+
+    public override Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider)
+    {
+        throw new Exception();
+    }
+
+    public override Task OnEnter(IServiceProvider serviceProvider) => Task.CompletedTask;
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/LongEnterState.cs

@@ -0,0 +1,18 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class LongEnterState: XceptoState
+{
+    public LongEnterState(string name) : base(name) { }
+
+    public override async Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider)
+    {
+        return true;
+    }
+
+    public override async Task OnEnter(IServiceProvider serviceProvider)
+    {
+        await Task.Delay(TimeSpan.FromSeconds(5));
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/LongFailingEnterState.cs

@@ -0,0 +1,20 @@
+using Xcepto.Data;
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class LongFailingEnterState: XceptoState
+{
+    public LongFailingEnterState(string name) : base(name) { }
+
+    public override Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider)
+    {
+        return Task.FromResult(true);
+    }
+
+    public override async Task OnEnter(IServiceProvider serviceProvider)
+    {
+        MostRecentFailingResult = new ConditionResult(new { }, "big problem!");
+        await Task.Delay(TimeSpan.FromSeconds(5));
+    }
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/LongFailingTransitionState.cs

@@ -0,0 +1,18 @@
+using Xcepto.Data;
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class LongFailingTransitionState: XceptoState
+{
+    public LongFailingTransitionState(string name) : base(name) { }
+
+    public override async Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider)
+    {
+        MostRecentFailingResult = new ConditionResult(new { }, "big problem!");
+        await Task.Delay(TimeSpan.FromSeconds(5));
+        return true;
+    }
+
+    public override Task OnEnter(IServiceProvider serviceProvider) => Task.CompletedTask;
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/States/LongTransitionState.cs

@@ -0,0 +1,16 @@
+using Xcepto.States;
+
+namespace Samples.ExceptionDetail.Tests.States;
+
+public class LongTransitionState: XceptoState
+{
+    public LongTransitionState(string name) : base(name) { }
+
+    public override async Task<bool> EvaluateConditionsForTransition(IServiceProvider serviceProvider)
+    {
+        await Task.Delay(TimeSpan.FromSeconds(5));
+        return true;
+    }
+
+    public override Task OnEnter(IServiceProvider serviceProvider) => Task.CompletedTask;
+}

Samples/ExceptionDetail/Samples.ExceptionDetail.Tests/Test/AdapterExceptionTests.cs

@@ -0,0 +1,55 @@
+using Samples.ExceptionDetail.Tests.Adapters;
+using Samples.ExceptionDetail.Tests.Scenarios;
+using Xcepto;
+using Xcepto.Exceptions;
+using Xcepto.Strategies;
+using Xcepto.Strategies.Execution;
+
+namespace Samples.ExceptionDetail.Tests.Test
+{
+    [TestFixtureSource(typeof(StrategyCombinations), nameof(StrategyCombinations.AllCombinations))]
+    public class AdapterExceptionTests
+    {
+        private XceptoTest _xceptoTest;
+        public AdapterExceptionTests(BaseExecutionStrategy executionStrategy)
+        {
+            _xceptoTest = new XceptoTest(executionStrategy);
+        }
+
+        [Test]
+        public void Failing_Setup()
+        {
+            Assert.ThrowsAsync<ArrangeTestException>(async () =>
+            {
+                await _xceptoTest.GivenWithStrategies(new CleanScenario(), builder =>
+                {
+                    _ = builder.RegisterAdapter(new FailingConstructionAdapter());
+                });
+            });
+        }
+
+        [Test]
+        public void Failing_Init()
+        {
+            Assert.ThrowsAsync<AdapterInitException>(async () =>
+            {
+                await _xceptoTest.GivenWithStrategies(new CleanScenario(), builder =>
+                {
+                    _ = builder.RegisterAdapter(new FailingInitAdapter());
+                });
+            });
+        }
+
+        [Test]
+        public void Failing_Cleanup()
+        {
+            Assert.ThrowsAsync<AdapterCleanupException>(async () =>
+            {
+                await _xceptoTest.GivenWithStrategies(new CleanScenario(), builder =>
+                {
+                    _ = builder.RegisterAdapter(new FailingCleanupAdapter());
+                });
+            });
+        }
+    }
+}