Support EnqueueAsync by job name

Add non-generic EnqueueAsync(string jobName, object args, ...) to IBackgroundJobManager and implement it across providers. Implementations and helpers added/updated for Hangfire (IJsonSerializer usage, new HangfireJobExecutionAdapter), Quartz (new QuartzJobExecutionAdapter and job-data based enqueue), RabbitMQ (IJobQueue non-generic EnqueueAsync, JobQueueManager.GetAsync(jobName)), TickerQ (reflective CreateTickerRequest helper), and DefaultBackgroundJobManager (returns string ids). Also update NullBackgroundJobManager to throw for the new overload and extend tests to cover enqueueing by job name. These changes enable enqueueing jobs dynamically by name with serialized arguments and unify cross-provider execution paths.

framework/src/Volo.Abp.BackgroundJobs.Abstractions/Volo/Abp/BackgroundJobs/IBackgroundJobManager.cs

@@ -21,4 +21,19 @@ public interface IBackgroundJobManager
         BackgroundJobPriority priority = BackgroundJobPriority.Normal,
         TimeSpan? delay = null
     );
+
+    /// <summary>
+    /// Enqueues a job to be executed by its name.
+    /// </summary>
+    /// <param name="jobName">Name of the background job.</param>
+    /// <param name="args">Job arguments.</param>
+    /// <param name="priority">Job priority.</param>
+    /// <param name="delay">Job delay (wait duration before first try).</param>
+    /// <returns>Unique identifier of a background job.</returns>
+    Task<string> EnqueueAsync(
+        string jobName,
+        object args,
+        BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null
+    );
 }

framework/src/Volo.Abp.BackgroundJobs.Abstractions/Volo/Abp/BackgroundJobs/NullBackgroundJobManager.cs

@@ -21,4 +21,10 @@ public class NullBackgroundJobManager : IBackgroundJobManager, ISingletonDepende
     {
         throw new AbpException("Background job system has not a real implementation. If it's mandatory, use an implementation (either the default provider or a 3rd party implementation). If it's optional, check IBackgroundJobManager.IsAvailable() extension method and act based on it.");
     }
+
+    public virtual Task<string> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null)
+    {
+        throw new AbpException("Background job system has not a real implementation. If it's mandatory, use an implementation (either the default provider or a 3rd party implementation). If it's optional, check IBackgroundJobManager.IsAvailable() extension method and act based on it.");
+    }
 }

framework/src/Volo.Abp.BackgroundJobs.HangFire/Volo/Abp/BackgroundJobs/Hangfire/HangfireBackgroundJobManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Reflection;
 using System.Threading.Tasks;
 using Hangfire;
@@ -6,6 +6,7 @@ using Hangfire.States;
 using Microsoft.Extensions.Options;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Hangfire;
+using Volo.Abp.Json;
 
 namespace Volo.Abp.BackgroundJobs.Hangfire;
 
@@ -14,11 +15,16 @@ public class HangfireBackgroundJobManager : IBackgroundJobManager, ITransientDep
 {
     protected IOptions<AbpBackgroundJobOptions> BackgroundJobOptions { get; }
     protected IOptions<AbpHangfireOptions> HangfireOptions { get; }
+    protected IJsonSerializer JsonSerializer { get; }
 
-    public HangfireBackgroundJobManager(IOptions<AbpBackgroundJobOptions> backgroundJobOptions, IOptions<AbpHangfireOptions> hangfireOptions)
+    public HangfireBackgroundJobManager(
+        IOptions<AbpBackgroundJobOptions> backgroundJobOptions,
+        IOptions<AbpHangfireOptions> hangfireOptions,
+        IJsonSerializer jsonSerializer)
     {
         BackgroundJobOptions = backgroundJobOptions;
         HangfireOptions = hangfireOptions;
+        JsonSerializer = jsonSerializer;
     }
 
     public virtual Task<string> EnqueueAsync<TArgs>(TArgs args, BackgroundJobPriority priority = BackgroundJobPriority.Normal,
@@ -34,9 +40,35 @@ public class HangfireBackgroundJobManager : IBackgroundJobManager, ITransientDep
             ));
     }
 
