CSharp Nunit - Unwrap TargetInvocationException

[driverog]

Hi team, I was trying to unwrap the TargetInvocationException that is thrown by Allure when a step throws an exception of its own. I tried to create a custom Aspect that uses the one provided by Allure, while I got the desired outcome of unwrapping the exception I found that now I have the steps duplicated (the actual method is only executed once). Here is how my code looks like:

namespace TestAllureWrap
{
    [Aspect(Scope.Global)]
    public class WrapInvokeAspect : AllureStepAspectBase
    {
        [Advice(Kind.Around, Targets = Target.Method | Target.Constructor)]
        public new object Around(
            [Argument(Source.Name)] string name,
            [Argument(Source.Arguments)] object[] args,
            [Argument(Source.Target)] Func<object[], object> target,
            [Argument(Source.Metadata)] MethodBase metadata,
            [Argument(Source.ReturnType)] Type returnType
        )
        {
            try
            {
                return base.Around(name, args, target, metadata, returnType);
            }
            catch (TargetInvocationException ex)
            {
                Exception wrappedException = ex;
                while (wrappedException is TargetInvocationException && wrappedException.InnerException is not null)
                {
                    wrappedException = wrappedException.InnerException;
                }

                if (wrappedException is not TargetInvocationException)
                    System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(wrappedException);
                throw;
            }
        }
    }

    [Injection(typeof(WrapInvokeAspect))]
    public class CustomStepAttribute : AbstractStepAttribute
    {

    }
}

Here is how the test looks like

namespace TestAllureWrap
{
    [AllureNUnit]
    public class Tests
    {
        [Test]
        public void Test()
        {
            Foo();
        }

        [CustomStep]
        public static void Foo()
        {

        }
    }
}

Here is how the logs look like

PD: Using composition instead of inheritance results in the same output. I was hoping to be able to reuse the implementation that you did for the several types of CSharp functions.

I am open to new approaches as well.

[Shm-Alex]

Hello:) Good work . I am newbie in Alure Framework and faced with problem
in code below

    [TestCase(Author = "XXXXX", Description = "XXXX")]
    [AllureTag("XXXX", "NEGATIVE")]
    [AllureLink("Test-case #449922", "XXX/project/1249/test-cases/449922?treeId=2900")]
   public void FFFFTests()
   {
    FFFFStep();
   } 

   [AllureStep("Action 4: ")]
   public void FFFFStep()
   {
    Assert.Fail("FFFFReserveCounterWithErrorsStep Test Alure");  
   } 

    [TestCase(Author = "XXXX", Description = " Some Description")]
    [AllureTag("RESERVECOUNTER", "NEGATIVE")]
    [AllureLink("Test-case #449922", "XXX/project/1249/test-cases/449922?treeId=2900")]
   public void AAAATest()
   {
    AllureApi.Step("Ssep + {}",()=>{
       Assert.Fail("dinamic step AAAAStep "); 
    });
   } 

That after FFFFTests and allure framework sets Test status as broken
but for AAAATest allure framework sets Test status as failed
But i want that all not passed asserts should be marked as failed tests and all another exceptions (Connection problem, test env problem, FormatException etc ) maked as broken test ( because in first case it is work for software under test development team , in second case it is work for test's automation team )
I understood that allure sets the test status analysing exception thrown in test step.
and if method marked by attribute [AllureStep] it throw TargetInvocationException . I try to setup [allure config] (https://allurereport.org/docs/nunit-configuration/) , it placed i found it in bin directory near test assembley dll

{
  "_schema": "https://raw.githubusercontent.com/allure-framework/allure-csharp/2.12.1/Allure.Net.Commons/Schemas/allureConfig.schema.json",
  "$schema": "allureConfig.schema.json",
  "allure": {
      "directory": "allure-results",
      "links": ["https://example.org/{issue}","https://example.org/{tms}"],
      "failExceptions": ["NUnit.Framework.AssertionException","System.Reflection.TargetInvocationException"]
    }
  }

But it is no work for me (i dont know why, may be i should read configuratin from the json file via code)
My workaround was smth like this:

        public void StepWrapper(System.Action action)
        {
            StepWrapper(()=>{action();return 0;});
        }
        public T StepWrapper<T>(Func<T> func)
        {
           
            try {
                return func();
            }
            catch(Exception ex)
            {
                var seekEx=ex; 
                byte exceptionStackMaxDepth=byte.MaxValue;
                // Search AssertionException in exception stack  
                while(
                    (seekEx!=null) &&  //inner exception null finish search
                    !(seekEx is NUnit.Framework.AssertionException )// found AssertionException finish search
                    &&((exceptionStackMaxDepth--)>0) // stack depth limit exceeded finish search
                    )
                seekEx=seekEx.InnerException;// continue exception stack search  
                throw (seekEx!=null)?seekEx:ex;// return first founded  inner exception of type AssertionException or Basic Exception 
            }
        }

and
test will be like this:

    [TestCase(Author = "XXX", Description = " some Description")]
    [AllureTag("RESERVECOUNTER", "NEGATIVE")]
    [AllureLink("Test-case #449922", "XXX/project/1249/test-cases/449922?treeId=2900")]
   public void FFFFTest()
   {
    StepWrapper(
        ()=>{ FFFFStep();}
    );
    
   } 

   [AllureStep("Action 4: ")]
   public void FFFFStep()
   {
    Assert.Fail(" Test Alure");  
   } 

Ithink i get your implementation with search acceptable Exception Types in exception stack (I think i should take it from configuration )

[driverog]

I did manage to solve this issue by changing my approach a little bit, instead of trying to override the actual allure aspect, I created one separate aspect that wraps around the base aspect. In order to do this we need to handle all type of function that we might get there (generics, tasks, etc...), for this purpose I used the library Aspect.Universal by the same contributors of the underlying AspectInjector used in Allure. Basically the code now looks like this.

namespace TestAllureWrap;

[Aspect(Scope.Global)]
public class WrapInvokeAspect : BaseUniversalWrapperAspect
{
    [Advice(Kind.Around, Targets = Target.Method | Target.Constructor)]
    public new object Around(
        [Argument(Source.Instance)] object instance,
        [Argument(Source.Type)] Type type,
        [Argument(Source.Metadata)] MethodBase method,
        [Argument(Source.Target)] Func<object[], object> target,
        [Argument(Source.Name)] string name,
        [Argument(Source.Arguments)] object[] args,
        [Argument(Source.ReturnType)] Type returnType,
        [Argument(Source.Triggers)] Attribute[] triggers
    )
    {
        try
        {
            return BaseHandle(instance, type, method, target, name, args, returnType, triggers);
        }
        catch (TargetInvocationException ex)
        {
            Exception wrappedException = ex;
            while (wrappedException is TargetInvocationException && wrappedException.InnerException is not null)
            {
                wrappedException = wrappedException.InnerException;
            }

            if (wrappedException is not TargetInvocationException)
                System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(wrappedException);
            throw;
        }
    }
}

[Injection(typeof(AllureStepAspectBase), Priority = 0)]
[Injection(typeof(WrapInvokeAspect), Priority = 1)]
public class CustomStepAttribute : AbstractStepAttribute;

[Shm-Alex]

Thank you . I 'll try your approch.
only one remark

 Exception wrappedException = ex;
            while (wrappedException is TargetInvocationException && wrappedException.InnerException is not null)
            {
                wrappedException = wrappedException.InnerException;
            }

            if (wrappedException is not TargetInvocationException)
                System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw(wrappedException);
            throw;

May be we should find in this loop exception that should be thrown using allure Configuration
and if in inner exception stack trace exist any exception from the acceptable exception types list