Simplify passing options or file to configuration

Author: rosa

lib/solid_queue/cli.rb

@@ -14,7 +14,7 @@ def self.exit_on_failure?
     default_command :start
 
     def start
-      SolidQueue::Supervisor.start(load_configuration_from: options["config_file"])
+      SolidQueue::Supervisor.start(config_file: options["config_file"])
     end
   end
 end

lib/solid_queue/configuration.rb

@@ -28,8 +28,8 @@ def instantiate
       dispatchers: [ DISPATCHER_DEFAULTS ]
     }
 
-    def initialize(load_from: nil)
-      @raw_config = config_from(load_from)
+    def initialize(config_file: nil, **options)
+      @raw_config = config_from(config_file || options.presence)
     end
 
     def configured_processes

lib/solid_queue/supervisor.rb

@@ -6,9 +6,9 @@ class Supervisor < Processes::Base
     include Maintenance, Signals, Pidfiled
 
     class << self
-      def start(load_configuration_from: nil)
+      def start(**options)
         SolidQueue.supervisor = true
-        configuration = Configuration.new(load_from: load_configuration_from)
+        configuration = Configuration.new(**options)
 
         if configuration.configured_processes.any?
           new(configuration).tap(&:start)

test/integration/concurrency_controls_test.rb

@@ -11,7 +11,7 @@ class ConcurrencyControlsTest < ActiveSupport::TestCase
     default_worker = { queues: "default", polling_interval: 0.1, processes: 3, threads: 2 }
     dispatcher = { polling_interval: 0.1, batch_size: 200, concurrency_maintenance_interval: 1 }
 
-    @pid = run_supervisor_as_fork(load_configuration_from: { workers: [ default_worker ], dispatchers: [ dispatcher ] })
+    @pid = run_supervisor_as_fork(workers: [ default_worker ], dispatchers: [ dispatcher ])
 
     wait_for_registered_processes(5, timeout: 0.5.second) # 3 workers working the default queue + dispatcher + supervisor
   end

test/integration/lifecycle_hooks_test.rb

@@ -12,7 +12,7 @@ class LifecycleHooksTest < ActiveSupport::TestCase
     SolidQueue.on_worker_start { JobResult.create!(status: :hook_called, value: :worker_start) }
     SolidQueue.on_worker_stop { JobResult.create!(status: :hook_called, value: :worker_stop) }
 
-    pid = run_supervisor_as_fork(load_configuration_from: { workers: [ { queues: "*" } ] })
+    pid = run_supervisor_as_fork(workers: [ { queues: "*" } ])
     wait_for_registered_processes(4)
 
     terminate_process(pid)

test/integration/processes_lifecycle_test.rb

@@ -7,7 +7,7 @@ class ProcessesLifecycleTest < ActiveSupport::TestCase
 
   setup do
     config_as_hash = { workers: [ { queues: :background }, { queues: :default, threads: 5 } ], dispatchers: [] }
-    @pid = run_supervisor_as_fork(load_configuration_from: config_as_hash)
+    @pid = run_supervisor_as_fork(config_as_hash)
 
     wait_for_registered_processes(3, timeout: 3.second)
     assert_registered_workers_for(:background, :default, supervisor_pid: @pid)

test/unit/configuration_test.rb

@@ -7,23 +7,23 @@ class ConfigurationTest < ActiveSupport::TestCase
     end
 
     assert_equal 2, configuration.configured_processes.count
-    assert_processes configuration, :worker, 1, queues: [ "*" ]
+    assert_processes configuration, :worker, 1, queues: "*"
     assert_processes configuration, :dispatcher, 1, batch_size: SolidQueue::Configuration::DISPATCHER_DEFAULTS[:batch_size]
   end
 
   test "default configuration when config given doesn't include any configuration" do
-    configuration = SolidQueue::Configuration.new(load_from: { random_wrong_key: :random_value })
+    configuration = SolidQueue::Configuration.new(random_wrong_key: :random_value)
 
     assert_equal 2, configuration.configured_processes.count
-    assert_processes configuration, :worker, 1, queues: [ "*" ]
+    assert_processes configuration, :worker, 1, queues: "*"
     assert_processes configuration, :dispatcher, 1, batch_size: SolidQueue::Configuration::DISPATCHER_DEFAULTS[:batch_size]
   end
 
   test "default configuration when config given is empty" do
-    configuration = SolidQueue::Configuration.new(load_from: {})
+    configuration = SolidQueue::Configuration.new(config_file: Rails.root.join("config/empty_configuration.yml"))
 
     assert_equal 2, configuration.configured_processes.count