+    public virtual Task<string> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null)
+    {
+        var serializedArgs = JsonSerializer.Serialize(args);
+        var queueName = GetQueueName(jobName);
+
+        return Task.FromResult(delay.HasValue
+            ? BackgroundJob.Schedule<HangfireJobExecutionAdapter>(
+                adapter => adapter.ExecuteAsync(queueName, jobName, serializedArgs, default),
+                delay.Value
+            )
+            : BackgroundJob.Enqueue<HangfireJobExecutionAdapter>(
+                adapter => adapter.ExecuteAsync(queueName, jobName, serializedArgs, default)
+            ));
+    }
+
     protected virtual string GetQueueName(Type argsType)
     {
-        var queueAttribute = BackgroundJobOptions.Value.GetJob(argsType).JobType.GetCustomAttribute<QueueAttribute>();
+        return GetQueueName(BackgroundJobOptions.Value.GetJob(argsType));
+    }
+
+    protected virtual string GetQueueName(string jobName)
+    {
+        return GetQueueName(BackgroundJobOptions.Value.GetJob(jobName));
+    }
+
+    protected virtual string GetQueueName(BackgroundJobConfiguration jobConfiguration)
+    {
+        var queueAttribute = jobConfiguration.JobType.GetCustomAttribute<QueueAttribute>();
         return queueAttribute != null ? HangfireOptions.Value.DefaultQueuePrefix + queueAttribute.Queue : HangfireOptions.Value.DefaultQueue;
     }
 }

framework/src/Volo.Abp.BackgroundJobs.HangFire/Volo/Abp/BackgroundJobs/Hangfire/HangfireJobExecutionAdapter.cs

@@ -1,8 +1,9 @@
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 using Hangfire;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
+using Volo.Abp.Json;
 
 namespace Volo.Abp.BackgroundJobs.Hangfire;
 
@@ -44,3 +45,46 @@ public class HangfireJobExecutionAdapter<TArgs>
         }
     }
 }
+
+public class HangfireJobExecutionAdapter
+{
+    protected AbpBackgroundJobOptions Options { get; }
+    protected IServiceScopeFactory ServiceScopeFactory { get; }
+    protected IBackgroundJobExecuter JobExecuter { get; }
+    protected IJsonSerializer JsonSerializer { get; }
+
+    public HangfireJobExecutionAdapter(
+        IOptions<AbpBackgroundJobOptions> options,
+        IBackgroundJobExecuter jobExecuter,
+        IServiceScopeFactory serviceScopeFactory,
+        IJsonSerializer jsonSerializer)
+    {
+        JobExecuter = jobExecuter;
+        ServiceScopeFactory = serviceScopeFactory;
+        JsonSerializer = jsonSerializer;
+        Options = options.Value;
+    }
+
+    [Queue("{0}")]
+    public async Task ExecuteAsync(string queue, string jobName, string serializedArgs, CancellationToken cancellationToken = default)
+    {
+        if (!Options.IsJobExecutionEnabled)
+        {
+            throw new AbpException(
+                "Background job execution is disabled. " +
+                "This method should not be called! " +
+                "If you want to enable the background job execution, " +
+                $"set {nameof(AbpBackgroundJobOptions)}.{nameof(AbpBackgroundJobOptions.IsJobExecutionEnabled)} to true! " +
+                "If you've intentionally disabled job execution and this seems a bug, please report it."
+            );
+        }
+
+        using (var scope = ServiceScopeFactory.CreateScope())
+        {
+            var jobConfiguration = Options.GetJob(jobName);
+            var args = JsonSerializer.Deserialize(jobConfiguration.ArgsType, serializedArgs);
+            var context = new JobExecutionContext(scope.ServiceProvider, jobConfiguration.JobType, args, cancellationToken: cancellationToken);
+            await JobExecuter.ExecuteAsync(context);
+        }
+    }
+}

framework/src/Volo.Abp.BackgroundJobs.Quartz/Volo/Abp/BackgroundJobs/Quartz/QuartzBackgroundJobManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 using Quartz;
@@ -32,6 +32,12 @@ public class QuartzBackgroundJobManager : IBackgroundJobManager, ITransientDepen
         return await ReEnqueueAsync(args, Options.RetryCount, Options.RetryIntervalMillisecond, priority, delay);
     }
 
