Make IJobWrapper public (#2313)

* make IJobWrapper public
* implement SetObjectProperties and ReturnJob recursive for any combination of JobWrapping with IJobWrapper;
* add a Property-Test for MicrosoftDependencyInjectionJobFactory

src/Quartz.Extensions.DependencyInjection/Simpl/MicrosoftDependencyInjectionJobFactory.cs

@@ -47,13 +47,6 @@ protected virtual void ConfigureScope(IServiceScope scope, TriggerFiredBundle bu
             // the ambient context of a Job
         }
 
-        public override void SetObjectProperties(object obj, JobDataMap data)
-        {
-            // we need to check if job is actually a scoped job wrapper
-            var target = obj is ScopedJob scopedJob ? scopedJob.InnerJob : obj;
-            base.SetObjectProperties(target, data);
-        }
-
         private (IJob Job, bool FromContainer) CreateJob(TriggerFiredBundle bundle, IServiceProvider serviceProvider)
         {
             var job = (IJob?) serviceProvider.GetService(bundle.JobDetail.JobType);

src/Quartz.Tests.Unit/Simpl/MicrosoftDependencyInjectionJobFactoryTest.cs

@@ -28,8 +28,11 @@ public async Task JobsShouldBeDisposedAfterExecute()
         var schedulerBuilder = SchedulerBuilder.Create()
             .Build();
 
+        const string testValue = "test";
+
         var jobDetail = JobBuilder.Create<TestJob>()
             .StoreDurably()
+            .UsingJobData(nameof(TestJob.Test), testValue)
             .Build();
 
         var serviceCollection = new ServiceCollection();
@@ -48,6 +51,7 @@ public async Task JobsShouldBeDisposedAfterExecute()
 
         TestJob.Executed.Should().BeTrue();
         TestJob.Disposed.Should().BeTrue();
+        TestJob.TestValue.Should().Be(testValue);
 
         Dependency.Disposed.Should().BeTrue();
     }
@@ -56,6 +60,9 @@ private class TestJob : IJob, IDisposable
     {
         public static bool Executed { get; set; }
         public static bool Disposed { get; set; }
+        public static string TestValue { get; set; }
+
+        public string Test { get; set; }
 
         public TestJob(Dependency dependency)
         {
@@ -64,6 +71,7 @@ public TestJob(Dependency dependency)
         public Task Execute(IJobExecutionContext context)
         {
             Executed = true;
+            TestValue = Test;
             return Task.CompletedTask;
         }
 

src/Quartz/IJobWrapper.cs

@@ -1,6 +1,6 @@
 namespace Quartz;
 
-internal interface IJobWrapper
+public interface IJobWrapper
 {
     IJob Target { get; }
 }

src/Quartz/Simpl/PropertySettingJobFactory.cs

@@ -132,13 +132,20 @@ protected virtual IJob InstantiateJob(TriggerFiredBundle bundle, IScheduler sche
         /// </summary>
         /// <param name="obj">The object to set properties to.</param>
         /// <param name="data">The data to set.</param>
-		public virtual void SetObjectProperties(object obj, JobDataMap data)
-		{
-			foreach (string name in data.Keys)
-			{
-				SetObjectProperty(obj, name, data[name]);
-			}
-		}
+        public virtual void SetObjectProperties(object obj, JobDataMap data)
+        {
+            if (obj is IJobWrapper jobWrapper)
+            {
+                SetObjectProperties(jobWrapper.Target, data);
+            }
+            else
+            {
+                foreach (string name in data.Keys)
+                {
+                    SetObjectProperty(obj, name, data[name]);
+                }
+            }
+        }
 
 	    /// <summary>
 	    /// Sets specific property to object, handles conversion and error conditions.

src/Quartz/Simpl/SimpleJobFactory.cs

@@ -101,17 +101,32 @@ async Task IJobWithAsyncReturnFactory.ReturnJobAsync(IJob job)
             {
                 disposableJob.Dispose();
             }
+
+            // check for wrapped jobs only if the current job is not disposable
+            // disposable wrappers should handle inner disposal on its own
+            else if (job is IJobWrapper jobWrapper)
+            {
+                await ((IJobWithAsyncReturnFactory) this).ReturnJobAsync(jobWrapper.Target).ConfigureAwait(false);
+            }
         }
 #endif
-	    /// <summary>
-	    /// Allows the job factory to destroy/cleanup the job if needed.
-	    /// No-op when using SimpleJobFactory.
-	    /// </summary>
-	    public virtual void ReturnJob(IJob job)
-	    {
-	        var disposable = job as IDisposable;
-	        disposable?.Dispose();
-	    }
+        /// <summary>
+        /// Allows the job factory to destroy/cleanup the job if needed.
+        /// No-op when using SimpleJobFactory.
+        /// </summary>
+        public virtual void ReturnJob(IJob job)
+        {
+            if (job is IDisposable disposableJob)
+            {
+                disposableJob.Dispose();
+            }
 
+            // check for wrapped jobs only if the current job is not disposable
+            // disposable wrappers should handle inner disposal on its own
+            else if (job is IJobWrapper jobWrapper)
+            {
+                ReturnJob(jobWrapper.Target);
+            }
+        }
 	}
 }