Allow configuring queue and priority for recurring tasks

And also setting a description that we can use from Mission Control in
the future.

Author: rosa

app/models/solid_queue/recurring_task.rb

@@ -17,7 +17,15 @@ def wrap(args)
       end
 
       def from_configuration(key, **options)
-        new(key: key, class_name: options[:class], schedule: options[:schedule], arguments: options[:args])
+        new \
+          key: key,
+          class_name: options[:class],
+          arguments: options[:args],
+          schedule: options[:schedule],
+          queue_name: options[:queue_name].presence,
+          priority: options[:priority].presence,
+          description: options[:description],
+          static: true
       end
 
       def create_or_update_all(tasks)
@@ -89,7 +97,7 @@ def using_solid_queue_adapter?
 
       def enqueue_and_record(run_at:)
         RecurringExecution.record(key, run_at) do
-          job_class.new(*arguments_with_kwargs).tap do |active_job|
+          job_class.new(*arguments_with_kwargs).set(enqueue_options).tap do |active_job|
             active_job.run_callbacks(:enqueue) do
               Job.enqueue(active_job)
             end
@@ -99,7 +107,7 @@ def enqueue_and_record(run_at:)
       end
 
       def perform_later(&block)
-        job_class.perform_later(*arguments_with_kwargs, &block)
+        job_class.set(enqueue_options).perform_later(*arguments_with_kwargs, &block)
       end
 
       def arguments_with_kwargs
@@ -118,5 +126,9 @@ def parsed_schedule
       def job_class
         @job_class ||= class_name&.safe_constantize
       end
+
+      def enqueue_options
+        { queue: queue_name, priority: priority }.compact
+      end
   end
 end

test/models/solid_queue/recurring_task_test.rb

@@ -25,6 +25,14 @@ def perform(value, options = {}, **kwargs)
     end
   end
 
+  class JobWithPriority < ApplicationJob
+    queue_with_priority 10
+
+    def perform
+      JobBuffer.add "job_with_priority"
+    end
+  end
+
   class JobUsingAsyncAdapter < ApplicationJob
     self.queue_adapter = :async
 
@@ -33,11 +41,6 @@ def perform
     end
   end
 
-  setup do
-    @worker = SolidQueue::Worker.new(queues: "*")
-    @worker.mode = :inline
-  end
-
   test "job without arguments" do
     task = recurring_task_with(class_name: "JobWithoutArguments")
     enqueue_and_assert_performed_with_result task, "job_without_arguments"
@@ -126,20 +129,48 @@ def perform
     assert_not SolidQueue::RecurringTask.new(key: "task-id", schedule: "every minute").valid?
   end
 
+  test "task with custom queue and priority" do
+    task = recurring_task_with(class_name: "JobWithoutArguments", queue_name: "my_new_queue", priority: 4)
+    enqueue_and_assert_performed_with_result task, "job_without_arguments"
+
+    job = SolidQueue::Job.last
+    assert_equal "my_new_queue", job.queue_name
+    assert_equal 4, job.priority
+  end
+
+  test "overriding existing priority" do
+    task = recurring_task_with(class_name: "JobWithPriority", priority: nil).tap(&:save!)
+    enqueue_and_assert_performed_with_result task.reload, "job_with_priority"
+
+    job = SolidQueue::Job.last
+    assert_equal 10, job.priority
+
+    task.destroy
+
+    task = recurring_task_with(class_name: "JobWithPriority", priority: 4).tap(&:save!)
+    enqueue_and_assert_performed_with_result task.reload, "job_with_priority"
+
+    job = SolidQueue::Job.last
+    assert_equal 4, job.priority
+  end
+
   private
     def enqueue_and_assert_performed_with_result(task, result)
       assert_difference [ -> { SolidQueue::Job.count }, -> { SolidQueue::ReadyExecution.count } ], +1 do
         task.enqueue(at: Time.now)
       end
 
       assert_difference -> { JobBuffer.size }, +1 do
-        @worker.start
+        SolidQueue::Worker.new(queues: "*").tap do |worker|
+          worker.mode = :inline
+          worker.start
+        end
       end
 
       assert_equal result, JobBuffer.last_value
     end
 
-    def recurring_task_with(class_name:, schedule: "every hour", args: nil)
-      SolidQueue::RecurringTask.new(key: "task-id", class_name: "SolidQueue::RecurringTaskTest::#{class_name}", schedule: schedule, arguments: args)
+    def recurring_task_with(class_name:, schedule: "every hour", args: nil, **options)
+      SolidQueue::RecurringTask.new(key: "task-id", class_name: "SolidQueue::RecurringTaskTest::#{class_name}", schedule: schedule, arguments: args, **options)
     end
 end

test/unit/configuration_test.rb

@@ -111,11 +111,7 @@ def assert_processes(configuration, kind, count, **attributes)
           value = value.first
         end
 
-        if expected_value.nil?
-          assert_nil value
-        else
-          assert_equal expected_value, value
-        end
+        assert_equal_value expected_value, value
       end
     end
 
@@ -124,7 +120,15 @@ def assert_has_recurring_task(dispatcher, key:, **attributes)
       task = dispatcher.recurring_schedule.configured_tasks.detect { |t| t.key == key }
 
       attributes.each do |attr, value|
-        assert_equal value, task.public_send(attr)
+        assert_equal_value value, task.public_send(attr)
+      end
+    end
+
+    def assert_equal_value(expected_value, value)
+      if expected_value.nil?
+        assert_nil value
+      else
+        assert_equal expected_value, value
       end
     end