+    public virtual async Task<string> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null)
+    {
+        return await ReEnqueueAsync(jobName, args, Options.RetryCount, Options.RetryIntervalMillisecond, priority, delay);
+    }
+
     public virtual async Task<string> ReEnqueueAsync<TArgs>(TArgs args, int retryCount, int retryIntervalMillisecond,
         BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
     {
@@ -48,4 +54,22 @@ public class QuartzBackgroundJobManager : IBackgroundJobManager, ITransientDepen
         await Scheduler.ScheduleJob(jobDetail, trigger);
         return jobDetail.Key.ToString();
     }
+
+    public virtual async Task<string> ReEnqueueAsync(string jobName, object args, int retryCount, int retryIntervalMillisecond,
+        BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
+    {
+        var jobDataMap = new JobDataMap
+            {
+                {QuartzJobExecutionAdapter.JobNameKey, jobName},
+                {QuartzJobExecutionAdapter.JobArgsKey, JsonSerializer.Serialize(args)},
+                {JobDataPrefix + nameof(Options.RetryCount), retryCount.ToString()},
+                {JobDataPrefix + nameof(Options.RetryIntervalMillisecond), retryIntervalMillisecond.ToString()},
+                {JobDataPrefix + RetryIndex, "0"}
+            };
+
+        var jobDetail = JobBuilder.Create<QuartzJobExecutionAdapter>().RequestRecovery().SetJobData(jobDataMap).Build();
+        var trigger = !delay.HasValue ? TriggerBuilder.Create().StartNow().Build() : TriggerBuilder.Create().StartAt(new DateTimeOffset(DateTime.Now.Add(delay.Value))).Build();
+        await Scheduler.ScheduleJob(jobDetail, trigger);
+        return jobDetail.Key.ToString();
+    }
 }

framework/src/Volo.Abp.BackgroundJobs.Quartz/Volo/Abp/BackgroundJobs/Quartz/QuartzJobExecutionAdapter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -60,3 +60,60 @@ public class QuartzJobExecutionAdapter<TArgs> : IJob
         }
     }
 }
+
+public class QuartzJobExecutionAdapter : IJob
+{
+    public const string JobNameKey = "AbpJobName";
+    public const string JobArgsKey = "AbpJobArgs";
+
+    public ILogger<QuartzJobExecutionAdapter> Logger { get; set; }
+
+    protected AbpBackgroundJobOptions Options { get; }
+    protected AbpBackgroundJobQuartzOptions BackgroundJobQuartzOptions { get; }
+    protected IServiceScopeFactory ServiceScopeFactory { get; }
+    protected IBackgroundJobExecuter JobExecuter { get; }
+    protected IJsonSerializer JsonSerializer { get; }
+
+    public QuartzJobExecutionAdapter(
+        IOptions<AbpBackgroundJobOptions> options,
+        IOptions<AbpBackgroundJobQuartzOptions> backgroundJobQuartzOptions,
+        IBackgroundJobExecuter jobExecuter,
+        IServiceScopeFactory serviceScopeFactory,
+        IJsonSerializer jsonSerializer)
+    {
+        JobExecuter = jobExecuter;
+        ServiceScopeFactory = serviceScopeFactory;
+        JsonSerializer = jsonSerializer;
+        Options = options.Value;
+        BackgroundJobQuartzOptions = backgroundJobQuartzOptions.Value;
+        Logger = NullLogger<QuartzJobExecutionAdapter>.Instance;
+    }
+
+    public async Task Execute(IJobExecutionContext context)
+    {
+        using (var scope = ServiceScopeFactory.CreateScope())
+        {
+            var jobName = context.JobDetail.JobDataMap.GetString(JobNameKey)!;
+            var serializedArgs = context.JobDetail.JobDataMap.GetString(JobArgsKey)!;
+            var jobConfiguration = Options.GetJob(jobName);
+            var args = JsonSerializer.Deserialize(jobConfiguration.ArgsType, serializedArgs);
+            var jobContext = new JobExecutionContext(scope.ServiceProvider, jobConfiguration.JobType, args, cancellationToken: context.CancellationToken);
+            try
+            {
+                await JobExecuter.ExecuteAsync(jobContext);
+            }
+            catch (Exception exception)
+            {
+                var jobExecutionException = new JobExecutionException(exception);
+
+                var retryIndex = context.JobDetail.JobDataMap.GetString(QuartzBackgroundJobManager.JobDataPrefix + QuartzBackgroundJobManager.RetryIndex)!.To<int>();
+                retryIndex++;
+                context.JobDetail.JobDataMap.Put(QuartzBackgroundJobManager.JobDataPrefix + QuartzBackgroundJobManager.RetryIndex, retryIndex.ToString());
+
+                await BackgroundJobQuartzOptions.RetryStrategy.Invoke(retryIndex, context, jobExecutionException);
+
+                throw jobExecutionException;
+            }
+        }
+    }
+}

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/IJobQueue.cs

@@ -1,10 +1,19 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Volo.Abp.Threading;
 
 namespace Volo.Abp.BackgroundJobs.RabbitMQ;
 
