wip order test case

Author: TheTrigger

F2.Testing.Tests/OrderedTests.cs

@@ -0,0 +1,53 @@
+using F2.Testing.Ordering;
+using Xunit;
+
+namespace F2.Tests;
+
+[TestCaseOrderer(ordererTypeName: "F2.Testing.Ordering.PriorityOrderer", ordererAssemblyName: "F2.Testing")]
+public class ByPriorityOrder
+{
+    public static bool Test1Called;
+    public static bool Test2ACalled;
+    public static bool Test2BCalled;
+    public static bool Test3Called;
+
+    [Fact, TestPriority(5)]
+    public void Test3()
+    {
+        Test3Called = true;
+
+        Assert.True(Test1Called);
+        Assert.True(Test2ACalled);
+        Assert.True(Test2BCalled);
+    }
+
+    [Fact, TestPriority(0)]
+    public void Test2B()
+    {
+        Test2BCalled = true;
+
+        Assert.True(Test1Called);
+        Assert.True(Test2ACalled);
+        Assert.False(Test3Called);
+    }
+
+    [Fact]
+    public void Test2A()
+    {
+        Test2ACalled = true;
+
+        Assert.True(Test1Called);
+        Assert.False(Test2BCalled);
+        Assert.False(Test3Called);
+    }
+
+    [Fact, TestPriority(-5)]
+    public void Test1()
+    {
+        Test1Called = true;
+
+        Assert.False(Test2ACalled);
+        Assert.False(Test2BCalled);
+        Assert.False(Test3Called);
+    }
+}

F2.Testing/Ordering/PriorityOrderer.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace F2.Testing.Ordering;
+
+/// <summary>
+/// <see href="https://learn.microsoft.com/it-it/dotnet/core/testing/order-unit-tests?pivots=xunit"></see>
+/// </summary>
+public class PriorityOrderer : ITestCaseOrderer
+{
+    public IEnumerable<TTestCase> OrderTestCases<TTestCase>(IEnumerable<TTestCase> testCases) where TTestCase : ITestCase
+    {
+        var sortedMethods = new SortedDictionary<int, List<TTestCase>>();
+
+        foreach (TTestCase testCase in testCases)
+        {
+            int priority = 0;
+
+            foreach (IAttributeInfo attr in testCase.TestMethod.Method.GetCustomAttributes((typeof(TestPriorityAttribute).AssemblyQualifiedName)))
+                priority = attr.GetNamedArgument<int>("Priority");
+
+            GetOrCreate(sortedMethods, priority).Add(testCase);
+        }
+
+        foreach (var list in sortedMethods.Keys.Select(priority => sortedMethods[priority]))
+        {
+            list.Sort((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));
+            foreach (TTestCase testCase in list)
+                yield return testCase;
+        }
+    }
+
+    static TValue GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue> dictionary, TKey key) where TValue : new()
+    {
+        ArgumentNullException.ThrowIfNull(dictionary, nameof(dictionary));
+
+        if (dictionary.TryGetValue(key, out TValue result)) return result;
+
+        result = new TValue();
+        dictionary[key] = result;
+
+        return result;
+    }
+}

F2.Testing/Ordering/TestPriorityAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace F2.Testing.Ordering;
+
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public class TestPriorityAttribute : Attribute
+{
+    public int Priority { get; private set; }
+
+    public TestPriorityAttribute(int priority) => Priority = priority;
+}

F2.Testing/ServerFixture.cs

@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Net;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -20,36 +21,48 @@ public class ServerFixture<TStartup> : WebApplicationFactory<TStartup>, IAsyncLi
     /// Your <see cref="HttpClient"/>
     /// </summary>
     public HttpClient Client { get; internal set; }
+    public CookieContainer CookieContainer { get; private set; } = new CookieContainer();
+
     //private bool _clientConfigured = false;
 
     //public ICollection GetRoutesOfController() => throw new NotImplementedException();
     //public ICollection GetRoutesOfControllerMethod() => throw new NotImplementedException();
 
     private IServiceScope _scope;
+    private HttpClientHandler _handler;
+
+    public ServerFixture()
+    {
+        //_handler = new HttpClientHandler
+        //{
+        //    CookieContainer = CookieContainer,
+        //    UseCookies = true,
+        //};
+
+        //var delegateHandler = new DelegatingHandler { InnerHandler = _handler };
+
+        //Client = this.CreateClient(new WebApplicationFactoryClientOptions { Handler = delegatingHandler });
+        //Client = CreateDefaultClient(_handler);
+    }
 
     /// <inheritdoc cref="ServiceProviderServiceExtensions.GetService{T}(IServiceProvider)"/>
     public TService GetService<TService>()
     {
-        return ServiceProvider.GetService<TService>();
+        return Services.GetService<TService>();
     }
 
-    /// <inheritdoc cref="ServiceProviderServiceExtensions.GetServices{T}(IServiceProvider)"/>
-    public IEnumerable<TService> GetServices<TService>()
+    /// <inheritdoc cref="ServiceProviderServiceExtensions.GetRequiredService{T}(IServiceProvider)"/>
+    public TService GetRequiredService<TService>()
     {
-        return ServiceProvider.GetServices<TService>();
+        return Services.GetRequiredService<TService>();
     }
 
-    /// <inheritdoc cref="IServiceProvider"/>
-    public IServiceProvider ServiceProvider
+    /// <inheritdoc cref="ServiceProviderServiceExtensions.GetServices{T}(IServiceProvider)"/>
+    public IEnumerable<TService> GetServices<TService>()
     {
-        get
-        {
-            _scope ??= Server.Services.CreateScope();
-            return _scope.ServiceProvider;
-        }
+        return Services.GetServices<TService>();
     }
 
-
     /// <summary>
     /// Instantiate a test server with asppsettings and environment valiables
     /// </summary>
@@ -154,7 +167,7 @@ public Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToke
         return Client.DeleteAsync(requestUri, cancellationToken);
     }
 
-    public Task InitializeAsync()
+    public virtual Task InitializeAsync()
     {
         //if (!_clientConfigured)
         {