-    assert_processes configuration, :worker, 1, queues: [ "*" ]
+    assert_processes configuration, :worker, 1, queues: "*"
     assert_processes configuration, :dispatcher, 1, batch_size: SolidQueue::Configuration::DISPATCHER_DEFAULTS[:batch_size]
   end
 
@@ -34,17 +34,22 @@ class ConfigurationTest < ActiveSupport::TestCase
     assert_processes configuration, :dispatcher, 1
   end
 
+  test "read configuration from provided file" do
+    configuration = SolidQueue::Configuration.new(config_file: Rails.root.join("config/alternative_configuration.yml"))
+
+    assert 3, configuration.configured_processes.count
+    assert_processes configuration, :worker, 3, processes: 1, polling_interval: 0.1, queues: %w[ queue_1 queue_2 queue_3 ], threads: [ 1, 2, 3 ]
+  end
+
   test "provide configuration as a hash and fill defaults" do
     background_worker = { queues: "background", polling_interval: 10 }
     dispatcher = { batch_size: 100 }
-    config_as_hash = { workers: [ background_worker, background_worker ], dispatchers: [ dispatcher ] }
-    configuration = SolidQueue::Configuration.new(load_from: config_as_hash)
+    configuration = SolidQueue::Configuration.new(workers: [ background_worker, background_worker ], dispatchers: [ dispatcher ])
 
     assert_processes configuration, :dispatcher, 1, polling_interval: SolidQueue::Configuration::DISPATCHER_DEFAULTS[:polling_interval], batch_size: 100
-    assert_processes configuration, :worker, 2, queues: [ "background" ], polling_interval: 10
+    assert_processes configuration, :worker, 2, queues: "background", polling_interval: 10
 
-    config_as_hash = { workers: [ background_worker, background_worker ] }
-    configuration = SolidQueue::Configuration.new(load_from: config_as_hash)
+    configuration = SolidQueue::Configuration.new(workers: [ background_worker, background_worker ])
 
     assert_processes configuration, :dispatcher, 0
     assert_processes configuration, :worker, 2
@@ -57,20 +62,24 @@ class ConfigurationTest < ActiveSupport::TestCase
 
   test "mulitple workers with the same configuration" do
     background_worker = { queues: "background", polling_interval: 10, processes: 3 }
-    config_as_hash = { workers: [ background_worker ] }
-    configuration = SolidQueue::Configuration.new(load_from: config_as_hash)
+    configuration = SolidQueue::Configuration.new(workers: [ background_worker ])
 
     assert_equal 3, configuration.configured_processes.count
-    assert_processes configuration, :worker, 3, queues: [ "background" ], polling_interval: 10
+    assert_processes configuration, :worker, 3, queues: "background", polling_interval: 10
   end
 
   private
     def assert_processes(configuration, kind, count, **attributes)
-      processes = configuration.configured_processes.select { |p| p.kind == kind }.map(&:instantiate)
+      processes = configuration.configured_processes.select { |p| p.kind == kind }
       assert_equal count, processes.size
 
-      attributes.each do |attr, value|
-        assert_equal value, processes.map { |p| p.public_send(attr) }.first
+      attributes.each do |attr, expected_value|
+        value = processes.map { |p| p.attributes.fetch(attr) }
+        unless expected_value.is_a?(Array)
+          value = value.first
+        end
+
+        assert_equal expected_value, value
       end
     end
 end

test/unit/supervisor_test.rb

@@ -29,7 +29,7 @@ class SupervisorTest < ActiveSupport::TestCase
 
   test "start with provided configuration" do
     config_as_hash = { workers: [], dispatchers: [ { batch_size: 100 } ] }
-    pid = run_supervisor_as_fork(load_configuration_from: config_as_hash)
+    pid = run_supervisor_as_fork(config_as_hash)
     wait_for_registered_processes(2, timeout: 2) # supervisor + dispatcher
 
     assert_registered_supervisor(pid)
@@ -44,7 +44,7 @@ class SupervisorTest < ActiveSupport::TestCase
   test "start with empty configuration" do
     config_as_hash = { workers: [], dispatchers: [] }
 
-    pid = run_supervisor_as_fork(load_configuration_from: config_as_hash)
+    pid = run_supervisor_as_fork(config_as_hash)
     sleep(0.5)
     assert_no_registered_processes
 
@@ -116,7 +116,7 @@ class SupervisorTest < ActiveSupport::TestCase
       workers: [ { queues: "background", polling_interval: 10, processes: 2 } ],
       dispatchers: []
     }
-    pid = run_supervisor_as_fork(load_configuration_from: config_as_hash)
+    pid = run_supervisor_as_fork(config_as_hash)
     wait_for_registered_processes(3)
     assert_registered_supervisor(pid)