-public interface IJobQueue<in TArgs> : IRunnable, IDisposable
+public interface IJobQueue : IRunnable, IDisposable
+{
+    Task<string?> EnqueueAsync(
+        object args,
+        BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null
+    );
+}
+
+public interface IJobQueue<in TArgs> : IJobQueue
 {
     Task<string?> EnqueueAsync(
         TArgs args,

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/IJobQueueManager.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Volo.Abp.Threading;
 
 namespace Volo.Abp.BackgroundJobs.RabbitMQ;
@@ -6,4 +6,6 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ;
 public interface IJobQueueManager : IRunnable
 {
     Task<IJobQueue<TArgs>> GetAsync<TArgs>();
+
+    Task<IJobQueue> GetAsync(string jobName);
 }

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/JobQueue.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Threading;
@@ -75,6 +75,14 @@ public class JobQueue<TArgs> : IJobQueue<TArgs>
                );
     }
 
+    async Task<string?> IJobQueue.EnqueueAsync(
+        object args,
+        BackgroundJobPriority priority,
+        TimeSpan? delay)
+    {
+        return await EnqueueAsync((TArgs)args, priority, delay);
+    }
+
     public virtual async Task<string?> EnqueueAsync(
         TArgs args,
         BackgroundJobPriority priority = BackgroundJobPriority.Normal,

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/JobQueueManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
@@ -80,4 +80,31 @@ public class JobQueueManager : IJobQueueManager, ISingletonDependency
             return (IJobQueue<TArgs>)jobQueue;
         }
     }
+
+    public async Task<IJobQueue> GetAsync(string jobName)
+    {
+        if (JobQueues.TryGetValue(jobName, out var jobQueue))
+        {
+            return (IJobQueue)jobQueue;
+        }
+
+        using (await SyncSemaphore.LockAsync())
+        {
+            if (JobQueues.TryGetValue(jobName, out jobQueue))
+            {
+                return (IJobQueue)jobQueue;
+            }
+
+            var jobConfiguration = Options.GetJob(jobName);
+
+            jobQueue = (IRunnable)ServiceProvider
+                .GetRequiredService(typeof(IJobQueue<>).MakeGenericType(jobConfiguration.ArgsType));
+
+            await jobQueue.StartAsync();
+
+            JobQueues.TryAdd(jobName, jobQueue);
+
+            return (IJobQueue)jobQueue;
+        }
+    }
 }

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/RabbitMqBackgroundJobManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Volo.Abp.DependencyInjection;
 
