Use instance method or prop as ServiceProviderMemberData source

docs/xunit.md

@@ -38,13 +38,21 @@ public class EnvironmentInitializer : IFrameworkInitializer
 ```
 
 **Parameterized tests with data from the IServiceProvider:**
-Create a static method that accepts IServiceProvider and returns IEnumerable<object>. Pass that method to ServiceProviderMemberDataAttribute to use it as data source for Theory.
+Create a instance method or property that returns IEnumerable<object>. Pass that method to ServiceProviderMemberDataAttribute to use it as data source for Theory.
 
 ```
 [Bss.Testing.Xunit.Sdk.Theory]
 [ServiceProviderMemberData(nameof(GetMemberData))]
 public void GetDataFromServiceProvider(FullSecurityRole role) => Assert.NotEmpty(role.Name);
 
-protected static IEnumerable<object> GetMemberData(IServiceProvider serviceProvider) =>
-    serviceProvider.GetRequiredService<ISecurityRoleSource>().SecurityRoles.Select(x => new [] { x });
+protected IEnumerable<object> GetMemberData() =>
+    this.ServiceProvider.GetRequiredService<ISecurityRoleSource>().SecurityRoles.Select(x => new [] { x });
+```
+
+```
+[Bss.Testing.Xunit.Sdk.Theory]
+[ServiceProviderMemberData(nameof(GetMemberData))]
+public void GetDataFromServiceProvider(FullSecurityRole role) => Assert.NotEmpty(role.Name);
+
+protected IEnumerable<object> GetMemberData => this.ServiceProvider.GetRequiredService<ISecurityRoleSource>().SecurityRoles.Select(x => new [] { x });
 ```

xunit/src/Bss.Testing.Xunit/Sdk/ServiceProviderMemberDataAttribute.cs

@@ -5,86 +5,101 @@
 
 using System.Reflection;
 
+using Microsoft.Extensions.DependencyInjection;
+
 namespace Bss.Testing.Xunit.Sdk;
 
 [DataDiscoverer("Bss.Testing.Xunit.Sdk.ServiceProviderMemberDataDiscoverer", "Bss.Testing.Xunit")]
 [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
-public class ServiceProviderMemberDataAttribute(string methodName) : DataAttribute
+public class ServiceProviderMemberDataAttribute(string methodOrPropertyName) : DataAttribute
 {
-    public Type? MemberType { get; set; }
+    public Type MemberType { get; set; }
 
-    string MemberName { get; set; } = methodName;
+    string MemberName { get; set; } = methodOrPropertyName;
 
-    public override IEnumerable<object[]>? GetData(MethodInfo testMethod) => null;
+    public override IEnumerable<object[]> GetData(MethodInfo testMethod) => null;
 
-    public IEnumerable<object[]>? GetData(MethodInfo testMethod, IServiceProvider? serviceProvider)
+    public IEnumerable<object[]> GetData(MethodInfo testMethod, IServiceProvider serviceProvider)
     {
         var type = this.MemberType ?? testMethod.DeclaringType;
-        if (type == null)
-        {
-            throw new ArgumentException(
-                string.Format(
-                    CultureInfo.CurrentCulture,
-                    "Could not find type {0}",
-                    type?.FullName)
-            );
-        }
+        var accessor = this.GetMethodAccessor(type, serviceProvider)
+                       ?? this.GetPropertyAccessor(type, serviceProvider);
 
-        var accessor = this.GetMethodAccessor(type, serviceProvider);
         if (accessor == null)
         {
             throw new ArgumentException(
                 string.Format(
                     CultureInfo.CurrentCulture,
-                    "Could not find public static method named '{0}' on {1}{2}",
+                    "Could not find parameterless method or property named '{0}' on {1} provided in ServiceProviderMemberDataAttribute",
                     this.MemberName,
-                    type?.FullName,
-                    " with parameter types: IServiceProvider")
+                    type?.FullName)
                 );
         }
 
         var obj = accessor();
         if (obj == null)
         {
-            return (IEnumerable<object[]>) Array.Empty<object>();
+            return null;
         }
 
         if (obj is not IEnumerable dataItems)
         {
-            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Method {0} on {1} did not return IEnumerable", this.MemberName, type?.FullName));
+            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Method/property {0} on {1} did not return IEnumerable", this.MemberName, type?.FullName));
         }
 
-        return dataItems.Cast<object>().Select(item => this.ConvertDataItem(testMethod, item))!;
+        return dataItems.Cast<object>().Select(item => this.ConvertDataItem(testMethod, item));
     }
 
-    protected Func<object>? GetMethodAccessor(Type type, IServiceProvider? serviceProvider)
+    private Func<object?>? GetMethodAccessor(Type type, IServiceProvider serviceProvider)
     {
         MethodInfo? methodInfo = null;
         for (var reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType)
         {
-            var runtimeMethodsWithGivenName = reflectionType.GetRuntimeMethods()
-                                                            .Where(m => m.Name == this.MemberName)
-                                                            .ToArray();
+            methodInfo = reflectionType
+                             .GetRuntimeMethods()
+                             .FirstOrDefault(m => m.Name == this.MemberName);
+            if (methodInfo != null)
+            {
+                break;
+            }
+        }
+
+        if (methodInfo == null)
+        {
+            return null;
+        }
 
-            methodInfo = runtimeMethodsWithGivenName
-                .FirstOrDefault(m => m.GetParameters()
-                                      .Count(x => x.ParameterType.IsAssignableTo(typeof(IServiceProvider))) == 1);
+        var @object = ActivatorUtilities.CreateInstance(serviceProvider, type);
 
-            if (methodInfo != null)
+        return () => methodInfo.Invoke(@object, null);
+    }
+
+    private Func<object?>? GetPropertyAccessor(Type type, IServiceProvider serviceProvider)
+    {
+        PropertyInfo? propertyInfo = null;
+        for (var reflectionType = type; reflectionType != null; reflectionType = reflectionType.GetTypeInfo().BaseType)
+        {
+            propertyInfo = reflectionType
+                         .GetProperties()
+                         .FirstOrDefault(m => m.Name == this.MemberName);
+
+            if (propertyInfo != null)
             {
                 break;
             }
         }
 
-        if (methodInfo == null || !methodInfo.IsStatic)
+        if (propertyInfo == null)
         {
             return null;
         }
 
-        return () => methodInfo.Invoke(null, [serviceProvider])!;
+        var @object = ActivatorUtilities.CreateInstance(serviceProvider, type);
+
+        return () => propertyInfo.GetValue(@object);
     }
 
-    protected object[]? ConvertDataItem(MethodInfo testMethod, object? item)
+    private object[]? ConvertDataItem(MethodInfo testMethod, object? item)
     {
         if (item == null)
         {

xunit/src/Bss.Testing.Xunit/Sdk/ServiceProviderMemberDataDiscoverer.cs

@@ -6,10 +6,16 @@
 public class ServiceProviderMemberDataDiscoverer : IDataDiscoverer
 {
     public IEnumerable<object[]> GetData(IAttributeInfo dataAttribute, IMethodInfo testMethod) =>
-        throw new ArgumentException($"ServiceProviderMemberDataDiscoverer cannot be used as discoverer for any *DataAttribute other than ServiceProviderMemberDataAttribute.");
+        throw new ArgumentException("ServiceProviderMemberDataDiscoverer cannot be used as discoverer for any *DataAttribute other than ServiceProviderMemberDataAttribute.");
 
     public IEnumerable<object[]>? GetData(IAttributeInfo dataAttribute, IMethodInfo testMethod, IServiceProvider? serviceProvider)
     {
+        if (serviceProvider == null)
+        {
+            throw new ArgumentException($"ServiceProvider cannot be null for {nameof(dataAttribute)}");
+        }
+
+
         if (dataAttribute is not IReflectionAttributeInfo reflectionDataAttribute
             || testMethod is not IReflectionMethodInfo reflectionTestMethod)
         {
@@ -30,7 +36,7 @@
             var reflectionTestMethodType = reflectionTestMethod.Type as IReflectionTypeInfo;
             if (attribute is { MemberType: null })
             {
                 attribute.MemberType = reflectionTestMethodType?.Type;
             }
 
             return attribute.GetData(reflectionTestMethod.MethodInfo, serviceProvider);

xunit/src/Directory.Build.props

@@ -10,8 +10,6 @@
 
         <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
         <GenerateDocumentationFile>false</GenerateDocumentationFile>
-
-        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(Configuration)'=='Release'">