@@ -7,19 +7,29 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ;
 [Dependency(ReplaceServices = true)]
 public class RabbitMqBackgroundJobManager : IBackgroundJobManager, ITransientDependency
 {
-    private readonly IJobQueueManager _jobQueueManager;
+    protected IJobQueueManager JobQueueManager { get; }
 
     public RabbitMqBackgroundJobManager(IJobQueueManager jobQueueManager)
     {
-        _jobQueueManager = jobQueueManager;
+        JobQueueManager = jobQueueManager;
     }
 
-    public async Task<string> EnqueueAsync<TArgs>(
+    public virtual async Task<string> EnqueueAsync<TArgs>(
         TArgs args,
         BackgroundJobPriority priority = BackgroundJobPriority.Normal,
         TimeSpan? delay = null)
     {
-        var jobQueue = await _jobQueueManager.GetAsync<TArgs>();
+        var jobQueue = await JobQueueManager.GetAsync<TArgs>();
+        return (await jobQueue.EnqueueAsync(args, priority, delay))!;
+    }
+
+    public virtual async Task<string> EnqueueAsync(
+        string jobName,
+        object args,
+        BackgroundJobPriority priority = BackgroundJobPriority.Normal,
+        TimeSpan? delay = null)
+    {
+        var jobQueue = await JobQueueManager.GetAsync(jobName);
         return (await jobQueue.EnqueueAsync(args, priority, delay))!;
     }
 }

framework/src/Volo.Abp.BackgroundJobs.TickerQ/Volo/Abp/BackgroundJobs/TickerQ/AbpTickerQBackgroundJobManager.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Reflection;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 using TickerQ.Utilities;
@@ -11,6 +12,8 @@ namespace Volo.Abp.BackgroundJobs.TickerQ;
 [Dependency(ReplaceServices = true)]
 public class AbpTickerQBackgroundJobManager : IBackgroundJobManager, ITransientDependency
 {
+    private readonly static MethodInfo CreateTickerRequestMethod = typeof(TickerHelper).GetMethod(nameof(TickerHelper.CreateTickerRequest), BindingFlags.Public | BindingFlags.Static)!;
+    
     protected ITimeTickerManager<TimeTickerEntity> TimeTickerManager { get; }
     protected AbpBackgroundJobOptions Options { get; }
     protected AbpBackgroundJobsTickerQOptions TickerQOptions { get; }
@@ -28,12 +31,23 @@ public class AbpTickerQBackgroundJobManager : IBackgroundJobManager, ITransientD
     public virtual async Task<string> EnqueueAsync<TArgs>(TArgs args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
     {
         var job = Options.GetJob(typeof(TArgs));
+        return await EnqueueAsync(job, args!, priority, delay);
+    }
+
+    public virtual async Task<string> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
+    {
+        var job = Options.GetJob(jobName);
+        return await EnqueueAsync(job, args, priority, delay);
+    }
+
+    protected virtual async Task<string> EnqueueAsync(BackgroundJobConfiguration job, object args, BackgroundJobPriority priority, TimeSpan? delay)
+    {
         var timeTicker = new TimeTickerEntity
         {
             Id = Guid.NewGuid(),
             Function = job.JobName,
             ExecutionTime = delay == null ? DateTime.UtcNow : DateTime.UtcNow.Add(delay.Value),
-            Request = TickerHelper.CreateTickerRequest<TArgs>(args),
+            Request = CreateTickerRequest(job.ArgsType, args),
         };
 
         var config = TickerQOptions.GetConfigurationOrNull(job.JobType);
@@ -47,4 +61,11 @@ public class AbpTickerQBackgroundJobManager : IBackgroundJobManager, ITransientD
         var result = await TimeTickerManager.AddAsync(timeTicker);
         return !result.IsSucceeded ? timeTicker.Id.ToString() : result.Result.Id.ToString();
     }
+
+    protected virtual byte[]? CreateTickerRequest(Type argsType, object args)
+    {
+        return (byte[]?)CreateTickerRequestMethod
+            .MakeGenericMethod(argsType)
+            .Invoke(null, [args]);
+    }
 }

framework/src/Volo.Abp.BackgroundJobs/Volo/Abp/BackgroundJobs/DefaultBackgroundJobManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 using Volo.Abp.BackgroundWorkers;
@@ -40,11 +40,10 @@ public class DefaultBackgroundJobManager : IBackgroundJobManager, ITransientDepe
     public virtual async Task<string> EnqueueAsync<TArgs>(TArgs args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
     {
         var jobName = BackgroundJobOptions.Value.GetBackgroundJobName(typeof(TArgs));
-        var jobId = await EnqueueAsync(jobName, args!, priority, delay);
-        return jobId.ToString();
+        return await EnqueueAsync(jobName, args!, priority, delay);
     }
 
-    protected virtual async Task<Guid> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
+    public virtual async Task<string> EnqueueAsync(string jobName, object args, BackgroundJobPriority priority = BackgroundJobPriority.Normal, TimeSpan? delay = null)
     {
         var jobInfo = new BackgroundJobInfo
         {
@@ -64,6 +63,6 @@ public class DefaultBackgroundJobManager : IBackgroundJobManager, ITransientDepe
 
         await Store.InsertAsync(jobInfo);
 
-        return jobInfo.Id;
+        return jobInfo.Id.ToString();
     }
 }

framework/test/Volo.Abp.BackgroundJobs.Tests/Volo/Abp/BackgroundJobs/BackgroundJobManager_Tests.cs

@@ -1,4 +1,5 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Shouldly;
 using Xunit;
@@ -31,4 +32,34 @@ public class BackgroundJobManager_Tests : BackgroundJobsTestBase
         jobIdAsString.ShouldNotBe(default);
         (await _backgroundJobStore.FindAsync(Guid.Parse(jobIdAsString))).ShouldNotBeNull();
     }
+
+    [Fact]
+    public async Task Should_Store_Jobs_With_JobName()
+    {
+        var jobName = BackgroundJobNameAttribute.GetName<MyJobArgs>();
+        var jobIdAsString = await _backgroundJobManager.EnqueueAsync(jobName, new
+        {
+            Value = "42"
+        });
+        jobIdAsString.ShouldNotBe(default);
+
+        var jobInfo = await _backgroundJobStore.FindAsync(Guid.Parse(jobIdAsString));
+        jobInfo.ShouldNotBeNull();
+        jobInfo.JobName.ShouldBe(jobName);
+    }
+
+    [Fact]
+    public async Task Should_Store_Async_Jobs_With_JobName()
+    {
+        var jobName = BackgroundJobNameAttribute.GetName<MyAsyncJobArgs>();
+        var jobIdAsString = await _backgroundJobManager.EnqueueAsync(jobName, new Dictionary<string, object>()
+        {
+            ["Value"] = "42"
+        });
+        jobIdAsString.ShouldNotBe(default);
+
+        var jobInfo = await _backgroundJobStore.FindAsync(Guid.Parse(jobIdAsString));
+        jobInfo.ShouldNotBeNull();
+        jobInfo.JobName.ShouldBe(jobName);
+    }
 }